52#include "llvm/ADT/STLExtras.h"
53#include "llvm/ADT/StringExtras.h"
54#include "llvm/ADT/StringSwitch.h"
55#include "llvm/Analysis/TargetLibraryInfo.h"
56#include "llvm/BinaryFormat/ELF.h"
57#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
58#include "llvm/IR/AttributeMask.h"
59#include "llvm/IR/CallingConv.h"
60#include "llvm/IR/DataLayout.h"
61#include "llvm/IR/Intrinsics.h"
62#include "llvm/IR/LLVMContext.h"
63#include "llvm/IR/Module.h"
64#include "llvm/IR/ProfileSummary.h"
65#include "llvm/ProfileData/InstrProfReader.h"
66#include "llvm/ProfileData/SampleProf.h"
67#include "llvm/Support/CRC.h"
68#include "llvm/Support/CodeGen.h"
69#include "llvm/Support/CommandLine.h"
70#include "llvm/Support/ConvertUTF.h"
71#include "llvm/Support/ErrorHandling.h"
72#include "llvm/Support/TimeProfiler.h"
73#include "llvm/Support/xxhash.h"
74#include "llvm/TargetParser/RISCVISAInfo.h"
75#include "llvm/TargetParser/Triple.h"
76#include "llvm/TargetParser/X86TargetParser.h"
77#include "llvm/Transforms/Utils/BuildLibCalls.h"
81using namespace CodeGen;
84 "limited-coverage-experimental", llvm::cl::Hidden,
85 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"));
91 case TargetCXXABI::AppleARM64:
92 case TargetCXXABI::Fuchsia:
93 case TargetCXXABI::GenericAArch64:
94 case TargetCXXABI::GenericARM:
95 case TargetCXXABI::iOS:
96 case TargetCXXABI::WatchOS:
97 case TargetCXXABI::GenericMIPS:
98 case TargetCXXABI::GenericItanium:
99 case TargetCXXABI::WebAssembly:
100 case TargetCXXABI::XL:
102 case TargetCXXABI::Microsoft:
106 llvm_unreachable(
"invalid C++ ABI kind");
109static std::unique_ptr<TargetCodeGenInfo>
115 switch (Triple.getArch()) {
119 case llvm::Triple::le32:
121 case llvm::Triple::m68k:
123 case llvm::Triple::mips:
124 case llvm::Triple::mipsel:
125 if (Triple.getOS() == llvm::Triple::NaCl)
129 case llvm::Triple::mips64:
130 case llvm::Triple::mips64el:
133 case llvm::Triple::avr: {
137 unsigned NPR =
Target.getABI() ==
"avrtiny" ? 6 : 18;
138 unsigned NRR =
Target.getABI() ==
"avrtiny" ? 4 : 8;
142 case llvm::Triple::aarch64:
143 case llvm::Triple::aarch64_32:
144 case llvm::Triple::aarch64_be: {
146 if (
Target.getABI() ==
"darwinpcs")
147 Kind = AArch64ABIKind::DarwinPCS;
148 else if (Triple.isOSWindows())
150 else if (
Target.getABI() ==
"aapcs-soft")
151 Kind = AArch64ABIKind::AAPCSSoft;
152 else if (
Target.getABI() ==
"pauthtest")
153 Kind = AArch64ABIKind::PAuthTest;
158 case llvm::Triple::wasm32:
159 case llvm::Triple::wasm64: {
161 if (
Target.getABI() ==
"experimental-mv")
162 Kind = WebAssemblyABIKind::ExperimentalMV;
166 case llvm::Triple::arm:
167 case llvm::Triple::armeb:
168 case llvm::Triple::thumb:
169 case llvm::Triple::thumbeb: {
170 if (Triple.getOS() == llvm::Triple::Win32)
174 StringRef ABIStr =
Target.getABI();
175 if (ABIStr ==
"apcs-gnu")
176 Kind = ARMABIKind::APCS;
177 else if (ABIStr ==
"aapcs16")
178 Kind = ARMABIKind::AAPCS16_VFP;
179 else if (CodeGenOpts.
FloatABI ==
"hard" ||
181 (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
182 Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
183 Triple.getEnvironment() == llvm::Triple::EABIHF)))
184 Kind = ARMABIKind::AAPCS_VFP;
189 case llvm::Triple::ppc: {
190 if (Triple.isOSAIX())
197 case llvm::Triple::ppcle: {
198 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
201 case llvm::Triple::ppc64:
202 if (Triple.isOSAIX())
205 if (Triple.isOSBinFormatELF()) {
207 if (
Target.getABI() ==
"elfv2")
208 Kind = PPC64_SVR4_ABIKind::ELFv2;
209 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
214 case llvm::Triple::ppc64le: {
215 assert(Triple.isOSBinFormatELF() &&
"PPC64 LE non-ELF not supported!");
217 if (
Target.getABI() ==
"elfv1")
218 Kind = PPC64_SVR4_ABIKind::ELFv1;
219 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
224 case llvm::Triple::nvptx:
225 case llvm::Triple::nvptx64:
228 case llvm::Triple::msp430:
231 case llvm::Triple::riscv32:
232 case llvm::Triple::riscv64: {
233 StringRef ABIStr =
Target.getABI();
234 unsigned XLen =
Target.getPointerWidth(LangAS::Default);
235 unsigned ABIFLen = 0;
236 if (ABIStr.ends_with(
"f"))
238 else if (ABIStr.ends_with(
"d"))
240 bool EABI = ABIStr.ends_with(
"e");
244 case llvm::Triple::systemz: {
245 bool SoftFloat = CodeGenOpts.
FloatABI ==
"soft";
246 bool HasVector = !SoftFloat &&
Target.getABI() ==
"vector";
250 case llvm::Triple::tce:
251 case llvm::Triple::tcele:
254 case llvm::Triple::x86: {
255 bool IsDarwinVectorABI = Triple.isOSDarwin();
256 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
258 if (Triple.getOS() == llvm::Triple::Win32) {
260 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
261 CodeGenOpts.NumRegisterParameters);
264 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
265 CodeGenOpts.NumRegisterParameters, CodeGenOpts.
FloatABI ==
"soft");
268 case llvm::Triple::x86_64: {
269 StringRef ABI =
Target.getABI();
270 X86AVXABILevel AVXLevel = (ABI ==
"avx512" ? X86AVXABILevel::AVX512
271 : ABI ==
"avx" ? X86AVXABILevel::AVX
272 : X86AVXABILevel::None);
274 switch (Triple.getOS()) {
275 case llvm::Triple::Win32:
281 case llvm::Triple::hexagon:
283 case llvm::Triple::lanai:
285 case llvm::Triple::r600:
287 case llvm::Triple::amdgcn:
289 case llvm::Triple::sparc:
291 case llvm::Triple::sparcv9:
293 case llvm::Triple::xcore:
295 case llvm::Triple::arc:
297 case llvm::Triple::spir:
298 case llvm::Triple::spir64:
300 case llvm::Triple::spirv32:
301 case llvm::Triple::spirv64:
303 case llvm::Triple::ve:
305 case llvm::Triple::csky: {
306 bool IsSoftFloat = !
Target.hasFeature(
"hard-float-abi");
308 Target.hasFeature(
"fpuv2_df") ||
Target.hasFeature(
"fpuv3_df");
313 case llvm::Triple::bpfeb:
314 case llvm::Triple::bpfel:
316 case llvm::Triple::loongarch32:
317 case llvm::Triple::loongarch64: {
318 StringRef ABIStr =
Target.getABI();
319 unsigned ABIFRLen = 0;
320 if (ABIStr.ends_with(
"f"))
322 else if (ABIStr.ends_with(
"d"))
325 CGM,
Target.getPointerWidth(LangAS::Default), ABIFRLen);
331 if (!TheTargetCodeGenInfo)
333 return *TheTargetCodeGenInfo;
343 : Context(
C), LangOpts(
C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
344 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
346 VMContext(M.getContext()), Types(*this), VTables(*this),
350 llvm::LLVMContext &LLVMContext = M.getContext();
351 VoidTy = llvm::Type::getVoidTy(LLVMContext);
352 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
353 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
354 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
355 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
356 HalfTy = llvm::Type::getHalfTy(LLVMContext);
357 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
358 FloatTy = llvm::Type::getFloatTy(LLVMContext);
359 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
365 C.toCharUnitsFromBits(
C.getTargetInfo().getMaxPointerWidth()).getQuantity();
367 C.toCharUnitsFromBits(
C.getTargetInfo().getIntAlign()).getQuantity();
369 llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getCharWidth());
370 IntTy = llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getIntWidth());
371 IntPtrTy = llvm::IntegerType::get(LLVMContext,
372 C.getTargetInfo().getMaxPointerWidth());
373 Int8PtrTy = llvm::PointerType::get(LLVMContext,
375 const llvm::DataLayout &DL = M.getDataLayout();
377 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
379 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
396 createOpenCLRuntime();
398 createOpenMPRuntime();
405 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread) ||
406 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
412 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
417 Block.GlobalUniqueCount = 0;
419 if (
C.getLangOpts().ObjC)
423 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
430 PGOReader = std::move(ReaderOrErr.get());
435 if (CodeGenOpts.CoverageMapping)
439 if (CodeGenOpts.UniqueInternalLinkageNames &&
440 !
getModule().getSourceFileName().empty()) {
444 if (
Path.rfind(Entry.first, 0) != std::string::npos) {
445 Path = Entry.second +
Path.substr(Entry.first.size());
448 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(
Path);
453 getModule().addModuleFlag(llvm::Module::Error,
"NumRegisterParameters",
454 CodeGenOpts.NumRegisterParameters);
459void CodeGenModule::createObjCRuntime() {
476 llvm_unreachable(
"bad runtime kind");
479void CodeGenModule::createOpenCLRuntime() {
483void CodeGenModule::createOpenMPRuntime() {
487 case llvm::Triple::nvptx:
488 case llvm::Triple::nvptx64:
489 case llvm::Triple::amdgcn:
491 "OpenMP AMDGPU/NVPTX is only prepared to deal with device code.");
495 if (LangOpts.OpenMPSimd)
503void CodeGenModule::createCUDARuntime() {
507void CodeGenModule::createHLSLRuntime() {
512 Replacements[Name] =
C;
515void CodeGenModule::applyReplacements() {
516 for (
auto &I : Replacements) {
517 StringRef MangledName = I.first;
518 llvm::Constant *Replacement = I.second;
522 auto *OldF = cast<llvm::Function>(Entry);
523 auto *NewF = dyn_cast<llvm::Function>(Replacement);
525 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
526 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
528 auto *CE = cast<llvm::ConstantExpr>(Replacement);
529 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
530 CE->getOpcode() == llvm::Instruction::GetElementPtr);
531 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
536 OldF->replaceAllUsesWith(Replacement);
538 NewF->removeFromParent();
539 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
542 OldF->eraseFromParent();
547 GlobalValReplacements.push_back(std::make_pair(GV,
C));
550void CodeGenModule::applyGlobalValReplacements() {
551 for (
auto &I : GlobalValReplacements) {
552 llvm::GlobalValue *GV = I.first;
553 llvm::Constant *
C = I.second;
555 GV->replaceAllUsesWith(
C);
556 GV->eraseFromParent();
563 const llvm::Constant *
C;
564 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
565 C = GA->getAliasee();
566 else if (
auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
567 C = GI->getResolver();
571 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(
C->stripPointerCasts());
575 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
584 bool IsIFunc,
const llvm::GlobalValue *Alias,
const llvm::GlobalValue *&GV,
585 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
589 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
593 if (GV->hasCommonLinkage()) {
595 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
596 Diags.
Report(Location, diag::err_alias_to_common);
601 if (GV->isDeclaration()) {
602 Diags.
Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
603 Diags.
Report(Location, diag::note_alias_requires_mangled_name)
604 << IsIFunc << IsIFunc;
607 for (
const auto &[
Decl, Name] : MangledDeclNames) {
608 if (
const auto *ND = dyn_cast<NamedDecl>(
Decl.getDecl())) {
609 if (ND->getName() == GV->getName()) {
610 Diags.
Report(Location, diag::note_alias_mangled_name_alternative)
614 (Twine(IsIFunc ?
"ifunc" :
"alias") +
"(\"" + Name +
"\")")
624 const auto *F = dyn_cast<llvm::Function>(GV);
626 Diags.
Report(Location, diag::err_alias_to_undefined)
627 << IsIFunc << IsIFunc;
631 llvm::FunctionType *FTy = F->getFunctionType();
632 if (!FTy->getReturnType()->isPointerTy()) {
633 Diags.
Report(Location, diag::err_ifunc_resolver_return);
647 if (GVar->hasAttribute(
"toc-data")) {
648 auto GVId = GVar->getName();
651 Diags.
Report(Location, diag::warn_toc_unsupported_type)
652 << GVId <<
"the variable has an alias";
654 llvm::AttributeSet CurrAttributes = GVar->getAttributes();
655 llvm::AttributeSet NewAttributes =
656 CurrAttributes.removeAttribute(GVar->getContext(),
"toc-data");
657 GVar->setAttributes(NewAttributes);
661void CodeGenModule::checkAliases() {
668 const auto *
D = cast<ValueDecl>(GD.getDecl());
671 bool IsIFunc =
D->
hasAttr<IFuncAttr>();
673 Location = A->getLocation();
674 Range = A->getRange();
676 llvm_unreachable(
"Not an alias or ifunc?");
680 const llvm::GlobalValue *GV =
nullptr;
682 MangledDeclNames,
Range)) {
688 if (
const llvm::GlobalVariable *GVar =
689 dyn_cast<const llvm::GlobalVariable>(GV))
693 llvm::Constant *Aliasee =
694 IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()
695 : cast<llvm::GlobalAlias>(Alias)->getAliasee();
697 llvm::GlobalValue *AliaseeGV;
698 if (
auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
699 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
701 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
703 if (
const SectionAttr *SA =
D->
getAttr<SectionAttr>()) {
704 StringRef AliasSection = SA->getName();
705 if (AliasSection != AliaseeGV->getSection())
706 Diags.
Report(SA->getLocation(), diag::warn_alias_with_section)
707 << AliasSection << IsIFunc << IsIFunc;
715 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
716 if (GA->isInterposable()) {
717 Diags.
Report(Location, diag::warn_alias_to_weak_alias)
718 << GV->getName() << GA->getName() << IsIFunc;
719 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
720 GA->getAliasee(), Alias->getType());
723 cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);
725 cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);
731 cast<llvm::Function>(Aliasee)->addFnAttr(
732 llvm::Attribute::DisableSanitizerInstrumentation);
740 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
741 Alias->eraseFromParent();
746 DeferredDeclsToEmit.clear();
747 EmittedDeferredDecls.clear();
748 DeferredAnnotations.clear();
750 OpenMPRuntime->clear();
754 StringRef MainFile) {
757 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
758 if (MainFile.empty())
759 MainFile =
"<stdin>";
760 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
763 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
766 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
770static std::optional<llvm::GlobalValue::VisibilityTypes>
777 return llvm::GlobalValue::DefaultVisibility;
779 return llvm::GlobalValue::HiddenVisibility;
781 return llvm::GlobalValue::ProtectedVisibility;
783 llvm_unreachable(
"unknown option value!");
787 std::optional<llvm::GlobalValue::VisibilityTypes>
V) {
796 GV.setDSOLocal(
false);
797 GV.setVisibility(*
V);
802 if (!LO.VisibilityFromDLLStorageClass)
805 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
808 std::optional<llvm::GlobalValue::VisibilityTypes>
809 NoDLLStorageClassVisibility =
812 std::optional<llvm::GlobalValue::VisibilityTypes>
813 ExternDeclDLLImportVisibility =
816 std::optional<llvm::GlobalValue::VisibilityTypes>
817 ExternDeclNoDLLStorageClassVisibility =
820 for (llvm::GlobalValue &GV : M.global_values()) {
821 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
824 if (GV.isDeclarationForLinker())
826 llvm::GlobalValue::DLLImportStorageClass
827 ? ExternDeclDLLImportVisibility
828 : ExternDeclNoDLLStorageClassVisibility);
831 llvm::GlobalValue::DLLExportStorageClass
832 ? DLLExportVisibility
833 : NoDLLStorageClassVisibility);
835 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
840 const llvm::Triple &Triple,
842 if (Triple.isAMDGPU() || Triple.isNVPTX())
844 return LangOpts.getStackProtector() == Mode;
850 EmitModuleInitializers(Primary);
852 DeferredDecls.insert(EmittedDeferredDecls.begin(),
853 EmittedDeferredDecls.end());
854 EmittedDeferredDecls.clear();
855 EmitVTablesOpportunistically();
856 applyGlobalValReplacements();
858 emitMultiVersionFunctions();
861 GlobalTopLevelStmtBlockInFlight.first) {
863 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->
getEndLoc());
864 GlobalTopLevelStmtBlockInFlight = {
nullptr,
nullptr};
870 EmitCXXModuleInitFunc(Primary);
872 EmitCXXGlobalInitFunc();
873 EmitCXXGlobalCleanUpFunc();
874 registerGlobalDtorsWithAtExit();
875 EmitCXXThreadLocalInitFunc();
877 if (llvm::Function *ObjCInitFunction =
ObjCRuntime->ModuleInitFunction())
880 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
884 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
885 OpenMPRuntime->clear();
889 PGOReader->getSummary(
false).getMD(VMContext),
890 llvm::ProfileSummary::PSK_Instr);
897 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
898 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
900 EmitStaticExternCAliases();
906 CoverageMapping->emit();
907 if (CodeGenOpts.SanitizeCfiCrossDso) {
913 emitAtAvailableLinkGuard();
921 if (
getTarget().getTargetOpts().CodeObjectVersion !=
922 llvm::CodeObjectVersionKind::COV_None) {
923 getModule().addModuleFlag(llvm::Module::Error,
924 "amdhsa_code_object_version",
925 getTarget().getTargetOpts().CodeObjectVersion);
930 auto *MDStr = llvm::MDString::get(
935 getModule().addModuleFlag(llvm::Module::Error,
"amdgpu_printf_kind",
948 if (
auto *FD = dyn_cast<FunctionDecl>(
D))
952 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
956 llvm::ArrayType *ATy = llvm::ArrayType::get(
Int8PtrTy, UsedArray.size());
958 auto *GV =
new llvm::GlobalVariable(
959 getModule(), ATy,
false, llvm::GlobalValue::InternalLinkage,
960 llvm::ConstantArray::get(ATy, UsedArray),
"__clang_gpu_used_external");
963 if (LangOpts.HIP && !
getLangOpts().OffloadingNewDriver) {
966 auto *GV =
new llvm::GlobalVariable(
968 llvm::Constant::getNullValue(
Int8Ty),
976 if (CodeGenOpts.Autolink &&
977 (Context.
getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
978 EmitModuleLinkOptions();
993 if (!ELFDependentLibraries.empty() && !Context.
getLangOpts().CUDAIsDevice) {
994 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
995 for (
auto *MD : ELFDependentLibraries)
999 if (CodeGenOpts.DwarfVersion) {
1000 getModule().addModuleFlag(llvm::Module::Max,
"Dwarf Version",
1001 CodeGenOpts.DwarfVersion);
1004 if (CodeGenOpts.Dwarf64)
1005 getModule().addModuleFlag(llvm::Module::Max,
"DWARF64", 1);
1009 getModule().setSemanticInterposition(
true);
1011 if (CodeGenOpts.EmitCodeView) {
1013 getModule().addModuleFlag(llvm::Module::Warning,
"CodeView", 1);
1015 if (CodeGenOpts.CodeViewGHash) {
1016 getModule().addModuleFlag(llvm::Module::Warning,
"CodeViewGHash", 1);
1018 if (CodeGenOpts.ControlFlowGuard) {
1020 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 2);
1021 }
else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1023 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 1);
1025 if (CodeGenOpts.EHContGuard) {
1027 getModule().addModuleFlag(llvm::Module::Warning,
"ehcontguard", 1);
1031 getModule().addModuleFlag(llvm::Module::Warning,
"ms-kernel", 1);
1033 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1038 getModule().addModuleFlag(llvm::Module::Error,
"StrictVTablePointers",1);
1040 llvm::Metadata *Ops[2] = {
1041 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
1042 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1043 llvm::Type::getInt32Ty(VMContext), 1))};
1045 getModule().addModuleFlag(llvm::Module::Require,
1046 "StrictVTablePointersRequirement",
1047 llvm::MDNode::get(VMContext, Ops));
1053 getModule().addModuleFlag(llvm::Module::Warning,
"Debug Info Version",
1054 llvm::DEBUG_METADATA_VERSION);
1059 uint64_t WCharWidth =
1061 getModule().addModuleFlag(llvm::Module::Error,
"wchar_size", WCharWidth);
1064 getModule().addModuleFlag(llvm::Module::Warning,
1065 "zos_product_major_version",
1066 uint32_t(CLANG_VERSION_MAJOR));
1067 getModule().addModuleFlag(llvm::Module::Warning,
1068 "zos_product_minor_version",
1069 uint32_t(CLANG_VERSION_MINOR));
1070 getModule().addModuleFlag(llvm::Module::Warning,
"zos_product_patchlevel",
1071 uint32_t(CLANG_VERSION_PATCHLEVEL));
1073 getModule().addModuleFlag(llvm::Module::Error,
"zos_product_id",
1074 llvm::MDString::get(VMContext, ProductId));
1079 getModule().addModuleFlag(llvm::Module::Error,
"zos_cu_language",
1080 llvm::MDString::get(VMContext, lang_str));
1084 : std::time(
nullptr);
1085 getModule().addModuleFlag(llvm::Module::Max,
"zos_translation_time",
1086 static_cast<uint64_t
>(TT));
1089 getModule().addModuleFlag(llvm::Module::Error,
"zos_le_char_mode",
1090 llvm::MDString::get(VMContext,
"ascii"));
1094 if (
T.isARM() ||
T.isThumb()) {
1096 uint64_t EnumWidth = Context.
getLangOpts().ShortEnums ? 1 : 4;
1097 getModule().addModuleFlag(llvm::Module::Error,
"min_enum_size", EnumWidth);
1101 StringRef ABIStr =
Target.getABI();
1102 llvm::LLVMContext &Ctx = TheModule.getContext();
1103 getModule().addModuleFlag(llvm::Module::Error,
"target-abi",
1104 llvm::MDString::get(Ctx, ABIStr));
1109 const std::vector<std::string> &Features =
1112 llvm::RISCVISAInfo::parseFeatures(
T.isRISCV64() ? 64 : 32, Features);
1113 if (!errorToBool(ParseResult.takeError()))
1115 llvm::Module::AppendUnique,
"riscv-isa",
1117 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1120 if (CodeGenOpts.SanitizeCfiCrossDso) {
1122 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
1125 if (CodeGenOpts.WholeProgramVTables) {
1129 getModule().addModuleFlag(llvm::Module::Error,
"Virtual Function Elim",
1130 CodeGenOpts.VirtualFunctionElimination);
1133 if (LangOpts.
Sanitize.
has(SanitizerKind::CFIICall)) {
1134 getModule().addModuleFlag(llvm::Module::Override,
1135 "CFI Canonical Jump Tables",
1136 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1140 getModule().addModuleFlag(llvm::Module::Override,
"kcfi", 1);
1143 if (CodeGenOpts.PatchableFunctionEntryOffset)
1144 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-offset",
1145 CodeGenOpts.PatchableFunctionEntryOffset);
1148 if (CodeGenOpts.CFProtectionReturn &&
1151 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-return",
1155 if (CodeGenOpts.CFProtectionBranch &&
1158 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-branch",
1162 if (CodeGenOpts.FunctionReturnThunks)
1163 getModule().addModuleFlag(llvm::Module::Override,
"function_return_thunk_extern", 1);
1165 if (CodeGenOpts.IndirectBranchCSPrefix)
1166 getModule().addModuleFlag(llvm::Module::Override,
"indirect_branch_cs_prefix", 1);
1178 LangOpts.getSignReturnAddressScope() !=
1180 getModule().addModuleFlag(llvm::Module::Override,
1181 "sign-return-address-buildattr", 1);
1182 if (LangOpts.
Sanitize.
has(SanitizerKind::MemtagStack))
1183 getModule().addModuleFlag(llvm::Module::Override,
1184 "tag-stack-memory-buildattr", 1);
1186 if (
T.isARM() ||
T.isThumb() ||
T.isAArch64()) {
1187 if (LangOpts.BranchTargetEnforcement)
1188 getModule().addModuleFlag(llvm::Module::Min,
"branch-target-enforcement",
1190 if (LangOpts.BranchProtectionPAuthLR)
1191 getModule().addModuleFlag(llvm::Module::Min,
"branch-protection-pauth-lr",
1193 if (LangOpts.GuardedControlStack)
1194 getModule().addModuleFlag(llvm::Module::Min,
"guarded-control-stack", 1);
1196 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address", 1);
1198 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address-all",
1201 getModule().addModuleFlag(llvm::Module::Min,
1202 "sign-return-address-with-bkey", 1);
1206 using namespace llvm::ELF;
1207 uint64_t PAuthABIVersion =
1208 (LangOpts.PointerAuthIntrinsics
1209 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INTRINSICS) |
1210 (LangOpts.PointerAuthCalls
1211 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_CALLS) |
1212 (LangOpts.PointerAuthReturns
1213 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_RETURNS) |
1214 (LangOpts.PointerAuthAuthTraps
1215 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_AUTHTRAPS) |
1216 (LangOpts.PointerAuthVTPtrAddressDiscrimination
1217 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRADDRDISCR) |
1218 (LangOpts.PointerAuthVTPtrTypeDiscrimination
1219 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRTYPEDISCR) |
1220 (LangOpts.PointerAuthInitFini
1221 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI);
1222 static_assert(AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI ==
1223 AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_LAST,
1224 "Update when new enum items are defined");
1225 if (PAuthABIVersion != 0) {
1226 getModule().addModuleFlag(llvm::Module::Error,
1227 "aarch64-elf-pauthabi-platform",
1228 AARCH64_PAUTH_PLATFORM_LLVM_LINUX);
1229 getModule().addModuleFlag(llvm::Module::Error,
1230 "aarch64-elf-pauthabi-version",
1236 if (CodeGenOpts.StackClashProtector)
1238 llvm::Module::Override,
"probe-stack",
1239 llvm::MDString::get(TheModule.getContext(),
"inline-asm"));
1241 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1242 getModule().addModuleFlag(llvm::Module::Min,
"stack-probe-size",
1243 CodeGenOpts.StackProbeSize);
1246 llvm::LLVMContext &Ctx = TheModule.getContext();
1248 llvm::Module::Error,
"MemProfProfileFilename",
1252 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
1256 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
1258 llvm::DenormalMode::IEEE);
1261 if (LangOpts.EHAsynch)
1262 getModule().addModuleFlag(llvm::Module::Warning,
"eh-asynch", 1);
1266 getModule().addModuleFlag(llvm::Module::Max,
"openmp", LangOpts.OpenMP);
1268 getModule().addModuleFlag(llvm::Module::Max,
"openmp-device",
1272 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())) {
1273 EmitOpenCLMetadata();
1281 llvm::Metadata *SPIRVerElts[] = {
1282 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1284 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1285 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1286 llvm::NamedMDNode *SPIRVerMD =
1287 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
1288 llvm::LLVMContext &Ctx = TheModule.getContext();
1289 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1297 if (uint32_t PLevel = Context.
getLangOpts().PICLevel) {
1298 assert(PLevel < 3 &&
"Invalid PIC Level");
1299 getModule().setPICLevel(
static_cast<llvm::PICLevel::Level
>(PLevel));
1301 getModule().setPIELevel(
static_cast<llvm::PIELevel::Level
>(PLevel));
1305 unsigned CM = llvm::StringSwitch<unsigned>(
getCodeGenOpts().CodeModel)
1306 .Case(
"tiny", llvm::CodeModel::Tiny)
1307 .Case(
"small", llvm::CodeModel::Small)
1308 .Case(
"kernel", llvm::CodeModel::Kernel)
1309 .Case(
"medium", llvm::CodeModel::Medium)
1310 .Case(
"large", llvm::CodeModel::Large)
1313 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
1316 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1318 llvm::Triple::x86_64) {
1324 if (CodeGenOpts.NoPLT)
1327 CodeGenOpts.DirectAccessExternalData !=
1328 getModule().getDirectAccessExternalData()) {
1329 getModule().setDirectAccessExternalData(
1330 CodeGenOpts.DirectAccessExternalData);
1332 if (CodeGenOpts.UnwindTables)
1333 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1335 switch (CodeGenOpts.getFramePointer()) {
1340 getModule().setFramePointer(llvm::FramePointerKind::Reserved);
1343 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1346 getModule().setFramePointer(llvm::FramePointerKind::All);
1350 SimplifyPersonality();
1363 EmitVersionIdentMetadata();
1366 EmitCommandLineMetadata();
1374 getModule().setStackProtectorGuardSymbol(
1377 getModule().setStackProtectorGuardOffset(
1382 getModule().addModuleFlag(llvm::Module::Override,
"SkipRaxSetup", 1);
1384 getModule().addModuleFlag(llvm::Module::Override,
"RegCallv4", 1);
1386 if (
getContext().getTargetInfo().getMaxTLSAlign())
1387 getModule().addModuleFlag(llvm::Module::Error,
"MaxTLSAlign",
1388 getContext().getTargetInfo().getMaxTLSAlign());
1406 if (
getTriple().isPPC() && !MustTailCallUndefinedGlobals.empty()) {
1407 for (
auto &I : MustTailCallUndefinedGlobals) {
1408 if (!I.first->isDefined())
1409 getDiags().
Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1413 if (!Entry || Entry->isWeakForLinker() ||
1414 Entry->isDeclarationForLinker())
1415 getDiags().
Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1421void CodeGenModule::EmitOpenCLMetadata() {
1427 auto EmitVersion = [
this](StringRef MDName,
int Version) {
1428 llvm::Metadata *OCLVerElts[] = {
1429 llvm::ConstantAsMetadata::get(
1430 llvm::ConstantInt::get(
Int32Ty, Version / 100)),
1431 llvm::ConstantAsMetadata::get(
1432 llvm::ConstantInt::get(
Int32Ty, (Version % 100) / 10))};
1433 llvm::NamedMDNode *OCLVerMD = TheModule.getOrInsertNamedMetadata(MDName);
1434 llvm::LLVMContext &Ctx = TheModule.getContext();
1435 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1438 EmitVersion(
"opencl.ocl.version", CLVersion);
1439 if (LangOpts.OpenCLCPlusPlus) {
1441 EmitVersion(
"opencl.cxx.version", LangOpts.OpenCLCPlusPlusVersion);
1445void CodeGenModule::EmitBackendOptionsMetadata(
1448 getModule().addModuleFlag(llvm::Module::Min,
"SmallDataLimit",
1449 CodeGenOpts.SmallDataLimit);
1466 return TBAA->getTypeInfo(QTy);
1485 return TBAA->getAccessInfo(AccessType);
1492 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1498 return TBAA->getTBAAStructInfo(QTy);
1504 return TBAA->getBaseTypeInfo(QTy);
1510 return TBAA->getAccessTagInfo(Info);
1517 return TBAA->mergeTBAAInfoForCast(SourceInfo,
TargetInfo);
1525 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1533 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1539 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1544 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1557 "cannot compile this %0 yet");
1558 std::string Msg =
Type;
1560 << Msg << S->getSourceRange();
1567 "cannot compile this %0 yet");
1568 std::string Msg =
Type;
1579 if (GV->hasLocalLinkage()) {
1580 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1594 Context.
getLangOpts().OpenMPIsTargetDevice && isa<VarDecl>(
D) &&
1595 D->
hasAttr<OMPDeclareTargetDeclAttr>() &&
1596 D->
getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1597 OMPDeclareTargetDeclAttr::DT_NoHost &&
1599 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1603 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1607 if (GV->hasDLLExportStorageClass()) {
1610 diag::err_hidden_visibility_dllexport);
1613 diag::err_non_default_visibility_dllimport);
1619 !GV->isDeclarationForLinker())
1624 llvm::GlobalValue *GV) {
1625 if (GV->hasLocalLinkage())
1628 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1632 if (GV->hasDLLImportStorageClass())
1635 const llvm::Triple &TT = CGM.
getTriple();
1637 if (TT.isWindowsGNUEnvironment()) {
1646 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1655 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1663 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1667 if (!TT.isOSBinFormatELF())
1673 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1679 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1681 return !(CGM.
getLangOpts().SemanticInterposition ||
1686 if (!GV->isDeclarationForLinker())
1692 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1699 if (CGOpts.DirectAccessExternalData) {
1705 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1706 if (!Var->isThreadLocal())
1715 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1731 const auto *
D = dyn_cast<NamedDecl>(GD.
getDecl());
1733 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(
D)) {
1742 if (
D &&
D->isExternallyVisible()) {
1744 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1745 else if ((
D->
hasAttr<DLLExportAttr>() ||
1747 !GV->isDeclarationForLinker())
1748 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1772 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1773 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1774 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1775 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1776 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1779llvm::GlobalVariable::ThreadLocalMode
1781 switch (CodeGenOpts.getDefaultTLSModel()) {
1783 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1785 return llvm::GlobalVariable::LocalDynamicTLSModel;
1787 return llvm::GlobalVariable::InitialExecTLSModel;
1789 return llvm::GlobalVariable::LocalExecTLSModel;
1791 llvm_unreachable(
"Invalid TLS model!");
1795 assert(
D.getTLSKind() &&
"setting TLS mode on non-TLS var!");
1797 llvm::GlobalValue::ThreadLocalMode TLM;
1801 if (
const TLSModelAttr *
Attr =
D.
getAttr<TLSModelAttr>()) {
1805 GV->setThreadLocalMode(TLM);
1811 return (Twine(
'.') + Twine(
Target.CPUSpecificManglingCharacter(Name))).str();
1815 const CPUSpecificAttr *
Attr,
1837 bool OmitMultiVersionMangling =
false) {
1839 llvm::raw_svector_ostream Out(Buffer);
1848 assert(II &&
"Attempt to mangle unnamed decl.");
1849 const auto *FD = dyn_cast<FunctionDecl>(ND);
1854 Out <<
"__regcall4__" << II->
getName();
1856 Out <<
"__regcall3__" << II->
getName();
1857 }
else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
1859 Out <<
"__device_stub__" << II->
getName();
1875 "Hash computed when not explicitly requested");
1879 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
1880 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1881 switch (FD->getMultiVersionKind()) {
1885 FD->getAttr<CPUSpecificAttr>(),
1889 auto *
Attr = FD->getAttr<TargetAttr>();
1890 assert(
Attr &&
"Expected TargetAttr to be present "
1891 "for attribute mangling");
1897 auto *
Attr = FD->getAttr<TargetVersionAttr>();
1898 assert(
Attr &&
"Expected TargetVersionAttr to be present "
1899 "for attribute mangling");
1905 auto *
Attr = FD->getAttr<TargetClonesAttr>();
1906 assert(
Attr &&
"Expected TargetClonesAttr to be present "
1907 "for attribute mangling");
1914 llvm_unreachable(
"None multiversion type isn't valid here");
1924 return std::string(Out.str());
1927void CodeGenModule::UpdateMultiVersionNames(
GlobalDecl GD,
1929 StringRef &CurName) {
1936 std::string NonTargetName =
1944 "Other GD should now be a multiversioned function");
1954 if (OtherName != NonTargetName) {
1957 const auto ExistingRecord = Manglings.find(NonTargetName);
1958 if (ExistingRecord != std::end(Manglings))
1959 Manglings.remove(&(*ExistingRecord));
1960 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1965 CurName = OtherNameRef;
1967 Entry->setName(OtherName);
1977 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
1991 auto FoundName = MangledDeclNames.find(CanonicalGD);
1992 if (FoundName != MangledDeclNames.end())
1993 return FoundName->second;
1997 const auto *ND = cast<NamedDecl>(GD.
getDecl());
2009 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
2020 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
2021 return MangledDeclNames[CanonicalGD] =
Result.first->first();
2030 llvm::raw_svector_ostream Out(Buffer);
2033 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.
getDecl()), Out);
2034 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(
D))
2036 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(
D))
2041 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
2042 return Result.first->first();
2046 auto it = MangledDeclNames.begin();
2047 while (it != MangledDeclNames.end()) {
2048 if (it->second == Name)
2063 llvm::Constant *AssociatedData) {
2071 bool IsDtorAttrFunc) {
2072 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
2074 DtorsUsingAtExit[
Priority].push_back(Dtor);
2082void CodeGenModule::EmitCtorList(CtorList &Fns,
const char *GlobalName) {
2083 if (Fns.empty())
return;
2086 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(
VoidTy,
false);
2087 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
2088 TheModule.getDataLayout().getProgramAddressSpace());
2091 llvm::StructType *CtorStructTy = llvm::StructType::get(
2096 auto ctors = builder.beginArray(CtorStructTy);
2097 for (
const auto &I : Fns) {
2098 auto ctor = ctors.beginStruct(CtorStructTy);
2099 ctor.addInt(
Int32Ty, I.Priority);
2100 ctor.add(I.Initializer);
2101 if (I.AssociatedData)
2102 ctor.add(I.AssociatedData);
2105 ctor.finishAndAddTo(ctors);
2111 llvm::GlobalValue::AppendingLinkage);
2115 list->setAlignment(std::nullopt);
2120llvm::GlobalValue::LinkageTypes
2122 const auto *
D = cast<FunctionDecl>(GD.
getDecl());
2126 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(
D))
2133 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2134 if (!MDS)
return nullptr;
2136 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
2142 FnType->getReturnType(), FnType->getParamTypes(),
2143 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
2145 std::string OutName;
2146 llvm::raw_string_ostream Out(OutName);
2151 Out <<
".normalized";
2153 return llvm::ConstantInt::get(
Int32Ty,
2154 static_cast<uint32_t
>(llvm::xxHash64(OutName)));
2159 llvm::Function *F,
bool IsThunk) {
2161 llvm::AttributeList PAL;
2164 if (
CallingConv == llvm::CallingConv::X86_VectorCall &&
2170 Error(
Loc,
"__vectorcall calling convention is not currently supported");
2172 F->setAttributes(PAL);
2173 F->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
CallingConv));
2177 std::string ReadOnlyQual(
"__read_only");
2178 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2179 if (ReadOnlyPos != std::string::npos)
2181 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2183 std::string WriteOnlyQual(
"__write_only");
2184 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2185 if (WriteOnlyPos != std::string::npos)
2186 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2188 std::string ReadWriteQual(
"__read_write");
2189 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2190 if (ReadWritePos != std::string::npos)
2191 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2224 assert(((FD && CGF) || (!FD && !CGF)) &&
2225 "Incorrect use - FD and CGF should either be both null or not!");
2251 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
2254 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
2259 std::string typeQuals;
2263 const Decl *PDecl = parm;
2265 PDecl = TD->getDecl();
2266 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
2267 if (A && A->isWriteOnly())
2268 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
2269 else if (A && A->isReadWrite())
2270 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
2272 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
2274 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
2276 auto getTypeSpelling = [&](
QualType Ty) {
2277 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2279 if (Ty.isCanonical()) {
2280 StringRef typeNameRef = typeName;
2282 if (typeNameRef.consume_front(
"unsigned "))
2283 return std::string(
"u") + typeNameRef.str();
2284 if (typeNameRef.consume_front(
"signed "))
2285 return typeNameRef.str();
2295 addressQuals.push_back(
2296 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
2300 std::string typeName = getTypeSpelling(pointeeTy) +
"*";
2301 std::string baseTypeName =
2303 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2304 argBaseTypeNames.push_back(
2305 llvm::MDString::get(VMContext, baseTypeName));
2309 typeQuals =
"restrict";
2312 typeQuals += typeQuals.empty() ?
"const" :
" const";
2314 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
2316 uint32_t AddrSpc = 0;
2321 addressQuals.push_back(
2322 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
2326 std::string typeName = getTypeSpelling(ty);
2338 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2339 argBaseTypeNames.push_back(
2340 llvm::MDString::get(VMContext, baseTypeName));
2345 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2349 Fn->setMetadata(
"kernel_arg_addr_space",
2350 llvm::MDNode::get(VMContext, addressQuals));
2351 Fn->setMetadata(
"kernel_arg_access_qual",
2352 llvm::MDNode::get(VMContext, accessQuals));
2353 Fn->setMetadata(
"kernel_arg_type",
2354 llvm::MDNode::get(VMContext, argTypeNames));
2355 Fn->setMetadata(
"kernel_arg_base_type",
2356 llvm::MDNode::get(VMContext, argBaseTypeNames));
2357 Fn->setMetadata(
"kernel_arg_type_qual",
2358 llvm::MDNode::get(VMContext, argTypeQuals));
2362 Fn->setMetadata(
"kernel_arg_name",
2363 llvm::MDNode::get(VMContext, argNames));
2373 if (!LangOpts.Exceptions)
return false;
2376 if (LangOpts.CXXExceptions)
return true;
2379 if (LangOpts.ObjCExceptions) {
2396 !isa<CXXConstructorDecl, CXXDestructorDecl>(MD);
2401 llvm::SetVector<const CXXRecordDecl *> MostBases;
2403 std::function<void (
const CXXRecordDecl *)> CollectMostBases;
2406 MostBases.insert(RD);
2408 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2410 CollectMostBases(RD);
2411 return MostBases.takeVector();
2415 llvm::Function *F) {
2416 llvm::AttrBuilder B(F->getContext());
2418 if ((!
D || !
D->
hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2419 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2421 if (CodeGenOpts.StackClashProtector)
2422 B.addAttribute(
"probe-stack",
"inline-asm");
2424 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2425 B.addAttribute(
"stack-probe-size",
2426 std::to_string(CodeGenOpts.StackProbeSize));
2429 B.addAttribute(llvm::Attribute::NoUnwind);
2431 if (
D &&
D->
hasAttr<NoStackProtectorAttr>())
2433 else if (
D &&
D->
hasAttr<StrictGuardStackCheckAttr>() &&
2435 B.addAttribute(llvm::Attribute::StackProtectStrong);
2437 B.addAttribute(llvm::Attribute::StackProtect);
2439 B.addAttribute(llvm::Attribute::StackProtectStrong);
2441 B.addAttribute(llvm::Attribute::StackProtectReq);
2447 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2449 B.addAttribute(llvm::Attribute::NoInline);
2457 if (
D->
hasAttr<ArmLocallyStreamingAttr>())
2458 B.addAttribute(
"aarch64_pstate_sm_body");
2461 if (
Attr->isNewZA())
2462 B.addAttribute(
"aarch64_new_za");
2463 if (
Attr->isNewZT0())
2464 B.addAttribute(
"aarch64_new_zt0");
2469 bool ShouldAddOptNone =
2470 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2472 ShouldAddOptNone &= !
D->
hasAttr<MinSizeAttr>();
2473 ShouldAddOptNone &= !
D->
hasAttr<AlwaysInlineAttr>();
2476 if ((ShouldAddOptNone ||
D->
hasAttr<OptimizeNoneAttr>()) &&
2477 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2478 B.addAttribute(llvm::Attribute::OptimizeNone);
2481 B.addAttribute(llvm::Attribute::NoInline);
2486 B.addAttribute(llvm::Attribute::Naked);
2489 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2490 F->removeFnAttr(llvm::Attribute::MinSize);
2491 }
else if (
D->
hasAttr<NakedAttr>()) {
2493 B.addAttribute(llvm::Attribute::Naked);
2494 B.addAttribute(llvm::Attribute::NoInline);
2495 }
else if (
D->
hasAttr<NoDuplicateAttr>()) {
2496 B.addAttribute(llvm::Attribute::NoDuplicate);
2497 }
else if (
D->
hasAttr<NoInlineAttr>() && !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2499 B.addAttribute(llvm::Attribute::NoInline);
2500 }
else if (
D->
hasAttr<AlwaysInlineAttr>() &&
2501 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2503 B.addAttribute(llvm::Attribute::AlwaysInline);
2507 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2508 B.addAttribute(llvm::Attribute::NoInline);
2512 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
2515 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
2516 return Redecl->isInlineSpecified();
2518 if (any_of(FD->
redecls(), CheckRedeclForInline))
2523 return any_of(Pattern->
redecls(), CheckRedeclForInline);
2525 if (CheckForInline(FD)) {
2526 B.addAttribute(llvm::Attribute::InlineHint);
2527 }
else if (CodeGenOpts.getInlining() ==
2530 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2531 B.addAttribute(llvm::Attribute::NoInline);
2538 if (!
D->
hasAttr<OptimizeNoneAttr>()) {
2540 if (!ShouldAddOptNone)
2541 B.addAttribute(llvm::Attribute::OptimizeForSize);
2542 B.addAttribute(llvm::Attribute::Cold);
2545 B.addAttribute(llvm::Attribute::Hot);
2547 B.addAttribute(llvm::Attribute::MinSize);
2554 F->setAlignment(llvm::Align(alignment));
2557 if (LangOpts.FunctionAlignment)
2558 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2565 if (isa<CXXMethodDecl>(
D) && F->getPointerAlignment(
getDataLayout()) < 2)
2566 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2571 if (CodeGenOpts.SanitizeCfiCrossDso &&
2572 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2573 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
2584 auto *MD = dyn_cast<CXXMethodDecl>(
D);
2587 llvm::Metadata *
Id =
2590 F->addTypeMetadata(0,
Id);
2597 if (isa_and_nonnull<NamedDecl>(
D))
2600 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2605 if (
const auto *VD = dyn_cast_if_present<VarDecl>(
D);
2607 ((CodeGenOpts.KeepPersistentStorageVariables &&
2608 (VD->getStorageDuration() ==
SD_Static ||
2609 VD->getStorageDuration() ==
SD_Thread)) ||
2610 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
2611 VD->getType().isConstQualified())))
2615bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
2616 llvm::AttrBuilder &Attrs,
2617 bool SetTargetFeatures) {
2623 std::vector<std::string> Features;
2624 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
2626 const auto *TD = FD ? FD->
getAttr<TargetAttr>() :
nullptr;
2627 const auto *TV = FD ? FD->
getAttr<TargetVersionAttr>() :
nullptr;
2628 assert((!TD || !TV) &&
"both target_version and target specified");
2629 const auto *SD = FD ? FD->
getAttr<CPUSpecificAttr>() :
nullptr;
2630 const auto *TC = FD ? FD->
getAttr<TargetClonesAttr>() :
nullptr;
2631 bool AddedAttr =
false;
2632 if (TD || TV || SD || TC) {
2633 llvm::StringMap<bool> FeatureMap;
2637 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2638 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
2646 Target.parseTargetAttr(TD->getFeaturesStr());
2668 if (!TargetCPU.empty()) {
2669 Attrs.addAttribute(
"target-cpu", TargetCPU);
2672 if (!TuneCPU.empty()) {
2673 Attrs.addAttribute(
"tune-cpu", TuneCPU);
2676 if (!Features.empty() && SetTargetFeatures) {
2677 llvm::erase_if(Features, [&](
const std::string& F) {
2680 llvm::sort(Features);
2681 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
2688void CodeGenModule::setNonAliasAttributes(
GlobalDecl GD,
2689 llvm::GlobalObject *GO) {
2694 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
2697 if (
auto *SA =
D->
getAttr<PragmaClangBSSSectionAttr>())
2698 GV->addAttribute(
"bss-section", SA->getName());
2699 if (
auto *SA =
D->
getAttr<PragmaClangDataSectionAttr>())
2700 GV->addAttribute(
"data-section", SA->getName());
2701 if (
auto *SA =
D->
getAttr<PragmaClangRodataSectionAttr>())
2702 GV->addAttribute(
"rodata-section", SA->getName());
2703 if (
auto *SA =
D->
getAttr<PragmaClangRelroSectionAttr>())
2704 GV->addAttribute(
"relro-section", SA->getName());
2707 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
2710 if (
auto *SA =
D->
getAttr<PragmaClangTextSectionAttr>())
2712 F->setSection(SA->getName());
2714 llvm::AttrBuilder Attrs(F->getContext());
2715 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
2719 llvm::AttributeMask RemoveAttrs;
2720 RemoveAttrs.addAttribute(
"target-cpu");
2721 RemoveAttrs.addAttribute(
"target-features");
2722 RemoveAttrs.addAttribute(
"tune-cpu");
2723 F->removeFnAttrs(RemoveAttrs);
2724 F->addFnAttrs(Attrs);
2728 if (
const auto *CSA =
D->
getAttr<CodeSegAttr>())
2729 GO->setSection(CSA->getName());
2730 else if (
const auto *SA =
D->
getAttr<SectionAttr>())
2731 GO->setSection(SA->getName());
2744 F->setLinkage(llvm::Function::InternalLinkage);
2746 setNonAliasAttributes(GD, F);
2757 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2761 llvm::Function *F) {
2763 if (!LangOpts.
Sanitize.
has(SanitizerKind::CFIICall))
2768 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2772 F->addTypeMetadata(0, MD);
2776 if (CodeGenOpts.SanitizeCfiCrossDso)
2778 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
2782 llvm::LLVMContext &Ctx = F->getContext();
2783 llvm::MDBuilder MDB(Ctx);
2784 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
2793 return llvm::all_of(Name, [](
const char &
C) {
2794 return llvm::isAlnum(
C) ||
C ==
'_' ||
C ==
'.';
2800 for (
auto &F : M.functions()) {
2802 bool AddressTaken = F.hasAddressTaken();
2803 if (!AddressTaken && F.hasLocalLinkage())
2804 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
2809 if (!AddressTaken || !F.isDeclaration())
2812 const llvm::ConstantInt *
Type;
2813 if (
const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
2814 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
2818 StringRef Name = F.getName();
2822 std::string
Asm = (
".weak __kcfi_typeid_" + Name +
"\n.set __kcfi_typeid_" +
2823 Name +
", " + Twine(
Type->getZExtValue()) +
"\n")
2825 M.appendModuleInlineAsm(
Asm);
2829void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
2830 bool IsIncompleteFunction,
2833 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
2836 F->setAttributes(llvm::Intrinsic::getAttributes(
getLLVMContext(), IID));
2840 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2842 if (!IsIncompleteFunction)
2849 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
2851 assert(!F->arg_empty() &&
2852 F->arg_begin()->getType()
2853 ->canLosslesslyBitCastTo(F->getReturnType()) &&
2854 "unexpected this return");
2855 F->addParamAttr(0, llvm::Attribute::Returned);
2865 if (!IsIncompleteFunction && F->isDeclaration())
2868 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
2869 F->setSection(CSA->getName());
2870 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
2871 F->setSection(SA->getName());
2873 if (
const auto *EA = FD->
getAttr<ErrorAttr>()) {
2875 F->addFnAttr(
"dontcall-error", EA->getUserDiagnostic());
2876 else if (EA->isWarning())
2877 F->addFnAttr(
"dontcall-warn", EA->getUserDiagnostic());
2883 bool HasBody = FD->
hasBody(FDBody);
2885 assert(HasBody &&
"Inline builtin declarations should always have an "
2887 if (shouldEmitFunction(FDBody))
2888 F->addFnAttr(llvm::Attribute::NoBuiltin);
2894 F->addFnAttr(llvm::Attribute::NoBuiltin);
2897 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
2898 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2899 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
2900 if (MD->isVirtual())
2901 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2907 if (!CodeGenOpts.SanitizeCfiCrossDso ||
2908 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
2917 if (CodeGenOpts.InlineMaxStackSize !=
UINT_MAX)
2918 F->addFnAttr(
"inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
2920 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
2924 llvm::LLVMContext &Ctx = F->getContext();
2925 llvm::MDBuilder MDB(Ctx);
2929 int CalleeIdx = *CB->encoding_begin();
2930 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
2931 F->addMetadata(llvm::LLVMContext::MD_callback,
2932 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
2933 CalleeIdx, PayloadIndices,
2939 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2940 "Only globals with definition can force usage.");
2941 LLVMUsed.emplace_back(GV);
2945 assert(!GV->isDeclaration() &&
2946 "Only globals with definition can force usage.");
2947 LLVMCompilerUsed.emplace_back(GV);
2951 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2952 "Only globals with definition can force usage.");
2954 LLVMCompilerUsed.emplace_back(GV);
2956 LLVMUsed.emplace_back(GV);
2960 std::vector<llvm::WeakTrackingVH> &List) {
2967 UsedArray.resize(List.size());
2968 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
2970 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
2971 cast<llvm::Constant>(&*List[i]), CGM.
Int8PtrTy);
2974 if (UsedArray.empty())
2976 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
2978 auto *GV =
new llvm::GlobalVariable(
2979 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
2980 llvm::ConstantArray::get(ATy, UsedArray), Name);
2982 GV->setSection(
"llvm.metadata");
2985void CodeGenModule::emitLLVMUsed() {
2986 emitUsed(*
this,
"llvm.used", LLVMUsed);
2987 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
2992 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
3001 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
3007 ELFDependentLibraries.push_back(
3008 llvm::MDNode::get(
C, llvm::MDString::get(
C, Lib)));
3015 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
C, MDOpts));
3030 if (
Visited.insert(Import).second)
3047 if (LL.IsFramework) {
3048 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
3049 llvm::MDString::get(Context, LL.Library)};
3051 Metadata.push_back(llvm::MDNode::get(Context, Args));
3057 llvm::Metadata *Args[2] = {
3058 llvm::MDString::get(Context,
"lib"),
3059 llvm::MDString::get(Context, LL.Library),
3061 Metadata.push_back(llvm::MDNode::get(Context, Args));
3065 auto *OptString = llvm::MDString::get(Context, Opt);
3066 Metadata.push_back(llvm::MDNode::get(Context, OptString));
3071void CodeGenModule::EmitModuleInitializers(
clang::Module *Primary) {
3073 "We should only emit module initializers for named modules.");
3079 if (isa<ImportDecl>(
D))
3081 assert(isa<VarDecl>(
D) &&
"GMF initializer decl is not a var?");
3088 if (isa<ImportDecl>(
D))
3096 if (isa<ImportDecl>(
D))
3098 assert(isa<VarDecl>(
D) &&
"PMF initializer decl is not a var?");
3104void CodeGenModule::EmitModuleLinkOptions() {
3108 llvm::SetVector<clang::Module *> LinkModules;
3113 for (
Module *M : ImportedModules) {
3116 if (M->getTopLevelModuleName() ==
getLangOpts().CurrentModule &&
3125 while (!Stack.empty()) {
3128 bool AnyChildren =
false;
3138 Stack.push_back(
SM);
3146 LinkModules.insert(Mod);
3155 for (
Module *M : LinkModules)
3158 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3159 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3162 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
3163 for (
auto *MD : LinkerOptionsMetadata)
3164 NMD->addOperand(MD);
3167void CodeGenModule::EmitDeferred() {
3176 if (!DeferredVTables.empty()) {
3177 EmitDeferredVTables();
3182 assert(DeferredVTables.empty());
3189 llvm::append_range(DeferredDeclsToEmit,
3193 if (DeferredDeclsToEmit.empty())
3198 std::vector<GlobalDecl> CurDeclsToEmit;
3199 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3206 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3224 if (!GV->isDeclaration())
3228 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(
D))
3232 EmitGlobalDefinition(
D, GV);
3237 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3239 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3244void CodeGenModule::EmitVTablesOpportunistically() {
3250 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3251 &&
"Only emit opportunistic vtables with optimizations");
3255 "This queue should only contain external vtables");
3256 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
3259 OpportunisticVTables.clear();
3263 for (
const auto& [MangledName, VD] : DeferredAnnotations) {
3268 DeferredAnnotations.clear();
3270 if (Annotations.empty())
3274 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3275 Annotations[0]->getType(), Annotations.size()), Annotations);
3276 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
3277 llvm::GlobalValue::AppendingLinkage,
3278 Array,
"llvm.global.annotations");
3283 llvm::Constant *&AStr = AnnotationStrings[Str];
3288 llvm::Constant *
s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
3289 auto *gv =
new llvm::GlobalVariable(
3290 getModule(),
s->getType(),
true, llvm::GlobalValue::PrivateLinkage,
s,
3291 ".str",
nullptr, llvm::GlobalValue::NotThreadLocal,
3294 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3311 SM.getExpansionLineNumber(L);
3312 return llvm::ConstantInt::get(
Int32Ty, LineNo);
3320 llvm::FoldingSetNodeID ID;
3321 for (
Expr *
E : Exprs) {
3322 ID.Add(cast<clang::ConstantExpr>(
E)->getAPValueResult());
3324 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3329 LLVMArgs.reserve(Exprs.size());
3331 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](
const Expr *
E) {
3332 const auto *CE = cast<clang::ConstantExpr>(
E);
3333 return ConstEmiter.
emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3336 auto *
Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3337 auto *GV =
new llvm::GlobalVariable(
getModule(),
Struct->getType(),
true,
3338 llvm::GlobalValue::PrivateLinkage,
Struct,
3341 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3348 const AnnotateAttr *AA,
3356 llvm::Constant *GVInGlobalsAS = GV;
3357 if (GV->getAddressSpace() !=
3359 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3361 llvm::PointerType::get(
3362 GV->getContext(),
getDataLayout().getDefaultGlobalsAddressSpace()));
3366 llvm::Constant *Fields[] = {
3367 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3369 return llvm::ConstantStruct::getAnon(Fields);
3373 llvm::GlobalValue *GV) {
3374 assert(
D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
3384 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3389 if (NoSanitizeL.containsMainFile(Kind, MainFile.
getName()))
3394 return NoSanitizeL.containsLocation(Kind,
Loc);
3397 return NoSanitizeL.containsFile(Kind, MainFile.
getName());
3401 llvm::GlobalVariable *GV,
3405 if (NoSanitizeL.containsGlobal(Kind, GV->getName(),
Category))
3408 if (NoSanitizeL.containsMainFile(
3409 Kind,
SM.getFileEntryRefForID(
SM.getMainFileID())->getName(),
3412 if (NoSanitizeL.containsLocation(Kind,
Loc,
Category))
3419 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
3420 Ty = AT->getElementType();
3425 if (NoSanitizeL.containsType(Kind, TypeStr,
Category))
3436 auto Attr = ImbueAttr::NONE;
3439 if (
Attr == ImbueAttr::NONE)
3440 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3442 case ImbueAttr::NONE:
3444 case ImbueAttr::ALWAYS:
3445 Fn->addFnAttr(
"function-instrument",
"xray-always");
3447 case ImbueAttr::ALWAYS_ARG1:
3448 Fn->addFnAttr(
"function-instrument",
"xray-always");
3449 Fn->addFnAttr(
"xray-log-args",
"1");
3451 case ImbueAttr::NEVER:
3452 Fn->addFnAttr(
"function-instrument",
"xray-never");
3476 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID()))
3490 if (NumGroups > 1) {
3491 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3500 if (LangOpts.EmitAllDecls)
3503 const auto *VD = dyn_cast<VarDecl>(
Global);
3505 ((CodeGenOpts.KeepPersistentStorageVariables &&
3506 (VD->getStorageDuration() ==
SD_Static ||
3507 VD->getStorageDuration() ==
SD_Thread)) ||
3508 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
3509 VD->getType().isConstQualified())))
3522 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3523 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3524 OMPDeclareTargetDeclAttr::getActiveAttr(
Global);
3525 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (
unsigned)-1)
3529 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3538 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
3544 if (CXX20ModuleInits && VD->getOwningModule() &&
3545 !VD->getOwningModule()->isModuleMapModule()) {
3554 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3557 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Global))
3570 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3574 llvm::Constant *
Init;
3577 if (!
V.isAbsent()) {
3588 llvm::Constant *Fields[4] = {
3592 llvm::ConstantDataArray::getRaw(
3593 StringRef(
reinterpret_cast<char *
>(Parts.
Part4And5), 8), 8,
3595 Init = llvm::ConstantStruct::getAnon(Fields);
3598 auto *GV =
new llvm::GlobalVariable(
3600 true, llvm::GlobalValue::LinkOnceODRLinkage,
Init, Name);
3602 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3605 if (!
V.isAbsent()) {
3618 llvm::GlobalVariable **Entry =
nullptr;
3619 Entry = &UnnamedGlobalConstantDeclMap[GCD];
3624 llvm::Constant *
Init;
3628 assert(!
V.isAbsent());
3632 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3634 llvm::GlobalValue::PrivateLinkage,
Init,
3636 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3650 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3654 llvm::Constant *
Init =
Emitter.emitForInitializer(
3662 llvm::GlobalValue::LinkageTypes
Linkage =
3664 ? llvm::GlobalValue::LinkOnceODRLinkage
3665 : llvm::GlobalValue::InternalLinkage;
3666 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3670 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3677 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
3678 assert(AA &&
"No alias?");
3688 llvm::Constant *Aliasee;
3689 if (isa<llvm::FunctionType>(DeclTy))
3690 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
3697 auto *F = cast<llvm::GlobalValue>(Aliasee);
3698 F->setLinkage(llvm::Function::ExternalWeakLinkage);
3699 WeakRefReferences.insert(F);
3708 return A->isImplicit();
3712bool CodeGenModule::shouldEmitCUDAGlobalVar(
const VarDecl *
Global)
const {
3713 assert(LangOpts.CUDA &&
"Should not be called by non-CUDA languages");
3718 return !LangOpts.CUDAIsDevice ||
Global->hasAttr<CUDADeviceAttr>() ||
3719 Global->hasAttr<CUDAConstantAttr>() ||
3720 Global->hasAttr<CUDASharedAttr>() ||
3721 Global->getType()->isCUDADeviceBuiltinSurfaceType() ||
3722 Global->getType()->isCUDADeviceBuiltinTextureType();
3729 if (
Global->hasAttr<WeakRefAttr>())
3734 if (
Global->hasAttr<AliasAttr>())
3735 return EmitAliasDefinition(GD);
3738 if (
Global->hasAttr<IFuncAttr>())
3739 return emitIFuncDefinition(GD);
3742 if (
Global->hasAttr<CPUDispatchAttr>())
3743 return emitCPUDispatchDefinition(GD);
3748 if (LangOpts.CUDA) {
3749 assert((isa<FunctionDecl>(
Global) || isa<VarDecl>(
Global)) &&
3750 "Expected Variable or Function");
3751 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
3752 if (!shouldEmitCUDAGlobalVar(VD))
3754 }
else if (LangOpts.CUDAIsDevice) {
3755 const auto *FD = dyn_cast<FunctionDecl>(
Global);
3756 if ((!
Global->hasAttr<CUDADeviceAttr>() ||
3757 (LangOpts.OffloadImplicitHostDeviceTemplates &&
3758 hasImplicitAttr<CUDAHostAttr>(FD) &&
3759 hasImplicitAttr<CUDADeviceAttr>(FD) && !FD->
isConstexpr() &&
3761 !
getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
3762 !
Global->hasAttr<CUDAGlobalAttr>() &&
3763 !(LangOpts.HIPStdPar && isa<FunctionDecl>(
Global) &&
3764 !
Global->hasAttr<CUDAHostAttr>()))
3767 }
else if (!
Global->hasAttr<CUDAHostAttr>() &&
3768 Global->hasAttr<CUDADeviceAttr>())
3772 if (LangOpts.OpenMP) {
3774 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
3776 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
Global)) {
3777 if (MustBeEmitted(
Global))
3781 if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(
Global)) {
3782 if (MustBeEmitted(
Global))
3789 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3792 if (FD->
hasAttr<AnnotateAttr>()) {
3795 DeferredAnnotations[MangledName] = FD;
3810 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
3815 const auto *VD = cast<VarDecl>(
Global);
3816 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
3819 if (LangOpts.OpenMP) {
3821 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3822 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
3826 if (VD->hasExternalStorage() &&
3827 Res != OMPDeclareTargetDeclAttr::MT_Link)
3830 bool UnifiedMemoryEnabled =
3832 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3833 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3834 !UnifiedMemoryEnabled) {
3837 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3838 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3839 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3840 UnifiedMemoryEnabled)) &&
3841 "Link clause or to clause with unified memory expected.");
3860 if (MustBeEmitted(
Global) && MayBeEmittedEagerly(
Global)) {
3862 EmitGlobalDefinition(GD);
3863 addEmittedDeferredDecl(GD);
3870 cast<VarDecl>(
Global)->hasInit()) {
3871 DelayedCXXInitPosition[
Global] = CXXGlobalInits.size();
3872 CXXGlobalInits.push_back(
nullptr);
3878 addDeferredDeclToEmit(GD);
3879 }
else if (MustBeEmitted(
Global)) {
3881 assert(!MayBeEmittedEagerly(
Global));
3882 addDeferredDeclToEmit(GD);
3887 DeferredDecls[MangledName] = GD;
3894 if (
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
3895 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
3902 struct FunctionIsDirectlyRecursive
3904 const StringRef Name;
3914 if (
Attr && Name ==
Attr->getLabel())
3919 StringRef BuiltinName = BI.
getName(BuiltinID);
3920 if (BuiltinName.starts_with(
"__builtin_") &&
3921 Name == BuiltinName.slice(strlen(
"__builtin_"), StringRef::npos)) {
3927 bool VisitStmt(
const Stmt *S) {
3928 for (
const Stmt *Child : S->children())
3929 if (Child && this->Visit(Child))
3936 struct DLLImportFunctionVisitor
3938 bool SafeToInline =
true;
3940 bool shouldVisitImplicitCode()
const {
return true; }
3942 bool VisitVarDecl(
VarDecl *VD) {
3945 SafeToInline =
false;
3946 return SafeToInline;
3953 return SafeToInline;
3957 if (
const auto *
D =
E->getTemporary()->getDestructor())
3958 SafeToInline =
D->
hasAttr<DLLImportAttr>();
3959 return SafeToInline;
3964 if (isa<FunctionDecl>(VD))
3965 SafeToInline = VD->
hasAttr<DLLImportAttr>();
3966 else if (
VarDecl *
V = dyn_cast<VarDecl>(VD))
3967 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
3968 return SafeToInline;
3972 SafeToInline =
E->getConstructor()->hasAttr<DLLImportAttr>();
3973 return SafeToInline;
3980 SafeToInline =
true;
3982 SafeToInline = M->
hasAttr<DLLImportAttr>();
3984 return SafeToInline;
3988 SafeToInline =
E->getOperatorDelete()->hasAttr<DLLImportAttr>();
3989 return SafeToInline;
3993 SafeToInline =
E->getOperatorNew()->hasAttr<DLLImportAttr>();
3994 return SafeToInline;
4003CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
4005 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
4010 Name =
Attr->getLabel();
4015 FunctionIsDirectlyRecursive Walker(Name, Context.
BuiltinInfo);
4017 return Body ? Walker.Visit(Body) :
false;
4020bool CodeGenModule::shouldEmitFunction(
GlobalDecl GD) {
4024 const auto *F = cast<FunctionDecl>(GD.
getDecl());
4025 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
4030 if (
const Module *M = F->getOwningModule();
4031 M && M->getTopLevelModule()->isNamedModule() &&
4032 getContext().getCurrentNamedModule() != M->getTopLevelModule()) {
4042 if (!F->isTemplateInstantiation() || !F->hasAttr<AlwaysInlineAttr>()) {
4047 if (F->hasAttr<NoInlineAttr>())
4050 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
4052 DLLImportFunctionVisitor Visitor;
4053 Visitor.TraverseFunctionDecl(
const_cast<FunctionDecl*
>(F));
4054 if (!Visitor.SafeToInline)
4060 for (
const Decl *
Member : Dtor->getParent()->decls())
4061 if (isa<FieldDecl>(
Member))
4072 if (F->isInlineBuiltinDeclaration())
4080 return !isTriviallyRecursive(F);
4083bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
4084 return CodeGenOpts.OptimizationLevel > 0;
4087void CodeGenModule::EmitMultiVersionFunctionDefinition(
GlobalDecl GD,
4088 llvm::GlobalValue *GV) {
4089 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4092 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
4093 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
4095 }
else if (
auto *TC = FD->
getAttr<TargetClonesAttr>()) {
4096 for (
unsigned I = 0; I < TC->featuresStrs_size(); ++I)
4099 TC->isFirstOfVersion(I))
4102 GetOrCreateMultiVersionResolver(GD);
4104 EmitGlobalFunctionDefinition(GD, GV);
4109 AddDeferredMultiVersionResolverToEmit(GD);
4112void CodeGenModule::EmitGlobalDefinition(
GlobalDecl GD, llvm::GlobalValue *GV) {
4113 const auto *
D = cast<ValueDecl>(GD.
getDecl());
4117 "Generating code for declaration");
4119 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
4122 if (!shouldEmitFunction(GD))
4125 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
4127 llvm::raw_string_ostream OS(Name);
4133 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
D)) {
4136 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
4137 ABI->emitCXXStructor(GD);
4139 EmitMultiVersionFunctionDefinition(GD, GV);
4141 EmitGlobalFunctionDefinition(GD, GV);
4143 if (Method->isVirtual())
4150 return EmitMultiVersionFunctionDefinition(GD, GV);
4151 return EmitGlobalFunctionDefinition(GD, GV);
4154 if (
const auto *VD = dyn_cast<VarDecl>(
D))
4155 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4157 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
4161 llvm::Function *NewFn);
4165 const CodeGenFunction::MultiVersionResolverOption &RO) {
4167 unsigned NumFeatures = 0;
4168 for (StringRef Feat : RO.Conditions.Features) {
4173 if (!RO.Conditions.Architecture.empty())
4191 return llvm::GlobalValue::InternalLinkage;
4192 return llvm::GlobalValue::WeakODRLinkage;
4195void CodeGenModule::emitMultiVersionFunctions() {
4196 std::vector<GlobalDecl> MVFuncsToEmit;
4197 MultiVersionFuncs.swap(MVFuncsToEmit);
4199 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4200 assert(FD &&
"Expected a FunctionDecl");
4207 if (
Decl->isDefined()) {
4208 EmitGlobalFunctionDefinition(CurGD,
nullptr);
4216 assert(
Func &&
"This should have just been created");
4218 return cast<llvm::Function>(
Func);
4232 if (
const auto *TA = CurFD->
getAttr<TargetAttr>()) {
4233 TA->getAddedFeatures(Feats);
4234 llvm::Function *Func = createFunction(CurFD);
4235 Options.emplace_back(Func, TA->getArchitecture(), Feats);
4236 }
else if (
const auto *TVA = CurFD->
getAttr<TargetVersionAttr>()) {
4237 if (TVA->isDefaultVersion() && IsDefined)
4238 ShouldEmitResolver = true;
4239 TVA->getFeatures(Feats);
4240 llvm::Function *Func = createFunction(CurFD);
4241 Options.emplace_back(Func,
"", Feats);
4242 }
else if (
const auto *TC = CurFD->
getAttr<TargetClonesAttr>()) {
4244 ShouldEmitResolver = true;
4245 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I) {
4246 if (!TC->isFirstOfVersion(I))
4249 llvm::Function *Func = createFunction(CurFD, I);
4250 StringRef Architecture;
4252 if (getTarget().getTriple().isAArch64())
4253 TC->getFeatures(Feats, I);
4255 StringRef Version = TC->getFeatureStr(I);
4256 if (Version.starts_with(
"arch="))
4257 Architecture = Version.drop_front(sizeof(
"arch=") - 1);
4258 else if (Version !=
"default")
4259 Feats.push_back(Version);
4261 Options.emplace_back(Func, Architecture, Feats);
4264 llvm_unreachable(
"unexpected MultiVersionKind");
4267 if (!ShouldEmitResolver)
4270 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4271 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4272 ResolverConstant = IFunc->getResolver();
4276 *
this, GD, FD,
true);
4283 auto *Alias = llvm::GlobalAlias::create(
4285 MangledName +
".ifunc", IFunc, &
getModule());
4290 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
4295 ResolverFunc->setComdat(
4296 getModule().getOrInsertComdat(ResolverFunc->getName()));
4300 Options, [&TI](
const CodeGenFunction::MultiVersionResolverOption &LHS,
4301 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4305 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4311 if (!MVFuncsToEmit.empty())
4316 if (!MultiVersionFuncs.empty())
4317 emitMultiVersionFunctions();
4321 llvm::Constant *New) {
4322 assert(cast<llvm::Function>(Old)->isDeclaration() &&
"Not a declaration");
4324 Old->replaceAllUsesWith(New);
4325 Old->eraseFromParent();
4328void CodeGenModule::emitCPUDispatchDefinition(
GlobalDecl GD) {
4329 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4330 assert(FD &&
"Not a FunctionDecl?");
4332 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
4333 assert(DD &&
"Not a cpu_dispatch Function?");
4339 UpdateMultiVersionNames(GD, FD, ResolverName);
4341 llvm::Type *ResolverType;
4344 ResolverType = llvm::FunctionType::get(
4345 llvm::PointerType::get(DeclTy,
4354 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
4355 ResolverName, ResolverType, ResolverGD,
false));
4358 ResolverFunc->setComdat(
4359 getModule().getOrInsertComdat(ResolverFunc->getName()));
4372 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4375 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
4381 Func = GetOrCreateLLVMFunction(
4382 MangledName, DeclTy, ExistingDecl,
4389 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4390 llvm::transform(Features, Features.begin(),
4391 [](StringRef Str) { return Str.substr(1); });
4392 llvm::erase_if(Features, [&
Target](StringRef Feat) {
4393 return !
Target.validateCpuSupports(Feat);
4395 Options.emplace_back(cast<llvm::Function>(
Func), StringRef{}, Features);
4400 Options, [](
const CodeGenFunction::MultiVersionResolverOption &LHS,
4401 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4402 return llvm::X86::getCpuSupportsMask(LHS.Conditions.Features) >
4403 llvm::X86::getCpuSupportsMask(RHS.Conditions.Features);
4410 while (Options.size() > 1 &&
4411 llvm::all_of(llvm::X86::getCpuSupportsMask(
4412 (Options.end() - 2)->Conditions.Features),
4413 [](
auto X) { return X == 0; })) {
4414 StringRef LHSName = (Options.end() - 2)->
Function->getName();
4415 StringRef RHSName = (Options.end() - 1)->
Function->getName();
4416 if (LHSName.compare(RHSName) < 0)
4417 Options.erase(Options.end() - 2);
4419 Options.erase(Options.end() - 1);
4423 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4427 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
4431 if (!isa<llvm::GlobalIFunc>(IFunc)) {
4432 auto *GI = llvm::GlobalIFunc::create(DeclTy, 0,
Linkage,
"", ResolverFunc,
4439 *
this, GD, FD,
true);
4442 auto *GA = llvm::GlobalAlias::create(DeclTy, 0,
Linkage, AliasName, IFunc,
4450void CodeGenModule::AddDeferredMultiVersionResolverToEmit(
GlobalDecl GD) {
4451 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4452 assert(FD &&
"Not a FunctionDecl?");
4455 std::string MangledName =
4457 if (!DeferredResolversToEmit.insert(MangledName).second)
4460 MultiVersionFuncs.push_back(GD);
4466llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
GlobalDecl GD) {
4467 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4468 assert(FD &&
"Not a FunctionDecl?");
4470 std::string MangledName =
4475 std::string ResolverName = MangledName;
4479 llvm_unreachable(
"unexpected MultiVersionKind::None for resolver");
4483 ResolverName +=
".ifunc";
4490 ResolverName +=
".resolver";
4501 (isa<llvm::GlobalIFunc>(ResolverGV) || !
getTarget().supportsIFunc()))
4510 AddDeferredMultiVersionResolverToEmit(GD);
4515 llvm::Type *ResolverType = llvm::FunctionType::get(
4516 llvm::PointerType::get(DeclTy,
4519 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4520 MangledName +
".resolver", ResolverType,
GlobalDecl{},
4522 llvm::GlobalIFunc *GIF =
4525 GIF->setName(ResolverName);
4532 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4534 assert(isa<llvm::GlobalValue>(Resolver) &&
4535 "Resolver should be created for the first time");
4542bool CodeGenModule::shouldDropDLLAttribute(
const Decl *
D,
4543 const llvm::GlobalValue *GV)
const {
4544 auto SC = GV->getDLLStorageClass();
4545 if (SC == llvm::GlobalValue::DefaultStorageClass)
4548 return (((SC == llvm::GlobalValue::DLLImportStorageClass &&
4549 !MRD->
hasAttr<DLLImportAttr>()) ||
4550 (SC == llvm::GlobalValue::DLLExportStorageClass &&
4551 !MRD->
hasAttr<DLLExportAttr>())) &&
4562llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4563 StringRef MangledName, llvm::Type *Ty,
GlobalDecl GD,
bool ForVTable,
4564 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
4568 std::string NameWithoutMultiVersionMangling;
4571 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(
D)) {
4573 if (
getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4574 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
4575 !DontDefer && !IsForDefinition) {
4578 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4580 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4589 UpdateMultiVersionNames(GD, FD, MangledName);
4590 if (!IsForDefinition) {
4596 AddDeferredMultiVersionResolverToEmit(GD);
4598 *
this, GD, FD,
true);
4600 return GetOrCreateMultiVersionResolver(GD);
4605 if (!NameWithoutMultiVersionMangling.empty())
4606 MangledName = NameWithoutMultiVersionMangling;
4611 if (WeakRefReferences.erase(Entry)) {
4613 if (FD && !FD->
hasAttr<WeakAttr>())
4614 Entry->setLinkage(llvm::Function::ExternalLinkage);
4618 if (
D && shouldDropDLLAttribute(
D, Entry)) {
4619 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4625 if (IsForDefinition && !Entry->isDeclaration()) {
4632 DiagnosedConflictingDefinitions.insert(GD).second) {
4636 diag::note_previous_definition);
4640 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
4641 (Entry->getValueType() == Ty)) {
4648 if (!IsForDefinition)
4655 bool IsIncompleteFunction =
false;
4657 llvm::FunctionType *FTy;
4658 if (isa<llvm::FunctionType>(Ty)) {
4659 FTy = cast<llvm::FunctionType>(Ty);
4661 FTy = llvm::FunctionType::get(
VoidTy,
false);
4662 IsIncompleteFunction =
true;
4666 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
4667 Entry ? StringRef() : MangledName, &
getModule());
4672 DeferredAnnotations[MangledName] = cast<ValueDecl>(
D);
4689 if (!Entry->use_empty()) {
4691 Entry->removeDeadConstantUsers();
4697 assert(F->getName() == MangledName &&
"name was uniqued!");
4699 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
4700 if (ExtraAttrs.hasFnAttrs()) {
4701 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
4709 if (isa_and_nonnull<CXXDestructorDecl>(
D) &&
4710 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(
D),
4712 addDeferredDeclToEmit(GD);
4717 auto DDI = DeferredDecls.find(MangledName);
4718 if (DDI != DeferredDecls.end()) {
4722 addDeferredDeclToEmit(DDI->second);
4723 DeferredDecls.erase(DDI);
4738 for (
const auto *FD = cast<FunctionDecl>(
D)->getMostRecentDecl(); FD;
4751 if (!IsIncompleteFunction) {
4752 assert(F->getFunctionType() == Ty);
4768 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4775 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
4778 DD->getParent()->getNumVBases() == 0)
4783 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
4784 false, llvm::AttributeList(),
4787 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
4788 cast<FunctionDecl>(GD.
getDecl())->hasAttr<CUDAGlobalAttr>()) {
4790 cast<llvm::Function>(F->stripPointerCasts()), GD);
4791 if (IsForDefinition)
4799 llvm::GlobalValue *F =
4802 return llvm::NoCFIValue::get(F);
4812 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4815 if (!
C.getLangOpts().CPlusPlus)
4820 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
4821 ?
C.Idents.get(
"terminate")
4822 :
C.Idents.get(Name);
4824 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
4828 if (
auto *LSD = dyn_cast<LinkageSpecDecl>(
Result))
4829 for (
const auto *
Result : LSD->lookup(&NS))
4830 if ((ND = dyn_cast<NamespaceDecl>(
Result)))
4835 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4847 llvm::AttributeList ExtraAttrs,
bool Local,
4848 bool AssumeConvergent) {
4849 if (AssumeConvergent) {
4851 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4855 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
4859 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
4868 if (!Local &&
getTriple().isWindowsItaniumEnvironment() &&
4871 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
4872 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4873 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
4880 markRegisterParameterAttributes(F);
4906 if (WeakRefReferences.erase(Entry)) {
4908 Entry->setLinkage(llvm::Function::ExternalLinkage);
4912 if (
D && shouldDropDLLAttribute(
D, Entry))
4913 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4915 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd &&
D)
4918 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
4923 if (IsForDefinition && !Entry->isDeclaration()) {
4931 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
4933 DiagnosedConflictingDefinitions.insert(
D).second) {
4937 diag::note_previous_definition);
4942 if (Entry->getType()->getAddressSpace() != TargetAS)
4943 return llvm::ConstantExpr::getAddrSpaceCast(
4944 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
4948 if (!IsForDefinition)
4954 auto *GV =
new llvm::GlobalVariable(
4955 getModule(), Ty,
false, llvm::GlobalValue::ExternalLinkage,
nullptr,
4956 MangledName,
nullptr, llvm::GlobalVariable::NotThreadLocal,
4957 getContext().getTargetAddressSpace(DAddrSpace));
4962 GV->takeName(Entry);
4964 if (!Entry->use_empty()) {
4965 Entry->replaceAllUsesWith(GV);
4968 Entry->eraseFromParent();
4974 auto DDI = DeferredDecls.find(MangledName);
4975 if (DDI != DeferredDecls.end()) {
4978 addDeferredDeclToEmit(DDI->second);
4979 DeferredDecls.erase(DDI);
4984 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
4989 GV->setConstant(
D->getType().isConstantStorage(
getContext(),
false,
false));
4991 GV->setAlignment(
getContext().getDeclAlign(
D).getAsAlign());
4995 if (
D->getTLSKind()) {
4997 CXXThreadLocals.push_back(
D);
5005 if (
getContext().isMSStaticDataMemberInlineDefinition(
D)) {
5006 EmitGlobalVarDefinition(
D);
5010 if (
D->hasExternalStorage()) {
5011 if (
const SectionAttr *SA =
D->
getAttr<SectionAttr>())
5012 GV->setSection(SA->getName());
5016 if (
getTriple().getArch() == llvm::Triple::xcore &&
5018 D->getType().isConstant(Context) &&
5020 GV->setSection(
".cp.rodata");
5023 if (
const auto *CMA =
D->
getAttr<CodeModelAttr>())
5024 GV->setCodeModel(CMA->getModel());
5029 if (Context.
getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
5030 D->getType().isConstQualified() && !GV->hasInitializer() &&
5031 !
D->hasDefinition() &&
D->hasInit() && !
D->
hasAttr<DLLImportAttr>()) {
5035 if (!HasMutableFields) {
5037 const Expr *InitExpr =
D->getAnyInitializer(InitDecl);
5042 auto *InitType =
Init->getType();
5043 if (GV->getValueType() != InitType) {
5048 GV->setName(StringRef());
5051 auto *NewGV = cast<llvm::GlobalVariable>(
5053 ->stripPointerCasts());
5056 GV->eraseFromParent();
5059 GV->setInitializer(
Init);
5060 GV->setConstant(
true);
5061 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
5076 D->hasExternalStorage())
5081 SanitizerMD->reportGlobal(GV, *
D);
5084 D ?
D->getType().getAddressSpace()
5086 assert(
getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
5087 if (DAddrSpace != ExpectedAS) {
5089 *
this, GV, DAddrSpace, ExpectedAS,
5100 if (isa<CXXConstructorDecl>(
D) || isa<CXXDestructorDecl>(
D))
5102 false, IsForDefinition);
5104 if (isa<CXXMethodDecl>(
D)) {
5112 if (isa<FunctionDecl>(
D)) {
5123 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes
Linkage,
5124 llvm::Align Alignment) {
5125 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
5126 llvm::GlobalVariable *OldGV =
nullptr;
5130 if (GV->getValueType() == Ty)
5135 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
5140 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
5145 GV->takeName(OldGV);
5147 if (!OldGV->use_empty()) {
5148 OldGV->replaceAllUsesWith(GV);
5151 OldGV->eraseFromParent();
5155 !GV->hasAvailableExternallyLinkage())
5156 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5158 GV->setAlignment(Alignment);
5172 assert(
D->hasGlobalStorage() &&
"Not a global variable");
5190 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
5195 assert(!
D->getInit() &&
"Cannot emit definite definitions here!");
5203 if (GV && !GV->isDeclaration())
5208 if (!MustBeEmitted(
D) && !GV) {
5209 DeferredDecls[MangledName] =
D;
5214 EmitGlobalVarDefinition(
D);
5218 if (
auto const *
V = dyn_cast<const VarDecl>(
D))
5219 EmitExternalVarDeclaration(
V);
5220 if (
auto const *FD = dyn_cast<const FunctionDecl>(
D))
5221 EmitExternalFunctionDeclaration(FD);
5230 if (LangOpts.OpenCL) {
5241 if (LangOpts.SYCLIsDevice &&
5245 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5247 if (
D->
hasAttr<CUDAConstantAttr>())
5253 if (
D->getType().isConstQualified())
5259 if (LangOpts.OpenMP) {
5261 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(
D, AS))
5269 if (LangOpts.OpenCL)
5271 if (LangOpts.SYCLIsDevice)
5273 if (LangOpts.HIP && LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())
5281 if (
auto AS =
getTarget().getConstantAddressSpace())
5294static llvm::Constant *
5296 llvm::GlobalVariable *GV) {
5297 llvm::Constant *Cast = GV;
5303 llvm::PointerType::get(
5310template<
typename SomeDecl>
5312 llvm::GlobalValue *GV) {
5318 if (!
D->template hasAttr<UsedAttr>())
5327 const SomeDecl *
First =
D->getFirstDecl();
5328 if (
First->getDeclContext()->isRecord() || !
First->isInExternCContext())
5334 std::pair<StaticExternCMap::iterator, bool> R =
5335 StaticExternCValues.insert(std::make_pair(
D->getIdentifier(), GV));
5340 R.first->second =
nullptr;
5351 if (
auto *VD = dyn_cast<VarDecl>(&
D))
5365 llvm_unreachable(
"No such linkage");
5373 llvm::GlobalObject &GO) {
5376 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
5380void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *
D,
5390 if (LangOpts.OpenMPIsTargetDevice && OpenMPRuntime &&
5391 OpenMPRuntime->emitTargetGlobalVariable(
D))
5394 llvm::TrackingVH<llvm::Constant>
Init;
5395 bool NeedsGlobalCtor =
false;
5399 bool IsDefinitionAvailableExternally =
5401 bool NeedsGlobalDtor =
5402 !IsDefinitionAvailableExternally &&
5409 if (IsDefinitionAvailableExternally &&
5410 (!
D->hasConstantInitialization() ||
5414 !
D->getType().isConstantStorage(
getContext(),
true,
true)))
5418 const Expr *InitExpr =
D->getAnyInitializer(InitDecl);
5420 std::optional<ConstantEmitter> emitter;
5425 bool IsCUDASharedVar =
5430 bool IsCUDAShadowVar =
5434 bool IsCUDADeviceShadowVar =
5436 (
D->getType()->isCUDADeviceBuiltinSurfaceType() ||
5437 D->getType()->isCUDADeviceBuiltinTextureType());
5439 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar))
5440 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5441 else if (
D->
hasAttr<LoaderUninitializedAttr>())
5442 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5443 else if (!InitExpr) {
5457 emitter.emplace(*
this);
5458 llvm::Constant *
Initializer = emitter->tryEmitForInitializer(*InitDecl);
5461 if (
D->getType()->isReferenceType())
5469 if (!IsDefinitionAvailableExternally)
5470 NeedsGlobalCtor =
true;
5481 DelayedCXXInitPosition.erase(
D);
5488 assert(VarSize == CstSize &&
"Emitted constant has unexpected size");
5493 llvm::Type* InitType =
Init->getType();
5494 llvm::Constant *Entry =
5498 Entry = Entry->stripPointerCasts();
5501 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
5512 if (!GV || GV->getValueType() != InitType ||
5513 GV->getType()->getAddressSpace() !=
5517 Entry->setName(StringRef());
5520 GV = cast<llvm::GlobalVariable>(
5522 ->stripPointerCasts());
5525 llvm::Constant *NewPtrForOldDecl =
5526 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
5528 Entry->replaceAllUsesWith(NewPtrForOldDecl);
5531 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
5549 if (LangOpts.CUDA) {
5550 if (LangOpts.CUDAIsDevice) {
5551 if (
Linkage != llvm::GlobalValue::InternalLinkage &&
5553 D->getType()->isCUDADeviceBuiltinSurfaceType() ||
5554 D->getType()->isCUDADeviceBuiltinTextureType()))
5555 GV->setExternallyInitialized(
true);
5562 GV->setInitializer(
Init);
5564 emitter->finalize(GV);
5567 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
5568 D->getType().isConstantStorage(
getContext(),
true,
true));
5571 if (
const SectionAttr *SA =
D->
getAttr<SectionAttr>()) {
5574 GV->setConstant(
true);
5579 if (std::optional<CharUnits> AlignValFromAllocate =
5581 AlignVal = *AlignValFromAllocate;
5599 Linkage == llvm::GlobalValue::ExternalLinkage &&
5602 Linkage = llvm::GlobalValue::InternalLinkage;
5606 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
5607 else if (
D->
hasAttr<DLLExportAttr>())
5608 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
5610 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
5612 if (
Linkage == llvm::GlobalVariable::CommonLinkage) {
5614 GV->setConstant(
false);
5619 if (!GV->getInitializer()->isNullValue())
5620 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
5623 setNonAliasAttributes(
D, GV);
5625 if (
D->getTLSKind() && !GV->isThreadLocal()) {
5627 CXXThreadLocals.push_back(
D);
5634 if (NeedsGlobalCtor || NeedsGlobalDtor)
5635 EmitCXXGlobalVarDeclInitFunc(
D, GV, NeedsGlobalCtor);
5637 SanitizerMD->reportGlobal(GV, *
D, NeedsGlobalCtor);
5642 DI->EmitGlobalVariable(GV,
D);
5645void CodeGenModule::EmitExternalVarDeclaration(
const VarDecl *
D) {
5650 llvm::Constant *GV =
5652 DI->EmitExternalVariable(
5653 cast<llvm::GlobalVariable>(GV->stripPointerCasts()),
D);
5657void CodeGenModule::EmitExternalFunctionDeclaration(
const FunctionDecl *FD) {
5662 auto *
Fn = dyn_cast<llvm::Function>(
5663 GetOrCreateLLVMFunction(MangledName, Ty, FD,
false));
5664 if (!
Fn->getSubprogram())
5681 if (
D->getInit() ||
D->hasExternalStorage())
5691 if (
D->
hasAttr<PragmaClangBSSSectionAttr>() ||
5692 D->
hasAttr<PragmaClangDataSectionAttr>() ||
5693 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
5694 D->
hasAttr<PragmaClangRodataSectionAttr>())
5698 if (
D->getTLSKind())
5721 if (FD->isBitField())
5723 if (FD->
hasAttr<AlignedAttr>())
5745llvm::GlobalValue::LinkageTypes
5749 return llvm::Function::InternalLinkage;
5752 return llvm::GlobalVariable::WeakAnyLinkage;
5756 return llvm::GlobalVariable::LinkOnceAnyLinkage;
5761 return llvm::GlobalValue::AvailableExternallyLinkage;
5775 return !Context.
getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
5776 : llvm::Function::InternalLinkage;
5790 return llvm::Function::ExternalLinkage;
5793 return D->
hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
5794 : llvm::Function::InternalLinkage;
5795 return llvm::Function::WeakODRLinkage;
5802 CodeGenOpts.NoCommon))
5803 return llvm::GlobalVariable::CommonLinkage;
5810 return llvm::GlobalVariable::WeakODRLinkage;
5814 return llvm::GlobalVariable::ExternalLinkage;
5817llvm::GlobalValue::LinkageTypes
5826 llvm::Function *newFn) {
5828 if (old->use_empty())
5831 llvm::Type *newRetTy = newFn->getReturnType();
5836 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
5838 llvm::User *user = ui->getUser();
5842 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
5843 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
5849 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
5852 if (!callSite->isCallee(&*ui))
5857 if (callSite->getType() != newRetTy && !callSite->use_empty())
5862 llvm::AttributeList oldAttrs = callSite->getAttributes();
5865 unsigned newNumArgs = newFn->arg_size();
5866 if (callSite->arg_size() < newNumArgs)
5872 bool dontTransform =
false;
5873 for (llvm::Argument &A : newFn->args()) {
5874 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
5875 dontTransform =
true;
5880 newArgAttrs.push_back(oldAttrs.getParamAttrs(argNo));
5888 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
5892 callSite->getOperandBundlesAsDefs(newBundles);
5894 llvm::CallBase *newCall;
5895 if (isa<llvm::CallInst>(callSite)) {
5897 llvm::CallInst::Create(newFn, newArgs, newBundles,
"", callSite);
5899 auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
5900 newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(),
5901 oldInvoke->getUnwindDest(), newArgs,
5902 newBundles,
"", callSite);
5906 if (!newCall->getType()->isVoidTy())
5907 newCall->takeName(callSite);
5908 newCall->setAttributes(
5909 llvm::AttributeList::get(newFn->getContext(), oldAttrs.getFnAttrs(),
5910 oldAttrs.getRetAttrs(), newArgAttrs));
5911 newCall->setCallingConv(callSite->getCallingConv());
5914 if (!callSite->use_empty())
5915 callSite->replaceAllUsesWith(newCall);
5918 if (callSite->getDebugLoc())
5919 newCall->setDebugLoc(callSite->getDebugLoc());
5921 callSitesToBeRemovedFromParent.push_back(callSite);
5924 for (
auto *callSite : callSitesToBeRemovedFromParent) {
5925 callSite->eraseFromParent();
5939 llvm::Function *NewFn) {
5941 if (!isa<llvm::Function>(Old))
return;
5949 (LangOpts.CUDA && !shouldEmitCUDAGlobalVar(VD)))
5961void CodeGenModule::EmitGlobalFunctionDefinition(
GlobalDecl GD,
5962 llvm::GlobalValue *GV) {
5963 const auto *
D = cast<FunctionDecl>(GD.
getDecl());
5970 if (!GV || (GV->getValueType() != Ty))
5976 if (!GV->isDeclaration())
5983 auto *Fn = cast<llvm::Function>(GV);
5995 setNonAliasAttributes(GD, Fn);
5998 if (
const ConstructorAttr *CA =
D->
getAttr<ConstructorAttr>())
6000 if (
const DestructorAttr *DA =
D->
getAttr<DestructorAttr>())
6006void CodeGenModule::EmitAliasDefinition(
GlobalDecl GD) {
6007 const auto *
D = cast<ValueDecl>(GD.
getDecl());
6008 const AliasAttr *AA =
D->
getAttr<AliasAttr>();
6009 assert(AA &&
"Not an alias?");
6013 if (AA->getAliasee() == MangledName) {
6014 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6021 if (Entry && !Entry->isDeclaration())
6024 Aliases.push_back(GD);
6030 llvm::Constant *Aliasee;
6031 llvm::GlobalValue::LinkageTypes
LT;
6032 if (isa<llvm::FunctionType>(DeclTy)) {
6033 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
6039 if (
const auto *VD = dyn_cast<VarDecl>(GD.
getDecl()))
6046 unsigned AS = Aliasee->getType()->getPointerAddressSpace();
6048 llvm::GlobalAlias::create(DeclTy, AS,
LT,
"", Aliasee, &
getModule());
6051 if (GA->getAliasee() == Entry) {
6052 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6056 assert(Entry->isDeclaration());
6065 GA->takeName(Entry);
6067 Entry->replaceAllUsesWith(GA);
6068 Entry->eraseFromParent();
6070 GA->setName(MangledName);
6078 GA->setLinkage(llvm::Function::WeakAnyLinkage);
6081 if (
const auto *VD = dyn_cast<VarDecl>(
D))
6082 if (VD->getTLSKind())
6088 if (isa<VarDecl>(
D))
6090 DI->EmitGlobalAlias(cast<llvm::GlobalValue>(GA->getAliasee()->stripPointerCasts()), GD);
6093void CodeGenModule::emitIFuncDefinition(
GlobalDecl GD) {
6094 const auto *
D = cast<ValueDecl>(GD.
getDecl());
6095 const IFuncAttr *IFA =
D->
getAttr<IFuncAttr>();
6096 assert(IFA &&
"Not an ifunc?");
6100 if (IFA->getResolver() == MangledName) {
6101 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6107 if (Entry && !Entry->isDeclaration()) {
6110 DiagnosedConflictingDefinitions.insert(GD).second) {
6114 diag::note_previous_definition);
6119 Aliases.push_back(GD);
6125 llvm::Constant *Resolver =
6126 GetOrCreateLLVMFunction(IFA->getResolver(),
VoidTy, {},
6129 llvm::GlobalIFunc *GIF =
6130 llvm::GlobalIFunc::create(DeclTy, 0, llvm::Function::ExternalLinkage,
6133 if (GIF->getResolver() == Entry) {
6134 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6137 assert(Entry->isDeclaration());
6146 GIF->takeName(Entry);
6148 Entry->replaceAllUsesWith(GIF);
6149 Entry->eraseFromParent();
6151 GIF->setName(MangledName);
6157 return llvm::Intrinsic::getDeclaration(&
getModule(), (llvm::Intrinsic::ID)IID,
6161static llvm::StringMapEntry<llvm::GlobalVariable *> &
6164 bool &IsUTF16,
unsigned &StringLength) {
6165 StringRef String = Literal->getString();
6166 unsigned NumBytes = String.size();
6169 if (!Literal->containsNonAsciiOrNull()) {
6170 StringLength = NumBytes;
6171 return *Map.insert(std::make_pair(String,
nullptr)).first;
6178 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
6179 llvm::UTF16 *ToPtr = &ToBuf[0];
6181 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
6182 ToPtr + NumBytes, llvm::strictConversion);
6185 StringLength = ToPtr - &ToBuf[0];
6189 return *Map.insert(std::make_pair(
6190 StringRef(
reinterpret_cast<const char *
>(ToBuf.data()),
6191 (StringLength + 1) * 2),
6197 unsigned StringLength = 0;
6198 bool isUTF16 =
false;
6199 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
6204 if (
auto *
C = Entry.second)
6209 const llvm::Triple &Triple =
getTriple();
6212 const bool IsSwiftABI =
6213 static_cast<unsigned>(CFRuntime) >=
6218 if (!CFConstantStringClassRef) {
6219 const char *CFConstantStringClassName =
"__CFConstantStringClassReference";
6221 Ty = llvm::ArrayType::get(Ty, 0);
6223 switch (CFRuntime) {
6227 CFConstantStringClassName =
6228 Triple.isOSDarwin() ?
"$s15SwiftFoundation19_NSCFConstantStringCN"
6229 :
"$s10Foundation19_NSCFConstantStringCN";
6233 CFConstantStringClassName =
6234 Triple.isOSDarwin() ?
"$S15SwiftFoundation19_NSCFConstantStringCN"
6235 :
"$S10Foundation19_NSCFConstantStringCN";
6239 CFConstantStringClassName =
6240 Triple.isOSDarwin() ?
"__T015SwiftFoundation19_NSCFConstantStringCN"
6241 :
"__T010Foundation19_NSCFConstantStringCN";
6248 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
6249 llvm::GlobalValue *GV =
nullptr;
6251 if ((GV = dyn_cast<llvm::GlobalValue>(
C))) {
6258 if ((VD = dyn_cast<VarDecl>(
Result)))
6261 if (Triple.isOSBinFormatELF()) {
6263 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6265 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6266 if (!VD || !VD->
hasAttr<DLLExportAttr>())
6267 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6269 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6277 CFConstantStringClassRef =
6278 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(
C, Ty) :
C;
6283 auto *STy = cast<llvm::StructType>(
getTypes().ConvertType(CFTy));
6286 auto Fields = Builder.beginStruct(STy);
6289 Fields.add(cast<llvm::Constant>(CFConstantStringClassRef));
6293 Fields.addInt(
IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
6294 Fields.addInt(
Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
6296 Fields.addInt(
IntTy, isUTF16 ? 0x07d0 : 0x07C8);
6300 llvm::Constant *
C =
nullptr;
6303 reinterpret_cast<uint16_t *
>(
const_cast<char *
>(Entry.first().data())),
6304 Entry.first().size() / 2);
6305 C = llvm::ConstantDataArray::get(VMContext, Arr);
6307 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
6313 new llvm::GlobalVariable(
getModule(),
C->getType(),
true,
6314 llvm::GlobalValue::PrivateLinkage,
C,
".str");
6315 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6325 if (Triple.isOSBinFormatMachO())
6326 GV->setSection(isUTF16 ?
"__TEXT,__ustring"
6327 :
"__TEXT,__cstring,cstring_literals");
6330 else if (Triple.isOSBinFormatELF())
6331 GV->setSection(
".rodata");
6337 llvm::IntegerType *LengthTy =
6347 Fields.addInt(LengthTy, StringLength);
6355 GV = Fields.finishAndCreateGlobal(
"_unnamed_cfstring_", Alignment,
6357 llvm::GlobalVariable::PrivateLinkage);
6358 GV->addAttribute(
"objc_arc_inert");
6359 switch (Triple.getObjectFormat()) {
6360 case llvm::Triple::UnknownObjectFormat:
6361 llvm_unreachable(
"unknown file format");
6362 case llvm::Triple::DXContainer:
6363 case llvm::Triple::GOFF:
6364 case llvm::Triple::SPIRV:
6365 case llvm::Triple::XCOFF:
6366 llvm_unreachable(
"unimplemented");
6367 case llvm::Triple::COFF:
6368 case llvm::Triple::ELF:
6369 case llvm::Triple::Wasm:
6370 GV->setSection(
"cfstring");
6372 case llvm::Triple::MachO:
6373 GV->setSection(
"__DATA,__cfstring");
6382 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
6386 if (ObjCFastEnumerationStateType.
isNull()) {
6388 D->startDefinition();
6396 for (
size_t i = 0; i < 4; ++i) {
6401 FieldTypes[i],
nullptr,
6409 D->completeDefinition();
6413 return ObjCFastEnumerationStateType;
6422 if (
E->getCharByteWidth() == 1) {
6427 assert(CAT &&
"String literal not of constant array type!");
6429 return llvm::ConstantDataArray::getString(VMContext, Str,
false);
6433 llvm::Type *ElemTy = AType->getElementType();
6434 unsigned NumElements = AType->getNumElements();
6437 if (ElemTy->getPrimitiveSizeInBits() == 16) {
6439 Elements.reserve(NumElements);
6441 for(
unsigned i = 0, e =
E->getLength(); i != e; ++i)
6442 Elements.push_back(
E->getCodeUnit(i));
6443 Elements.resize(NumElements);
6444 return llvm::ConstantDataArray::get(VMContext, Elements);
6447 assert(ElemTy->getPrimitiveSizeInBits() == 32);
6449 Elements.reserve(NumElements);
6451 for(
unsigned i = 0, e =
E->getLength(); i != e; ++i)
6452 Elements.push_back(
E->getCodeUnit(i));
6453 Elements.resize(NumElements);
6454 return llvm::ConstantDataArray::get(VMContext, Elements);
6457static llvm::GlobalVariable *
6466 auto *GV =
new llvm::GlobalVariable(
6467 M,
C->getType(), !CGM.
getLangOpts().WritableStrings,
LT,
C, GlobalName,
6468 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
6470 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6471 if (GV->isWeakForLinker()) {
6472 assert(CGM.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
6473 GV->setComdat(M.getOrInsertComdat(GV->getName()));
6489 llvm::GlobalVariable **Entry =
nullptr;
6490 if (!LangOpts.WritableStrings) {
6491 Entry = &ConstantStringMap[
C];
6492 if (
auto GV = *Entry) {
6493 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6496 GV->getValueType(), Alignment);
6501 StringRef GlobalVariableName;
6502 llvm::GlobalValue::LinkageTypes
LT;
6507 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
6508 !LangOpts.WritableStrings) {
6509 llvm::raw_svector_ostream Out(MangledNameBuffer);
6511 LT = llvm::GlobalValue::LinkOnceODRLinkage;
6512 GlobalVariableName = MangledNameBuffer;
6514 LT = llvm::GlobalValue::PrivateLinkage;
6515 GlobalVariableName = Name;
6527 SanitizerMD->reportGlobal(GV, S->getStrTokenLoc(0),
"<string literal>");
6530 GV->getValueType(), Alignment);
6547 const std::string &Str,
const char *GlobalName) {
6548 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
6553 llvm::ConstantDataArray::getString(
getLLVMContext(), StrWithNull,
false);
6556 llvm::GlobalVariable **Entry =
nullptr;
6557 if (!LangOpts.WritableStrings) {
6558 Entry = &ConstantStringMap[
C];
6559 if (
auto GV = *Entry) {
6560 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6563 GV->getValueType(), Alignment);
6569 GlobalName =
".str";
6572 GlobalName, Alignment);
6577 GV->getValueType(), Alignment);
6582 assert((
E->getStorageDuration() ==
SD_Static ||
6583 E->getStorageDuration() ==
SD_Thread) &&
"not a global temporary");
6584 const auto *VD = cast<VarDecl>(
E->getExtendingDecl());
6589 if (
Init ==
E->getSubExpr())
6594 auto InsertResult = MaterializedGlobalTemporaryMap.insert({
E,
nullptr});
6595 if (!InsertResult.second) {
6598 if (!InsertResult.first->second) {
6603 InsertResult.first->second =
new llvm::GlobalVariable(
6604 getModule(),
Type,
false, llvm::GlobalVariable::InternalLinkage,
6608 llvm::cast<llvm::GlobalVariable>(
6609 InsertResult.first->second->stripPointerCasts())
6618 llvm::raw_svector_ostream Out(Name);
6620 VD,
E->getManglingNumber(), Out);
6623 if (
E->getStorageDuration() ==
SD_Static && VD->evaluateValue()) {
6629 Value =
E->getOrCreateValue(
false);
6640 std::optional<ConstantEmitter> emitter;
6641 llvm::Constant *InitialValue =
nullptr;
6642 bool Constant =
false;
6646 emitter.emplace(*
this);
6647 InitialValue = emitter->emitForInitializer(*
Value, AddrSpace,
6652 Type = InitialValue->getType();
6661 if (
Linkage == llvm::GlobalVariable::ExternalLinkage) {
6663 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
6667 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
6671 Linkage = llvm::GlobalVariable::InternalLinkage;
6675 auto *GV =
new llvm::GlobalVariable(
6677 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
6678 if (emitter) emitter->finalize(GV);
6680 if (!llvm::GlobalValue::isLocalLinkage(
Linkage)) {
6682 if (GV->getDLLStorageClass() == llvm::GlobalVariable::DLLExportStorageClass)
6684 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
6688 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
6689 if (VD->getTLSKind())
6691 llvm::Constant *CV = GV;
6695 llvm::PointerType::get(
6701 llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[
E];
6703 Entry->replaceAllUsesWith(CV);
6704 llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
6713void CodeGenModule::EmitObjCPropertyImplementations(
const
6715 for (
const auto *PID :
D->property_impls()) {
6726 if (!Getter || Getter->isSynthesizedAccessorStub())
6729 auto *Setter = PID->getSetterMethodDecl();
6730 if (!PD->
isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
6741 if (ivar->getType().isDestructedType())
6751 E =
D->init_end(); B !=
E; ++B) {
6774 D->addInstanceMethod(DTORMethod);
6776 D->setHasDestructors(
true);
6781 if (
D->getNumIvarInitializers() == 0 ||
6795 D->addInstanceMethod(CTORMethod);
6797 D->setHasNonZeroConstructors(
true);
6808 EmitDeclContext(LSD);
6813 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
6816 std::unique_ptr<CodeGenFunction> &CurCGF =
6817 GlobalTopLevelStmtBlockInFlight.first;
6821 if (CurCGF && CXXGlobalInits.back() != CurCGF->CurFn) {
6829 std::string Name =
"__stmts__" + llvm::utostr(CXXGlobalInits.size());
6835 llvm::Function *
Fn = llvm::Function::Create(
6836 FnTy, llvm::GlobalValue::InternalLinkage, Name, &
getModule());
6839 GlobalTopLevelStmtBlockInFlight.second =
D;
6840 CurCGF->StartFunction(
GlobalDecl(), RetTy, Fn, FnInfo, Args,
6842 CXXGlobalInits.push_back(Fn);
6845 CurCGF->EmitStmt(
D->getStmt());
6848void CodeGenModule::EmitDeclContext(
const DeclContext *DC) {
6849 for (
auto *I : DC->
decls()) {
6855 if (
auto *OID = dyn_cast<ObjCImplDecl>(I)) {
6856 for (
auto *M : OID->methods())
6875 case Decl::CXXConversion:
6876 case Decl::CXXMethod:
6877 case Decl::Function:
6884 case Decl::CXXDeductionGuide:
6889 case Decl::Decomposition:
6890 case Decl::VarTemplateSpecialization:
6892 if (
auto *DD = dyn_cast<DecompositionDecl>(
D))
6893 for (
auto *B : DD->bindings())
6894 if (
auto *HD = B->getHoldingVar())
6900 case Decl::IndirectField:
6904 case Decl::Namespace:
6905 EmitDeclContext(cast<NamespaceDecl>(
D));
6907 case Decl::ClassTemplateSpecialization: {
6908 const auto *Spec = cast<ClassTemplateSpecializationDecl>(
D);
6910 if (Spec->getSpecializationKind() ==
6912 Spec->hasDefinition())
6913 DI->completeTemplateDefinition(*Spec);
6915 case Decl::CXXRecord: {
6922 DI->completeUnusedClass(*CRD);
6925 for (
auto *I : CRD->
decls())
6926 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
6931 case Decl::UsingShadow:
6932 case Decl::ClassTemplate:
6933 case Decl::VarTemplate:
6935 case Decl::VarTemplatePartialSpecialization:
6936 case Decl::FunctionTemplate:
6937 case Decl::TypeAliasTemplate:
6944 DI->EmitUsingDecl(cast<UsingDecl>(*
D));
6946 case Decl::UsingEnum:
6948 DI->EmitUsingEnumDecl(cast<UsingEnumDecl>(*
D));
6950 case Decl::NamespaceAlias:
6952 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*
D));
6954 case Decl::UsingDirective:
6956 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*
D));
6958 case Decl::CXXConstructor:
6961 case Decl::CXXDestructor:
6965 case Decl::StaticAssert:
6972 case Decl::ObjCInterface:
6973 case Decl::ObjCCategory:
6976 case Decl::ObjCProtocol: {
6977 auto *Proto = cast<ObjCProtocolDecl>(
D);
6978 if (Proto->isThisDeclarationADefinition())
6983 case Decl::ObjCCategoryImpl:
6986 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(
D));
6989 case Decl::ObjCImplementation: {
6990 auto *OMD = cast<ObjCImplementationDecl>(
D);
6991 EmitObjCPropertyImplementations(OMD);
6992 EmitObjCIvarInitializations(OMD);
6997 DI->getOrCreateInterfaceType(
getContext().getObjCInterfaceType(
6998 OMD->getClassInterface()), OMD->getLocation());
7001 case Decl::ObjCMethod: {
7002 auto *OMD = cast<ObjCMethodDecl>(
D);
7008 case Decl::ObjCCompatibleAlias:
7009 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(
D));
7012 case Decl::PragmaComment: {
7013 const auto *PCD = cast<PragmaCommentDecl>(
D);
7014 switch (PCD->getCommentKind()) {
7016 llvm_unreachable(
"unexpected pragma comment kind");
7031 case Decl::PragmaDetectMismatch: {
7032 const auto *PDMD = cast<PragmaDetectMismatchDecl>(
D);
7037 case Decl::LinkageSpec:
7038 EmitLinkageSpec(cast<LinkageSpecDecl>(
D));
7041 case Decl::FileScopeAsm: {
7043 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
7046 if (LangOpts.OpenMPIsTargetDevice)
7049 if (LangOpts.SYCLIsDevice)
7051 auto *AD = cast<FileScopeAsmDecl>(
D);
7052 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
7056 case Decl::TopLevelStmt:
7057 EmitTopLevelStmt(cast<TopLevelStmtDecl>(
D));
7060 case Decl::Import: {
7061 auto *Import = cast<ImportDecl>(
D);
7064 if (!ImportedModules.insert(Import->getImportedModule()))
7068 if (!Import->getImportedOwningModule()) {
7070 DI->EmitImportDecl(*Import);
7076 if (CXX20ModuleInits && Import->getImportedOwningModule() &&
7077 !Import->getImportedOwningModule()->isModuleMapModule())
7086 Visited.insert(Import->getImportedModule());
7087 Stack.push_back(Import->getImportedModule());
7089 while (!Stack.empty()) {
7091 if (!EmittedModuleInitializers.insert(Mod).second)
7101 if (Submodule->IsExplicit)
7104 if (
Visited.insert(Submodule).second)
7105 Stack.push_back(Submodule);
7112 EmitDeclContext(cast<ExportDecl>(
D));
7115 case Decl::OMPThreadPrivate:
7119 case Decl::OMPAllocate:
7123 case Decl::OMPDeclareReduction:
7127 case Decl::OMPDeclareMapper:
7131 case Decl::OMPRequires:
7136 case Decl::TypeAlias:
7138 DI->EmitAndRetainType(
7139 getContext().getTypedefType(cast<TypedefNameDecl>(
D)));
7151 DI->EmitAndRetainType(
getContext().getEnumType(cast<EnumDecl>(
D)));
7154 case Decl::HLSLBuffer:
7162 assert(isa<TypeDecl>(
D) &&
"Unsupported decl kind");
7169 if (!CodeGenOpts.CoverageMapping)
7172 case Decl::CXXConversion:
7173 case Decl::CXXMethod:
7174 case Decl::Function:
7175 case Decl::ObjCMethod:
7176 case Decl::CXXConstructor:
7177 case Decl::CXXDestructor: {
7178 if (!cast<FunctionDecl>(
D)->doesThisDeclarationHaveABody())
7186 DeferredEmptyCoverageMappingDecls.try_emplace(
D,
true);
7196 if (!CodeGenOpts.CoverageMapping)
7198 if (
const auto *Fn = dyn_cast<FunctionDecl>(
D)) {
7199 if (Fn->isTemplateInstantiation())
7202 DeferredEmptyCoverageMappingDecls.insert_or_assign(
D,
false);
7210 for (
const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
7213 const Decl *
D = Entry.first;
7215 case Decl::CXXConversion:
7216 case Decl::CXXMethod:
7217 case Decl::Function:
7218 case Decl::ObjCMethod: {
7225 case Decl::CXXConstructor: {
7232 case Decl::CXXDestructor: {
7249 if (llvm::Function *F =
getModule().getFunction(
"main")) {
7250 if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
7252 auto *GA = llvm::GlobalAlias::create(
"__main_void", F);
7253 GA->setVisibility(llvm::GlobalValue::HiddenVisibility);
7262 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
7263 return llvm::ConstantInt::get(i64, PtrInt);
7267 llvm::NamedMDNode *&GlobalMetadata,
7269 llvm::GlobalValue *Addr) {
7270 if (!GlobalMetadata)
7272 CGM.
getModule().getOrInsertNamedMetadata(
"clang.global.decl.ptrs");
7275 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
7278 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
7281bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
7282 llvm::GlobalValue *CppFunc) {
7290 if (Elem == CppFunc)
7296 for (llvm::User *User : Elem->users()) {
7300 if (
auto *ConstExpr = dyn_cast<llvm::ConstantExpr>(User)) {
7301 if (ConstExpr->getOpcode() != llvm::Instruction::BitCast)
7304 for (llvm::User *CEUser : ConstExpr->users()) {
7305 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(CEUser)) {
7306 IFuncs.push_back(IFunc);
7311 CEs.push_back(ConstExpr);
7312 }
else if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(User)) {
7313 IFuncs.push_back(IFunc);
7325 for (llvm::GlobalIFunc *IFunc : IFuncs)
7326 IFunc->setResolver(
nullptr);
7327 for (llvm::ConstantExpr *ConstExpr : CEs)
7328 ConstExpr->destroyConstant();
7332 Elem->eraseFromParent();
7334 for (llvm::GlobalIFunc *IFunc : IFuncs) {
7339 llvm::FunctionType::get(IFunc->getType(),
false);
7340 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
7341 CppFunc->getName(), ResolverTy, {},
false);
7342 IFunc->setResolver(Resolver);
7352void CodeGenModule::EmitStaticExternCAliases() {
7355 for (
auto &I : StaticExternCValues) {
7357 llvm::GlobalValue *Val = I.second;
7365 llvm::GlobalValue *ExistingElem =
7366 getModule().getNamedValue(Name->getName());
7370 if (!ExistingElem || CheckAndReplaceExternCIFuncs(ExistingElem, Val))
7377 auto Res = Manglings.find(MangledName);
7378 if (Res == Manglings.end())
7380 Result = Res->getValue();
7391void CodeGenModule::EmitDeclMetadata() {
7392 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7394 for (
auto &I : MangledDeclNames) {
7395 llvm::GlobalValue *Addr =
getModule().getNamedValue(I.second);
7405void CodeGenFunction::EmitDeclMetadata() {
7406 if (LocalDeclMap.empty())
return;
7411 unsigned DeclPtrKind = Context.getMDKindID(
"clang.decl.ptr");
7413 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7415 for (
auto &I : LocalDeclMap) {
7416 const Decl *
D = I.first;
7417 llvm::Value *Addr = I.second.emitRawPointer(*
this);
7418 if (
auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
7420 Alloca->setMetadata(
7421 DeclPtrKind, llvm::MDNode::get(
7422 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
7423 }
else if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
7430void CodeGenModule::EmitVersionIdentMetadata() {
7431 llvm::NamedMDNode *IdentMetadata =
7432 TheModule.getOrInsertNamedMetadata(
"llvm.ident");
7434 llvm::LLVMContext &Ctx = TheModule.getContext();
7436 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
7437 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
7440void CodeGenModule::EmitCommandLineMetadata() {
7441 llvm::NamedMDNode *CommandLineMetadata =
7442 TheModule.getOrInsertNamedMetadata(
"llvm.commandline");
7444 llvm::LLVMContext &Ctx = TheModule.getContext();
7446 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
7447 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
7450void CodeGenModule::EmitCoverageFile() {
7451 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata(
"llvm.dbg.cu");
7455 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata(
"llvm.gcov");
7456 llvm::LLVMContext &Ctx = TheModule.getContext();
7457 auto *CoverageDataFile =
7459 auto *CoverageNotesFile =
7461 for (
int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
7462 llvm::MDNode *CU = CUNode->getOperand(i);
7463 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
7464 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
7485 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
7487 for (
auto RefExpr :
D->varlists()) {
7488 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
7490 VD->getAnyInitializer() &&
7491 !VD->getAnyInitializer()->isConstantInitializer(
getContext(),
7498 VD, Addr, RefExpr->getBeginLoc(), PerformInit))
7499 CXXGlobalInits.push_back(InitFunction);
7504CodeGenModule::CreateMetadataIdentifierImpl(
QualType T, MetadataTypeMap &Map,
7508 FnType->getReturnType(), FnType->getParamTypes(),
7509 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
7511 llvm::Metadata *&InternalId = Map[
T.getCanonicalType()];
7516 std::string OutName;
7517 llvm::raw_string_ostream Out(OutName);
7522 Out <<
".normalized";
7536 return CreateMetadataIdentifierImpl(
T, MetadataIdMap,
"");
7541 return CreateMetadataIdentifierImpl(
T, VirtualMetadataIdMap,
".virtual");
7561 for (
auto &Param : FnType->param_types())
7566 GeneralizedParams, FnType->getExtProtoInfo());
7573 llvm_unreachable(
"Encountered unknown FunctionType");
7578 GeneralizedMetadataIdMap,
".generalized");
7585 return ((LangOpts.
Sanitize.
has(SanitizerKind::CFIVCall) &&
7587 (LangOpts.
Sanitize.
has(SanitizerKind::CFINVCall) &&
7589 (LangOpts.
Sanitize.
has(SanitizerKind::CFIDerivedCast) &&
7591 (LangOpts.
Sanitize.
has(SanitizerKind::CFIUnrelatedCast) &&
7598 llvm::Metadata *MD =
7600 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7602 if (CodeGenOpts.SanitizeCfiCrossDso)
7604 VTable->addTypeMetadata(Offset.getQuantity(),
7605 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
7608 llvm::Metadata *MD = llvm::MDString::get(
getLLVMContext(),
"all-vtables");
7609 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7615 SanStats = std::make_unique<llvm::SanitizerStatReport>(&
getModule());
7625 auto *FTy = llvm::FunctionType::get(SamplerT, {
C->getType()},
false);
7640 bool forPointeeType) {
7651 if (
auto Align = TT->getDecl()->getMaxAlignment()) {
7681 if (
T.getQualifiers().hasUnaligned()) {
7683 }
else if (forPointeeType && !AlignForArray &&
7695 if (
unsigned MaxAlign =
getLangOpts().MaxTypeAlign) {
7708 if (NumAutoVarInit >= StopAfter) {
7711 if (!NumAutoVarInit) {
7714 "-ftrivial-auto-var-init-stop-after=%0 has been enabled to limit the "
7715 "number of times ftrivial-auto-var-init=%1 gets applied.");
7729 const Decl *
D)
const {
7733 OS << (isa<VarDecl>(
D) ?
".static." :
".intern.");
7735 OS << (isa<VarDecl>(
D) ?
"__static__" :
"__intern__");
7741 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7745 llvm::MD5::MD5Result
Result;
7746 for (
const auto &Arg : PreprocessorOpts.
Macros)
7747 Hash.update(Arg.first);
7751 llvm::sys::fs::UniqueID ID;
7752 if (llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID)) {
7754 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7755 if (
auto EC = llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID))
7756 SM.getDiagnostics().Report(diag::err_cannot_open_file)
7759 OS << llvm::format(
"%x", ID.getFile()) << llvm::format(
"%x", ID.getDevice())
7760 <<
"_" << llvm::utohexstr(
Result.low(),
true, 8);
7767 assert(DeferredDeclsToEmit.empty() &&
7768 "Should have emitted all decls deferred to emit.");
7769 assert(NewBuilder->DeferredDecls.empty() &&
7770 "Newly created module should not have deferred decls");
7771 NewBuilder->DeferredDecls = std::move(DeferredDecls);
7772 assert(EmittedDeferredDecls.empty() &&
7773 "Still have (unmerged) EmittedDeferredDecls deferred decls");
7775 assert(NewBuilder->DeferredVTables.empty() &&
7776 "Newly created module should not have deferred vtables");
7777 NewBuilder->DeferredVTables = std::move(DeferredVTables);
7779 assert(NewBuilder->MangledDeclNames.empty() &&
7780 "Newly created module should not have mangled decl names");
7781 assert(NewBuilder->Manglings.empty() &&
7782 "Newly created module should not have manglings");
7783 NewBuilder->Manglings = std::move(Manglings);
7785 NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
7787 NewBuilder->TBAA = std::move(TBAA);
7789 NewBuilder->ABI->MangleCtx = std::move(ABI->MangleCtx);
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM, const CPUSpecificAttr *Attr, unsigned CPUIndex, raw_ostream &Out)
static bool AllTrivialInitializers(CodeGenModule &CGM, ObjCImplementationDecl *D)
static const FunctionDecl * GetRuntimeFunctionDecl(ASTContext &C, StringRef Name)
static void checkAliasForTocData(llvm::GlobalVariable *GVar, const CodeGenOptions &CodeGenOpts, DiagnosticsEngine &Diags, SourceLocation Location)
llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM, GlobalDecl GD)
static bool hasImplicitAttr(const ValueDecl *D)
static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector< llvm::WeakTrackingVH > &List)
static bool HasNonDllImportDtor(QualType T)
static llvm::Constant * GetPointerConstant(llvm::LLVMContext &Context, const void *Ptr)
Turns the given pointer into a constant.
static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S)
static unsigned TargetMVPriority(const TargetInfo &TI, const CodeGenFunction::MultiVersionResolverOption &RO)
static void setVisibilityFromDLLStorageClass(const clang::LangOptions &LO, llvm::Module &M)
static std::string getCPUSpecificMangling(const CodeGenModule &CGM, StringRef Name)
static const char AnnotationSection[]
static bool isUniqueInternalLinkageDecl(GlobalDecl GD, CodeGenModule &CGM)
static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty)
static bool allowKCFIIdentifier(StringRef Name)
static bool shouldAssumeDSOLocal(const CodeGenModule &CGM, llvm::GlobalValue *GV)
static void replaceUsesOfNonProtoConstant(llvm::Constant *old, llvm::Function *newFn)
Replace the uses of a function that was declared with a non-proto type.
static llvm::Constant * castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM, llvm::GlobalVariable *GV)
static bool needsDestructMethod(ObjCImplementationDecl *impl)
static bool isStackProtectorOn(const LangOptions &LangOpts, const llvm::Triple &Triple, clang::LangOptions::StackProtectorMode Mode)
static void removeImageAccessQualifier(std::string &TyName)
static llvm::StringMapEntry< llvm::GlobalVariable * > & GetConstantCFStringEntry(llvm::StringMap< llvm::GlobalVariable * > &Map, const StringLiteral *Literal, bool TargetIsLSB, bool &IsUTF16, unsigned &StringLength)
static llvm::GlobalVariable * GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, CodeGenModule &CGM, StringRef GlobalName, CharUnits Alignment)
static bool hasUnwindExceptions(const LangOptions &LangOpts)
Determines whether the language options require us to model unwind exceptions.
static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl< llvm::MDNode * > &Metadata, llvm::SmallPtrSet< Module *, 16 > &Visited)
Add link options implied by the given module, including modules it depends on, using a postorder walk...
static llvm::cl::opt< bool > LimitedCoverage("limited-coverage-experimental", llvm::cl::Hidden, llvm::cl::desc("Emit limited coverage mapping information (experimental)"))
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
static std::unique_ptr< TargetCodeGenInfo > createTargetCodeGenInfo(CodeGenModule &CGM)
static const llvm::GlobalValue * getAliasedGlobal(const llvm::GlobalValue *GV)
void setLLVMVisibility(llvm::GlobalValue &GV, std::optional< llvm::GlobalValue::VisibilityTypes > V)
static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D)
static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD, const NamedDecl *ND, bool OmitMultiVersionMangling=false)
static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND)
static unsigned ArgInfoAddressSpace(LangAS AS)
static void replaceDeclarationWith(llvm::GlobalValue *Old, llvm::Constant *New)
static QualType GeneralizeType(ASTContext &Ctx, QualType Ty)
static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, llvm::Function *NewFn)
ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we implement a function with...
static bool isVarDeclStrongDefinition(const ASTContext &Context, CodeGenModule &CGM, const VarDecl *D, bool NoCommon)
static std::optional< llvm::GlobalValue::VisibilityTypes > getLLVMVisibility(clang::LangOptions::VisibilityFromDLLStorageClassKinds K)
static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM, const CXXMethodDecl *MD)
static bool checkAliasedGlobal(const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames, SourceRange AliasRange)
static void EmitGlobalDeclMetadata(CodeGenModule &CGM, llvm::NamedMDNode *&GlobalMetadata, GlobalDecl D, llvm::GlobalValue *Addr)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::FileManager interface and associated types.
llvm::DenseSet< const void * > Visited
llvm::MachO::Target Target
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType.
static const NamedDecl * getDefinition(const Decl *D)
Defines the SourceManager interface.
static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type)
Defines version macros and version-related utility functions for Clang.
__device__ __2f16 float __ockl_bool s
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
@ Strong
Strong definition.
@ WeakUnknown
Weak for now, might become strong later in this TU.
const ProfileList & getProfileList() const
llvm::StringMap< SectionInfo > SectionInfos
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getRecordType(const RecordDecl *Decl) const
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
FullSourceLoc getFullLoc(SourceLocation Loc) const
const XRayFunctionFilter & getXRayFilter() const
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=RecordDecl::TagKind::Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
StringRef getCUIDHash() const
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const
Returns true if this is an inline-initialized static data member which is treated as a definition for...
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
SelectorTable & Selectors
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getCFConstantStringType() const
Return the C structure type used to represent constant CFStrings.
const NoSanitizeList & getNoSanitizeList() const
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType UnsignedLongTy
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
const clang::PrintingPolicy & getPrintingPolicy() const
CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const
Return the alignment in characters that should be given to a global variable with type T.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
QualType getObjCIdType() const
Represents the Objective-CC id type.
llvm::DenseSet< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
TargetCXXABI::Kind getCXXABIKind() const
Return the C++ ABI kind that should be used.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
unsigned getTargetAddressSpace(LangAS AS) const
QualType getWideCharType() const
Return the type of wide characters.
InlineVariableDefinitionKind getInlineVariableDefinitionKind(const VarDecl *VD) const
Determine whether a definition of this inline variable should be treated as a weak or strong definiti...
Module * getCurrentNamedModule() const
Get module under construction, nullptr if this is not a C++20 module.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Attr - This represents one attribute.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
bool isLibFunction(unsigned ID) const
Return true if this is a builtin for a libc/libm function, with a "__builtin_" prefix (e....
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
Represents a call to a C++ constructor.
Represents a C++ base or member initializer.
Expr * getInit() const
Get the initializer.
Represents a delete expression for memory deallocation and destructor calls, e.g.
Represents a C++ destructor within a class.
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Represents a C++ struct/union/class.
bool hasMutableFields() const
Determine whether this class, or any of its class subobjects, contains a mutable field.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
bool hasDefinition() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CharUnits - This is an opaque type for sizes expressed in character units.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits One()
One - Construct a CharUnits quantity of one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::string RecordCommandLine
The string containing the commandline for the llvm.commandline metadata, if non-empty.
std::string FloatABI
The ABI to use for passing floating point arguments.
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::vector< std::string > TocDataVarsUserSpecified
List of global variables explicitly specified by the user as toc-data.
std::string CoverageDataFile
The filename with path we use for coverage data files.
llvm::DenormalMode FP32DenormalMode
The floating-point denormal mode to use, for float.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
std::string ProfileRemappingFile
Name of the profile remapping file to apply to the profile data supplied by -fprofile-sample-use or -...
bool hasProfileClangUse() const
Check if Clang profile use is on.
std::string SymbolPartition
The name of the partition that symbols are assigned to, specified with -fsymbol-partition (see https:...
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.
virtual void appendAttributeMangling(TargetAttr *Attr, raw_ostream &Out) const
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
virtual void handleVarRegistration(const VarDecl *VD, llvm::GlobalVariable &Var)=0
Check whether a variable is a device variable and register it if true.
virtual llvm::GlobalValue * getKernelHandle(llvm::Function *Stub, GlobalDecl GD)=0
Get kernel handle by stub function.
virtual void internalizeDeviceSideVar(const VarDecl *D, llvm::GlobalValue::LinkageTypes &Linkage)=0
Adjust linkage of shadow variables in host compilation.
Implements C++ ABI-specific code generation functions.
virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0
Emit constructor variants required by this ABI.
virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0
virtual void EmitCXXDestructors(const CXXDestructorDecl *D)=0
Emit destructor variants required by this ABI.
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
MangleContext & getMangleContext()
Gets the mangle context.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
void AddStringLiteralDebugInfo(llvm::GlobalVariable *GV, const StringLiteral *S)
DebugInfo isn't attached to string literals by default.
CGFunctionInfo - Class to encapsulate the information about a function definition.
void addBuffer(const HLSLBufferDecl *D)
llvm::Type * getSamplerType(const Type *T)
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual void emitDeclareTargetFunction(const FunctionDecl *FD, llvm::GlobalValue *GV)
Emit code for handling declare target functions in the runtime.
virtual ConstantAddress getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
Class supports emissionof SIMD-only code.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property.
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
llvm::LLVMContext & getLLVMContext()
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
This class organizes the cross-function state that is used while generating LLVM code.
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)
Create and attach type metadata for the given vtable.
void UpdateCompletedType(const TagDecl *TD)
llvm::MDNode * getTBAAAccessTagInfo(TBAAAccessInfo Info)
getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const
Get LLVM TLS mode from CodeGenOptions.
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
void setDSOLocal(llvm::GlobalValue *GV) const
llvm::MDNode * getTBAAStructInfo(QualType QTy)
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Constant * EmitAnnotationArgs(const AnnotateAttr *Attr)
Emit additional args of the annotation.
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
CGDebugInfo * getModuleDebugInfo()
bool NeedAllVtablesTypeId() const
Returns whether this module needs the "all-vtables" type identifier.
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
CodeGenVTables & getVTables()
llvm::ConstantInt * CreateCrossDsoCfiTypeId(llvm::Metadata *MD)
Generate a cross-DSO type identifier for MD.
CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const
Return the store size, in character units, of the given LLVM type.
bool getExpressionLocationsEnabled() const
Return true if we should emit location information for expressions.
void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C)
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const
void EmitMainVoidAlias()
Emit an alias for "main" if it has no arguments (needed for wasm).
void DecorateInstructionWithInvariantGroup(llvm::Instruction *I, const CXXRecordDecl *RD)
Adds !invariant.barrier !tag to instruction.
DiagnosticsEngine & getDiags() const
bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const
llvm::Constant * getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
llvm::Constant * EmitAnnotateAttr(llvm::GlobalValue *GV, const AnnotateAttr *AA, SourceLocation L)
Generate the llvm::ConstantStruct which contains the annotation information for a given GlobalValue.
llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage)
Returns LLVM linkage for a declarator.
TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, TBAAAccessInfo SrcInfo)
mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the purposes of memory transfer call...
const LangOptions & getLangOpts() const
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
QualType getObjCFastEnumerationStateType()
Retrieve the record type that describes the state of an Objective-C fast enumeration loop (for....
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
CodeGenTypes & getTypes()
bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
const std::string & getModuleNameHash() const
const TargetInfo & getTarget() const
bool shouldEmitRTTI(bool ForEH=false)
void EmitGlobal(GlobalDecl D)
Emit code for a single global function or var decl.
llvm::Metadata * CreateMetadataIdentifierForType(QualType T)
Create a metadata identifier for the given type.
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
void AppendLinkerOptions(StringRef Opts)
Appends Opts to the "llvm.linker.options" metadata value.
void EmitExternalDeclaration(const DeclaratorDecl *D)
void AddDependentLib(StringRef Lib)
Appends a dependent lib to the appropriate metadata value.
void Release()
Finalize LLVM code generation.
ProfileList::ExclusionType isFunctionBlockedByProfileList(llvm::Function *Fn, SourceLocation Loc) const
llvm::MDNode * getTBAABaseTypeInfo(QualType QTy)
getTBAABaseTypeInfo - Get metadata that describes the given base access type.
bool lookupRepresentativeDecl(StringRef MangledName, GlobalDecl &Result) const
void EmitOMPAllocateDecl(const OMPAllocateDecl *D)
Emit a code for the allocate directive.
void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const
Set the visibility for the given LLVM GlobalValue.
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)
Returns LLVM linkage for a declarator.
bool HasHiddenLTOVisibility(const CXXRecordDecl *RD)
Returns whether the given record has hidden LTO visibility and therefore may participate in (single-m...
const llvm::DataLayout & getDataLayout() const
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType)
getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an access to a virtual table poi...
CGCXXABI & getCXXABI() const
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
llvm::Constant * GetFunctionStart(const ValueDecl *Decl)
static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V)
void EmitTentativeDefinition(const VarDecl *D)
void EmitDeferredUnusedCoverageMappings()
Emit all the deferred coverage mappings for the uninstrumented functions.
void addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category=StringRef()) const
Imbue XRay attributes to a function, applying the always/never attribute lists in the process.
llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)
Create a metadata identifier for the generalization of the given type.
void EmitGlobalAnnotations()
Emit all the global annotations.
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
const llvm::Triple & getTriple() const
SmallVector< const CXXRecordDecl *, 0 > getMostBaseClasses(const CXXRecordDecl *RD)
Return a vector of most-base classes for RD.
void AddDeferredUnusedCoverageMapping(Decl *D)
Stored a deferred empty coverage mapping for an unused and thus uninstrumented top level declaration.
void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV)
If the declaration has internal linkage but is inside an extern "C" linkage specification,...
void DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo)
DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.
llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD)
void AddGlobalDtor(llvm::Function *Dtor, int Priority=65535, bool IsDtorAttrFunc=false)
AddGlobalDtor - Add a function to the list that will be called when the module is unloaded.
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk)
Get the LLVM attributes and calling convention to use for a particular function type.
llvm::Constant * GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace, const VarDecl *D, ForDefinition_t IsForDefinition=NotForDefinition)
GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, create and return an llvm...
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.
void setFunctionLinkage(GlobalDecl GD, llvm::Function *F)
llvm::Constant * GetAddrOfGlobal(GlobalDecl GD, ForDefinition_t IsForDefinition=NotForDefinition)
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
ProfileList::ExclusionType isFunctionBlockedFromProfileInstr(llvm::Function *Fn, SourceLocation Loc) const
void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)
Add global annotations that are set on D, for the global GV.
void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const
Set the TLS mode for the given LLVM GlobalValue for the thread-local variable declaration D.
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
ASTContext & getContext() const
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D)
Emit a code for threadprivate directive.
ConstantAddress GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD)
Get the address of a UnnamedGlobalConstant.
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
llvm::SanitizerStatReport & getSanStats()
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare mapper construct.
bool supportsCOMDAT() const
void RefreshTypeCacheForClass(const CXXRecordDecl *Class)
llvm::MDNode * getTBAATypeInfo(QualType QTy)
getTBAATypeInfo - Get metadata used to describe accesses to objects of the given type.
void EmitOMPRequiresDecl(const OMPRequiresDecl *D)
Emit a code for requires directive.
void HandleCXXStaticMemberVarInstantiation(VarDecl *VD)
Tell the consumer that this variable has been instantiated.
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
StringRef getMangledName(GlobalDecl GD)
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV)
Set attributes which are common to any form of a global definition (alias, Objective-C method,...
std::optional< CharUnits > getOMPAllocateAlignment(const VarDecl *VD)
Return the alignment specified in an allocate directive, if present.
llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment)
Will return a global variable of the given type.
CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)
mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purposes of conditional ope...
llvm::LLVMContext & getLLVMContext()
llvm::GlobalValue * GetGlobalValue(StringRef Ref)
void GenKernelArgMetadata(llvm::Function *FN, const FunctionDecl *FD=nullptr, CodeGenFunction *CGF=nullptr)
OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument information in the program executab...
void CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata to the given function.
void setKCFIType(const FunctionDecl *FD, llvm::Function *F)
Set type metadata to the given function.
void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
void AddDetectMismatch(StringRef Name, StringRef Value)
Appends a detect mismatch command to the linker options.
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
llvm::Value * createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF)
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
LangAS GetGlobalVarAddressSpace(const VarDecl *D)
Return the AST address space of the underlying global variable for D, as determined by its declaratio...
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
void addReplacement(StringRef Name, llvm::Constant *C)
llvm::ConstantInt * CreateKCFITypeId(QualType T)
Generate a KCFI type identifier for T.
void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535, unsigned LexOrder=~0U, llvm::Constant *AssociatedData=nullptr)
AddGlobalCtor - Add a function to the list that will be called before main() runs.
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)
Create a metadata identifier that is intended to be used to check virtual calls via a member function...
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
const GlobalDecl getMangledNameDecl(StringRef)
void ClearUnusedCoverageMapping(const Decl *D)
Remove the deferred empty coverage mapping as this declaration is actually instrumented.
void EmitTopLevelDecl(Decl *D)
Emit code for a single top level declaration.
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation's translation unit.
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating '\0' character.
void printPostfixForExternalizedDecl(llvm::raw_ostream &OS, const Decl *D) const
Print the postfix for externalized static variable or kernels for single source offloading languages ...
void moveLazyEmissionStates(CodeGenModule *NewBuilder)
Move some lazily-emitted states to the NewBuilder.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
void finalizeKCFITypes()
Emit KCFI type identifier constants and remove unused identifiers.
void setValueProfilingFlag(llvm::Module &M)
void setProfileVersion(llvm::Module &M)
void emitEmptyCounterMapping(const Decl *D, StringRef FuncName, llvm::GlobalValue::LinkageTypes Linkage)
Emit a coverage mapping range with a counter zero for an unused declaration.
CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LL...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
void RefreshTypeCacheForClass(const CXXRecordDecl *RD)
Remove stale types from the type cache when an inheritance model gets assigned to a class.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the 'opaque' type we pr...
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
void GenerateClassData(const CXXRecordDecl *RD)
GenerateClassData - Generate all the class data required to be generated upon definition of a KeyFunc...
void EmitThunks(GlobalDecl GD)
EmitThunks - Emit the associated thunks for the given global decl.
A specialization of Address that requires the address to be an LLVM Constant.
static ConstantAddress invalid()
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
void finalize(llvm::GlobalVariable *global)
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
The standard implementation of ConstantInitBuilder used in Clang.
Organizes the cross-function state that is used while generating code coverage mapping data.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
bool hasDiagnostics()
Whether or not the stats we've gathered indicate any potential problems.
void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile)
Report potential problems we've found to Diags.
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
const T & getABIInfo() const
virtual LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const
Get target favored AST address space of a global variable for languages other than OpenCL and CUDA.
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
virtual LangAS getASTAllocaAddressSpace() const
Get the AST address space for alloca.
virtual void emitTargetMetadata(CodeGen::CodeGenModule &CGM, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames) const
emitTargetMetadata - Provides a convenient hook to handle extra target-specific metadata for the give...
virtual void emitTargetGlobals(CodeGen::CodeGenModule &CGM) const
Provides a convenient hook to handle extra target-specific globals.
virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString< 32 > &Opt) const
Gets the linker options necessary to detect object file mismatches on this platform.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Represents the canonical version of C arrays with a specified constant size.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Stores additional source code information like skipped ranges which is required by the coverage mappi...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
SourceLocation getEndLoc() const LLVM_READONLY
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
const Attr * getDefiningAttr() const
Return this declaration's defining attribute if it has one.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Represents a ValueDecl that came out of a declarator.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
This represents one expression.
Represents a member of a struct/union/class.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
StringRef getName() const
The name of this FileEntry.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Represents a function declaration or definition.
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isImmediateFunction() const
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
GlobalDecl - represents a global declaration.
GlobalDecl getWithMultiVersionIndex(unsigned Index)
CXXCtorType getCtorType() const
GlobalDecl getWithKernelReferenceKind(KernelReferenceKind Kind)
GlobalDecl getCanonicalDecl() const
KernelReferenceKind getKernelReferenceKind() const
GlobalDecl getWithDecl(const Decl *D)
unsigned getMultiVersionIndex() const
CXXDtorType getDtorType() const
const Decl * getDecl() const
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
@ None
No signing for any function.
@ Swift5_0
Interoperability with the Swift 5.0 runtime.
@ Swift
Interoperability with the latest known version of the Swift runtime.
@ Swift4_2
Interoperability with the Swift 4.2 runtime.
@ Swift4_1
Interoperability with the Swift 4.1 runtime.
VisibilityFromDLLStorageClassKinds
@ Keep
Keep the IR-gen assigned visibility.
@ Protected
Override the IR-gen assigned visibility with protected visibility.
@ Default
Override the IR-gen assigned visibility with default visibility.
@ Hidden
Override the IR-gen assigned visibility with hidden visibility.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isSignReturnAddressWithAKey() const
Check if return address signing uses AKey.
clang::ObjCRuntime ObjCRuntime
CoreFoundationABI CFRuntime
SanitizerSet Sanitize
Set of enabled sanitizers.
bool hasSignReturnAddress() const
Check if return address signing is enabled.
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE, BASE_FILE and __builtin_FILE().
LangStandard::Kind LangStd
The used language standard.
bool isSignReturnAddressScopeAll() const
Check if leaf functions are also signed.
std::string CUID
The user provided compilation unit ID, if non-empty.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Visibility getVisibility() const
void setLinkage(Linkage L)
Linkage getLinkage() const
bool isVisibilityExplicit() const
Represents a linkage specification.
LinkageSpecLanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Parts getParts() const
Get the decomposed parts of this declaration.
APValue & getAsAPValue() const
Get the value of this MSGuidDecl as an APValue.
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
void mangleBlock(const DeclContext *DC, const BlockDecl *BD, raw_ostream &Out)
void mangleCtorBlock(const CXXConstructorDecl *CD, CXXCtorType CT, const BlockDecl *BD, raw_ostream &Out)
void mangleGlobalBlock(const BlockDecl *BD, const NamedDecl *ID, raw_ostream &Out)
bool shouldMangleDeclName(const NamedDecl *D)
void mangleName(GlobalDecl GD, raw_ostream &)
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
virtual void mangleStringLiteral(const StringLiteral *SL, raw_ostream &)=0
ManglerKind getKind() const
virtual void needsUniqueInternalLinkageNames()
virtual void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber, raw_ostream &)=0
void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT, const BlockDecl *BD, raw_ostream &Out)
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Describes a module or submodule.
bool isInterfaceOrPartition() const
bool isNamedModuleUnit() const
Is this a C++20 named module unit.
Module * Parent
The parent of this module.
Module * getPrivateModuleFragment() const
Get the Private Module Fragment (sub-module) for this module, it there is one.
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Module * getGlobalModuleFragment() const
Get the Global Module Fragment (sub-module) for this module, it there is one.
llvm::iterator_range< submodule_iterator > submodules()
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
bool UseExportAsModuleLinkName
Autolinking uses the framework name for linking purposes when this is false and the export_as name ot...
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Represent a C++ namespace.
This represents '#pragma omp threadprivate ...' directive.
ObjCEncodeExpr, used for @encode in Objective-C.
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Represents an ObjC class declaration.
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarDecl * getNextIvar()
ObjCMethodDecl - Represents an instance or class method declaration.
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isSynthesizedAccessorStub=false, bool isImplicitlyDeclared=false, bool isDefined=false, ObjCImplementationControl impControl=ObjCImplementationControl::None, bool HasRelatedResultType=false)
Represents one property declaration in an Objective-C interface.
ObjCMethodDecl * getGetterMethodDecl() const
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
The basic abstraction for the target Objective-C runtime.
bool hasUnwindExceptions() const
Does this runtime use zero-cost exceptions?
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
Represents a parameter to a function.
ParsedAttr - Represents a syntactic attribute.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::optional< uint64_t > SourceDateEpoch
If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
std::vector< std::pair< std::string, bool > > Macros
Represents an unpacked "presumed" location which can be presented to the user.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
std::optional< ExclusionType > isFunctionExcluded(StringRef FunctionName, CodeGenOptions::ProfileInstrKind Kind) const
std::optional< ExclusionType > isLocationExcluded(SourceLocation Loc, CodeGenOptions::ProfileInstrKind Kind) const
ExclusionType
Represents if an how something should be excluded from profiling.
@ Skip
Profiling is skipped using the skipprofile attribute.
@ Allow
Profiling is allowed.
ExclusionType getDefault(CodeGenOptions::ProfileInstrKind Kind) const
std::optional< ExclusionType > isFileExcluded(StringRef FileName, CodeGenOptions::ProfileInstrKind Kind) const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) const
bool isConstQualified() const
Determine whether this type is const-qualified.
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
StringLiteral - This represents a string literal expression, e.g.
Represents the declaration of a struct/union/class/enum.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
TargetOptions & getTargetOpts() const
Retrieve the target options.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isReadOnlyFeature(StringRef Feature) const
Determine whether the given target feature is read only.
virtual unsigned multiVersionSortPriority(StringRef Name) const
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
virtual unsigned multiVersionFeatureCost() const
bool supportsIFunc() const
Identify whether this target supports IFuncs.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
@ Hostcall
printf lowering scheme involving hostcalls, currently used by HIP programs by default
A template parameter object.
const APValue & getValue() const
A declaration that models statements at global scope.
The top declaration context.
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
const Type * getTypeForDecl() const
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
Linkage getLinkage() const
Determine the linkage of this type.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
const APValue & getValue() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
TLSKind getTLSKind() const
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
CharUnits getFlexibleArrayInitChars(const ASTContext &Ctx) const
If hasFlexibleArrayInit is true, compute the number of additional bytes necessary to store those elem...
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Defines the clang::TargetInfo interface.
std::unique_ptr< TargetCodeGenInfo > createARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind Kind)
std::unique_ptr< TargetCodeGenInfo > createM68kTargetCodeGenInfo(CodeGenModule &CGM)
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
std::unique_ptr< TargetCodeGenInfo > createBPFTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createMSP430TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
std::unique_ptr< TargetCodeGenInfo > createWebAssemblyTargetCodeGenInfo(CodeGenModule &CGM, WebAssemblyABIKind K)
std::unique_ptr< TargetCodeGenInfo > createPPC64_SVR4_TargetCodeGenInfo(CodeGenModule &CGM, PPC64_SVR4_ABIKind Kind, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32)
std::unique_ptr< TargetCodeGenInfo > createHexagonTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createNVPTXTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createSystemZTargetCodeGenInfo(CodeGenModule &CGM, bool HasVector, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createWinX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters)
std::unique_ptr< TargetCodeGenInfo > createAIXTargetCodeGenInfo(CodeGenModule &CGM, bool Is64Bit)
std::unique_ptr< TargetCodeGenInfo > createAMDGPUTargetCodeGenInfo(CodeGenModule &CGM)
CGObjCRuntime * CreateMacObjCRuntime(CodeGenModule &CGM)
X86AVXABILevel
The AVX ABI level for X86 targets.
std::unique_ptr< TargetCodeGenInfo > createTCETargetCodeGenInfo(CodeGenModule &CGM)
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
std::unique_ptr< TargetCodeGenInfo > createWindowsARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind K)
std::unique_ptr< TargetCodeGenInfo > createAVRTargetCodeGenInfo(CodeGenModule &CGM, unsigned NPR, unsigned NRR)
std::unique_ptr< TargetCodeGenInfo > createARCTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createDefaultTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind Kind)
std::unique_ptr< TargetCodeGenInfo > createSPIRVTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createSparcV8TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createVETargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createCommonSPIRTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createRISCVTargetCodeGenInfo(CodeGenModule &CGM, unsigned XLen, unsigned FLen, bool EABI)
std::unique_ptr< TargetCodeGenInfo > createWindowsAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind K)
std::unique_ptr< TargetCodeGenInfo > createSparcV9TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createPNaClTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createLanaiTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createPPC32TargetCodeGenInfo(CodeGenModule &CGM, bool SoftFloatABI)
CGCUDARuntime * CreateNVCUDARuntime(CodeGenModule &CGM)
Creates an instance of a CUDA runtime class.
std::unique_ptr< TargetCodeGenInfo > createLoongArchTargetCodeGenInfo(CodeGenModule &CGM, unsigned GRLen, unsigned FLen)
std::unique_ptr< TargetCodeGenInfo > createPPC64TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createWinX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
std::unique_ptr< TargetCodeGenInfo > createXCoreTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createCSKYTargetCodeGenInfo(CodeGenModule &CGM, unsigned FLen)
llvm::PointerUnion< const Decl *, const Expr * > DeclTy
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_Complete
Complete object ctor.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, DiagnosticsEngine &Diags)
GVALinkage
A more specific kind of linkage than enum Linkage.
@ GVA_AvailableExternally
std::string getClangVendor()
Retrieves the Clang vendor tag.
@ ICIS_NoInit
No in-class initializer.
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
StringRef languageToString(Language L)
@ Dtor_Base
Base object dtor.
@ Dtor_Complete
Complete object dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
const FunctionProtoType * T
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
bool isExternallyVisible(Linkage L)
@ EST_None
no exception specification
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
@ DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects.
cl::opt< bool > SystemHeadersCoverage
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
llvm::CallingConv::ID RuntimeCC
llvm::PointerType * VoidPtrTy
llvm::IntegerType * Int64Ty
llvm::PointerType * ConstGlobalsPtrTy
void* in the address space for constant globals
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::IntegerType * CharTy
char
LangAS ASTAllocaAddressSpace
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
unsigned char IntAlignInBytes
llvm::Type * HalfTy
half, bfloat, float, double
unsigned char SizeSizeInBytes
llvm::CallingConv::ID getRuntimeCC() const
llvm::IntegerType * SizeTy
llvm::PointerType * GlobalsInt8PtrTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntPtrTy
llvm::IntegerType * IntTy
int
llvm::IntegerType * Int16Ty
unsigned char PointerAlignInBytes
llvm::PointerType * Int8PtrTy
CharUnits getPointerAlign() const
llvm::PointerType * AllocaInt8PtrTy
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool hasSideEffects() const
static const LangStandard & getLangStandardForKind(Kind K)
Parts of a decomposed MSGuidDecl.
uint16_t Part2
...-89ab-...
uint32_t Part1
{01234567-...
uint16_t Part3
...-cdef-...
uint8_t Part4And5[8]
...-0123-456789abcdef}
A library or framework to link against when an entity from this module is used.
Contains information gathered from parsing the contents of TargetAttr.
Describes how types, statements, expressions, and declarations should be printed.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.