50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/ADT/StringSwitch.h"
53#include "llvm/Analysis/TargetLibraryInfo.h"
54#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
55#include "llvm/IR/CallingConv.h"
56#include "llvm/IR/DataLayout.h"
57#include "llvm/IR/Intrinsics.h"
58#include "llvm/IR/LLVMContext.h"
59#include "llvm/IR/Module.h"
60#include "llvm/IR/ProfileSummary.h"
61#include "llvm/ProfileData/InstrProfReader.h"
62#include "llvm/ProfileData/SampleProf.h"
63#include "llvm/Support/CRC.h"
64#include "llvm/Support/CodeGen.h"
65#include "llvm/Support/CommandLine.h"
66#include "llvm/Support/ConvertUTF.h"
67#include "llvm/Support/ErrorHandling.h"
68#include "llvm/Support/TimeProfiler.h"
69#include "llvm/Support/xxhash.h"
70#include "llvm/TargetParser/Triple.h"
71#include "llvm/TargetParser/X86TargetParser.h"
75using namespace CodeGen;
78 "limited-coverage-experimental", llvm::cl::Hidden,
79 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"));
85 case TargetCXXABI::AppleARM64:
86 case TargetCXXABI::Fuchsia:
87 case TargetCXXABI::GenericAArch64:
88 case TargetCXXABI::GenericARM:
89 case TargetCXXABI::iOS:
90 case TargetCXXABI::WatchOS:
91 case TargetCXXABI::GenericMIPS:
92 case TargetCXXABI::GenericItanium:
93 case TargetCXXABI::WebAssembly:
94 case TargetCXXABI::XL:
96 case TargetCXXABI::Microsoft:
100 llvm_unreachable(
"invalid C++ ABI kind");
110 : Context(
C), LangOpts(
C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
111 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
113 VMContext(M.getContext()), Types(*this), VTables(*this),
117 llvm::LLVMContext &LLVMContext = M.getContext();
118 VoidTy = llvm::Type::getVoidTy(LLVMContext);
119 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
120 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
121 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
122 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
123 HalfTy = llvm::Type::getHalfTy(LLVMContext);
124 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
125 FloatTy = llvm::Type::getFloatTy(LLVMContext);
126 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
132 C.toCharUnitsFromBits(
C.getTargetInfo().getMaxPointerWidth()).getQuantity();
134 C.toCharUnitsFromBits(
C.getTargetInfo().getIntAlign()).getQuantity();
136 llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getCharWidth());
137 IntTy = llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getIntWidth());
138 IntPtrTy = llvm::IntegerType::get(LLVMContext,
139 C.getTargetInfo().getMaxPointerWidth());
142 const llvm::DataLayout &DL = M.getDataLayout();
161 createOpenCLRuntime();
163 createOpenMPRuntime();
170 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread) ||
171 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
178 CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
181 Block.GlobalUniqueCount = 0;
183 if (
C.getLangOpts().ObjC)
187 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
194 PGOReader = std::move(ReaderOrErr.get());
199 if (CodeGenOpts.CoverageMapping)
203 if (CodeGenOpts.UniqueInternalLinkageNames &&
204 !
getModule().getSourceFileName().empty()) {
205 std::string Path =
getModule().getSourceFileName();
208 if (Path.rfind(Entry.first, 0) != std::string::npos) {
209 Path = Entry.second + Path.substr(Entry.first.size());
212 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(Path);
218void CodeGenModule::createObjCRuntime() {
235 llvm_unreachable(
"bad runtime kind");
238void CodeGenModule::createOpenCLRuntime() {
242void CodeGenModule::createOpenMPRuntime() {
246 case llvm::Triple::nvptx:
247 case llvm::Triple::nvptx64:
248 case llvm::Triple::amdgcn:
250 "OpenMP AMDGPU/NVPTX is only prepared to deal with device code.");
254 if (LangOpts.OpenMPSimd)
262void CodeGenModule::createCUDARuntime() {
266void CodeGenModule::createHLSLRuntime() {
271 Replacements[Name] =
C;
274void CodeGenModule::applyReplacements() {
275 for (
auto &I : Replacements) {
276 StringRef MangledName = I.first();
277 llvm::Constant *Replacement = I.second;
281 auto *OldF = cast<llvm::Function>(Entry);
282 auto *NewF = dyn_cast<llvm::Function>(Replacement);
284 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
285 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
287 auto *CE = cast<llvm::ConstantExpr>(Replacement);
288 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
289 CE->getOpcode() == llvm::Instruction::GetElementPtr);
290 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
295 OldF->replaceAllUsesWith(Replacement);
297 NewF->removeFromParent();
298 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
301 OldF->eraseFromParent();
306 GlobalValReplacements.push_back(std::make_pair(GV,
C));
309void CodeGenModule::applyGlobalValReplacements() {
310 for (
auto &I : GlobalValReplacements) {
311 llvm::GlobalValue *GV = I.first;
312 llvm::Constant *
C = I.second;
314 GV->replaceAllUsesWith(
C);
315 GV->eraseFromParent();
322 const llvm::Constant *
C;
323 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
324 C = GA->getAliasee();
325 else if (
auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
326 C = GI->getResolver();
330 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(
C->stripPointerCasts());
334 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
343 const llvm::GlobalValue *Alias,
const llvm::GlobalValue *&GV,
344 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
348 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
352 if (GV->isDeclaration()) {
353 Diags.
Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
354 Diags.
Report(Location, diag::note_alias_requires_mangled_name)
355 << IsIFunc << IsIFunc;
358 for (
const auto &[
Decl, Name] : MangledDeclNames) {
359 if (
const auto *ND = dyn_cast<NamedDecl>(
Decl.getDecl())) {
360 if (ND->getName() == GV->getName()) {
361 Diags.
Report(Location, diag::note_alias_mangled_name_alternative)
365 (Twine(IsIFunc ?
"ifunc" :
"alias") +
"(\"" + Name +
"\")")
375 const auto *F = dyn_cast<llvm::Function>(GV);
377 Diags.
Report(Location, diag::err_alias_to_undefined)
378 << IsIFunc << IsIFunc;
382 llvm::FunctionType *FTy = F->getFunctionType();
383 if (!FTy->getReturnType()->isPointerTy()) {
384 Diags.
Report(Location, diag::err_ifunc_resolver_return);
392void CodeGenModule::checkAliases() {
399 const auto *D = cast<ValueDecl>(GD.getDecl());
402 bool IsIFunc = D->hasAttr<IFuncAttr>();
403 if (
const Attr *A = D->getDefiningAttr()) {
404 Location = A->getLocation();
405 Range = A->getRange();
407 llvm_unreachable(
"Not an alias or ifunc?");
411 const llvm::GlobalValue *GV =
nullptr;
413 MangledDeclNames, Range)) {
418 llvm::Constant *Aliasee =
419 IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()
420 : cast<llvm::GlobalAlias>(Alias)->getAliasee();
422 llvm::GlobalValue *AliaseeGV;
423 if (
auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
424 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
426 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
428 if (
const SectionAttr *SA = D->getAttr<SectionAttr>()) {
429 StringRef AliasSection = SA->getName();
430 if (AliasSection != AliaseeGV->getSection())
431 Diags.
Report(SA->getLocation(), diag::warn_alias_with_section)
432 << AliasSection << IsIFunc << IsIFunc;
440 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
441 if (GA->isInterposable()) {
442 Diags.
Report(Location, diag::warn_alias_to_weak_alias)
443 << GV->getName() << GA->getName() << IsIFunc;
444 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
445 GA->getAliasee(), Alias->getType());
448 cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);
450 cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);
460 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
461 Alias->eraseFromParent();
466 DeferredDeclsToEmit.clear();
467 EmittedDeferredDecls.clear();
469 OpenMPRuntime->clear();
473 StringRef MainFile) {
476 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
477 if (MainFile.empty())
478 MainFile =
"<stdin>";
479 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
482 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
485 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
491 if (!LO.VisibilityFromDLLStorageClass)
494 llvm::GlobalValue::VisibilityTypes DLLExportVisibility =
496 llvm::GlobalValue::VisibilityTypes NoDLLStorageClassVisibility =
498 llvm::GlobalValue::VisibilityTypes ExternDeclDLLImportVisibility =
500 llvm::GlobalValue::VisibilityTypes ExternDeclNoDLLStorageClassVisibility =
502 LO.getExternDeclNoDLLStorageClassVisibility());
504 for (llvm::GlobalValue &GV : M.global_values()) {
505 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
513 GV.setDSOLocal(
false);
515 if (GV.isDeclarationForLinker()) {
516 GV.setVisibility(GV.getDLLStorageClass() ==
517 llvm::GlobalValue::DLLImportStorageClass
518 ? ExternDeclDLLImportVisibility
519 : ExternDeclNoDLLStorageClassVisibility);
521 GV.setVisibility(GV.getDLLStorageClass() ==
522 llvm::GlobalValue::DLLExportStorageClass
523 ? DLLExportVisibility
524 : NoDLLStorageClassVisibility);
527 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
534 EmitModuleInitializers(Primary);
536 DeferredDecls.insert(EmittedDeferredDecls.begin(),
537 EmittedDeferredDecls.end());
538 EmittedDeferredDecls.clear();
539 EmitVTablesOpportunistically();
540 applyGlobalValReplacements();
542 emitMultiVersionFunctions();
545 GlobalTopLevelStmtBlockInFlight.first) {
547 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->
getEndLoc());
548 GlobalTopLevelStmtBlockInFlight = {
nullptr,
nullptr};
554 EmitCXXModuleInitFunc(Primary);
556 EmitCXXGlobalInitFunc();
557 EmitCXXGlobalCleanUpFunc();
558 registerGlobalDtorsWithAtExit();
559 EmitCXXThreadLocalInitFunc();
561 if (llvm::Function *ObjCInitFunction =
ObjCRuntime->ModuleInitFunction())
562 AddGlobalCtor(ObjCInitFunction);
564 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
565 AddGlobalCtor(CudaCtorFunction);
568 if (llvm::Function *OpenMPRequiresDirectiveRegFun =
569 OpenMPRuntime->emitRequiresDirectiveRegFun()) {
570 AddGlobalCtor(OpenMPRequiresDirectiveRegFun, 0);
572 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
573 OpenMPRuntime->clear();
577 PGOReader->getSummary(
false).getMD(VMContext),
578 llvm::ProfileSummary::PSK_Instr);
585 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
586 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
588 EmitStaticExternCAliases();
593 CoverageMapping->emit();
594 if (CodeGenOpts.SanitizeCfiCrossDso) {
600 emitAtAvailableLinkGuard();
607 if (
getTarget().getTargetOpts().CodeObjectVersion !=
609 getModule().addModuleFlag(llvm::Module::Error,
610 "amdgpu_code_object_version",
611 getTarget().getTargetOpts().CodeObjectVersion);
623 if (
auto *FD = dyn_cast<FunctionDecl>(D))
627 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
631 llvm::ArrayType *ATy = llvm::ArrayType::get(
Int8PtrTy, UsedArray.size());
633 auto *GV =
new llvm::GlobalVariable(
634 getModule(), ATy,
false, llvm::GlobalValue::InternalLinkage,
635 llvm::ConstantArray::get(ATy, UsedArray),
"__clang_gpu_used_external");
643 if (CodeGenOpts.Autolink &&
644 (Context.
getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
645 EmitModuleLinkOptions();
660 if (!ELFDependentLibraries.empty() && !Context.
getLangOpts().CUDAIsDevice) {
661 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
662 for (
auto *MD : ELFDependentLibraries)
668 getModule().addModuleFlag(llvm::Module::Error,
"NumRegisterParameters",
669 CodeGenOpts.NumRegisterParameters);
671 if (CodeGenOpts.DwarfVersion) {
672 getModule().addModuleFlag(llvm::Module::Max,
"Dwarf Version",
673 CodeGenOpts.DwarfVersion);
676 if (CodeGenOpts.Dwarf64)
677 getModule().addModuleFlag(llvm::Module::Max,
"DWARF64", 1);
681 getModule().setSemanticInterposition(
true);
683 if (CodeGenOpts.EmitCodeView) {
685 getModule().addModuleFlag(llvm::Module::Warning,
"CodeView", 1);
687 if (CodeGenOpts.CodeViewGHash) {
688 getModule().addModuleFlag(llvm::Module::Warning,
"CodeViewGHash", 1);
690 if (CodeGenOpts.ControlFlowGuard) {
692 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 2);
693 }
else if (CodeGenOpts.ControlFlowGuardNoChecks) {
695 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 1);
697 if (CodeGenOpts.EHContGuard) {
699 getModule().addModuleFlag(llvm::Module::Warning,
"ehcontguard", 1);
703 getModule().addModuleFlag(llvm::Module::Warning,
"ms-kernel", 1);
705 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
710 getModule().addModuleFlag(llvm::Module::Error,
"StrictVTablePointers",1);
712 llvm::Metadata *Ops[2] = {
713 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
714 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
715 llvm::Type::getInt32Ty(VMContext), 1))};
717 getModule().addModuleFlag(llvm::Module::Require,
718 "StrictVTablePointersRequirement",
719 llvm::MDNode::get(VMContext, Ops));
725 getModule().addModuleFlag(llvm::Module::Warning,
"Debug Info Version",
726 llvm::DEBUG_METADATA_VERSION);
731 uint64_t WCharWidth =
733 getModule().addModuleFlag(llvm::Module::Error,
"wchar_size", WCharWidth);
736 if ( Arch == llvm::Triple::arm
737 || Arch == llvm::Triple::armeb
738 || Arch == llvm::Triple::thumb
739 || Arch == llvm::Triple::thumbeb) {
741 uint64_t EnumWidth = Context.
getLangOpts().ShortEnums ? 1 : 4;
742 getModule().addModuleFlag(llvm::Module::Error,
"min_enum_size", EnumWidth);
745 if (Arch == llvm::Triple::riscv32 || Arch == llvm::Triple::riscv64) {
746 StringRef ABIStr = Target.
getABI();
747 llvm::LLVMContext &Ctx = TheModule.getContext();
748 getModule().addModuleFlag(llvm::Module::Error,
"target-abi",
749 llvm::MDString::get(Ctx, ABIStr));
752 if (CodeGenOpts.SanitizeCfiCrossDso) {
754 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
757 if (CodeGenOpts.WholeProgramVTables) {
761 getModule().addModuleFlag(llvm::Module::Error,
"Virtual Function Elim",
762 CodeGenOpts.VirtualFunctionElimination);
765 if (LangOpts.
Sanitize.
has(SanitizerKind::CFIICall)) {
766 getModule().addModuleFlag(llvm::Module::Override,
767 "CFI Canonical Jump Tables",
768 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
772 getModule().addModuleFlag(llvm::Module::Override,
"kcfi", 1);
775 if (CodeGenOpts.PatchableFunctionEntryOffset)
776 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-offset",
777 CodeGenOpts.PatchableFunctionEntryOffset);
780 if (CodeGenOpts.CFProtectionReturn &&
783 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-return",
787 if (CodeGenOpts.CFProtectionBranch &&
790 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-branch",
794 if (CodeGenOpts.FunctionReturnThunks)
795 getModule().addModuleFlag(llvm::Module::Override,
"function_return_thunk_extern", 1);
797 if (CodeGenOpts.IndirectBranchCSPrefix)
798 getModule().addModuleFlag(llvm::Module::Override,
"indirect_branch_cs_prefix", 1);
810 LangOpts.getSignReturnAddressScope() !=
812 getModule().addModuleFlag(llvm::Module::Override,
813 "sign-return-address-buildattr", 1);
814 if (LangOpts.
Sanitize.
has(SanitizerKind::MemtagStack))
815 getModule().addModuleFlag(llvm::Module::Override,
816 "tag-stack-memory-buildattr", 1);
818 if (Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
819 Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
820 Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_32 ||
821 Arch == llvm::Triple::aarch64_be) {
822 if (LangOpts.BranchTargetEnforcement)
823 getModule().addModuleFlag(llvm::Module::Min,
"branch-target-enforcement",
826 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address", 1);
828 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address-all",
831 getModule().addModuleFlag(llvm::Module::Min,
832 "sign-return-address-with-bkey", 1);
836 llvm::LLVMContext &Ctx = TheModule.getContext();
838 llvm::Module::Error,
"MemProfProfileFilename",
842 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
846 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
848 llvm::DenormalMode::IEEE);
851 if (LangOpts.EHAsynch)
852 getModule().addModuleFlag(llvm::Module::Warning,
"eh-asynch", 1);
856 getModule().addModuleFlag(llvm::Module::Max,
"openmp", LangOpts.OpenMP);
858 getModule().addModuleFlag(llvm::Module::Max,
"openmp-device",
862 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())) {
863 EmitOpenCLMetadata();
871 llvm::Metadata *SPIRVerElts[] = {
872 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
874 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
875 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
876 llvm::NamedMDNode *SPIRVerMD =
877 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
878 llvm::LLVMContext &Ctx = TheModule.getContext();
879 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
887 if (uint32_t PLevel = Context.
getLangOpts().PICLevel) {
888 assert(PLevel < 3 &&
"Invalid PIC Level");
889 getModule().setPICLevel(
static_cast<llvm::PICLevel::Level
>(PLevel));
891 getModule().setPIELevel(
static_cast<llvm::PIELevel::Level
>(PLevel));
895 unsigned CM = llvm::StringSwitch<unsigned>(
getCodeGenOpts().CodeModel)
896 .Case(
"tiny", llvm::CodeModel::Tiny)
897 .Case(
"small", llvm::CodeModel::Small)
898 .Case(
"kernel", llvm::CodeModel::Kernel)
899 .Case(
"medium", llvm::CodeModel::Medium)
900 .Case(
"large", llvm::CodeModel::Large)
903 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
908 if (CodeGenOpts.NoPLT)
910 if (CodeGenOpts.UnwindTables)
911 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
913 switch (CodeGenOpts.getFramePointer()) {
918 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
921 getModule().setFramePointer(llvm::FramePointerKind::All);
925 SimplifyPersonality();
937 EmitVersionIdentMetadata();
940 EmitCommandLineMetadata();
948 getModule().setStackProtectorGuardSymbol(
951 getModule().setStackProtectorGuardOffset(
956 getModule().addModuleFlag(llvm::Module::Override,
"SkipRaxSetup", 1);
958 if (
getContext().getTargetInfo().getMaxTLSAlign())
959 getModule().addModuleFlag(llvm::Module::Error,
"MaxTLSAlign",
960 getContext().getTargetInfo().getMaxTLSAlign());
976void CodeGenModule::EmitOpenCLMetadata() {
981 llvm::Metadata *OCLVerElts[] = {
982 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
984 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
985 Int32Ty, (Version % 100) / 10))};
986 llvm::NamedMDNode *OCLVerMD =
987 TheModule.getOrInsertNamedMetadata(
"opencl.ocl.version");
988 llvm::LLVMContext &Ctx = TheModule.getContext();
989 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
992void CodeGenModule::EmitBackendOptionsMetadata(
995 getModule().addModuleFlag(llvm::Module::Min,
"SmallDataLimit",
996 CodeGenOpts.SmallDataLimit);
1013 return TBAA->getTypeInfo(QTy);
1032 return TBAA->getAccessInfo(AccessType);
1039 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1045 return TBAA->getTBAAStructInfo(QTy);
1051 return TBAA->getBaseTypeInfo(QTy);
1057 return TBAA->getAccessTagInfo(Info);
1064 return TBAA->mergeTBAAInfoForCast(SourceInfo,
TargetInfo);
1072 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1080 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1086 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1091 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1104 "cannot compile this %0 yet");
1105 std::string Msg =
Type;
1107 << Msg << S->getSourceRange();
1114 "cannot compile this %0 yet");
1115 std::string Msg =
Type;
1126 if (GV->hasLocalLinkage()) {
1127 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1135 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1139 if (GV->hasDLLExportStorageClass()) {
1142 diag::err_hidden_visibility_dllexport);
1145 diag::err_non_default_visibility_dllimport);
1151 !GV->isDeclarationForLinker())
1156 llvm::GlobalValue *GV) {
1157 if (GV->hasLocalLinkage())
1160 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1164 if (GV->hasDLLImportStorageClass())
1167 const llvm::Triple &TT = CGM.
getTriple();
1168 if (TT.isWindowsGNUEnvironment()) {
1177 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1185 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1193 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1197 if (!TT.isOSBinFormatELF())
1204 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1210 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1212 return !(CGM.
getLangOpts().SemanticInterposition ||
1217 if (!GV->isDeclarationForLinker())
1223 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1230 if (CGOpts.DirectAccessExternalData) {
1236 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1237 if (!Var->isThreadLocal())
1246 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1262 const auto *D = dyn_cast<NamedDecl>(GD.
getDecl());
1264 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
1274 if (D->
hasAttr<DLLImportAttr>())
1275 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1276 else if ((D->
hasAttr<DLLExportAttr>() ||
1278 !GV->isDeclarationForLinker())
1279 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1303 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1304 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1305 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1306 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1307 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1310llvm::GlobalVariable::ThreadLocalMode
1312 switch (CodeGenOpts.getDefaultTLSModel()) {
1314 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1316 return llvm::GlobalVariable::LocalDynamicTLSModel;
1318 return llvm::GlobalVariable::InitialExecTLSModel;
1320 return llvm::GlobalVariable::LocalExecTLSModel;
1322 llvm_unreachable(
"Invalid TLS model!");
1326 assert(D.
getTLSKind() &&
"setting TLS mode on non-TLS var!");
1328 llvm::GlobalValue::ThreadLocalMode TLM;
1332 if (
const TLSModelAttr *
Attr = D.
getAttr<TLSModelAttr>()) {
1336 GV->setThreadLocalMode(TLM);
1342 return (Twine(
'.') + Twine(
Target.CPUSpecificManglingCharacter(Name))).str();
1346 const CPUSpecificAttr *
Attr,
1358 const TargetVersionAttr *
Attr,
1360 if (
Attr->isDefaultVersion())
1364 Attr->getFeatures(Feats);
1365 for (
const auto &Feat : Feats) {
1372 const TargetAttr *
Attr, raw_ostream &Out) {
1373 if (
Attr->isDefaultVersion())
1379 llvm::sort(Info.
Features, [&
Target](StringRef LHS, StringRef RHS) {
1382 assert(LHS.startswith(
"+") && RHS.startswith(
"+") &&
1383 "Features should always have a prefix.");
1384 return Target.multiVersionSortPriority(LHS.substr(1)) >
1385 Target.multiVersionSortPriority(RHS.substr(1));
1388 bool IsFirst =
true;
1390 if (!Info.
CPU.empty()) {
1392 Out <<
"arch_" << Info.
CPU;
1395 for (StringRef Feat : Info.
Features) {
1399 Out << Feat.substr(1);
1413 const TargetClonesAttr *
Attr,
1414 unsigned VersionIndex,
1417 StringRef FeatureStr =
Attr->getFeatureStr(VersionIndex);
1418 if (FeatureStr ==
"default")
1422 FeatureStr.split(Features,
"+");
1423 for (
auto &Feat : Features) {
1429 StringRef FeatureStr =
Attr->getFeatureStr(VersionIndex);
1430 if (FeatureStr.startswith(
"arch="))
1431 Out <<
"arch_" << FeatureStr.substr(
sizeof(
"arch=") - 1);
1435 Out <<
'.' <<
Attr->getMangledIndex(VersionIndex);
1441 bool OmitMultiVersionMangling =
false) {
1443 llvm::raw_svector_ostream Out(Buffer);
1452 assert(II &&
"Attempt to mangle unnamed decl.");
1453 const auto *FD = dyn_cast<FunctionDecl>(ND);
1457 Out <<
"__regcall3__" << II->
getName();
1458 }
else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
1460 Out <<
"__device_stub__" << II->
getName();
1476 "Hash computed when not explicitly requested");
1480 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
1481 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1482 switch (FD->getMultiVersionKind()) {
1486 FD->getAttr<CPUSpecificAttr>(),
1500 llvm_unreachable(
"None multiversion type isn't valid here");
1510 return std::string(Out.str());
1513void CodeGenModule::UpdateMultiVersionNames(
GlobalDecl GD,
1515 StringRef &CurName) {
1522 std::string NonTargetName =
1530 "Other GD should now be a multiversioned function");
1540 if (OtherName != NonTargetName) {
1543 const auto ExistingRecord = Manglings.find(NonTargetName);
1544 if (ExistingRecord != std::end(Manglings))
1545 Manglings.remove(&(*ExistingRecord));
1546 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1551 CurName = OtherNameRef;
1553 Entry->setName(OtherName);
1563 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
1577 auto FoundName = MangledDeclNames.find(CanonicalGD);
1578 if (FoundName != MangledDeclNames.end())
1579 return FoundName->second;
1583 const auto *ND = cast<NamedDecl>(GD.
getDecl());
1595 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
1606 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
1607 return MangledDeclNames[CanonicalGD] =
Result.first->first();
1616 llvm::raw_svector_ostream Out(Buffer);
1619 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.
getDecl()), Out);
1620 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1622 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1625 MangleCtx.
mangleBlock(cast<DeclContext>(D), BD, Out);
1627 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
1628 return Result.first->first();
1632 auto it = MangledDeclNames.begin();
1633 while (it != MangledDeclNames.end()) {
1634 if (it->second == Name)
1647void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor,
int Priority,
1649 llvm::Constant *AssociatedData) {
1651 GlobalCtors.push_back(Structor(Priority, LexOrder, Ctor, AssociatedData));
1656void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor,
int Priority,
1657 bool IsDtorAttrFunc) {
1658 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
1660 DtorsUsingAtExit[
Priority].push_back(Dtor);
1665 GlobalDtors.push_back(Structor(Priority, ~0
U, Dtor,
nullptr));
1668void CodeGenModule::EmitCtorList(CtorList &Fns,
const char *GlobalName) {
1669 if (Fns.empty())
return;
1672 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(
VoidTy,
false);
1673 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
1674 TheModule.getDataLayout().getProgramAddressSpace());
1677 llvm::StructType *CtorStructTy = llvm::StructType::get(
1682 auto ctors = builder.beginArray(CtorStructTy);
1683 for (
const auto &I : Fns) {
1684 auto ctor = ctors.beginStruct(CtorStructTy);
1685 ctor.addInt(
Int32Ty, I.Priority);
1686 ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy));
1687 if (I.AssociatedData)
1688 ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData,
VoidPtrTy));
1691 ctor.finishAndAddTo(ctors);
1697 llvm::GlobalValue::AppendingLinkage);
1701 list->setAlignment(std::nullopt);
1706llvm::GlobalValue::LinkageTypes
1708 const auto *D = cast<FunctionDecl>(GD.
getDecl());
1712 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
1715 if (isa<CXXConstructorDecl>(D) &&
1716 cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
1721 return llvm::GlobalValue::InternalLinkage;
1728 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
1729 if (!MDS)
return nullptr;
1731 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
1737 FnType->getReturnType(), FnType->getParamTypes(),
1738 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
1740 std::string OutName;
1741 llvm::raw_string_ostream Out(OutName);
1746 Out <<
".normalized";
1748 return llvm::ConstantInt::get(
Int32Ty,
1749 static_cast<uint32_t
>(llvm::xxHash64(OutName)));
1754 llvm::Function *F,
bool IsThunk) {
1756 llvm::AttributeList PAL;
1759 F->setAttributes(PAL);
1760 F->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
CallingConv));
1764 std::string ReadOnlyQual(
"__read_only");
1765 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
1766 if (ReadOnlyPos != std::string::npos)
1768 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
1770 std::string WriteOnlyQual(
"__write_only");
1771 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
1772 if (WriteOnlyPos != std::string::npos)
1773 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
1775 std::string ReadWriteQual(
"__read_write");
1776 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
1777 if (ReadWritePos != std::string::npos)
1778 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
1811 assert(((FD && CGF) || (!FD && !CGF)) &&
1812 "Incorrect use - FD and CGF should either be both null or not!");
1838 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
1841 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
1846 std::string typeQuals;
1850 const Decl *PDecl = parm;
1852 PDecl = TD->getDecl();
1853 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
1854 if (A && A->isWriteOnly())
1855 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
1856 else if (A && A->isReadWrite())
1857 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
1859 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
1861 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
1863 auto getTypeSpelling = [&](
QualType Ty) {
1864 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
1866 if (Ty.isCanonical()) {
1867 StringRef typeNameRef = typeName;
1869 if (typeNameRef.consume_front(
"unsigned "))
1870 return std::string(
"u") + typeNameRef.str();
1871 if (typeNameRef.consume_front(
"signed "))
1872 return typeNameRef.str();
1882 addressQuals.push_back(
1883 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
1887 std::string typeName = getTypeSpelling(pointeeTy) +
"*";
1888 std::string baseTypeName =
1890 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
1891 argBaseTypeNames.push_back(
1892 llvm::MDString::get(VMContext, baseTypeName));
1896 typeQuals =
"restrict";
1899 typeQuals += typeQuals.empty() ?
"const" :
" const";
1901 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
1903 uint32_t AddrSpc = 0;
1908 addressQuals.push_back(
1909 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
1913 std::string typeName = getTypeSpelling(ty);
1925 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
1926 argBaseTypeNames.push_back(
1927 llvm::MDString::get(VMContext, baseTypeName));
1932 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
1936 Fn->setMetadata(
"kernel_arg_addr_space",
1937 llvm::MDNode::get(VMContext, addressQuals));
1938 Fn->setMetadata(
"kernel_arg_access_qual",
1939 llvm::MDNode::get(VMContext, accessQuals));
1940 Fn->setMetadata(
"kernel_arg_type",
1941 llvm::MDNode::get(VMContext, argTypeNames));
1942 Fn->setMetadata(
"kernel_arg_base_type",
1943 llvm::MDNode::get(VMContext, argBaseTypeNames));
1944 Fn->setMetadata(
"kernel_arg_type_qual",
1945 llvm::MDNode::get(VMContext, argTypeQuals));
1949 Fn->setMetadata(
"kernel_arg_name",
1950 llvm::MDNode::get(VMContext, argNames));
1960 if (!LangOpts.Exceptions)
return false;
1963 if (LangOpts.CXXExceptions)
return true;
1966 if (LangOpts.ObjCExceptions) {
1983 !isa<CXXDestructorDecl>(MD);
1986std::vector<const CXXRecordDecl *>
1988 llvm::SetVector<const CXXRecordDecl *> MostBases;
1990 std::function<void (
const CXXRecordDecl *)> CollectMostBases;
1993 MostBases.insert(RD);
1995 CollectMostBases(B.getType()->getAsCXXRecordDecl());
1997 CollectMostBases(RD);
1998 return MostBases.takeVector();
2001llvm::GlobalVariable *
2003 auto It = RTTIProxyMap.find(Addr);
2004 if (It != RTTIProxyMap.end())
2007 auto *FTRTTIProxy =
new llvm::GlobalVariable(
2008 TheModule, Addr->getType(),
2009 true, llvm::GlobalValue::PrivateLinkage, Addr,
2010 "__llvm_rtti_proxy");
2011 FTRTTIProxy->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2013 RTTIProxyMap[Addr] = FTRTTIProxy;
2018 llvm::Function *F) {
2019 llvm::AttrBuilder B(F->getContext());
2021 if ((!D || !D->
hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2022 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2024 if (CodeGenOpts.StackClashProtector)
2025 B.addAttribute(
"probe-stack",
"inline-asm");
2028 B.addAttribute(llvm::Attribute::NoUnwind);
2030 if (D && D->
hasAttr<NoStackProtectorAttr>())
2032 else if (D && D->
hasAttr<StrictGuardStackCheckAttr>() &&
2034 B.addAttribute(llvm::Attribute::StackProtectStrong);
2036 B.addAttribute(llvm::Attribute::StackProtect);
2038 B.addAttribute(llvm::Attribute::StackProtectStrong);
2040 B.addAttribute(llvm::Attribute::StackProtectReq);
2046 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2048 B.addAttribute(llvm::Attribute::NoInline);
2056 bool ShouldAddOptNone =
2057 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2059 ShouldAddOptNone &= !D->
hasAttr<MinSizeAttr>();
2060 ShouldAddOptNone &= !D->
hasAttr<AlwaysInlineAttr>();
2063 if ((ShouldAddOptNone || D->
hasAttr<OptimizeNoneAttr>()) &&
2064 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2065 B.addAttribute(llvm::Attribute::OptimizeNone);
2068 B.addAttribute(llvm::Attribute::NoInline);
2073 B.addAttribute(llvm::Attribute::Naked);
2076 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2077 F->removeFnAttr(llvm::Attribute::MinSize);
2078 }
else if (D->
hasAttr<NakedAttr>()) {
2080 B.addAttribute(llvm::Attribute::Naked);
2081 B.addAttribute(llvm::Attribute::NoInline);
2082 }
else if (D->
hasAttr<NoDuplicateAttr>()) {
2083 B.addAttribute(llvm::Attribute::NoDuplicate);
2084 }
else if (D->
hasAttr<NoInlineAttr>() && !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2086 B.addAttribute(llvm::Attribute::NoInline);
2087 }
else if (D->
hasAttr<AlwaysInlineAttr>() &&
2088 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2090 B.addAttribute(llvm::Attribute::AlwaysInline);
2094 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2095 B.addAttribute(llvm::Attribute::NoInline);
2099 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2102 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
2103 return Redecl->isInlineSpecified();
2105 if (any_of(FD->
redecls(), CheckRedeclForInline))
2110 return any_of(Pattern->
redecls(), CheckRedeclForInline);
2112 if (CheckForInline(FD)) {
2113 B.addAttribute(llvm::Attribute::InlineHint);
2114 }
else if (CodeGenOpts.getInlining() ==
2117 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2118 B.addAttribute(llvm::Attribute::NoInline);
2125 if (!D->
hasAttr<OptimizeNoneAttr>()) {
2127 if (!ShouldAddOptNone)
2128 B.addAttribute(llvm::Attribute::OptimizeForSize);
2129 B.addAttribute(llvm::Attribute::Cold);
2132 B.addAttribute(llvm::Attribute::Hot);
2133 if (D->
hasAttr<MinSizeAttr>())
2134 B.addAttribute(llvm::Attribute::MinSize);
2141 F->setAlignment(llvm::Align(alignment));
2143 if (!D->
hasAttr<AlignedAttr>())
2144 if (LangOpts.FunctionAlignment)
2145 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2152 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
2153 F->setAlignment(llvm::Align(2));
2158 if (CodeGenOpts.SanitizeCfiCrossDso &&
2159 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2160 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2171 auto *MD = dyn_cast<CXXMethodDecl>(D);
2174 llvm::Metadata *
Id =
2177 F->addTypeMetadata(0,
Id);
2183 llvm::Function *F) {
2184 if (D->
hasAttr<StrictFPAttr>()) {
2185 llvm::AttrBuilder FuncAttrs(F->getContext());
2186 FuncAttrs.addAttribute(
"strictfp");
2187 F->addFnAttrs(FuncAttrs);
2193 if (isa_and_nonnull<NamedDecl>(D))
2196 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2198 if (D && D->
hasAttr<UsedAttr>())
2201 if (CodeGenOpts.KeepStaticConsts && D && isa<VarDecl>(D)) {
2202 const auto *VD = cast<VarDecl>(D);
2203 if (VD->getType().isConstQualified() &&
2209bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
2210 llvm::AttrBuilder &Attrs) {
2216 std::vector<std::string> Features;
2217 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
2219 const auto *TD = FD ? FD->
getAttr<TargetAttr>() :
nullptr;
2220 const auto *TV = FD ? FD->
getAttr<TargetVersionAttr>() :
nullptr;
2221 assert((!TD || !TV) &&
"both target_version and target specified");
2222 const auto *SD = FD ? FD->
getAttr<CPUSpecificAttr>() :
nullptr;
2223 const auto *TC = FD ? FD->
getAttr<TargetClonesAttr>() :
nullptr;
2224 bool AddedAttr =
false;
2225 if (TD || TV || SD || TC) {
2226 llvm::StringMap<bool> FeatureMap;
2230 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2231 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
2262 if (!TargetCPU.empty()) {
2263 Attrs.addAttribute(
"target-cpu", TargetCPU);
2266 if (!TuneCPU.empty()) {
2267 Attrs.addAttribute(
"tune-cpu", TuneCPU);
2270 if (!Features.empty()) {
2271 llvm::sort(Features);
2272 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
2279void CodeGenModule::setNonAliasAttributes(
GlobalDecl GD,
2280 llvm::GlobalObject *GO) {
2285 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
2288 if (
auto *SA = D->
getAttr<PragmaClangBSSSectionAttr>())
2289 GV->addAttribute(
"bss-section", SA->getName());
2290 if (
auto *SA = D->
getAttr<PragmaClangDataSectionAttr>())
2291 GV->addAttribute(
"data-section", SA->getName());
2292 if (
auto *SA = D->
getAttr<PragmaClangRodataSectionAttr>())
2293 GV->addAttribute(
"rodata-section", SA->getName());
2294 if (
auto *SA = D->
getAttr<PragmaClangRelroSectionAttr>())
2295 GV->addAttribute(
"relro-section", SA->getName());
2298 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
2301 if (
auto *SA = D->
getAttr<PragmaClangTextSectionAttr>())
2302 if (!D->
getAttr<SectionAttr>())
2303 F->addFnAttr(
"implicit-section-name", SA->getName());
2305 llvm::AttrBuilder Attrs(F->getContext());
2306 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
2310 llvm::AttributeMask RemoveAttrs;
2311 RemoveAttrs.addAttribute(
"target-cpu");
2312 RemoveAttrs.addAttribute(
"target-features");
2313 RemoveAttrs.addAttribute(
"tune-cpu");
2314 F->removeFnAttrs(RemoveAttrs);
2315 F->addFnAttrs(Attrs);
2319 if (
const auto *CSA = D->
getAttr<CodeSegAttr>())
2320 GO->setSection(CSA->getName());
2321 else if (
const auto *SA = D->
getAttr<SectionAttr>())
2322 GO->setSection(SA->getName());
2335 F->setLinkage(llvm::Function::InternalLinkage);
2337 setNonAliasAttributes(GD, F);
2348 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2352 llvm::Function *F) {
2354 if (!LangOpts.
Sanitize.
has(SanitizerKind::CFIICall))
2359 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2363 F->addTypeMetadata(0, MD);
2367 if (CodeGenOpts.SanitizeCfiCrossDso)
2369 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
2373 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2376 llvm::LLVMContext &Ctx = F->getContext();
2377 llvm::MDBuilder MDB(Ctx);
2378 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
2387 return llvm::all_of(Name, [](
const char &
C) {
2388 return llvm::isAlnum(
C) ||
C ==
'_' ||
C ==
'.';
2394 for (
auto &F : M.functions()) {
2396 bool AddressTaken = F.hasAddressTaken();
2397 if (!AddressTaken && F.hasLocalLinkage())
2398 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
2403 if (!AddressTaken || !F.isDeclaration())
2406 const llvm::ConstantInt *
Type;
2407 if (
const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
2408 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
2412 StringRef Name = F.getName();
2416 std::string
Asm = (
".weak __kcfi_typeid_" + Name +
"\n.set __kcfi_typeid_" +
2417 Name +
", " + Twine(
Type->getZExtValue()) +
"\n")
2419 M.appendModuleInlineAsm(
Asm);
2423void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
2424 bool IsIncompleteFunction,
2427 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
2430 F->setAttributes(llvm::Intrinsic::getAttributes(
getLLVMContext(), IID));
2434 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2436 if (!IsIncompleteFunction)
2443 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
2445 assert(!F->arg_empty() &&
2446 F->arg_begin()->getType()
2447 ->canLosslesslyBitCastTo(F->getReturnType()) &&
2448 "unexpected this return");
2449 F->addParamAttr(0, llvm::Attribute::Returned);
2459 if (!IsIncompleteFunction && F->isDeclaration())
2462 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
2463 F->setSection(CSA->getName());
2464 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
2465 F->setSection(SA->getName());
2467 if (
const auto *EA = FD->
getAttr<ErrorAttr>()) {
2469 F->addFnAttr(
"dontcall-error", EA->getUserDiagnostic());
2470 else if (EA->isWarning())
2471 F->addFnAttr(
"dontcall-warn", EA->getUserDiagnostic());
2477 bool HasBody = FD->
hasBody(FDBody);
2479 assert(HasBody &&
"Inline builtin declarations should always have an "
2481 if (shouldEmitFunction(FDBody))
2482 F->addFnAttr(llvm::Attribute::NoBuiltin);
2488 F->addFnAttr(llvm::Attribute::NoBuiltin);
2491 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
2492 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2493 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
2494 if (MD->isVirtual())
2495 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2501 if (!CodeGenOpts.SanitizeCfiCrossDso ||
2502 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
2511 if (CodeGenOpts.InlineMaxStackSize !=
UINT_MAX)
2512 F->addFnAttr(
"inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
2514 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
2518 llvm::LLVMContext &Ctx = F->getContext();
2519 llvm::MDBuilder MDB(Ctx);
2523 int CalleeIdx = *CB->encoding_begin();
2524 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
2525 F->addMetadata(llvm::LLVMContext::MD_callback,
2526 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
2527 CalleeIdx, PayloadIndices,
2533 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2534 "Only globals with definition can force usage.");
2535 LLVMUsed.emplace_back(GV);
2539 assert(!GV->isDeclaration() &&
2540 "Only globals with definition can force usage.");
2541 LLVMCompilerUsed.emplace_back(GV);
2545 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2546 "Only globals with definition can force usage.");
2548 LLVMCompilerUsed.emplace_back(GV);
2550 LLVMUsed.emplace_back(GV);
2554 std::vector<llvm::WeakTrackingVH> &List) {
2561 UsedArray.resize(List.size());
2562 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
2564 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
2565 cast<llvm::Constant>(&*List[i]), CGM.
Int8PtrTy);
2568 if (UsedArray.empty())
2570 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
2572 auto *GV =
new llvm::GlobalVariable(
2573 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
2574 llvm::ConstantArray::get(ATy, UsedArray), Name);
2576 GV->setSection(
"llvm.metadata");
2579void CodeGenModule::emitLLVMUsed() {
2580 emitUsed(*
this,
"llvm.used", LLVMUsed);
2581 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
2586 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
2595 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
2601 ELFDependentLibraries.push_back(
2602 llvm::MDNode::get(
C, llvm::MDString::get(
C, Lib)));
2609 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
C, MDOpts));
2618 if (Mod->
Parent && Visited.insert(Mod->
Parent).second) {
2624 if (Visited.insert(Import).second)
2641 if (LL.IsFramework) {
2642 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
2643 llvm::MDString::get(Context, LL.Library)};
2645 Metadata.push_back(llvm::MDNode::get(Context, Args));
2651 llvm::Metadata *Args[2] = {
2652 llvm::MDString::get(Context,
"lib"),
2653 llvm::MDString::get(Context, LL.Library),
2655 Metadata.push_back(llvm::MDNode::get(Context, Args));
2659 auto *OptString = llvm::MDString::get(Context, Opt);
2660 Metadata.push_back(llvm::MDNode::get(Context, OptString));
2665void CodeGenModule::EmitModuleInitializers(
clang::Module *Primary) {
2670 if (isa<ImportDecl>(D))
2672 assert(isa<VarDecl>(D) &&
"GMF initializer decl is not a var?");
2679 if (isa<ImportDecl>(D))
2686 assert(isa<VarDecl>(D) &&
"PMF initializer decl is not a var?");
2692void CodeGenModule::EmitModuleLinkOptions() {
2696 llvm::SetVector<clang::Module *> LinkModules;
2701 for (
Module *M : ImportedModules) {
2704 if (M->getTopLevelModuleName() ==
getLangOpts().CurrentModule &&
2707 if (Visited.insert(M).second)
2713 while (!Stack.empty()) {
2716 bool AnyChildren =
false;
2725 if (Visited.insert(
SM).second) {
2726 Stack.push_back(
SM);
2734 LinkModules.insert(Mod);
2743 for (
Module *M : LinkModules)
2744 if (Visited.insert(M).second)
2746 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
2747 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
2750 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
2751 for (
auto *MD : LinkerOptionsMetadata)
2752 NMD->addOperand(MD);
2755void CodeGenModule::EmitDeferred() {
2764 if (!DeferredVTables.empty()) {
2765 EmitDeferredVTables();
2770 assert(DeferredVTables.empty());
2777 llvm::append_range(DeferredDeclsToEmit,
2781 if (DeferredDeclsToEmit.empty())
2786 std::vector<GlobalDecl> CurDeclsToEmit;
2787 CurDeclsToEmit.swap(DeferredDeclsToEmit);
2794 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
2812 if (!GV->isDeclaration())
2816 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
2820 EmitGlobalDefinition(D, GV);
2825 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
2827 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
2832void CodeGenModule::EmitVTablesOpportunistically() {
2838 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
2839 &&
"Only emit opportunistic vtables with optimizations");
2843 "This queue should only contain external vtables");
2844 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
2847 OpportunisticVTables.clear();
2851 if (Annotations.empty())
2855 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
2856 Annotations[0]->getType(), Annotations.size()), Annotations);
2857 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
2858 llvm::GlobalValue::AppendingLinkage,
2859 Array,
"llvm.global.annotations");
2864 llvm::Constant *&AStr = AnnotationStrings[Str];
2869 llvm::Constant *
s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
2870 auto *gv =
new llvm::GlobalVariable(
2871 getModule(),
s->getType(),
true, llvm::GlobalValue::PrivateLinkage,
s,
2872 ".str",
nullptr, llvm::GlobalValue::NotThreadLocal,
2875 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2892 SM.getExpansionLineNumber(L);
2893 return llvm::ConstantInt::get(
Int32Ty, LineNo);
2901 llvm::FoldingSetNodeID ID;
2902 for (
Expr *E : Exprs) {
2903 ID.Add(cast<clang::ConstantExpr>(E)->getAPValueResult());
2905 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
2910 LLVMArgs.reserve(Exprs.size());
2912 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](
const Expr *E) {
2913 const auto *CE = cast<clang::ConstantExpr>(E);
2914 return ConstEmiter.
emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
2917 auto *Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
2918 auto *GV =
new llvm::GlobalVariable(
getModule(), Struct->getType(),
true,
2919 llvm::GlobalValue::PrivateLinkage, Struct,
2922 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2930 const AnnotateAttr *AA,
2938 llvm::Constant *GVInGlobalsAS = GV;
2939 if (GV->getAddressSpace() !=
2941 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
2942 GV, GV->getValueType()->getPointerTo(
2947 llvm::Constant *Fields[] = {
2954 return llvm::ConstantStruct::getAnon(Fields);
2958 llvm::GlobalValue *GV) {
2959 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2969 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
2973 const FileEntry &MainFile = *
SM.getFileEntryForID(
SM.getMainFileID());
2974 if (NoSanitizeL.containsMainFile(Kind, MainFile.
getName()))
2979 return NoSanitizeL.containsLocation(Kind, Loc);
2982 return NoSanitizeL.containsFile(Kind, MainFile.
getName());
2986 llvm::GlobalVariable *GV,
2990 if (NoSanitizeL.containsGlobal(Kind, GV->getName(),
Category))
2993 if (NoSanitizeL.containsMainFile(
2994 Kind,
SM.getFileEntryForID(
SM.getMainFileID())->getName(),
Category))
2996 if (NoSanitizeL.containsLocation(Kind, Loc,
Category))
3003 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
3004 Ty = AT->getElementType();
3009 if (NoSanitizeL.containsType(Kind, TypeStr,
Category))
3020 auto Attr = ImbueAttr::NONE;
3023 if (
Attr == ImbueAttr::NONE)
3024 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3026 case ImbueAttr::NONE:
3028 case ImbueAttr::ALWAYS:
3029 Fn->addFnAttr(
"function-instrument",
"xray-always");
3031 case ImbueAttr::ALWAYS_ARG1:
3032 Fn->addFnAttr(
"function-instrument",
"xray-always");
3033 Fn->addFnAttr(
"xray-log-args",
"1");
3035 case ImbueAttr::NEVER:
3036 Fn->addFnAttr(
"function-instrument",
"xray-never");
3060 if (
const auto *MainFile =
SM.getFileEntryForID(
SM.getMainFileID()))
3074 if (NumGroups > 1) {
3075 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3082bool CodeGenModule::MustBeEmitted(
const ValueDecl *Global) {
3084 if (LangOpts.EmitAllDecls)
3087 if (CodeGenOpts.KeepStaticConsts) {
3088 const auto *VD = dyn_cast<VarDecl>(Global);
3089 if (VD && VD->getType().isConstQualified() &&
3097bool CodeGenModule::MayBeEmittedEagerly(
const ValueDecl *Global) {
3104 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3105 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3106 OMPDeclareTargetDeclAttr::getActiveAttr(Global);
3107 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (
unsigned)-1)
3111 if (
const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3117 if (
const auto *VD = dyn_cast<VarDecl>(Global)) {
3123 if (CXX20ModuleInits && VD->getOwningModule() &&
3124 !VD->getOwningModule()->isModuleMapModule()) {
3133 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3134 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) &&
3136 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
3149 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3153 llvm::Constant *Init;
3156 if (!
V.isAbsent()) {
3159 Init =
Emitter.emitForInitializer(
3167 llvm::Constant *Fields[4] = {
3171 llvm::ConstantDataArray::getRaw(
3172 StringRef(
reinterpret_cast<char *
>(Parts.
Part4And5), 8), 8,
3174 Init = llvm::ConstantStruct::getAnon(Fields);
3177 auto *GV =
new llvm::GlobalVariable(
3179 true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
3181 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3184 if (!
V.isAbsent()) {
3190 llvm::Constant *Addr = llvm::ConstantExpr::getBitCast(
3191 GV, Ty->getPointerTo(GV->getAddressSpace()));
3199 llvm::GlobalVariable **Entry =
nullptr;
3200 Entry = &UnnamedGlobalConstantDeclMap[GCD];
3205 llvm::Constant *Init;
3209 assert(!
V.isAbsent());
3213 auto *GV =
new llvm::GlobalVariable(
getModule(), Init->getType(),
3215 llvm::GlobalValue::PrivateLinkage, Init,
3217 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3231 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3235 llvm::Constant *Init =
Emitter.emitForInitializer(
3243 llvm::GlobalValue::LinkageTypes
Linkage =
3245 ? llvm::GlobalValue::LinkOnceODRLinkage
3246 : llvm::GlobalValue::InternalLinkage;
3247 auto *GV =
new llvm::GlobalVariable(
getModule(), Init->getType(),
3251 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3258 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
3259 assert(AA &&
"No alias?");
3268 auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
3272 llvm::Constant *Aliasee;
3273 if (isa<llvm::FunctionType>(DeclTy))
3274 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
3278 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), DeclTy,
LangAS::Default,
3281 auto *F = cast<llvm::GlobalValue>(Aliasee);
3282 F->setLinkage(llvm::Function::ExternalWeakLinkage);
3283 WeakRefReferences.insert(F);
3289 const auto *Global = cast<ValueDecl>(GD.
getDecl());
3292 if (Global->
hasAttr<WeakRefAttr>())
3297 if (Global->
hasAttr<AliasAttr>())
3298 return EmitAliasDefinition(GD);
3301 if (Global->
hasAttr<IFuncAttr>())
3302 return emitIFuncDefinition(GD);
3305 if (Global->
hasAttr<CPUDispatchAttr>())
3306 return emitCPUDispatchDefinition(GD);
3309 if (LangOpts.CUDA) {
3310 if (LangOpts.CUDAIsDevice) {
3311 if (!Global->
hasAttr<CUDADeviceAttr>() &&
3312 !Global->
hasAttr<CUDAGlobalAttr>() &&
3313 !Global->
hasAttr<CUDAConstantAttr>() &&
3314 !Global->
hasAttr<CUDASharedAttr>() &&
3325 if (isa<FunctionDecl>(Global) && !Global->
hasAttr<CUDAHostAttr>() &&
3326 Global->
hasAttr<CUDADeviceAttr>())
3329 assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
3330 "Expected Variable or Function");
3334 if (LangOpts.OpenMP) {
3336 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
3338 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
3339 if (MustBeEmitted(Global))
3343 if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Global)) {
3344 if (MustBeEmitted(Global))
3351 if (
const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3363 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
3368 const auto *VD = cast<VarDecl>(Global);
3369 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
3372 if (LangOpts.OpenMP) {
3374 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3375 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
3376 bool UnifiedMemoryEnabled =
3378 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3379 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3380 !UnifiedMemoryEnabled) {
3383 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3384 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3385 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3386 UnifiedMemoryEnabled)) &&
3387 "Link clause or to clause with unified memory expected.");
3406 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
3408 EmitGlobalDefinition(GD);
3415 cast<VarDecl>(Global)->hasInit()) {
3416 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
3417 CXXGlobalInits.push_back(
nullptr);
3423 addDeferredDeclToEmit(GD);
3424 }
else if (MustBeEmitted(Global)) {
3426 assert(!MayBeEmittedEagerly(Global));
3427 addDeferredDeclToEmit(GD);
3428 EmittedDeferredDecls[MangledName] = GD;
3433 DeferredDecls[MangledName] = GD;
3440 if (
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
3441 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
3448 struct FunctionIsDirectlyRecursive
3450 const StringRef Name;
3455 bool VisitCallExpr(
const CallExpr *E) {
3460 if (
Attr && Name ==
Attr->getLabel())
3465 StringRef BuiltinName = BI.
getName(BuiltinID);
3466 if (BuiltinName.startswith(
"__builtin_") &&
3467 Name == BuiltinName.slice(strlen(
"__builtin_"), StringRef::npos)) {
3473 bool VisitStmt(
const Stmt *S) {
3474 for (
const Stmt *Child : S->children())
3475 if (Child && this->Visit(Child))
3482 struct DLLImportFunctionVisitor
3484 bool SafeToInline =
true;
3486 bool shouldVisitImplicitCode()
const {
return true; }
3488 bool VisitVarDecl(
VarDecl *VD) {
3491 SafeToInline =
false;
3492 return SafeToInline;
3499 return SafeToInline;
3504 SafeToInline = D->
hasAttr<DLLImportAttr>();
3505 return SafeToInline;
3510 if (isa<FunctionDecl>(VD))
3511 SafeToInline = VD->
hasAttr<DLLImportAttr>();
3512 else if (
VarDecl *
V = dyn_cast<VarDecl>(VD))
3513 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
3514 return SafeToInline;
3519 return SafeToInline;
3526 SafeToInline =
true;
3528 SafeToInline = M->
hasAttr<DLLImportAttr>();
3530 return SafeToInline;
3535 return SafeToInline;
3540 return SafeToInline;
3549CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
3551 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
3556 Name =
Attr->getLabel();
3561 FunctionIsDirectlyRecursive Walker(Name, Context.
BuiltinInfo);
3563 return Body ? Walker.Visit(Body) :
false;
3566bool CodeGenModule::shouldEmitFunction(
GlobalDecl GD) {
3569 const auto *F = cast<FunctionDecl>(GD.
getDecl());
3570 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
3573 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
3575 DLLImportFunctionVisitor Visitor;
3576 Visitor.TraverseFunctionDecl(
const_cast<FunctionDecl*
>(F));
3577 if (!Visitor.SafeToInline)
3583 for (
const Decl *
Member : Dtor->getParent()->decls())
3584 if (isa<FieldDecl>(
Member))
3595 if (F->isInlineBuiltinDeclaration())
3603 return !isTriviallyRecursive(F);
3606bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
3607 return CodeGenOpts.OptimizationLevel > 0;
3610void CodeGenModule::EmitMultiVersionFunctionDefinition(
GlobalDecl GD,
3611 llvm::GlobalValue *GV) {
3612 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3615 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
3616 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
3619 auto *Clone = FD->
getAttr<TargetClonesAttr>();
3620 for (
unsigned I = 0; I < Clone->featuresStrs_size(); ++I)
3621 if (Clone->isFirstOfVersion(I))
3624 GetOrCreateMultiVersionResolver(GD);
3626 EmitGlobalFunctionDefinition(GD, GV);
3629void CodeGenModule::EmitGlobalDefinition(
GlobalDecl GD, llvm::GlobalValue *GV) {
3630 const auto *D = cast<ValueDecl>(GD.
getDecl());
3634 "Generating code for declaration");
3636 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
3639 if (!shouldEmitFunction(GD))
3642 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
3644 llvm::raw_string_ostream
OS(Name);
3650 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3653 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
3654 ABI->emitCXXStructor(GD);
3656 EmitMultiVersionFunctionDefinition(GD, GV);
3658 EmitGlobalFunctionDefinition(GD, GV);
3660 if (Method->isVirtual())
3667 return EmitMultiVersionFunctionDefinition(GD, GV);
3668 return EmitGlobalFunctionDefinition(GD, GV);
3671 if (
const auto *VD = dyn_cast<VarDecl>(D))
3672 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
3674 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
3678 llvm::Function *NewFn);
3682 const CodeGenFunction::MultiVersionResolverOption &RO) {
3684 unsigned NumFeatures = 0;
3685 for (StringRef Feat : RO.Conditions.Features) {
3690 if (!RO.Conditions.Architecture.empty())
3708 return llvm::GlobalValue::InternalLinkage;
3709 return llvm::GlobalValue::WeakODRLinkage;
3712void CodeGenModule::emitMultiVersionFunctions() {
3713 std::vector<GlobalDecl> MVFuncsToEmit;
3714 MultiVersionFuncs.swap(MVFuncsToEmit);
3716 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3717 assert(FD &&
"Expected a FunctionDecl");
3729 EmitGlobalFunctionDefinition(CurGD,
nullptr);
3738 assert(Func &&
"This should have just been created");
3741 const auto *TA = CurFD->
getAttr<TargetAttr>();
3743 TA->getAddedFeatures(Feats);
3744 Options.emplace_back(cast<llvm::Function>(Func),
3745 TA->getArchitecture(), Feats);
3747 const auto *TVA = CurFD->
getAttr<TargetVersionAttr>();
3749 TVA->getFeatures(Feats);
3750 Options.emplace_back(cast<llvm::Function>(Func),
3755 const auto *TC = FD->
getAttr<TargetClonesAttr>();
3756 for (
unsigned VersionIndex = 0; VersionIndex < TC->featuresStrs_size();
3758 if (!TC->isFirstOfVersion(VersionIndex))
3762 StringRef Version = TC->getFeatureStr(VersionIndex);
3767 EmitGlobalFunctionDefinition(CurGD,
nullptr);
3776 assert(Func &&
"This should have just been created");
3779 StringRef Architecture;
3783 if (Version !=
"default") {
3785 Version.split(VerFeats,
"+");
3786 for (
auto &CurFeat : VerFeats)
3787 Feature.push_back(CurFeat.trim());
3790 if (Version.startswith(
"arch="))
3791 Architecture = Version.drop_front(
sizeof(
"arch=") - 1);
3792 else if (Version !=
"default")
3793 Feature.push_back(Version);
3796 Options.emplace_back(cast<llvm::Function>(Func), Architecture, Feature);
3799 assert(0 &&
"Expected a target or target_clones multiversion function");
3803 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
3804 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant))
3805 ResolverConstant = IFunc->getResolver();
3806 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
3811 ResolverFunc->setComdat(
3812 getModule().getOrInsertComdat(ResolverFunc->getName()));
3816 Options, [&TI](
const CodeGenFunction::MultiVersionResolverOption &LHS,
3817 const CodeGenFunction::MultiVersionResolverOption &RHS) {
3821 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
3827 if (!MVFuncsToEmit.empty())
3832 if (!MultiVersionFuncs.empty())
3833 emitMultiVersionFunctions();
3836void CodeGenModule::emitCPUDispatchDefinition(
GlobalDecl GD) {
3837 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3838 assert(FD &&
"Not a FunctionDecl?");
3840 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
3841 assert(DD &&
"Not a cpu_dispatch Function?");
3847 UpdateMultiVersionNames(GD, FD, ResolverName);
3849 llvm::Type *ResolverType;
3852 ResolverType = llvm::FunctionType::get(
3853 llvm::PointerType::get(DeclTy,
3862 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
3863 ResolverName, ResolverType, ResolverGD,
false));
3866 ResolverFunc->setComdat(
3867 getModule().getOrInsertComdat(ResolverFunc->getName()));
3880 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
3883 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
3889 Func = GetOrCreateLLVMFunction(
3890 MangledName, DeclTy, ExistingDecl,
3897 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
3898 llvm::transform(Features, Features.begin(),
3899 [](StringRef Str) { return Str.substr(1); });
3900 llvm::erase_if(Features, [&Target](StringRef Feat) {
3901 return !
Target.validateCpuSupports(Feat);
3903 Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features);
3908 Options, [](
const CodeGenFunction::MultiVersionResolverOption &LHS,
3909 const CodeGenFunction::MultiVersionResolverOption &RHS) {
3910 return llvm::X86::getCpuSupportsMask(LHS.Conditions.Features) >
3911 llvm::X86::getCpuSupportsMask(RHS.Conditions.Features);
3918 while (Options.size() > 1 &&
3919 llvm::X86::getCpuSupportsMask(
3920 (Options.end() - 2)->Conditions.Features) == 0) {
3921 StringRef LHSName = (Options.end() - 2)->
Function->getName();
3922 StringRef RHSName = (Options.end() - 1)->
Function->getName();
3923 if (LHSName.compare(RHSName) < 0)
3924 Options.erase(Options.end() - 2);
3926 Options.erase(Options.end() - 1);
3930 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
3934 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
3938 if (!isa<llvm::GlobalIFunc>(IFunc)) {
3939 assert(cast<llvm::Function>(IFunc)->isDeclaration());
3940 auto *GI = llvm::GlobalIFunc::create(DeclTy, 0,
Linkage,
"", ResolverFunc,
3942 GI->takeName(IFunc);
3943 IFunc->replaceAllUsesWith(GI);
3944 IFunc->eraseFromParent();
3949 *
this, GD, FD,
true);
3952 auto *GA = llvm::GlobalAlias::create(DeclTy, 0,
Linkage, AliasName, IFunc,
3961llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
GlobalDecl GD) {
3962 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3963 assert(FD &&
"Not a FunctionDecl?");
3965 std::string MangledName =
3970 std::string ResolverName = MangledName;
3972 ResolverName +=
".ifunc";
3974 ResolverName +=
".resolver";
3977 if (llvm::GlobalValue *ResolverGV =
GetGlobalValue(ResolverName))
3986 MultiVersionFuncs.push_back(GD);
3991 llvm::Type *ResolverType = llvm::FunctionType::get(
3992 llvm::PointerType::get(DeclTy,
3995 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
3996 MangledName +
".resolver", ResolverType,
GlobalDecl{},
3998 llvm::GlobalIFunc *GIF =
4001 GIF->setName(ResolverName);
4007 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4009 assert(isa<llvm::GlobalValue>(Resolver) &&
4010 "Resolver should be created for the first time");
4022llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4023 StringRef MangledName, llvm::Type *Ty,
GlobalDecl GD,
bool ForVTable,
4024 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
4030 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
4032 if (
getLangOpts().OpenMPIsDevice && OpenMPRuntime &&
4033 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
4034 !DontDefer && !IsForDefinition) {
4037 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4039 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4048 UpdateMultiVersionNames(GD, FD, MangledName);
4049 if (!IsForDefinition)
4050 return GetOrCreateMultiVersionResolver(GD);
4057 if (WeakRefReferences.erase(Entry)) {
4058 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
4059 if (FD && !FD->
hasAttr<WeakAttr>())
4060 Entry->setLinkage(llvm::Function::ExternalLinkage);
4064 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>() &&
4066 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4072 if (IsForDefinition && !Entry->isDeclaration()) {
4079 DiagnosedConflictingDefinitions.insert(GD).second) {
4083 diag::note_previous_definition);
4087 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
4088 (Entry->getValueType() == Ty)) {
4095 if (!IsForDefinition)
4096 return llvm::ConstantExpr::getBitCast(
4097 Entry, Ty->getPointerTo(Entry->getAddressSpace()));
4103 bool IsIncompleteFunction =
false;
4105 llvm::FunctionType *FTy;
4106 if (isa<llvm::FunctionType>(Ty)) {
4107 FTy = cast<llvm::FunctionType>(Ty);
4109 FTy = llvm::FunctionType::get(
VoidTy,
false);
4110 IsIncompleteFunction =
true;
4114 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
4115 Entry ? StringRef() : MangledName, &
getModule());
4132 if (!Entry->use_empty()) {
4134 Entry->removeDeadConstantUsers();
4137 llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
4138 F, Entry->getValueType()->getPointerTo(Entry->getAddressSpace()));
4142 assert(F->getName() == MangledName &&
"name was uniqued!");
4144 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
4145 if (ExtraAttrs.hasFnAttrs()) {
4146 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
4154 if (isa_and_nonnull<CXXDestructorDecl>(D) &&
4155 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
4157 addDeferredDeclToEmit(GD);
4162 auto DDI = DeferredDecls.find(MangledName);
4163 if (DDI != DeferredDecls.end()) {
4167 addDeferredDeclToEmit(DDI->second);
4168 EmittedDeferredDecls[DDI->first] = DDI->second;
4169 DeferredDecls.erase(DDI);
4184 for (
const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
4197 if (!IsIncompleteFunction) {
4198 assert(F->getFunctionType() == Ty);
4202 return llvm::ConstantExpr::getBitCast(F,
4203 Ty->getPointerTo(F->getAddressSpace()));
4214 assert(!cast<FunctionDecl>(GD.
getDecl())->isConsteval() &&
4215 "consteval function should never be emitted");
4218 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4225 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
4228 DD->getParent()->getNumVBases() == 0)
4233 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
4234 false, llvm::AttributeList(),
4237 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
4238 cast<FunctionDecl>(GD.
getDecl())->hasAttr<CUDAGlobalAttr>()) {
4240 cast<llvm::Function>(F->stripPointerCasts()), GD);
4241 if (IsForDefinition)
4243 return llvm::ConstantExpr::getBitCast(Handle, Ty->getPointerTo());
4249 llvm::GlobalValue *F =
4252 return llvm::ConstantExpr::getBitCast(
4253 llvm::NoCFIValue::get(F),
4254 llvm::Type::getInt8PtrTy(VMContext, F->getAddressSpace()));
4264 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4267 if (!
C.getLangOpts().CPlusPlus)
4272 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
4273 ?
C.Idents.get(
"terminate")
4274 :
C.Idents.get(Name);
4276 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
4280 if (
auto *LSD = dyn_cast<LinkageSpecDecl>(
Result))
4281 for (
const auto *
Result : LSD->lookup(&NS))
4282 if ((ND = dyn_cast<NamespaceDecl>(
Result)))
4287 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4299 llvm::AttributeList ExtraAttrs,
bool Local,
4300 bool AssumeConvergent) {
4301 if (AssumeConvergent) {
4303 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4307 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
4311 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
4320 if (!Local &&
getTriple().isWindowsItaniumEnvironment() &&
4323 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
4324 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4325 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
4349 return ExcludeCtor && !Record->hasMutableFields() &&
4350 (Record->hasTrivialDestructor() || ExcludeDtor);
4368CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty,
4375 if (WeakRefReferences.erase(Entry)) {
4376 if (D && !D->
hasAttr<WeakAttr>())
4377 Entry->setLinkage(llvm::Function::ExternalLinkage);
4381 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>() &&
4383 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4385 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
4388 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
4393 if (IsForDefinition && !Entry->isDeclaration()) {
4401 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
4403 DiagnosedConflictingDefinitions.insert(D).second) {
4407 diag::note_previous_definition);
4412 if (Entry->getType()->getAddressSpace() != TargetAS) {
4413 return llvm::ConstantExpr::getAddrSpaceCast(Entry,
4414 Ty->getPointerTo(TargetAS));
4419 if (!IsForDefinition)
4420 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo(TargetAS));
4425 auto *GV =
new llvm::GlobalVariable(
4426 getModule(), Ty,
false, llvm::GlobalValue::ExternalLinkage,
nullptr,
4427 MangledName,
nullptr, llvm::GlobalVariable::NotThreadLocal,
4428 getContext().getTargetAddressSpace(DAddrSpace));
4433 GV->takeName(Entry);
4435 if (!Entry->use_empty()) {
4436 llvm::Constant *NewPtrForOldDecl =
4437 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
4438 Entry->replaceAllUsesWith(NewPtrForOldDecl);
4441 Entry->eraseFromParent();
4447 auto DDI = DeferredDecls.find(MangledName);
4448 if (DDI != DeferredDecls.end()) {
4451 addDeferredDeclToEmit(DDI->second);
4452 EmittedDeferredDecls[DDI->first] = DDI->second;
4453 DeferredDecls.erase(DDI);
4458 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
4465 GV->setAlignment(
getContext().getDeclAlign(D).getAsAlign());
4471 CXXThreadLocals.push_back(D);
4479 if (
getContext().isMSStaticDataMemberInlineDefinition(D)) {
4480 EmitGlobalVarDefinition(D);
4485 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>())
4486 GV->setSection(SA->getName());
4490 if (
getTriple().getArch() == llvm::Triple::xcore &&
4494 GV->setSection(
".cp.rodata");
4499 if (Context.
getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
4504 bool HasMutableFields =
Record &&
Record->hasMutableFields();
4505 if (!HasMutableFields) {
4510 llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
4512 auto *InitType = Init->getType();
4513 if (GV->getValueType() != InitType) {
4518 GV->setName(StringRef());
4521 auto *NewGV = cast<llvm::GlobalVariable>(
4523 ->stripPointerCasts());
4526 GV->eraseFromParent();
4529 GV->setInitializer(Init);
4530 GV->setConstant(
true);
4531 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
4533 emitter.finalize(GV);
4540 if (GV->isDeclaration()) {
4550 SanitizerMD->reportGlobal(GV, *D);
4555 assert(
getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
4556 if (DAddrSpace != ExpectedAS) {
4558 *
this, GV, DAddrSpace, ExpectedAS, Ty->getPointerTo(TargetAS));
4568 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
4570 false, IsForDefinition);
4572 if (isa<CXXMethodDecl>(D)) {
4580 if (isa<FunctionDecl>(D)) {
4591 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes
Linkage,
4592 llvm::Align Alignment) {
4593 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
4594 llvm::GlobalVariable *OldGV =
nullptr;
4598 if (GV->getValueType() == Ty)
4603 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
4608 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
4613 GV->takeName(OldGV);
4615 if (!OldGV->use_empty()) {
4616 llvm::Constant *NewPtrForOldDecl =
4617 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
4618 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
4621 OldGV->eraseFromParent();
4625 !GV->hasAvailableExternallyLinkage())
4626 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4628 GV->setAlignment(Alignment);
4648 return GetOrCreateLLVMGlobal(MangledName, Ty, ASTTy.
getAddressSpace(), D,
4659 auto *Ret = GetOrCreateLLVMGlobal(Name, Ty, AddrSpace,
nullptr);
4660 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
4665 assert(!D->
getInit() &&
"Cannot emit definite definitions here!");
4673 if (GV && !GV->isDeclaration())
4678 if (!MustBeEmitted(D) && !GV) {
4679 DeferredDecls[MangledName] = D;
4684 EmitGlobalVarDefinition(D);
4688 EmitExternalVarDeclaration(D);
4697 if (LangOpts.OpenCL) {
4708 if (LangOpts.SYCLIsDevice &&
4712 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
4714 if (D->
hasAttr<CUDAConstantAttr>())
4716 if (D->
hasAttr<CUDASharedAttr>())
4718 if (D->
hasAttr<CUDADeviceAttr>())
4726 if (LangOpts.OpenMP) {
4728 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
4736 if (LangOpts.OpenCL)
4738 if (LangOpts.SYCLIsDevice)
4740 if (LangOpts.HIP && LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())
4748 if (
auto AS =
getTarget().getConstantAddressSpace())
4761static llvm::Constant *
4763 llvm::GlobalVariable *GV) {
4764 llvm::Constant *Cast = GV;
4770 GV->getValueType()->getPointerTo(
4776template<
typename SomeDecl>
4778 llvm::GlobalValue *GV) {
4784 if (!D->template hasAttr<UsedAttr>())
4793 const SomeDecl *
First = D->getFirstDecl();
4794 if (
First->getDeclContext()->isRecord() || !
First->isInExternCContext())
4800 std::pair<StaticExternCMap::iterator, bool> R =
4801 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
4806 R.first->second =
nullptr;
4813 if (D.
hasAttr<SelectAnyAttr>())
4817 if (
auto *VD = dyn_cast<VarDecl>(&D))
4831 llvm_unreachable(
"No such linkage");
4835 llvm::GlobalObject &GO) {
4838 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
4842void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *D,
4852 if (LangOpts.OpenMPIsDevice && OpenMPRuntime &&
4853 OpenMPRuntime->emitTargetGlobalVariable(D))
4856 llvm::TrackingVH<llvm::Constant> Init;
4857 bool NeedsGlobalCtor =
false;
4861 bool IsDefinitionAvailableExternally =
4863 bool NeedsGlobalDtor =
4864 !IsDefinitionAvailableExternally &&
4870 std::optional<ConstantEmitter> emitter;
4875 bool IsCUDASharedVar =
4880 bool IsCUDAShadowVar =
4882 (D->
hasAttr<CUDAConstantAttr>() || D->
hasAttr<CUDADeviceAttr>() ||
4883 D->
hasAttr<CUDASharedAttr>());
4884 bool IsCUDADeviceShadowVar =
4889 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar))
4890 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
4891 else if (D->
hasAttr<LoaderUninitializedAttr>())
4892 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
4893 else if (!InitExpr) {
4907 emitter.emplace(*
this);
4908 llvm::Constant *
Initializer = emitter->tryEmitForInitializer(*InitDecl);
4919 if (!IsDefinitionAvailableExternally)
4920 NeedsGlobalCtor =
true;
4923 Init = llvm::UndefValue::get(
getTypes().ConvertType(T));
4931 DelayedCXXInitPosition.erase(D);
4938 assert(VarSize == CstSize &&
"Emitted constant has unexpected size");
4943 llvm::Type* InitType = Init->getType();
4944 llvm::Constant *Entry =
4948 Entry = Entry->stripPointerCasts();
4951 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
4962 if (!GV || GV->getValueType() != InitType ||
4963 GV->getType()->getAddressSpace() !=
4967 Entry->setName(StringRef());
4970 GV = cast<llvm::GlobalVariable>(
4972 ->stripPointerCasts());
4975 llvm::Constant *NewPtrForOldDecl =
4976 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
4978 Entry->replaceAllUsesWith(NewPtrForOldDecl);
4981 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
4986 if (D->
hasAttr<AnnotateAttr>())
4990 llvm::GlobalValue::LinkageTypes
Linkage =
5000 if (GV && LangOpts.CUDA) {
5001 if (LangOpts.CUDAIsDevice) {
5002 if (
Linkage != llvm::GlobalValue::InternalLinkage &&
5003 (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>() ||
5006 GV->setExternallyInitialized(
true);
5013 GV->setInitializer(Init);
5015 emitter->finalize(GV);
5018 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
5022 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>()) {
5025 GV->setConstant(
true);
5030 if (std::optional<CharUnits> AlignValFromAllocate =
5032 AlignVal = *AlignValFromAllocate;
5050 Linkage == llvm::GlobalValue::ExternalLinkage &&
5053 Linkage = llvm::GlobalValue::InternalLinkage;
5056 if (D->
hasAttr<DLLImportAttr>())
5057 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
5058 else if (D->
hasAttr<DLLExportAttr>())
5059 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
5061 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
5063 if (
Linkage == llvm::GlobalVariable::CommonLinkage) {
5065 GV->setConstant(
false);
5070 if (!GV->getInitializer()->isNullValue())
5071 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
5074 setNonAliasAttributes(D, GV);
5076 if (D->
getTLSKind() && !GV->isThreadLocal()) {
5078 CXXThreadLocals.push_back(D);
5085 if (NeedsGlobalCtor || NeedsGlobalDtor)
5086 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
5088 SanitizerMD->reportGlobal(GV, *D, NeedsGlobalCtor);
5093 DI->EmitGlobalVariable(GV, D);
5096void CodeGenModule::EmitExternalVarDeclaration(
const VarDecl *D) {
5101 llvm::Constant *GV =
5103 DI->EmitExternalVariable(
5104 cast<llvm::GlobalVariable>(GV->stripPointerCasts()), D);
5113 if ((NoCommon || D->
hasAttr<NoCommonAttr>()) && !D->
hasAttr<CommonAttr>())
5124 if (D->
hasAttr<SectionAttr>())
5130 if (D->
hasAttr<PragmaClangBSSSectionAttr>() ||
5131 D->
hasAttr<PragmaClangDataSectionAttr>() ||
5132 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
5133 D->
hasAttr<PragmaClangRodataSectionAttr>())
5141 if (D->
hasAttr<WeakImportAttr>())
5151 if (D->
hasAttr<AlignedAttr>())
5160 if (FD->isBitField())
5162 if (FD->
hasAttr<AlignedAttr>())
5187 return llvm::Function::InternalLinkage;
5190 return llvm::GlobalVariable::WeakAnyLinkage;
5194 return llvm::GlobalVariable::LinkOnceAnyLinkage;
5199 return llvm::GlobalValue::AvailableExternallyLinkage;
5213 return !Context.
getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
5214 : llvm::Function::InternalLinkage;
5228 return llvm::Function::ExternalLinkage;
5231 return D->
hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
5232 : llvm::Function::InternalLinkage;
5233 return llvm::Function::WeakODRLinkage;
5238 if (!
getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
5240 CodeGenOpts.NoCommon))
5241 return llvm::GlobalVariable::CommonLinkage;
5247 if (D->
hasAttr<SelectAnyAttr>())
5248 return llvm::GlobalVariable::WeakODRLinkage;
5252 return llvm::GlobalVariable::ExternalLinkage;
5256 const VarDecl *VD,
bool IsConstant) {
5264 llvm::Function *newFn) {
5266 if (old->use_empty())
return;
5268 llvm::Type *newRetTy = newFn->getReturnType();
5271 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
5273 llvm::Value::use_iterator use = ui++;
5274 llvm::User *user = use->getUser();
5278 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
5279 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
5285 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
5286 if (!callSite)
continue;
5287 if (!callSite->isCallee(&*use))
5292 if (callSite->getType() != newRetTy && !callSite->use_empty())
5297 llvm::AttributeList oldAttrs = callSite->getAttributes();
5300 unsigned newNumArgs = newFn->arg_size();
5301 if (callSite->arg_size() < newNumArgs)
5307 bool dontTransform =
false;
5308 for (llvm::Argument &A : newFn->args()) {
5309 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {