47 #include "llvm/ADT/StringSwitch.h" 48 #include "llvm/ADT/Triple.h" 49 #include "llvm/Analysis/TargetLibraryInfo.h" 50 #include "llvm/IR/CallingConv.h" 51 #include "llvm/IR/DataLayout.h" 52 #include "llvm/IR/Intrinsics.h" 53 #include "llvm/IR/LLVMContext.h" 54 #include "llvm/IR/Module.h" 55 #include "llvm/IR/ProfileSummary.h" 56 #include "llvm/ProfileData/InstrProfReader.h" 57 #include "llvm/Support/CodeGen.h" 58 #include "llvm/Support/ConvertUTF.h" 59 #include "llvm/Support/ErrorHandling.h" 60 #include "llvm/Support/MD5.h" 61 #include "llvm/Support/TimeProfiler.h" 63 using namespace clang;
64 using namespace CodeGen;
67 "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
68 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"),
69 llvm::cl::init(
false));
88 llvm_unreachable(
"invalid C++ ABI kind");
96 : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO),
97 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
99 VMContext(M.getContext()), Types(*this), VTables(*this),
103 llvm::LLVMContext &LLVMContext = M.getContext();
104 VoidTy = llvm::Type::getVoidTy(LLVMContext);
105 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
106 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
107 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
108 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
109 HalfTy = llvm::Type::getHalfTy(LLVMContext);
110 FloatTy = llvm::Type::getFloatTy(LLVMContext);
111 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
120 IntPtrTy = llvm::IntegerType::get(LLVMContext,
125 M.getDataLayout().getAllocaAddrSpace());
133 createOpenCLRuntime();
135 createOpenMPRuntime();
140 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread) ||
141 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
148 CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
151 Block.GlobalUniqueCount = 0;
159 if (
auto E = ReaderOrErr.takeError()) {
161 "Could not read profile %0: %1");
162 llvm::handleAllErrors(std::move(E), [&](
const llvm::ErrorInfoBase &EI) {
167 PGOReader = std::move(ReaderOrErr.get());
172 if (CodeGenOpts.CoverageMapping)
178 void CodeGenModule::createObjCRuntime() {
195 llvm_unreachable(
"bad runtime kind");
198 void CodeGenModule::createOpenCLRuntime() {
202 void CodeGenModule::createOpenMPRuntime() {
206 case llvm::Triple::nvptx:
207 case llvm::Triple::nvptx64:
209 "OpenMP NVPTX is only prepared to deal with device code.");
213 if (LangOpts.OpenMPSimd)
221 void CodeGenModule::createCUDARuntime() {
226 Replacements[Name] = C;
229 void CodeGenModule::applyReplacements() {
230 for (
auto &I : Replacements) {
231 StringRef MangledName = I.first();
232 llvm::Constant *Replacement = I.second;
236 auto *OldF = cast<llvm::Function>(Entry);
237 auto *NewF = dyn_cast<llvm::Function>(Replacement);
239 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
240 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
242 auto *CE = cast<llvm::ConstantExpr>(Replacement);
243 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
244 CE->getOpcode() == llvm::Instruction::GetElementPtr);
245 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
250 OldF->replaceAllUsesWith(Replacement);
252 NewF->removeFromParent();
253 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
256 OldF->eraseFromParent();
261 GlobalValReplacements.push_back(std::make_pair(GV, C));
264 void CodeGenModule::applyGlobalValReplacements() {
265 for (
auto &I : GlobalValReplacements) {
266 llvm::GlobalValue *GV = I.first;
267 llvm::Constant *C = I.second;
269 GV->replaceAllUsesWith(C);
270 GV->eraseFromParent();
277 const llvm::GlobalIndirectSymbol &GIS) {
278 llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited;
279 const llvm::Constant *C = &GIS;
281 C = C->stripPointerCasts();
282 if (
auto *GO = dyn_cast<llvm::GlobalObject>(C))
285 auto *GIS2 = dyn_cast<llvm::GlobalIndirectSymbol>(C);
288 if (!Visited.insert(GIS2).second)
290 C = GIS2->getIndirectSymbol();
294 void CodeGenModule::checkAliases() {
301 const auto *D = cast<ValueDecl>(GD.getDecl());
303 bool IsIFunc = D->hasAttr<IFuncAttr>();
304 if (
const Attr *A = D->getDefiningAttr())
305 Location = A->getLocation();
307 llvm_unreachable(
"Not an alias or ifunc?");
310 auto *Alias = cast<llvm::GlobalIndirectSymbol>(Entry);
314 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
315 }
else if (GV->isDeclaration()) {
317 Diags.
Report(Location, diag::err_alias_to_undefined)
318 << IsIFunc << IsIFunc;
319 }
else if (IsIFunc) {
321 llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
322 GV->getType()->getPointerElementType());
324 if (!FTy->getReturnType()->isPointerTy())
325 Diags.
Report(Location, diag::err_ifunc_resolver_return);
328 llvm::Constant *Aliasee = Alias->getIndirectSymbol();
329 llvm::GlobalValue *AliaseeGV;
330 if (
auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
331 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
333 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
335 if (
const SectionAttr *SA = D->getAttr<SectionAttr>()) {
336 StringRef AliasSection = SA->getName();
337 if (AliasSection != AliaseeGV->getSection())
338 Diags.
Report(SA->getLocation(), diag::warn_alias_with_section)
339 << AliasSection << IsIFunc << IsIFunc;
347 if (
auto GA = dyn_cast<llvm::GlobalIndirectSymbol>(AliaseeGV)) {
348 if (GA->isInterposable()) {
349 Diags.
Report(Location, diag::warn_alias_to_weak_alias)
350 << GV->getName() << GA->getName() << IsIFunc;
351 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
352 GA->getIndirectSymbol(), Alias->getType());
353 Alias->setIndirectSymbol(Aliasee);
363 auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry);
364 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
365 Alias->eraseFromParent();
370 DeferredDeclsToEmit.clear();
372 OpenMPRuntime->clear();
376 StringRef MainFile) {
377 if (!hasDiagnostics())
379 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
380 if (MainFile.empty())
381 MainFile =
"<stdin>";
382 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
385 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
388 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
394 EmitVTablesOpportunistically();
395 applyGlobalValReplacements();
398 emitMultiVersionFunctions();
399 EmitCXXGlobalInitFunc();
400 EmitCXXGlobalDtorFunc();
401 registerGlobalDtorsWithAtExit();
402 EmitCXXThreadLocalInitFunc();
404 if (llvm::Function *ObjCInitFunction =
ObjCRuntime->ModuleInitFunction())
405 AddGlobalCtor(ObjCInitFunction);
408 if (llvm::Function *CudaCtorFunction =
409 CUDARuntime->makeModuleCtorFunction())
410 AddGlobalCtor(CudaCtorFunction);
413 if (llvm::Function *OpenMPRequiresDirectiveRegFun =
414 OpenMPRuntime->emitRequiresDirectiveRegFun()) {
415 AddGlobalCtor(OpenMPRequiresDirectiveRegFun, 0);
417 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
418 OpenMPRuntime->clear();
422 PGOReader->getSummary(
false).getMD(VMContext),
423 llvm::ProfileSummary::PSK_Instr);
427 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
428 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
430 EmitStaticExternCAliases();
433 CoverageMapping->emit();
434 if (CodeGenOpts.SanitizeCfiCrossDso) {
438 emitAtAvailableLinkGuard();
443 if (CodeGenOpts.Autolink &&
444 (Context.
getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
445 EmitModuleLinkOptions();
460 if (!ELFDependentLibraries.empty() && !Context.
getLangOpts().CUDAIsDevice) {
461 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
462 for (
auto *MD : ELFDependentLibraries)
469 CodeGenOpts.NumRegisterParameters);
471 if (CodeGenOpts.DwarfVersion) {
475 CodeGenOpts.DwarfVersion);
477 if (CodeGenOpts.EmitCodeView) {
481 if (CodeGenOpts.CodeViewGHash) {
484 if (CodeGenOpts.ControlFlowGuard) {
488 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
495 llvm::Metadata *Ops[2] = {
496 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
497 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
498 llvm::Type::getInt32Ty(VMContext), 1))};
500 getModule().addModuleFlag(llvm::Module::Require,
501 "StrictVTablePointersRequirement",
502 llvm::MDNode::get(VMContext, Ops));
509 llvm::DEBUG_METADATA_VERSION);
514 uint64_t WCharWidth =
519 if ( Arch == llvm::Triple::arm
520 || Arch == llvm::Triple::armeb
521 || Arch == llvm::Triple::thumb
522 || Arch == llvm::Triple::thumbeb) {
524 uint64_t EnumWidth = Context.
getLangOpts().ShortEnums ? 1 : 4;
528 if (CodeGenOpts.SanitizeCfiCrossDso) {
530 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
533 if (LangOpts.
Sanitize.
has(SanitizerKind::CFIICall)) {
534 getModule().addModuleFlag(llvm::Module::Override,
535 "CFI Canonical Jump Tables",
536 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
539 if (CodeGenOpts.CFProtectionReturn &&
542 getModule().addModuleFlag(llvm::Module::Override,
"cf-protection-return",
546 if (CodeGenOpts.CFProtectionBranch &&
549 getModule().addModuleFlag(llvm::Module::Override,
"cf-protection-branch",
553 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
557 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
558 CodeGenOpts.FlushDenorm ? 1 : 0);
562 if (LangOpts.OpenCL) {
563 EmitOpenCLMetadata();
569 auto Version = LangOpts.OpenCLCPlusPlus ? 200 : LangOpts.OpenCLVersion;
570 llvm::Metadata *SPIRVerElts[] = {
571 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
573 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
574 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
575 llvm::NamedMDNode *SPIRVerMD =
576 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
577 llvm::LLVMContext &Ctx = TheModule.getContext();
578 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
582 if (uint32_t PLevel = Context.
getLangOpts().PICLevel) {
583 assert(PLevel < 3 &&
"Invalid PIC Level");
584 getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
586 getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
591 .Case(
"tiny", llvm::CodeModel::Tiny)
592 .Case(
"small", llvm::CodeModel::Small)
593 .Case(
"kernel", llvm::CodeModel::Kernel)
594 .Case(
"medium", llvm::CodeModel::Medium)
595 .Case(
"large", llvm::CodeModel::Large)
598 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
603 if (CodeGenOpts.NoPLT)
606 SimplifyPersonality();
615 DebugInfo->finalize();
618 EmitVersionIdentMetadata();
621 EmitCommandLineMetadata();
623 EmitTargetMetadata();
626 void CodeGenModule::EmitOpenCLMetadata() {
631 auto Version = LangOpts.OpenCLCPlusPlus ? 200 : LangOpts.OpenCLVersion;
632 llvm::Metadata *OCLVerElts[] = {
633 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
635 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
636 Int32Ty, (Version % 100) / 10))};
637 llvm::NamedMDNode *OCLVerMD =
638 TheModule.getOrInsertNamedMetadata(
"opencl.ocl.version");
639 llvm::LLVMContext &Ctx = TheModule.getContext();
640 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
656 return TBAA->getTypeInfo(QTy);
662 return TBAA->getAccessInfo(AccessType);
669 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
675 return TBAA->getTBAAStructInfo(QTy);
681 return TBAA->getBaseTypeInfo(QTy);
687 return TBAA->getAccessTagInfo(Info);
694 return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
702 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
710 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
716 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
721 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
734 "cannot compile this %0 yet");
735 std::string Msg =
Type;
744 "cannot compile this %0 yet");
745 std::string Msg =
Type;
755 if (GV->hasDLLImportStorageClass())
758 if (GV->hasLocalLinkage()) {
768 !GV->isDeclarationForLinker())
773 llvm::GlobalValue *GV) {
774 if (GV->hasLocalLinkage())
777 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
781 if (GV->hasDLLImportStorageClass())
784 const llvm::Triple &TT = CGM.
getTriple();
785 if (TT.isWindowsGNUEnvironment()) {
789 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
790 !GV->isThreadLocal())
797 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
805 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
809 if (!TT.isOSBinFormatELF())
816 if (RM != llvm::Reloc::Static && !LOpts.PIE && !LOpts.OpenMPIsDevice)
820 if (!GV->isDeclarationForLinker())
826 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
830 llvm::Triple::ArchType Arch = TT.getArch();
831 if (Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
832 Arch == llvm::Triple::ppc64le)
836 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
837 if (!Var->isThreadLocal() &&
838 (RM == llvm::Reloc::Static || CGOpts.PIECopyRelocations))
844 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
859 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
869 if (D->
hasAttr<DLLImportAttr>())
870 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
871 else if (D->
hasAttr<DLLExportAttr>() && !GV->isDeclarationForLinker())
872 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
896 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
897 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
898 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
899 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
900 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
907 return llvm::GlobalVariable::GeneralDynamicTLSModel;
909 return llvm::GlobalVariable::LocalDynamicTLSModel;
911 return llvm::GlobalVariable::InitialExecTLSModel;
913 return llvm::GlobalVariable::LocalExecTLSModel;
915 llvm_unreachable(
"Invalid TLS model!");
919 assert(D.
getTLSKind() &&
"setting TLS mode on non-TLS var!");
921 llvm::GlobalValue::ThreadLocalMode TLM;
925 if (
const TLSModelAttr *
Attr = D.
getAttr<TLSModelAttr>()) {
929 GV->setThreadLocalMode(TLM);
939 const CPUSpecificAttr *
Attr,
951 const TargetAttr *
Attr, raw_ostream &Out) {
952 if (Attr->isDefaultVersion())
957 TargetAttr::ParsedTargetAttr Info =
958 Attr->parse([&Target](StringRef LHS, StringRef RHS) {
961 assert(LHS.startswith(
"+") && RHS.startswith(
"+") &&
962 "Features should always have a prefix.");
969 if (!Info.Architecture.empty()) {
971 Out <<
"arch_" << Info.Architecture;
974 for (StringRef Feat : Info.Features) {
978 Out << Feat.substr(1);
984 bool OmitMultiVersionMangling =
false) {
986 llvm::raw_svector_ostream Out(Buffer);
989 llvm::raw_svector_ostream Out(Buffer);
990 if (
const auto *D = dyn_cast<CXXConstructorDecl>(ND))
992 else if (
const auto *D = dyn_cast<CXXDestructorDecl>(ND))
998 assert(II &&
"Attempt to mangle unnamed decl.");
1003 llvm::raw_svector_ostream Out(Buffer);
1004 Out <<
"__regcall3__" << II->
getName();
1010 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
1011 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1012 switch (FD->getMultiVersionKind()) {
1016 FD->getAttr<CPUSpecificAttr>(),
1023 llvm_unreachable(
"None multiversion type isn't valid here");
1030 void CodeGenModule::UpdateMultiVersionNames(
GlobalDecl GD,
1038 std::string NonTargetName =
1046 "Other GD should now be a multiversioned function");
1056 if (OtherName != NonTargetName) {
1059 const auto ExistingRecord = Manglings.find(NonTargetName);
1060 if (ExistingRecord != std::end(Manglings))
1061 Manglings.remove(&(*ExistingRecord));
1062 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1065 Entry->setName(OtherName);
1075 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
1084 auto FoundName = MangledDeclNames.find(CanonicalGD);
1085 if (FoundName != MangledDeclNames.end())
1086 return FoundName->second;
1089 const auto *ND = cast<NamedDecl>(GD.
getDecl());
1094 if (
auto *FD = dyn_cast<FunctionDecl>(GD.
getDecl()))
1098 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
1099 return MangledDeclNames[CanonicalGD] = Result.first->first();
1108 llvm::raw_svector_ostream Out(Buffer);
1111 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.
getDecl()), Out);
1112 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1114 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1117 MangleCtx.
mangleBlock(cast<DeclContext>(D), BD, Out);
1119 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
1120 return Result.first->first();
1129 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor,
int Priority,
1130 llvm::Constant *AssociatedData) {
1132 GlobalCtors.push_back(
Structor(Priority, Ctor, AssociatedData));
1137 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor,
int Priority) {
1138 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit) {
1139 DtorsUsingAtExit[
Priority].push_back(Dtor);
1144 GlobalDtors.push_back(
Structor(Priority, Dtor,
nullptr));
1147 void CodeGenModule::EmitCtorList(
CtorList &Fns,
const char *GlobalName) {
1148 if (Fns.empty())
return;
1151 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(
VoidTy,
false);
1152 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
1153 TheModule.getDataLayout().getProgramAddressSpace());
1156 llvm::StructType *CtorStructTy = llvm::StructType::get(
1161 auto ctors = builder.
beginArray(CtorStructTy);
1162 for (
const auto &I : Fns) {
1163 auto ctor = ctors.beginStruct(CtorStructTy);
1164 ctor.addInt(
Int32Ty, I.Priority);
1165 ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy));
1166 if (I.AssociatedData)
1167 ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData,
VoidPtrTy));
1170 ctor.finishAndAddTo(ctors);
1176 llvm::GlobalValue::AppendingLinkage);
1185 llvm::GlobalValue::LinkageTypes
1187 const auto *D = cast<FunctionDecl>(GD.
getDecl());
1191 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
1194 if (isa<CXXConstructorDecl>(D) &&
1195 cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
1207 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
1208 if (!MDS)
return nullptr;
1210 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
1215 llvm::Function *F) {
1217 llvm::AttributeList PAL;
1219 F->setAttributes(PAL);
1220 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
1224 std::string ReadOnlyQual(
"__read_only");
1225 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
1226 if (ReadOnlyPos != std::string::npos)
1228 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
1230 std::string WriteOnlyQual(
"__write_only");
1231 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
1232 if (WriteOnlyPos != std::string::npos)
1233 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
1235 std::string ReadWriteQual(
"__read_write");
1236 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
1237 if (ReadWritePos != std::string::npos)
1238 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
1263 assert(((FD && CGF) || (!FD && !CGF)) &&
1264 "Incorrect use - FD and CGF should either be both null or not!");
1290 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
1293 std::string typeQuals;
1299 addressQuals.push_back(
1300 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
1304 std::string typeName =
1308 std::string::size_type pos = typeName.find(
"unsigned");
1309 if (pointeeTy.
isCanonical() && pos != std::string::npos)
1310 typeName.erase(pos + 1, 8);
1312 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
1314 std::string baseTypeName =
1320 pos = baseTypeName.find(
"unsigned");
1321 if (pos != std::string::npos)
1322 baseTypeName.erase(pos + 1, 8);
1324 argBaseTypeNames.push_back(
1325 llvm::MDString::get(VMContext, baseTypeName));
1329 typeQuals =
"restrict";
1332 typeQuals += typeQuals.empty() ?
"const" :
" const";
1334 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
1336 uint32_t AddrSpc = 0;
1341 addressQuals.push_back(
1342 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
1345 std::string typeName;
1350 .getAsString(Policy);
1355 std::string::size_type pos = typeName.find(
"unsigned");
1357 typeName.erase(pos + 1, 8);
1359 std::string baseTypeName;
1365 .getAsString(Policy);
1379 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
1382 pos = baseTypeName.find(
"unsigned");
1383 if (pos != std::string::npos)
1384 baseTypeName.erase(pos + 1, 8);
1386 argBaseTypeNames.push_back(
1387 llvm::MDString::get(VMContext, baseTypeName));
1393 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
1397 const Decl *PDecl = parm;
1398 if (
auto *TD = dyn_cast<TypedefType>(ty))
1399 PDecl = TD->getDecl();
1400 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
1401 if (A && A->isWriteOnly())
1402 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
1403 else if (A && A->isReadWrite())
1404 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
1406 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
1408 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
1411 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
1414 Fn->setMetadata(
"kernel_arg_addr_space",
1415 llvm::MDNode::get(VMContext, addressQuals));
1416 Fn->setMetadata(
"kernel_arg_access_qual",
1417 llvm::MDNode::get(VMContext, accessQuals));
1418 Fn->setMetadata(
"kernel_arg_type",
1419 llvm::MDNode::get(VMContext, argTypeNames));
1420 Fn->setMetadata(
"kernel_arg_base_type",
1421 llvm::MDNode::get(VMContext, argBaseTypeNames));
1422 Fn->setMetadata(
"kernel_arg_type_qual",
1423 llvm::MDNode::get(VMContext, argTypeQuals));
1425 Fn->setMetadata(
"kernel_arg_name",
1426 llvm::MDNode::get(VMContext, argNames));
1436 if (!LangOpts.Exceptions)
return false;
1439 if (LangOpts.CXXExceptions)
return true;
1442 if (LangOpts.ObjCExceptions) {
1459 !isa<CXXDestructorDecl>(MD);
1462 std::vector<const CXXRecordDecl *>
1464 llvm::SetVector<const CXXRecordDecl *> MostBases;
1466 std::function<void (const CXXRecordDecl *)> CollectMostBases;
1469 MostBases.insert(RD);
1471 CollectMostBases(B.getType()->getAsCXXRecordDecl());
1473 CollectMostBases(RD);
1474 return MostBases.takeVector();
1478 llvm::Function *F) {
1479 llvm::AttrBuilder B;
1481 if (CodeGenOpts.UnwindTables)
1482 B.addAttribute(llvm::Attribute::UWTable);
1485 B.addAttribute(llvm::Attribute::NoUnwind);
1487 if (!D || !D->
hasAttr<NoStackProtectorAttr>()) {
1489 B.addAttribute(llvm::Attribute::StackProtect);
1491 B.addAttribute(llvm::Attribute::StackProtectStrong);
1493 B.addAttribute(llvm::Attribute::StackProtectReq);
1500 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1502 B.addAttribute(llvm::Attribute::NoInline);
1504 F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1510 bool ShouldAddOptNone =
1511 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
1513 ShouldAddOptNone &= !D->
hasAttr<MinSizeAttr>();
1514 ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline);
1515 ShouldAddOptNone &= !D->
hasAttr<AlwaysInlineAttr>();
1517 if (ShouldAddOptNone || D->
hasAttr<OptimizeNoneAttr>()) {
1518 B.addAttribute(llvm::Attribute::OptimizeNone);
1521 B.addAttribute(llvm::Attribute::NoInline);
1522 assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1523 "OptimizeNone and AlwaysInline on same function!");
1528 B.addAttribute(llvm::Attribute::Naked);
1531 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
1532 F->removeFnAttr(llvm::Attribute::MinSize);
1533 }
else if (D->
hasAttr<NakedAttr>()) {
1535 B.addAttribute(llvm::Attribute::Naked);
1536 B.addAttribute(llvm::Attribute::NoInline);
1537 }
else if (D->
hasAttr<NoDuplicateAttr>()) {
1538 B.addAttribute(llvm::Attribute::NoDuplicate);
1539 }
else if (D->
hasAttr<NoInlineAttr>()) {
1540 B.addAttribute(llvm::Attribute::NoInline);
1541 }
else if (D->
hasAttr<AlwaysInlineAttr>() &&
1542 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
1544 B.addAttribute(llvm::Attribute::AlwaysInline);
1548 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
1549 B.addAttribute(llvm::Attribute::NoInline);
1553 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
1556 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
1557 return Redecl->isInlineSpecified();
1559 if (any_of(FD->
redecls(), CheckRedeclForInline))
1564 return any_of(Pattern->
redecls(), CheckRedeclForInline);
1566 if (CheckForInline(FD)) {
1567 B.addAttribute(llvm::Attribute::InlineHint);
1568 }
else if (CodeGenOpts.getInlining() ==
1571 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
1572 B.addAttribute(llvm::Attribute::NoInline);
1579 if (!D->
hasAttr<OptimizeNoneAttr>()) {
1581 if (!ShouldAddOptNone)
1582 B.addAttribute(llvm::Attribute::OptimizeForSize);
1583 B.addAttribute(llvm::Attribute::Cold);
1586 if (D->
hasAttr<MinSizeAttr>())
1587 B.addAttribute(llvm::Attribute::MinSize);
1590 F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1594 F->setAlignment(llvm::Align(alignment));
1596 if (!D->
hasAttr<AlignedAttr>())
1597 if (LangOpts.FunctionAlignment)
1598 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
1605 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
1606 F->setAlignment(llvm::Align(2));
1611 if (CodeGenOpts.SanitizeCfiCrossDso &&
1612 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
1613 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
1627 llvm::Metadata *
Id =
1630 F->addTypeMetadata(0, Id);
1637 if (dyn_cast_or_null<NamedDecl>(D))
1642 if (D && D->
hasAttr<UsedAttr>())
1645 if (CodeGenOpts.KeepStaticConsts && D && isa<VarDecl>(D)) {
1646 const auto *VD = cast<VarDecl>(D);
1647 if (VD->getType().isConstQualified() &&
1653 bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
1654 llvm::AttrBuilder &Attrs) {
1659 std::vector<std::string> Features;
1660 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
1662 const auto *TD = FD ? FD->
getAttr<TargetAttr>() :
nullptr;
1663 const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() :
nullptr;
1664 bool AddedAttr =
false;
1666 llvm::StringMap<bool> FeatureMap;
1670 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
1671 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
1678 TargetAttr::ParsedTargetAttr
ParsedAttr = TD->parse();
1679 if (ParsedAttr.Architecture !=
"" &&
1680 getTarget().isValidCPUName(ParsedAttr.Architecture))
1681 TargetCPU = ParsedAttr.Architecture;
1689 if (TargetCPU !=
"") {
1690 Attrs.addAttribute(
"target-cpu", TargetCPU);
1693 if (!Features.empty()) {
1694 llvm::sort(Features);
1695 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
1702 void CodeGenModule::setNonAliasAttributes(
GlobalDecl GD,
1703 llvm::GlobalObject *GO) {
1708 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
1709 if (
auto *SA = D->
getAttr<PragmaClangBSSSectionAttr>())
1710 GV->addAttribute(
"bss-section", SA->getName());
1711 if (
auto *SA = D->
getAttr<PragmaClangDataSectionAttr>())
1712 GV->addAttribute(
"data-section", SA->getName());
1713 if (
auto *SA = D->
getAttr<PragmaClangRodataSectionAttr>())
1714 GV->addAttribute(
"rodata-section", SA->getName());
1715 if (
auto *SA = D->
getAttr<PragmaClangRelroSectionAttr>())
1716 GV->addAttribute(
"relro-section", SA->getName());
1719 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
1720 if (
auto *SA = D->
getAttr<PragmaClangTextSectionAttr>())
1721 if (!D->
getAttr<SectionAttr>())
1722 F->addFnAttr(
"implicit-section-name", SA->getName());
1724 llvm::AttrBuilder Attrs;
1725 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
1729 F->removeFnAttr(
"target-cpu");
1730 F->removeFnAttr(
"target-features");
1731 F->addAttributes(llvm::AttributeList::FunctionIndex, Attrs);
1735 if (
const auto *CSA = D->
getAttr<CodeSegAttr>())
1736 GO->setSection(CSA->getName());
1737 else if (
const auto *SA = D->
getAttr<SectionAttr>())
1738 GO->setSection(SA->getName());
1753 setNonAliasAttributes(GD, F);
1764 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1768 llvm::Function *F) {
1770 if (!LangOpts.
Sanitize.
has(SanitizerKind::CFIICall))
1775 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
1779 F->addTypeMetadata(0, MD);
1783 if (CodeGenOpts.SanitizeCfiCrossDso)
1785 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
1788 void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
1789 bool IsIncompleteFunction,
1795 F->setAttributes(llvm::Intrinsic::getAttributes(
getLLVMContext(), IID));
1799 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
1801 if (!IsIncompleteFunction)
1807 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
1809 assert(!F->arg_empty() &&
1810 F->arg_begin()->getType()
1811 ->canLosslesslyBitCastTo(F->getReturnType()) &&
1812 "unexpected this return");
1813 F->addAttribute(1, llvm::Attribute::Returned);
1823 if (!IsIncompleteFunction && F->isDeclaration())
1826 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
1827 F->setSection(CSA->getName());
1828 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
1829 F->setSection(SA->getName());
1834 F->addAttribute(llvm::AttributeList::FunctionIndex,
1835 llvm::Attribute::NoBuiltin);
1842 (
Kind == OO_New ||
Kind == OO_Array_New))
1843 F->addAttribute(llvm::AttributeList::ReturnIndex,
1844 llvm::Attribute::NoAlias);
1847 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
1848 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1849 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1850 if (MD->isVirtual())
1851 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1857 if (!CodeGenOpts.SanitizeCfiCrossDso ||
1858 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
1864 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
1868 llvm::LLVMContext &Ctx = F->getContext();
1869 llvm::MDBuilder MDB(Ctx);
1873 int CalleeIdx = *CB->encoding_begin();
1874 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
1875 F->addMetadata(llvm::LLVMContext::MD_callback,
1876 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
1877 CalleeIdx, PayloadIndices,
1883 assert(!GV->isDeclaration() &&
1884 "Only globals with definition can force usage.");
1885 LLVMUsed.emplace_back(GV);
1889 assert(!GV->isDeclaration() &&
1890 "Only globals with definition can force usage.");
1891 LLVMCompilerUsed.emplace_back(GV);
1895 std::vector<llvm::WeakTrackingVH> &List) {
1902 UsedArray.resize(List.size());
1903 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
1905 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1906 cast<llvm::Constant>(&*List[i]), CGM.
Int8PtrTy);
1909 if (UsedArray.empty())
1911 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
1913 auto *GV =
new llvm::GlobalVariable(
1914 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
1915 llvm::ConstantArray::get(ATy, UsedArray), Name);
1917 GV->setSection(
"llvm.metadata");
1920 void CodeGenModule::emitLLVMUsed() {
1921 emitUsed(*
this,
"llvm.used", LLVMUsed);
1922 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
1927 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
1934 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
1940 ELFDependentLibraries.push_back(
1941 llvm::MDNode::get(C, llvm::MDString::get(C, Lib)));
1948 LinkerOptionsMetadata.push_back(llvm::MDNode::get(C, MDOpts));
1955 llvm::SmallPtrSet<Module *, 16> &Visited) {
1957 if (Mod->
Parent && Visited.insert(Mod->
Parent).second) {
1962 for (
unsigned I = Mod->
Imports.size(); I > 0; --I) {
1963 if (Visited.insert(Mod->
Imports[I - 1]).second)
1981 llvm::Metadata *Args[2] = {
1982 llvm::MDString::get(Context,
"-framework"),
1983 llvm::MDString::get(Context, Mod->
LinkLibraries[I - 1].Library)};
1985 Metadata.push_back(llvm::MDNode::get(Context, Args));
1991 llvm::Metadata *Args[2] = {
1992 llvm::MDString::get(Context,
"lib"),
1993 llvm::MDString::get(Context, Mod->
LinkLibraries[I - 1].Library),
1995 Metadata.push_back(llvm::MDNode::get(Context, Args));
2000 auto *OptString = llvm::MDString::get(Context, Opt);
2001 Metadata.push_back(llvm::MDNode::get(Context, OptString));
2006 void CodeGenModule::EmitModuleLinkOptions() {
2010 llvm::SetVector<clang::Module *> LinkModules;
2011 llvm::SmallPtrSet<clang::Module *, 16> Visited;
2015 for (
Module *M : ImportedModules) {
2021 if (Visited.insert(M).second)
2027 while (!Stack.empty()) {
2030 bool AnyChildren =
false;
2039 if (Visited.insert(
SM).second) {
2040 Stack.push_back(
SM);
2048 LinkModules.insert(Mod);
2057 for (
Module *M : LinkModules)
2058 if (Visited.insert(M).second)
2060 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
2061 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
2064 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
2065 for (
auto *MD : LinkerOptionsMetadata)
2066 NMD->addOperand(MD);
2069 void CodeGenModule::EmitDeferred() {
2078 if (!DeferredVTables.empty()) {
2079 EmitDeferredVTables();
2084 assert(DeferredVTables.empty());
2088 if (DeferredDeclsToEmit.empty())
2093 std::vector<GlobalDecl> CurDeclsToEmit;
2094 CurDeclsToEmit.swap(DeferredDeclsToEmit);
2101 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
2119 if (!GV->isDeclaration())
2123 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
2127 EmitGlobalDefinition(D, GV);
2132 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
2134 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
2139 void CodeGenModule::EmitVTablesOpportunistically() {
2145 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
2146 &&
"Only emit opportunistic vtables with optimizations");
2150 "This queue should only contain external vtables");
2151 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
2154 OpportunisticVTables.clear();
2158 if (Annotations.empty())
2162 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
2163 Annotations[0]->getType(), Annotations.size()), Annotations);
2164 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
2165 llvm::GlobalValue::AppendingLinkage,
2166 Array,
"llvm.global.annotations");
2167 gv->setSection(AnnotationSection);
2171 llvm::Constant *&AStr = AnnotationStrings[Str];
2176 llvm::Constant *s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
2178 new llvm::GlobalVariable(
getModule(), s->getType(),
true,
2179 llvm::GlobalValue::PrivateLinkage, s,
".str");
2180 gv->setSection(AnnotationSection);
2181 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2199 return llvm::ConstantInt::get(
Int32Ty, LineNo);
2203 const AnnotateAttr *AA,
2211 llvm::Constant *Fields[4] = {
2212 llvm::ConstantExpr::getBitCast(GV,
Int8PtrTy),
2213 llvm::ConstantExpr::getBitCast(AnnoGV,
Int8PtrTy),
2214 llvm::ConstantExpr::getBitCast(UnitGV,
Int8PtrTy),
2217 return llvm::ConstantStruct::getAnon(Fields);
2221 llvm::GlobalValue *GV) {
2222 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
2233 if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName()))
2242 return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName());
2253 (SanitizerKind::Address | SanitizerKind::KernelAddress |
2254 SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
2255 SanitizerKind::MemTag);
2256 if (!EnabledAsanMask)
2259 if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(),
Category))
2261 if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category))
2267 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
2268 Ty = AT->getElementType();
2273 if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category))
2284 auto Attr = ImbueAttr::NONE;
2286 Attr = XRayFilter.shouldImbueLocation(Loc, Category);
2287 if (
Attr == ImbueAttr::NONE)
2288 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
2290 case ImbueAttr::NONE:
2292 case ImbueAttr::ALWAYS:
2293 Fn->addFnAttr(
"function-instrument",
"xray-always");
2295 case ImbueAttr::ALWAYS_ARG1:
2296 Fn->addFnAttr(
"function-instrument",
"xray-always");
2297 Fn->addFnAttr(
"xray-log-args",
"1");
2299 case ImbueAttr::NEVER:
2300 Fn->addFnAttr(
"function-instrument",
"xray-never");
2306 bool CodeGenModule::MustBeEmitted(
const ValueDecl *Global) {
2308 if (LangOpts.EmitAllDecls)
2311 if (CodeGenOpts.KeepStaticConsts) {
2312 const auto *VD = dyn_cast<
VarDecl>(Global);
2313 if (VD && VD->getType().isConstQualified() &&
2321 bool CodeGenModule::MayBeEmittedEagerly(
const ValueDecl *Global) {
2322 if (
const auto *FD = dyn_cast<FunctionDecl>(Global)) {
2330 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd &&
2331 !LangOpts.OpenMPIsDevice &&
2332 !OMPDeclareTargetDeclAttr::getDeviceType(FD) &&
2336 if (
const auto *VD = dyn_cast<VarDecl>(Global))
2344 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
2347 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
2358 std::string Name =
"_GUID_" + Uuid.lower();
2359 std::replace(Name.begin(), Name.end(),
'-',
'_');
2365 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
2368 llvm::Constant *Init = EmitUuidofInitializer(Uuid);
2369 assert(Init &&
"failed to initialize as constant");
2371 auto *GV =
new llvm::GlobalVariable(
2373 true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
2375 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
2381 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
2382 assert(AA &&
"No alias?");
2391 auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
2395 llvm::Constant *Aliasee;
2396 if (isa<llvm::FunctionType>(DeclTy))
2397 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(),
DeclTy,
2401 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2402 llvm::PointerType::getUnqual(DeclTy),
2405 auto *F = cast<llvm::GlobalValue>(Aliasee);
2406 F->setLinkage(llvm::Function::ExternalWeakLinkage);
2407 WeakRefReferences.insert(F);
2413 const auto *Global = cast<ValueDecl>(GD.
getDecl());
2416 if (Global->
hasAttr<WeakRefAttr>())
2421 if (Global->
hasAttr<AliasAttr>())
2422 return EmitAliasDefinition(GD);
2425 if (Global->
hasAttr<IFuncAttr>())
2426 return emitIFuncDefinition(GD);
2429 if (Global->
hasAttr<CPUDispatchAttr>())
2430 return emitCPUDispatchDefinition(GD);
2433 if (LangOpts.CUDA) {
2434 if (LangOpts.CUDAIsDevice) {
2435 if (!Global->
hasAttr<CUDADeviceAttr>() &&
2436 !Global->
hasAttr<CUDAGlobalAttr>() &&
2437 !Global->
hasAttr<CUDAConstantAttr>() &&
2438 !Global->
hasAttr<CUDASharedAttr>() &&
2439 !(LangOpts.HIP && Global->
hasAttr<HIPPinnedShadowAttr>()))
2448 if (isa<FunctionDecl>(Global) && !Global->
hasAttr<CUDAHostAttr>() &&
2449 Global->
hasAttr<CUDADeviceAttr>())
2452 assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
2453 "Expected Variable or Function");
2457 if (LangOpts.OpenMP) {
2459 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
2461 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
2462 if (MustBeEmitted(Global))
2465 }
else if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Global)) {
2466 if (MustBeEmitted(Global))
2473 if (
const auto *FD = dyn_cast<FunctionDecl>(Global)) {
2485 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
2490 const auto *VD = cast<VarDecl>(Global);
2491 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
2494 if (LangOpts.OpenMP) {
2497 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
2498 bool UnifiedMemoryEnabled =
2500 if (*Res == OMPDeclareTargetDeclAttr::MT_To &&
2501 !UnifiedMemoryEnabled) {
2504 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
2505 (*Res == OMPDeclareTargetDeclAttr::MT_To &&
2506 UnifiedMemoryEnabled)) &&
2507 "Link clause or to clause with unified memory expected.");
2526 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
2528 EmitGlobalDefinition(GD);
2533 if (LangOpts.OpenMP && isa<FunctionDecl>(Global) && OpenMPRuntime &&
2534 OpenMPRuntime->emitDeclareVariant(GD,
false))
2539 if (
getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
2540 cast<VarDecl>(Global)->hasInit()) {
2541 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
2542 CXXGlobalInits.push_back(
nullptr);
2548 addDeferredDeclToEmit(GD);
2549 }
else if (MustBeEmitted(Global)) {
2551 assert(!MayBeEmittedEagerly(Global));
2552 addDeferredDeclToEmit(GD);
2557 DeferredDecls[MangledName] = GD;
2564 if (
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2565 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
2572 struct FunctionIsDirectlyRecursive
2574 const StringRef Name;
2579 bool VisitCallExpr(
const CallExpr *E) {
2584 if (Attr && Name == Attr->getLabel())
2589 StringRef BuiltinName = BI.
getName(BuiltinID);
2590 if (BuiltinName.startswith(
"__builtin_") &&
2591 Name == BuiltinName.slice(strlen(
"__builtin_"), StringRef::npos)) {
2597 bool VisitStmt(
const Stmt *S) {
2599 if (Child && this->Visit(Child))
2606 struct DLLImportFunctionVisitor
2608 bool SafeToInline =
true;
2610 bool shouldVisitImplicitCode()
const {
return true; }
2612 bool VisitVarDecl(
VarDecl *VD) {
2615 SafeToInline =
false;
2616 return SafeToInline;
2623 return SafeToInline;
2628 SafeToInline = D->hasAttr<DLLImportAttr>();
2629 return SafeToInline;
2634 if (isa<FunctionDecl>(VD))
2635 SafeToInline = VD->
hasAttr<DLLImportAttr>();
2636 else if (
VarDecl *
V = dyn_cast<VarDecl>(VD))
2637 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
2638 return SafeToInline;
2643 return SafeToInline;
2650 SafeToInline =
true;
2652 SafeToInline = M->
hasAttr<DLLImportAttr>();
2654 return SafeToInline;
2659 return SafeToInline;
2664 return SafeToInline;
2673 CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
2675 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
2680 Name = Attr->getLabel();
2685 FunctionIsDirectlyRecursive Walker(Name, Context.
BuiltinInfo);
2687 return Body ? Walker.Visit(Body) :
false;
2690 bool CodeGenModule::shouldEmitFunction(
GlobalDecl GD) {
2693 const auto *F = cast<FunctionDecl>(GD.
getDecl());
2694 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
2697 if (F->hasAttr<DLLImportAttr>()) {
2699 DLLImportFunctionVisitor Visitor;
2700 Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
2701 if (!Visitor.SafeToInline)
2707 for (
const Decl *Member : Dtor->getParent()->decls())
2708 if (isa<FieldDecl>(Member))
2722 return !isTriviallyRecursive(F);
2725 bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
2726 return CodeGenOpts.OptimizationLevel > 0;
2729 void CodeGenModule::EmitMultiVersionFunctionDefinition(
GlobalDecl GD,
2730 llvm::GlobalValue *GV) {
2731 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2734 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
2735 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
2739 EmitGlobalFunctionDefinition(GD, GV);
2745 OpenMPRuntime &&
"Expected OpenMP device mode.");
2746 const auto *D = cast<FunctionDecl>(OldGD.
getDecl());
2753 if (!GV || (GV->getType()->getElementType() != Ty)) {
2754 GV = cast<llvm::GlobalValue>(GetOrCreateLLVMFunction(
2756 true,
false, llvm::AttributeList(),
2758 SetFunctionAttributes(OldGD, cast<llvm::Function>(GV),
2766 auto *Fn = cast<llvm::Function>(GV);
2779 setNonAliasAttributes(OldGD, Fn);
2782 if (D->hasAttr<AnnotateAttr>())
2786 void CodeGenModule::EmitGlobalDefinition(
GlobalDecl GD, llvm::GlobalValue *GV) {
2787 const auto *D = cast<ValueDecl>(GD.
getDecl());
2791 "Generating code for declaration");
2793 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
2796 if (!shouldEmitFunction(GD))
2799 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
2801 llvm::raw_string_ostream OS(Name);
2807 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2810 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
2811 ABI->emitCXXStructor(GD);
2813 EmitMultiVersionFunctionDefinition(GD, GV);
2815 EmitGlobalFunctionDefinition(GD, GV);
2817 if (Method->isVirtual())
2824 return EmitMultiVersionFunctionDefinition(GD, GV);
2825 return EmitGlobalFunctionDefinition(GD, GV);
2828 if (
const auto *VD = dyn_cast<VarDecl>(D))
2829 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
2831 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
2835 llvm::Function *NewFn);
2840 unsigned Priority = 0;
2850 void CodeGenModule::emitMultiVersionFunctions() {
2862 EmitGlobalFunctionDefinition(CurGD,
nullptr);
2871 assert(Func &&
"This should have just been created");
2874 const auto *TA = CurFD->
getAttr<TargetAttr>();
2876 TA->getAddedFeatures(Feats);
2878 Options.emplace_back(cast<llvm::Function>(Func),
2879 TA->getArchitecture(), Feats);
2882 llvm::Function *ResolverFunc;
2886 ResolverFunc = cast<llvm::Function>(
2888 ResolverFunc->setLinkage(llvm::Function::WeakODRLinkage);
2894 ResolverFunc->setComdat(
2895 getModule().getOrInsertComdat(ResolverFunc->getName()));
2903 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
2907 void CodeGenModule::emitCPUDispatchDefinition(
GlobalDecl GD) {
2908 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2909 assert(FD &&
"Not a FunctionDecl?");
2910 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
2911 assert(DD &&
"Not a cpu_dispatch Function?");
2914 if (
const auto *CXXFD = dyn_cast<CXXMethodDecl>(FD)) {
2924 ResolverType = llvm::FunctionType::get(
2925 llvm::PointerType::get(DeclTy,
2933 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
2934 ResolverName, ResolverType, ResolverGD,
false));
2935 ResolverFunc->setLinkage(llvm::Function::WeakODRLinkage);
2937 ResolverFunc->setComdat(
2938 getModule().getOrInsertComdat(ResolverFunc->getName()));
2951 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
2954 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
2960 Func = GetOrCreateLLVMFunction(
2961 MangledName, DeclTy, ExistingDecl,
2969 llvm::transform(Features, Features.begin(),
2970 [](StringRef Str) {
return Str.substr(1); });
2971 Features.erase(std::remove_if(
2972 Features.begin(), Features.end(), [&Target](StringRef Feat) {
2974 }), Features.end());
2975 Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features);
2990 while (Options.size() > 1 &&
2992 (Options.end() - 2)->Conditions.Features) == 0) {
2993 StringRef LHSName = (Options.end() - 2)->Function->getName();
2994 StringRef RHSName = (Options.end() - 1)->Function->getName();
2995 if (LHSName.compare(RHSName) < 0)
2996 Options.erase(Options.end() - 2);
2998 Options.erase(Options.end() - 1);
3006 *
this, GD, FD,
true);
3009 auto *IFunc = cast<llvm::GlobalIFunc>(GetOrCreateLLVMFunction(
3010 AliasName, DeclTy, GD,
false,
true,
3014 GA->setLinkage(llvm::Function::WeakODRLinkage);
3022 llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
3024 std::string MangledName =
3029 std::string ResolverName = MangledName;
3031 ResolverName +=
".ifunc";
3033 ResolverName +=
".resolver";
3036 if (llvm::GlobalValue *ResolverGV =
GetGlobalValue(ResolverName))
3043 MultiVersionFuncs.push_back(GD);
3046 llvm::Type *ResolverType = llvm::FunctionType::get(
3047 llvm::PointerType::get(
3050 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
3051 MangledName +
".resolver", ResolverType,
GlobalDecl{},
3054 DeclTy, 0, llvm::Function::WeakODRLinkage,
"", Resolver, &
getModule());
3055 GIF->setName(ResolverName);
3061 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
3063 assert(isa<llvm::GlobalValue>(Resolver) &&
3064 "Resolver should be created for the first time");
3076 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
3078 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
3084 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
3086 if (
getLangOpts().OpenMPIsDevice && OpenMPRuntime &&
3087 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
3088 !DontDefer && !IsForDefinition) {
3091 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
3093 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
3102 if (LangOpts.OpenMP && OpenMPRuntime)
3103 (void)OpenMPRuntime->emitDeclareVariant(GD,
true);
3106 const auto *TA = FD->
getAttr<TargetAttr>();
3107 if (TA && TA->isDefaultVersion())
3108 UpdateMultiVersionNames(GD, FD);
3109 if (!IsForDefinition)
3110 return GetOrCreateMultiVersionResolver(GD, Ty, FD);
3117 if (WeakRefReferences.erase(Entry)) {
3118 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
3119 if (FD && !FD->
hasAttr<WeakAttr>())
3124 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>()) {
3125 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
3131 if (IsForDefinition && !Entry->isDeclaration()) {
3138 DiagnosedConflictingDefinitions.insert(GD).second) {
3142 diag::note_previous_definition);
3146 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
3147 (Entry->getType()->getElementType() == Ty)) {
3154 if (!IsForDefinition)
3155 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
3161 bool IsIncompleteFunction =
false;
3163 llvm::FunctionType *FTy;
3164 if (isa<llvm::FunctionType>(Ty)) {
3165 FTy = cast<llvm::FunctionType>(Ty);
3167 FTy = llvm::FunctionType::get(
VoidTy,
false);
3168 IsIncompleteFunction =
true;
3173 Entry ? StringRef() : MangledName, &
getModule());
3190 if (!Entry->use_empty()) {
3192 Entry->removeDeadConstantUsers();
3195 llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
3196 F, Entry->getType()->getElementType()->getPointerTo());
3200 assert(F->getName() == MangledName &&
"name was uniqued!");
3202 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
3203 if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) {
3204 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex);
3205 F->addAttributes(llvm::AttributeList::FunctionIndex, B);
3212 if (D && isa<CXXDestructorDecl>(D) &&
3213 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
3215 addDeferredDeclToEmit(GD);
3220 auto DDI = DeferredDecls.find(MangledName);
3221 if (DDI != DeferredDecls.end()) {
3225 addDeferredDeclToEmit(DDI->second);
3226 DeferredDecls.erase(DDI);
3241 for (
const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
3254 if (!IsIncompleteFunction) {
3255 assert(F->getType()->getElementType() == Ty);
3259 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
3260 return llvm::ConstantExpr::getBitCast(F, PTy);
3273 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3280 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
3283 DD->getParent()->getNumVBases() == 0)
3288 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
3289 false, llvm::AttributeList(),
3299 for (
const auto &Result : DC->
lookup(&CII))
3300 if (
const auto FD = dyn_cast<FunctionDecl>(Result))
3308 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
3312 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
3314 for (
const auto &Result : DC->
lookup(&NS)) {
3316 if (
auto LSD = dyn_cast<LinkageSpecDecl>(Result))
3317 for (
const auto &Result : LSD->lookup(&NS))
3318 if ((ND = dyn_cast<NamespaceDecl>(Result)))
3322 for (
const auto &Result : ND->
lookup(&CXXII))
3323 if (
const auto *FD = dyn_cast<FunctionDecl>(Result))
3333 llvm::FunctionCallee
3335 llvm::AttributeList ExtraAttrs,
3338 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
3342 if (
auto *F = dyn_cast<llvm::Function>(C)) {
3351 if (!Local &&
getTriple().isWindowsItaniumEnvironment() &&
3354 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
3355 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
3379 return ExcludeCtor && !Record->hasMutableFields() &&
3380 Record->hasTrivialDestructor();
3398 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
3399 llvm::PointerType *Ty,
3405 if (WeakRefReferences.erase(Entry)) {
3406 if (D && !D->
hasAttr<WeakAttr>())
3411 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>())
3412 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
3414 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
3417 if (Entry->getType() == Ty)
3422 if (IsForDefinition && !Entry->isDeclaration()) {
3430 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
3432 DiagnosedConflictingDefinitions.insert(D).second) {
3436 diag::note_previous_definition);
3441 if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
3442 return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
3446 if (!IsForDefinition)
3447 return llvm::ConstantExpr::getBitCast(Entry, Ty);
3453 auto *GV =
new llvm::GlobalVariable(
3454 getModule(), Ty->getElementType(),
false,
3456 llvm::GlobalVariable::NotThreadLocal, TargetAddrSpace);
3461 GV->takeName(Entry);
3463 if (!Entry->use_empty()) {
3464 llvm::Constant *NewPtrForOldDecl =
3465 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
3466 Entry->replaceAllUsesWith(NewPtrForOldDecl);
3469 Entry->eraseFromParent();
3475 auto DDI = DeferredDecls.find(MangledName);
3476 if (DDI != DeferredDecls.end()) {
3479 addDeferredDeclToEmit(DDI->second);
3480 DeferredDecls.erase(DDI);
3485 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
3498 CXXThreadLocals.push_back(D);
3506 if (
getContext().isMSStaticDataMemberInlineDefinition(D)) {
3507 EmitGlobalVarDefinition(D);
3512 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>())
3513 GV->setSection(SA->getName());
3517 if (
getTriple().getArch() == llvm::Triple::xcore &&
3521 GV->setSection(
".cp.rodata");
3526 if (Context.
getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
3529 const auto *Record =
3531 bool HasMutableFields = Record && Record->hasMutableFields();
3532 if (!HasMutableFields) {
3539 auto *InitType = Init->getType();
3540 if (GV->getType()->getElementType() != InitType) {
3545 GV->setName(StringRef());
3548 auto *NewGV = cast<llvm::GlobalVariable>(
3550 ->stripPointerCasts());
3553 GV->eraseFromParent();
3556 GV->setInitializer(Init);
3557 GV->setConstant(
true);
3558 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
3570 assert(
getContext().getTargetAddressSpace(ExpectedAS) ==
3571 Ty->getPointerAddressSpace());
3572 if (AddrSpace != ExpectedAS)
3576 if (GV->isDeclaration())
3586 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
3588 false, IsForDefinition);
3589 else if (isa<CXXMethodDecl>(D)) {
3591 cast<CXXMethodDecl>(D));
3595 }
else if (isa<FunctionDecl>(D)) {
3607 unsigned Alignment) {
3608 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
3609 llvm::GlobalVariable *OldGV =
nullptr;
3613 if (GV->getType()->getElementType() == Ty)
3618 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
3623 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
3624 Linkage,
nullptr, Name);
3628 GV->takeName(OldGV);
3630 if (!OldGV->use_empty()) {
3631 llvm::Constant *NewPtrForOldDecl =
3632 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3633 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
3636 OldGV->eraseFromParent();
3640 !GV->hasAvailableExternallyLinkage())
3641 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3643 GV->setAlignment(llvm::MaybeAlign(Alignment));
3662 llvm::PointerType *PTy =
3663 llvm::PointerType::get(Ty,
getContext().getTargetAddressSpace(ASTTy));
3666 return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition);
3676 ? llvm::PointerType::get(
3678 : llvm::PointerType::getUnqual(Ty);
3679 auto *
Ret = GetOrCreateLLVMGlobal(Name, PtrTy,
nullptr);
3685 assert(!D->
getInit() &&
"Cannot emit definite definitions here!");
3693 if (GV && !GV->isDeclaration())
3698 if (!MustBeEmitted(D) && !GV) {
3699 DeferredDecls[MangledName] = D;
3704 EmitGlobalVarDefinition(D);
3714 if (LangOpts.OpenCL) {
3723 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
3724 if (D && D->
hasAttr<CUDAConstantAttr>())
3726 else if (D && D->
hasAttr<CUDASharedAttr>())
3728 else if (D && D->
hasAttr<CUDADeviceAttr>())
3736 if (LangOpts.OpenMP) {
3738 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
3746 if (LangOpts.OpenCL)
3748 if (
auto AS =
getTarget().getConstantAddressSpace())
3749 return AS.getValue();
3761 static llvm::Constant *
3763 llvm::GlobalVariable *GV) {
3764 llvm::Constant *
Cast = GV;
3770 GV->getValueType()->getPointerTo(
3777 template<
typename SomeDecl>
3779 llvm::GlobalValue *GV) {
3785 if (!D->template hasAttr<UsedAttr>())
3794 const SomeDecl *
First = D->getFirstDecl();
3795 if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
3801 std::pair<StaticExternCMap::iterator, bool> R =
3802 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
3807 R.first->second =
nullptr;
3816 if (D.
hasAttr<CUDAGlobalAttr>())
3819 if (D.
hasAttr<SelectAnyAttr>())
3823 if (
auto *VD = dyn_cast<VarDecl>(&D))
3837 llvm_unreachable(
"No such linkage");
3841 llvm::GlobalObject &GO) {
3844 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
3848 void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *D,
3858 if (LangOpts.OpenMPIsDevice && OpenMPRuntime &&
3859 OpenMPRuntime->emitTargetGlobalVariable(D))
3862 llvm::Constant *Init =
nullptr;
3863 bool NeedsGlobalCtor =
false;
3864 bool NeedsGlobalDtor =
3875 bool IsCUDASharedVar =
3879 bool IsCUDAShadowVar =
3881 (D->
hasAttr<CUDAConstantAttr>() || D->
hasAttr<CUDADeviceAttr>() ||
3882 D->
hasAttr<CUDASharedAttr>());
3885 bool IsHIPPinnedShadowVar =
3888 (IsCUDASharedVar || IsCUDAShadowVar || IsHIPPinnedShadowVar))
3889 Init = llvm::UndefValue::get(
getTypes().ConvertType(ASTTy));
3890 else if (!InitExpr) {
3904 emitter.emplace(*
this);
3905 Init = emitter->tryEmitForInitializer(*InitDecl);
3914 NeedsGlobalCtor =
true;
3917 Init = llvm::UndefValue::get(
getTypes().ConvertType(T));
3924 DelayedCXXInitPosition.erase(D);
3929 llvm::Constant *Entry =
3933 Entry = Entry->stripPointerCasts();
3936 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
3947 if (!GV || GV->getType()->getElementType() != InitType ||
3948 GV->getType()->getAddressSpace() !=
3952 Entry->setName(StringRef());
3955 GV = cast<llvm::GlobalVariable>(
3957 ->stripPointerCasts());
3960 llvm::Constant *NewPtrForOldDecl =
3961 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
3962 Entry->replaceAllUsesWith(NewPtrForOldDecl);
3965 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
3970 if (D->
hasAttr<AnnotateAttr>())
3974 llvm::GlobalValue::LinkageTypes
Linkage =
3984 if (GV && LangOpts.CUDA) {
3985 if (LangOpts.CUDAIsDevice) {
3987 (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>()))
3988 GV->setExternallyInitialized(
true);
3994 if (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>() ||
3995 D->
hasAttr<HIPPinnedShadowAttr>()) {
4003 if (D->
hasAttr<CUDAConstantAttr>())
4009 }
else if (D->
hasAttr<CUDASharedAttr>())
4019 if (!IsHIPPinnedShadowVar)
4020 GV->setInitializer(Init);
4021 if (emitter) emitter->finalize(GV);
4024 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
4028 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>()) {
4031 GV->setConstant(
true);
4045 !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) &&
4046 !llvm::GlobalVariable::isWeakLinkage(Linkage))
4049 GV->setLinkage(Linkage);
4050 if (D->
hasAttr<DLLImportAttr>())
4051 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
4052 else if (D->
hasAttr<DLLExportAttr>())
4053 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
4055 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
4057 if (Linkage == llvm::GlobalVariable::CommonLinkage) {
4059 GV->setConstant(
false);
4064 if (!GV->getInitializer()->isNullValue())
4065 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
4068 setNonAliasAttributes(D, GV);
4070 if (D->
getTLSKind() && !GV->isThreadLocal()) {
4072 CXXThreadLocals.push_back(D);
4079 if (NeedsGlobalCtor || NeedsGlobalDtor)
4080 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
4082 SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
4087 DI->EmitGlobalVariable(GV, D);
4095 if ((NoCommon || D->
hasAttr<NoCommonAttr>()) && !D->
hasAttr<CommonAttr>())
4106 if (D->
hasAttr<SectionAttr>())
4112 if (D->
hasAttr<PragmaClangBSSSectionAttr>() ||
4113 D->
hasAttr<PragmaClangDataSectionAttr>() ||
4114 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
4115 D->
hasAttr<PragmaClangRodataSectionAttr>())
4123 if (D->
hasAttr<WeakImportAttr>())
4133 if (D->
hasAttr<AlignedAttr>())
4142 if (FD->isBitField())
4144 if (FD->
hasAttr<AlignedAttr>())
4172 if (IsConstantVariable)
4173 return llvm::GlobalVariable::WeakODRLinkage;
4175 return llvm::GlobalVariable::WeakAnyLinkage;
4180 return llvm::GlobalVariable::LinkOnceAnyLinkage;
4185 return llvm::GlobalValue::AvailableExternallyLinkage;
4199 return !Context.
getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
4216 return llvm::Function::WeakODRLinkage;
4221 if (!
getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
4223 CodeGenOpts.NoCommon))
4224 return llvm::GlobalVariable::CommonLinkage;
4230 if (D->
hasAttr<SelectAnyAttr>())
4231 return llvm::GlobalVariable::WeakODRLinkage;
4239 const VarDecl *VD,
bool IsConstant) {
4247 llvm::Function *newFn) {
4249 if (old->use_empty())
return;
4251 llvm::Type *newRetTy = newFn->getReturnType();
4255 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
4257 llvm::Value::use_iterator use = ui++;
4258 llvm::User *user = use->getUser();
4262 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
4263 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
4269 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
4270 if (!callSite)
continue;
4271 if (!callSite->isCallee(&*use))
4276 if (callSite->getType() != newRetTy && !callSite->use_empty())
4281 llvm::AttributeList oldAttrs = callSite->getAttributes();
4284 unsigned newNumArgs = newFn->arg_size();
4285 if (callSite->arg_size() < newNumArgs)
4291 bool dontTransform =
false;
4292 for (llvm::Argument &A : newFn->args()) {
4293 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
4294 dontTransform =
true;
4299 newArgAttrs.push_back(oldAttrs.getParamAttributes(argNo));
4307 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
4310 callSite->getOperandBundlesAsDefs(newBundles);
4312 llvm::CallBase *newCall;
4313 if (dyn_cast<llvm::CallInst>(callSite)) {
4317 auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
4319 oldInvoke->getUnwindDest(), newArgs,
4320 newBundles,
"", callSite);
4324 if (!newCall->getType()->isVoidTy())
4325 newCall->takeName(callSite);
4326 newCall->setAttributes(llvm::AttributeList::get(
4327 newFn->getContext(), oldAttrs.getFnAttributes(),
4328 oldAttrs.getRetAttributes(), newArgAttrs));
4329 newCall->setCallingConv(callSite->getCallingConv());
4332 if (!callSite->use_empty())
4333 callSite->replaceAllUsesWith(newCall);
4336 if (callSite->getDebugLoc())
4337 newCall->setDebugLoc(callSite->getDebugLoc());
4339 callSite->eraseFromParent();
4353 llvm::Function *NewFn) {
4355 if (!isa<llvm::Function>(Old))
return;
4374 void CodeGenModule::EmitGlobalFunctionDefinition(
GlobalDecl GD,
4375 llvm::GlobalValue *GV) {
4377 if (LangOpts.OpenMP && OpenMPRuntime &&
4378 OpenMPRuntime->emitDeclareVariant(GD,
true))
4381 const auto *D = cast<FunctionDecl>(GD.
getDecl());
4388 if (!GV || (GV->getType()->getElementType() != Ty))
4394 if (!GV->isDeclaration())
4401 auto *Fn = cast<llvm::Function>(GV);
4414 setNonAliasAttributes(GD, Fn);
4417 if (
const ConstructorAttr *CA = D->
getAttr<ConstructorAttr>())
4418 AddGlobalCtor(Fn, CA->getPriority());
4419 if (
const DestructorAttr *DA = D->
getAttr<DestructorAttr>())
4420 AddGlobalDtor(Fn, DA->getPriority());
4421 if (D->
hasAttr<AnnotateAttr>())
4425 void CodeGenModule::EmitAliasDefinition(
GlobalDecl GD) {
4426 const auto *D = cast<ValueDecl>(GD.
getDecl());
4427 const AliasAttr *AA = D->
getAttr<AliasAttr>();
4428 assert(AA &&
"Not an alias?");
4432 if (AA->getAliasee() == MangledName) {
4433 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
4440 if (Entry && !Entry->isDeclaration())
4443 Aliases.push_back(GD);
4449 llvm::Constant *Aliasee;
4450 llvm::GlobalValue::LinkageTypes
LT;
4451 if (isa<llvm::FunctionType>(DeclTy)) {
4452 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(),
DeclTy, GD,
4456 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
4457 llvm::PointerType::getUnqual(DeclTy),
4468 if (GA->getAliasee() == Entry) {
4469 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
4473 assert(Entry->isDeclaration());
4482 GA->takeName(Entry);
4484 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
4486 Entry->eraseFromParent();
4488 GA->setName(MangledName);
4496 GA->setLinkage(llvm::Function::WeakAnyLinkage);
4499 if (
const auto *VD = dyn_cast<VarDecl>(D))
4500 if (VD->getTLSKind())
4506 void CodeGenModule::emitIFuncDefinition(
GlobalDecl GD) {
4507 const auto *D = cast<ValueDecl>(GD.
getDecl());
4508 const IFuncAttr *IFA = D->
getAttr<IFuncAttr>();
4509 assert(IFA &&
"Not an ifunc?");
4513 if (IFA->getResolver() == MangledName) {
4514 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
4520 if (Entry && !Entry->isDeclaration()) {
4523 DiagnosedConflictingDefinitions.insert(GD).second) {
4524 Diags.Report(D->
getLocation(), diag::err_duplicate_mangled_name)
4527 diag::note_previous_definition);
4532 Aliases.push_back(GD);
4535 llvm::Constant *Resolver =
4536 GetOrCreateLLVMFunction(IFA->getResolver(),
DeclTy, GD,
4538 llvm::GlobalIFunc *GIF =
4542 if (GIF->getResolver() == Entry) {
4543 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
4546 assert(Entry->isDeclaration());
4555 GIF->takeName(Entry);
4557 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GIF,
4559 Entry->eraseFromParent();
4561 GIF->setName(MangledName);
4572 static llvm::StringMapEntry<llvm::GlobalVariable *> &
4575 bool &IsUTF16,
unsigned &StringLength) {
4576 StringRef String = Literal->
getString();
4577 unsigned NumBytes = String.size();
4581 StringLength = NumBytes;
4582 return *Map.insert(std::make_pair(String,
nullptr)).first;
4589 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
4590 llvm::UTF16 *ToPtr = &ToBuf[0];
4592 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
4593 ToPtr + NumBytes, llvm::strictConversion);
4596 StringLength = ToPtr - &ToBuf[0];
4600 return *Map.insert(std::make_pair(
4601 StringRef(reinterpret_cast<const char *>(ToBuf.data()),
4602 (StringLength + 1) * 2),
4608 unsigned StringLength = 0;
4609 bool isUTF16 =
false;
4610 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
4615 if (
auto *C = Entry.second)
4618 llvm::Constant *
Zero = llvm::Constant::getNullValue(
Int32Ty);
4619 llvm::Constant *Zeros[] = {
Zero, Zero };
4622 const llvm::Triple &Triple =
getTriple();
4625 const bool IsSwiftABI =
4626 static_cast<unsigned>(CFRuntime) >=
4631 if (!CFConstantStringClassRef) {
4632 const char *CFConstantStringClassName =
"__CFConstantStringClassReference";
4634 Ty = llvm::ArrayType::get(Ty, 0);
4636 switch (CFRuntime) {
4640 CFConstantStringClassName =
4641 Triple.isOSDarwin() ?
"$s15SwiftFoundation19_NSCFConstantStringCN" 4642 :
"$s10Foundation19_NSCFConstantStringCN";
4646 CFConstantStringClassName =
4647 Triple.isOSDarwin() ?
"$S15SwiftFoundation19_NSCFConstantStringCN" 4648 :
"$S10Foundation19_NSCFConstantStringCN";
4652 CFConstantStringClassName =
4653 Triple.isOSDarwin() ?
"__T015SwiftFoundation19_NSCFConstantStringCN" 4654 :
"__T010Foundation19_NSCFConstantStringCN";
4661 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
4662 llvm::GlobalValue *GV =
nullptr;
4664 if ((GV = dyn_cast<llvm::GlobalValue>(C))) {
4670 for (
const auto &Result : DC->
lookup(&II))
4671 if ((VD = dyn_cast<VarDecl>(Result)))
4674 if (Triple.isOSBinFormatELF()) {
4679 if (!VD || !VD->
hasAttr<DLLExportAttr>())
4680 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4682 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
4690 CFConstantStringClassRef =
4691 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(C, Ty)
4692 : llvm::ConstantExpr::getGetElementPtr(Ty, C, Zeros);
4700 auto Fields = Builder.beginStruct(STy);
4703 Fields.add(cast<llvm::ConstantExpr>(CFConstantStringClassRef));
4707 Fields.addInt(
IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
4708 Fields.addInt(
Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
4710 Fields.addInt(
IntTy, isUTF16 ? 0x07d0 : 0x07C8);
4714 llvm::Constant *C =
nullptr;
4716 auto Arr = llvm::makeArrayRef(
4717 reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
4718 Entry.first().size() / 2);
4719 C = llvm::ConstantDataArray::get(VMContext, Arr);
4721 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
4727 new llvm::GlobalVariable(
getModule(), C->getType(),
true,
4728 llvm::GlobalValue::PrivateLinkage, C,
".str");
4729 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4739 if (Triple.isOSBinFormatMachO())
4740 GV->setSection(isUTF16 ?
"__TEXT,__ustring" 4741 :
"__TEXT,__cstring,cstring_literals");
4744 else if (Triple.isOSBinFormatELF())
4745 GV->setSection(
".rodata");
4748 llvm::Constant *Str =
4749 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
4753 Str = llvm::ConstantExpr::getBitCast(Str,
Int8PtrTy);
4757 llvm::IntegerType *LengthTy =
4767 Fields.addInt(LengthTy, StringLength);
4775 GV = Fields.finishAndCreateGlobal(
"_unnamed_cfstring_", Alignment,
4777 llvm::GlobalVariable::PrivateLinkage);
4778 GV->addAttribute(
"objc_arc_inert");
4779 switch (Triple.getObjectFormat()) {
4780 case llvm::Triple::UnknownObjectFormat:
4781 llvm_unreachable(
"unknown file format");
4782 case llvm::Triple::XCOFF:
4783 llvm_unreachable(
"XCOFF is not yet implemented");
4784 case llvm::Triple::COFF:
4785 case llvm::Triple::ELF:
4786 case llvm::Triple::Wasm:
4787 GV->setSection(
"cfstring");
4789 case llvm::Triple::MachO:
4790 GV->setSection(
"__DATA,__cfstring");
4799 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
4803 if (ObjCFastEnumerationStateType.isNull()) {
4815 for (
size_t i = 0; i < 4; ++i) {
4820 FieldTypes[i],
nullptr,
4832 return ObjCFastEnumerationStateType;
4846 Str.resize(CAT->getSize().getZExtValue());
4847 return llvm::ConstantDataArray::getString(VMContext, Str,
false);
4851 llvm::Type *ElemTy = AType->getElementType();
4852 unsigned NumElements = AType->getNumElements();
4855 if (ElemTy->getPrimitiveSizeInBits() == 16) {
4857 Elements.reserve(NumElements);
4859 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
4861 Elements.resize(NumElements);
4862 return llvm::ConstantDataArray::get(VMContext, Elements);
4865 assert(ElemTy->getPrimitiveSizeInBits() == 32);
4867 Elements.reserve(NumElements);
4869 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
4871 Elements.resize(NumElements);
4872 return llvm::ConstantDataArray::get(VMContext, Elements);
4875 static llvm::GlobalVariable *
4884 auto *GV =
new llvm::GlobalVariable(
4885 M, C->getType(), !CGM.
getLangOpts().WritableStrings,
LT, C, GlobalName,
4886 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
4888 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4889 if (GV->isWeakForLinker()) {
4890 assert(CGM.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
4891 GV->setComdat(M.getOrInsertComdat(GV->getName()));
4906 llvm::GlobalVariable **Entry =
nullptr;
4907 if (!LangOpts.WritableStrings) {
4908 Entry = &ConstantStringMap[C];
4909 if (
auto GV = *Entry) {
4918 StringRef GlobalVariableName;
4919 llvm::GlobalValue::LinkageTypes
LT;
4924 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
4925 !LangOpts.WritableStrings) {
4926 llvm::raw_svector_ostream Out(MangledNameBuffer);
4928 LT = llvm::GlobalValue::LinkOnceODRLinkage;
4929 GlobalVariableName = MangledNameBuffer;
4931 LT = llvm::GlobalValue::PrivateLinkage;
4932 GlobalVariableName = Name;
4939 SanitizerMD->reportGlobalToASan(GV, S->
getStrTokenLoc(0),
"<string literal>",
4960 const std::string &Str,
const char *GlobalName) {
4961 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
4966 llvm::ConstantDataArray::getString(
getLLVMContext(), StrWithNull,
false);
4969 llvm::GlobalVariable **Entry =
nullptr;
4970 if (!LangOpts.WritableStrings) {
4971 Entry = &ConstantStringMap[C];
4972 if (
auto GV = *Entry) {
4973 if (Alignment.getQuantity() > GV->getAlignment())
4974 GV->setAlignment(Alignment.getAsAlign());
4982 GlobalName =
".str";
4985 GlobalName, Alignment);
5003 MaterializedType = E->
getType();
5007 if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E])
5014 llvm::raw_svector_ostream Out(Name);
5016 VD, E->getManglingNumber(), Out);
5019 if (E->getStorageDuration() ==
SD_Static && VD && VD->evaluateValue()) {
5032 Value = &EvalResult.
Val;
5038 llvm::Constant *InitialValue =
nullptr;
5039 bool Constant =
false;
5043 emitter.emplace(*
this);
5044 InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
5047 Type = InitialValue->getType();
5055 llvm::GlobalValue::LinkageTypes
Linkage =
5059 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
5063 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
5071 auto *GV =
new llvm::GlobalVariable(
5072 getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
5073 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
5074 if (emitter) emitter->finalize(GV);
5078 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5079 if (VD->getTLSKind())
5081 llvm::Constant *CV = GV;
5087 MaterializedGlobalTemporaryMap[E] = CV;
5093 void CodeGenModule::EmitObjCPropertyImplementations(
const 5107 const_cast<ObjCImplementationDecl *>(D), PID);
5111 const_cast<ObjCImplementationDecl *>(D), PID);
5120 if (ivar->getType().isDestructedType())
5192 EmitDeclContext(LSD);
5195 void CodeGenModule::EmitDeclContext(
const DeclContext *DC) {
5196 for (
auto *I : DC->
decls()) {
5202 if (
auto *OID = dyn_cast<ObjCImplDecl>(I)) {
5203 for (
auto *M : OID->methods())
5218 case Decl::CXXConversion:
5219 case Decl::CXXMethod:
5227 case Decl::CXXDeductionGuide:
5232 case Decl::Decomposition:
5233 case Decl::VarTemplateSpecialization:
5235 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
5236 for (
auto *B : DD->bindings())
5237 if (
auto *HD = B->getHoldingVar())
5243 case Decl::IndirectField:
5247 case Decl::Namespace:
5248 EmitDeclContext(cast<NamespaceDecl>(D));
5250 case Decl::ClassTemplateSpecialization: {
5251 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
5254 Spec->hasDefinition())
5255 DebugInfo->completeTemplateDefinition(*Spec);
5257 case Decl::CXXRecord:
5261 DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D));
5264 for (
auto *I : cast<CXXRecordDecl>(D)->decls())
5265 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
5269 case Decl::UsingShadow:
5270 case Decl::ClassTemplate:
5271 case Decl::VarTemplate:
5273 case Decl::VarTemplatePartialSpecialization:
5274 case Decl::FunctionTemplate:
5275 case Decl::TypeAliasTemplate:
5282 DI->EmitUsingDecl(cast<UsingDecl>(*D));
5284 case Decl::NamespaceAlias:
5286 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
5288 case Decl::UsingDirective:
5290 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
5292 case Decl::CXXConstructor:
5295 case Decl::CXXDestructor:
5299 case Decl::StaticAssert:
5306 case Decl::ObjCInterface:
5307 case Decl::ObjCCategory:
5310 case Decl::ObjCProtocol: {
5311 auto *Proto = cast<ObjCProtocolDecl>(D);
5312 if (Proto->isThisDeclarationADefinition())
5317 case Decl::ObjCCategoryImpl:
5320 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
5323 case Decl::ObjCImplementation: {
5324 auto *OMD = cast<ObjCImplementationDecl>(D);
5325 EmitObjCPropertyImplementations(OMD);
5326 EmitObjCIvarInitializations(OMD);
5331 DI->getOrCreateInterfaceType(
getContext().getObjCInterfaceType(
5332 OMD->getClassInterface()), OMD->getLocation());
5335 case Decl::ObjCMethod: {
5336 auto *OMD = cast<ObjCMethodDecl>(D);
5342 case Decl::ObjCCompatibleAlias:
5343 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
5346 case Decl::PragmaComment: {
5347 const auto *PCD = cast<PragmaCommentDecl>(D);
5348 switch (PCD->getCommentKind()) {
5350 llvm_unreachable(
"unexpected pragma comment kind");
5365 case Decl::PragmaDetectMismatch: {
5366 const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
5371 case Decl::LinkageSpec:
5372 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
5375 case Decl::FileScopeAsm: {
5377 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
5380 if (LangOpts.OpenMPIsDevice)
5382 auto *AD = cast<FileScopeAsmDecl>(D);
5383 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
5387 case Decl::Import: {
5388 auto *Import = cast<ImportDecl>(D);
5391 if (!ImportedModules.insert(Import->getImportedModule()))
5395 if (!Import->getImportedOwningModule()) {
5397 DI->EmitImportDecl(*Import);
5401 llvm::SmallPtrSet<clang::Module *, 16> Visited;
5403 Visited.insert(Import->getImportedModule());
5404 Stack.push_back(Import->getImportedModule());
5406 while (!Stack.empty()) {
5408 if (!EmittedModuleInitializers.insert(Mod).second)
5420 if ((*Sub)->IsExplicit)
5423 if (Visited.insert(*Sub).second)
5424 Stack.push_back(*
Sub);
5431 EmitDeclContext(cast<ExportDecl>(D));
5434 case Decl::OMPThreadPrivate:
5438 case Decl::OMPAllocate:
5441 case Decl::OMPDeclareReduction:
5445 case Decl::OMPDeclareMapper:
5449 case Decl::OMPRequires:
5457 assert(isa<TypeDecl>(D) &&
"Unsupported decl kind");
5464 if (!CodeGenOpts.CoverageMapping)
5467 case Decl::CXXConversion:
5468 case Decl::CXXMethod:
5470 case Decl::ObjCMethod:
5471 case Decl::CXXConstructor:
5472 case Decl::CXXDestructor: {
5473 if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
5478 auto I = DeferredEmptyCoverageMappingDecls.find(D);
5479 if (I == DeferredEmptyCoverageMappingDecls.end())
5480 DeferredEmptyCoverageMappingDecls[D] =
true;
5490 if (!CodeGenOpts.CoverageMapping)
5492 if (
const auto *Fn = dyn_cast<FunctionDecl>(D)) {
5493 if (Fn->isTemplateInstantiation())
5496 auto I = DeferredEmptyCoverageMappingDecls.find(D);
5497 if (I == DeferredEmptyCoverageMappingDecls.end())
5498 DeferredEmptyCoverageMappingDecls[D] =
false;
5508 for (
const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
5511 const Decl *D = Entry.first;
5513 case Decl::CXXConversion:
5514 case Decl::CXXMethod:
5516 case Decl::ObjCMethod: {
5523 case Decl::CXXConstructor: {
5530 case Decl::CXXDestructor: {
5547 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
5548 return llvm::ConstantInt::get(i64, PtrInt);
5552 llvm::NamedMDNode *&GlobalMetadata,
5554 llvm::GlobalValue *Addr) {
5555 if (!GlobalMetadata)
5557 CGM.
getModule().getOrInsertNamedMetadata(
"clang.global.decl.ptrs");
5560 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
5563 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
5571 void CodeGenModule::EmitStaticExternCAliases() {
5574 for (
auto &I : StaticExternCValues) {
5576 llvm::GlobalValue *Val = I.second;
5584 auto Res = Manglings.find(MangledName);
5585 if (Res == Manglings.end())
5587 Result = Res->getValue();
5598 void CodeGenModule::EmitDeclMetadata() {
5599 llvm::NamedMDNode *GlobalMetadata =
nullptr;
5601 for (
auto &I : MangledDeclNames) {
5602 llvm::GlobalValue *Addr =
getModule().getNamedValue(I.second);
5612 void CodeGenFunction::EmitDeclMetadata() {
5613 if (LocalDeclMap.empty())
return;
5618 unsigned DeclPtrKind = Context.getMDKindID(
"clang.decl.ptr");
5620 llvm::NamedMDNode *GlobalMetadata =
nullptr;
5622 for (
auto &I : LocalDeclMap) {
5623 const Decl *D = I.first;
5625 if (
auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
5627 Alloca->setMetadata(
5628 DeclPtrKind, llvm::MDNode::get(
5629 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
5630 }
else if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
5637 void CodeGenModule::EmitVersionIdentMetadata() {
5638 llvm::NamedMDNode *IdentMetadata =
5639 TheModule.getOrInsertNamedMetadata(
"llvm.ident");
5641 llvm::LLVMContext &Ctx = TheModule.getContext();
5643 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
5644 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
5647 void CodeGenModule::EmitCommandLineMetadata() {
5648 llvm::NamedMDNode *CommandLineMetadata =
5649 TheModule.getOrInsertNamedMetadata(
"llvm.commandline");
5651 llvm::LLVMContext &Ctx = TheModule.getContext();
5653 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
5654 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
5657 void CodeGenModule::EmitTargetMetadata() {
5664 for (
unsigned I = 0; I != MangledDeclNames.size(); ++I) {
5665 auto Val = *(MangledDeclNames.begin() + I);
5672 void CodeGenModule::EmitCoverageFile() {
5677 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata(
"llvm.dbg.cu");
5681 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata(
"llvm.gcov");
5682 llvm::LLVMContext &Ctx = TheModule.getContext();
5683 auto *CoverageDataFile =
5685 auto *CoverageNotesFile =
5687 for (
int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
5688 llvm::MDNode *CU = CUNode->getOperand(i);
5689 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
5690 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
5694 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
5697 assert(Uuid.size() == 36);
5698 for (
unsigned i = 0; i < 36; ++i) {
5699 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] ==
'-');
5704 const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
5706 llvm::Constant *Field3[8];
5707 for (
unsigned Idx = 0; Idx < 8; ++Idx)
5708 Field3[Idx] = llvm::ConstantInt::get(
5709 Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
5711 llvm::Constant *Fields[4] = {
5712 llvm::ConstantInt::get(
Int32Ty, Uuid.substr(0, 8), 16),
5713 llvm::ConstantInt::get(
Int16Ty, Uuid.substr(9, 4), 16),
5714 llvm::ConstantInt::get(
Int16Ty, Uuid.substr(14, 4), 16),
5715 llvm::ConstantArray::get(llvm::ArrayType::get(
Int8Ty, 8), Field3)
5718 return llvm::ConstantStruct::getAnon(Fields);
5727 return llvm::Constant::getNullValue(
Int8PtrTy);
5730 LangOpts.ObjCRuntime.isGNUFamily())
5738 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
5740 for (
auto RefExpr : D->
varlists()) {
5741 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
5743 VD->getAnyInitializer() &&
5744 !VD->getAnyInitializer()->isConstantInitializer(
getContext(),
5749 VD, Addr, RefExpr->getBeginLoc(), PerformInit))