1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This coordinates the per-module state used while generating code.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenModule.h"
15 #include "CGCUDARuntime.h"
18 #include "CGDebugInfo.h"
19 #include "CGObjCRuntime.h"
20 #include "CGOpenCLRuntime.h"
21 #include "CGOpenMPRuntime.h"
22 #include "CodeGenFunction.h"
23 #include "CodeGenPGO.h"
24 #include "CodeGenTBAA.h"
25 #include "CoverageMappingGen.h"
26 #include "TargetInfo.h"
27 #include "clang/AST/ASTContext.h"
28 #include "clang/AST/CharUnits.h"
29 #include "clang/AST/DeclCXX.h"
30 #include "clang/AST/DeclObjC.h"
31 #include "clang/AST/DeclTemplate.h"
32 #include "clang/AST/Mangle.h"
33 #include "clang/AST/RecordLayout.h"
34 #include "clang/AST/RecursiveASTVisitor.h"
35 #include "clang/Basic/Builtins.h"
36 #include "clang/Basic/CharInfo.h"
37 #include "clang/Basic/Diagnostic.h"
38 #include "clang/Basic/Module.h"
39 #include "clang/Basic/SourceManager.h"
40 #include "clang/Basic/TargetInfo.h"
41 #include "clang/Basic/Version.h"
42 #include "clang/Frontend/CodeGenOptions.h"
43 #include "clang/Sema/SemaDiagnostic.h"
44 #include "llvm/ADT/APSInt.h"
45 #include "llvm/ADT/Triple.h"
46 #include "llvm/IR/CallSite.h"
47 #include "llvm/IR/CallingConv.h"
48 #include "llvm/IR/DataLayout.h"
49 #include "llvm/IR/Intrinsics.h"
50 #include "llvm/IR/LLVMContext.h"
51 #include "llvm/IR/Module.h"
52 #include "llvm/ProfileData/InstrProfReader.h"
53 #include "llvm/Support/ConvertUTF.h"
54 #include "llvm/Support/ErrorHandling.h"
56 using namespace clang;
57 using namespace CodeGen;
59 static const char AnnotationSection[] = "llvm.metadata";
61 static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
62 switch (CGM.getTarget().getCXXABI().getKind()) {
63 case TargetCXXABI::GenericAArch64:
64 case TargetCXXABI::GenericARM:
65 case TargetCXXABI::iOS:
66 case TargetCXXABI::iOS64:
67 case TargetCXXABI::GenericMIPS:
68 case TargetCXXABI::GenericItanium:
69 return CreateItaniumCXXABI(CGM);
70 case TargetCXXABI::Microsoft:
71 return CreateMicrosoftCXXABI(CGM);
74 llvm_unreachable("invalid C++ ABI kind");
77 CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
78 const PreprocessorOptions &PPO,
79 const CodeGenOptions &CGO, llvm::Module &M,
80 const llvm::DataLayout &TD,
81 DiagnosticsEngine &diags,
82 CoverageSourceInfo *CoverageInfo)
83 : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO),
84 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
85 TheDataLayout(TD), Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
86 VMContext(M.getContext()), TBAA(nullptr), TheTargetCodeGenInfo(nullptr),
87 Types(*this), VTables(*this), ObjCRuntime(nullptr),
88 OpenCLRuntime(nullptr), OpenMPRuntime(nullptr), CUDARuntime(nullptr),
89 DebugInfo(nullptr), ARCData(nullptr),
90 NoObjCARCExceptionsMetadata(nullptr), RRData(nullptr), PGOReader(nullptr),
91 CFConstantStringClassRef(nullptr), ConstantStringClassRef(nullptr),
92 NSConstantStringType(nullptr), NSConcreteGlobalBlock(nullptr),
93 NSConcreteStackBlock(nullptr), BlockObjectAssign(nullptr),
94 BlockObjectDispose(nullptr), BlockDescriptorType(nullptr),
95 GenericBlockLiteralType(nullptr), LifetimeStartFn(nullptr),
96 LifetimeEndFn(nullptr), SanitizerMD(new SanitizerMetadata(*this)) {
98 // Initialize the type cache.
99 llvm::LLVMContext &LLVMContext = M.getContext();
100 VoidTy = llvm::Type::getVoidTy(LLVMContext);
101 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
102 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
103 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
104 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
105 FloatTy = llvm::Type::getFloatTy(LLVMContext);
106 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
107 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
108 PointerAlignInBytes =
109 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
110 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
111 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
112 Int8PtrTy = Int8Ty->getPointerTo(0);
113 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
115 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
116 BuiltinCC = getTargetCodeGenInfo().getABIInfo().getBuiltinCC();
121 createOpenCLRuntime();
123 createOpenMPRuntime();
127 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
128 if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
129 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
130 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
131 getCXXABI().getMangleContext());
133 // If debug info or coverage generation is enabled, create the CGDebugInfo
135 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
136 CodeGenOpts.EmitGcovArcs ||
137 CodeGenOpts.EmitGcovNotes)
138 DebugInfo = new CGDebugInfo(*this);
140 Block.GlobalUniqueCount = 0;
142 if (C.getLangOpts().ObjCAutoRefCount)
143 ARCData = new ARCEntrypoints();
144 RRData = new RREntrypoints();
146 if (!CodeGenOpts.InstrProfileInput.empty()) {
148 llvm::IndexedInstrProfReader::create(CodeGenOpts.InstrProfileInput);
149 if (std::error_code EC = ReaderOrErr.getError()) {
150 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
151 "Could not read profile %0: %1");
152 getDiags().Report(DiagID) << CodeGenOpts.InstrProfileInput
155 PGOReader = std::move(ReaderOrErr.get());
158 // If coverage mapping generation is enabled, create the
159 // CoverageMappingModuleGen object.
160 if (CodeGenOpts.CoverageMapping)
161 CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
164 CodeGenModule::~CodeGenModule() {
166 delete OpenCLRuntime;
167 delete OpenMPRuntime;
169 delete TheTargetCodeGenInfo;
176 void CodeGenModule::createObjCRuntime() {
177 // This is just isGNUFamily(), but we want to force implementors of
178 // new ABIs to decide how best to do this.
179 switch (LangOpts.ObjCRuntime.getKind()) {
180 case ObjCRuntime::GNUstep:
181 case ObjCRuntime::GCC:
182 case ObjCRuntime::ObjFW:
183 ObjCRuntime = CreateGNUObjCRuntime(*this);
186 case ObjCRuntime::FragileMacOSX:
187 case ObjCRuntime::MacOSX:
188 case ObjCRuntime::iOS:
189 ObjCRuntime = CreateMacObjCRuntime(*this);
192 llvm_unreachable("bad runtime kind");
195 void CodeGenModule::createOpenCLRuntime() {
196 OpenCLRuntime = new CGOpenCLRuntime(*this);
199 void CodeGenModule::createOpenMPRuntime() {
200 OpenMPRuntime = new CGOpenMPRuntime(*this);
203 void CodeGenModule::createCUDARuntime() {
204 CUDARuntime = CreateNVCUDARuntime(*this);
207 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
208 Replacements[Name] = C;
211 void CodeGenModule::applyReplacements() {
212 for (auto &I : Replacements) {
213 StringRef MangledName = I.first();
214 llvm::Constant *Replacement = I.second;
215 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
218 auto *OldF = cast<llvm::Function>(Entry);
219 auto *NewF = dyn_cast<llvm::Function>(Replacement);
221 if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
222 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
224 auto *CE = cast<llvm::ConstantExpr>(Replacement);
225 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
226 CE->getOpcode() == llvm::Instruction::GetElementPtr);
227 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
231 // Replace old with new, but keep the old order.
232 OldF->replaceAllUsesWith(Replacement);
234 NewF->removeFromParent();
235 OldF->getParent()->getFunctionList().insertAfter(OldF, NewF);
237 OldF->eraseFromParent();
241 // This is only used in aliases that we created and we know they have a
243 static const llvm::GlobalObject *getAliasedGlobal(const llvm::GlobalAlias &GA) {
244 llvm::SmallPtrSet<const llvm::GlobalAlias*, 4> Visited;
245 const llvm::Constant *C = &GA;
247 C = C->stripPointerCasts();
248 if (auto *GO = dyn_cast<llvm::GlobalObject>(C))
250 // stripPointerCasts will not walk over weak aliases.
251 auto *GA2 = dyn_cast<llvm::GlobalAlias>(C);
254 if (!Visited.insert(GA2).second)
256 C = GA2->getAliasee();
260 void CodeGenModule::checkAliases() {
261 // Check if the constructed aliases are well formed. It is really unfortunate
262 // that we have to do this in CodeGen, but we only construct mangled names
263 // and aliases during codegen.
265 DiagnosticsEngine &Diags = getDiags();
266 for (const GlobalDecl &GD : Aliases) {
267 const auto *D = cast<ValueDecl>(GD.getDecl());
268 const AliasAttr *AA = D->getAttr<AliasAttr>();
269 StringRef MangledName = getMangledName(GD);
270 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
271 auto *Alias = cast<llvm::GlobalAlias>(Entry);
272 const llvm::GlobalValue *GV = getAliasedGlobal(*Alias);
275 Diags.Report(AA->getLocation(), diag::err_cyclic_alias);
276 } else if (GV->isDeclaration()) {
278 Diags.Report(AA->getLocation(), diag::err_alias_to_undefined);
281 llvm::Constant *Aliasee = Alias->getAliasee();
282 llvm::GlobalValue *AliaseeGV;
283 if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
284 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
286 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
288 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
289 StringRef AliasSection = SA->getName();
290 if (AliasSection != AliaseeGV->getSection())
291 Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
295 // We have to handle alias to weak aliases in here. LLVM itself disallows
296 // this since the object semantics would not match the IL one. For
297 // compatibility with gcc we implement it by just pointing the alias
298 // to its aliasee's aliasee. We also warn, since the user is probably
299 // expecting the link to be weak.
300 if (auto GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
301 if (GA->mayBeOverridden()) {
302 Diags.Report(AA->getLocation(), diag::warn_alias_to_weak_alias)
303 << GV->getName() << GA->getName();
304 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
305 GA->getAliasee(), Alias->getType());
306 Alias->setAliasee(Aliasee);
313 for (const GlobalDecl &GD : Aliases) {
314 StringRef MangledName = getMangledName(GD);
315 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
316 auto *Alias = cast<llvm::GlobalAlias>(Entry);
317 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
318 Alias->eraseFromParent();
322 void CodeGenModule::clear() {
323 DeferredDeclsToEmit.clear();
325 OpenMPRuntime->clear();
328 void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags,
329 StringRef MainFile) {
330 if (!hasDiagnostics())
332 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
333 if (MainFile.empty())
334 MainFile = "<stdin>";
335 Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
337 Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Missing
341 void CodeGenModule::Release() {
345 EmitCXXGlobalInitFunc();
346 EmitCXXGlobalDtorFunc();
347 EmitCXXThreadLocalInitFunc();
349 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
350 AddGlobalCtor(ObjCInitFunction);
351 if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
353 if (llvm::Function *CudaCtorFunction = CUDARuntime->makeModuleCtorFunction())
354 AddGlobalCtor(CudaCtorFunction);
355 if (llvm::Function *CudaDtorFunction = CUDARuntime->makeModuleDtorFunction())
356 AddGlobalDtor(CudaDtorFunction);
358 if (PGOReader && PGOStats.hasDiagnostics())
359 PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
360 EmitCtorList(GlobalCtors, "llvm.global_ctors");
361 EmitCtorList(GlobalDtors, "llvm.global_dtors");
362 EmitGlobalAnnotations();
363 EmitStaticExternCAliases();
364 EmitDeferredUnusedCoverageMappings();
366 CoverageMapping->emit();
369 if (CodeGenOpts.Autolink &&
370 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
371 EmitModuleLinkOptions();
373 if (CodeGenOpts.DwarfVersion)
374 // We actually want the latest version when there are conflicts.
375 // We can change from Warning to Latest if such mode is supported.
376 getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
377 CodeGenOpts.DwarfVersion);
379 // We support a single version in the linked module. The LLVM
380 // parser will drop debug info with a different version number
381 // (and warn about it, too).
382 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
383 llvm::DEBUG_METADATA_VERSION);
385 // We need to record the widths of enums and wchar_t, so that we can generate
386 // the correct build attributes in the ARM backend.
387 llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
388 if ( Arch == llvm::Triple::arm
389 || Arch == llvm::Triple::armeb
390 || Arch == llvm::Triple::thumb
391 || Arch == llvm::Triple::thumbeb) {
392 // Width of wchar_t in bytes
393 uint64_t WCharWidth =
394 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
395 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
397 // The minimum width of an enum in bytes
398 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
399 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
402 if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
403 llvm::PICLevel::Level PL = llvm::PICLevel::Default;
406 case 1: PL = llvm::PICLevel::Small; break;
407 case 2: PL = llvm::PICLevel::Large; break;
408 default: llvm_unreachable("Invalid PIC Level");
411 getModule().setPICLevel(PL);
414 SimplifyPersonality();
416 if (getCodeGenOpts().EmitDeclMetadata)
419 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
423 DebugInfo->finalize();
425 EmitVersionIdentMetadata();
427 EmitTargetMetadata();
430 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
431 // Make sure that this type is translated.
432 Types.UpdateCompletedType(TD);
435 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
438 return TBAA->getTBAAInfo(QTy);
441 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
444 return TBAA->getTBAAInfoForVTablePtr();
447 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
450 return TBAA->getTBAAStructInfo(QTy);
453 llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) {
456 return TBAA->getTBAAStructTypeInfo(QTy);
459 llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy,
460 llvm::MDNode *AccessN,
464 return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O);
467 /// Decorate the instruction with a TBAA tag. For both scalar TBAA
468 /// and struct-path aware TBAA, the tag has the same format:
469 /// base type, access type and offset.
470 /// When ConvertTypeToTag is true, we create a tag based on the scalar type.
471 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
472 llvm::MDNode *TBAAInfo,
473 bool ConvertTypeToTag) {
474 if (ConvertTypeToTag && TBAA)
475 Inst->setMetadata(llvm::LLVMContext::MD_tbaa,
476 TBAA->getTBAAScalarTagInfo(TBAAInfo));
478 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
481 void CodeGenModule::Error(SourceLocation loc, StringRef message) {
482 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
483 getDiags().Report(Context.getFullLoc(loc), diagID) << message;
486 /// ErrorUnsupported - Print out an error that codegen doesn't support the
487 /// specified stmt yet.
488 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
489 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
490 "cannot compile this %0 yet");
491 std::string Msg = Type;
492 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
493 << Msg << S->getSourceRange();
496 /// ErrorUnsupported - Print out an error that codegen doesn't support the
497 /// specified decl yet.
498 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
499 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
500 "cannot compile this %0 yet");
501 std::string Msg = Type;
502 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
505 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
506 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
509 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
510 const NamedDecl *D) const {
511 // Internal definitions always have default visibility.
512 if (GV->hasLocalLinkage()) {
513 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
517 // Set visibility for definitions.
518 LinkageInfo LV = D->getLinkageAndVisibility();
519 if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
520 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
523 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
524 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
525 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
526 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
527 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
528 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
531 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
532 CodeGenOptions::TLSModel M) {
534 case CodeGenOptions::GeneralDynamicTLSModel:
535 return llvm::GlobalVariable::GeneralDynamicTLSModel;
536 case CodeGenOptions::LocalDynamicTLSModel:
537 return llvm::GlobalVariable::LocalDynamicTLSModel;
538 case CodeGenOptions::InitialExecTLSModel:
539 return llvm::GlobalVariable::InitialExecTLSModel;
540 case CodeGenOptions::LocalExecTLSModel:
541 return llvm::GlobalVariable::LocalExecTLSModel;
543 llvm_unreachable("Invalid TLS model!");
546 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
547 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
549 llvm::GlobalValue::ThreadLocalMode TLM;
550 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
552 // Override the TLS model if it is explicitly specified.
553 if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
554 TLM = GetLLVMTLSModel(Attr->getModel());
557 GV->setThreadLocalMode(TLM);
560 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
561 StringRef &FoundStr = MangledDeclNames[GD.getCanonicalDecl()];
562 if (!FoundStr.empty())
565 const auto *ND = cast<NamedDecl>(GD.getDecl());
566 SmallString<256> Buffer;
568 if (getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
569 llvm::raw_svector_ostream Out(Buffer);
570 if (const auto *D = dyn_cast<CXXConstructorDecl>(ND))
571 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
572 else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND))
573 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
575 getCXXABI().getMangleContext().mangleName(ND, Out);
578 IdentifierInfo *II = ND->getIdentifier();
579 assert(II && "Attempt to mangle unnamed decl.");
583 // Keep the first result in the case of a mangling collision.
584 auto Result = Manglings.insert(std::make_pair(Str, GD));
585 return FoundStr = Result.first->first();
588 StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD,
589 const BlockDecl *BD) {
590 MangleContext &MangleCtx = getCXXABI().getMangleContext();
591 const Decl *D = GD.getDecl();
593 SmallString<256> Buffer;
594 llvm::raw_svector_ostream Out(Buffer);
596 MangleCtx.mangleGlobalBlock(BD,
597 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
598 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
599 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
600 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
601 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
603 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
605 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
606 return Result.first->first();
609 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
610 return getModule().getNamedValue(Name);
613 /// AddGlobalCtor - Add a function to the list that will be called before
615 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
616 llvm::Constant *AssociatedData) {
617 // FIXME: Type coercion of void()* types.
618 GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
621 /// AddGlobalDtor - Add a function to the list that will be called
622 /// when the module is unloaded.
623 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
624 // FIXME: Type coercion of void()* types.
625 GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
628 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
629 // Ctor function type is void()*.
630 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
631 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
633 // Get the type of a ctor entry, { i32, void ()*, i8* }.
634 llvm::StructType *CtorStructTy = llvm::StructType::get(
635 Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy, nullptr);
637 // Construct the constructor and destructor arrays.
638 SmallVector<llvm::Constant *, 8> Ctors;
639 for (const auto &I : Fns) {
640 llvm::Constant *S[] = {
641 llvm::ConstantInt::get(Int32Ty, I.Priority, false),
642 llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy),
644 ? llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy)
645 : llvm::Constant::getNullValue(VoidPtrTy))};
646 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
649 if (!Ctors.empty()) {
650 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
651 new llvm::GlobalVariable(TheModule, AT, false,
652 llvm::GlobalValue::AppendingLinkage,
653 llvm::ConstantArray::get(AT, Ctors),
658 llvm::GlobalValue::LinkageTypes
659 CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
660 const auto *D = cast<FunctionDecl>(GD.getDecl());
662 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
664 if (isa<CXXDestructorDecl>(D) &&
665 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
667 // Destructor variants in the Microsoft C++ ABI are always internal or
668 // linkonce_odr thunks emitted on an as-needed basis.
669 return Linkage == GVA_Internal ? llvm::GlobalValue::InternalLinkage
670 : llvm::GlobalValue::LinkOnceODRLinkage;
673 return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false);
676 void CodeGenModule::setFunctionDLLStorageClass(GlobalDecl GD, llvm::Function *F) {
677 const auto *FD = cast<FunctionDecl>(GD.getDecl());
679 if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) {
680 if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) {
681 // Don't dllexport/import destructor thunks.
682 F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
687 if (FD->hasAttr<DLLImportAttr>())
688 F->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
689 else if (FD->hasAttr<DLLExportAttr>())
690 F->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
692 F->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
695 void CodeGenModule::setFunctionDefinitionAttributes(const FunctionDecl *D,
697 setNonAliasAttributes(D, F);
700 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
701 const CGFunctionInfo &Info,
703 unsigned CallingConv;
704 AttributeListType AttributeList;
705 ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
706 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
707 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
710 /// Determines whether the language options require us to model
711 /// unwind exceptions. We treat -fexceptions as mandating this
712 /// except under the fragile ObjC ABI with only ObjC exceptions
713 /// enabled. This means, for example, that C with -fexceptions
715 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
716 // If exceptions are completely disabled, obviously this is false.
717 if (!LangOpts.Exceptions) return false;
719 // If C++ exceptions are enabled, this is true.
720 if (LangOpts.CXXExceptions) return true;
722 // If ObjC exceptions are enabled, this depends on the ABI.
723 if (LangOpts.ObjCExceptions) {
724 return LangOpts.ObjCRuntime.hasUnwindExceptions();
730 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
734 if (CodeGenOpts.UnwindTables)
735 B.addAttribute(llvm::Attribute::UWTable);
737 if (!hasUnwindExceptions(LangOpts))
738 B.addAttribute(llvm::Attribute::NoUnwind);
740 if (D->hasAttr<NakedAttr>()) {
741 // Naked implies noinline: we should not be inlining such functions.
742 B.addAttribute(llvm::Attribute::Naked);
743 B.addAttribute(llvm::Attribute::NoInline);
744 } else if (D->hasAttr<NoDuplicateAttr>()) {
745 B.addAttribute(llvm::Attribute::NoDuplicate);
746 } else if (D->hasAttr<NoInlineAttr>()) {
747 B.addAttribute(llvm::Attribute::NoInline);
748 } else if (D->hasAttr<AlwaysInlineAttr>() &&
749 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
750 llvm::Attribute::NoInline)) {
751 // (noinline wins over always_inline, and we can't specify both in IR)
752 B.addAttribute(llvm::Attribute::AlwaysInline);
755 if (D->hasAttr<ColdAttr>()) {
756 if (!D->hasAttr<OptimizeNoneAttr>())
757 B.addAttribute(llvm::Attribute::OptimizeForSize);
758 B.addAttribute(llvm::Attribute::Cold);
761 if (D->hasAttr<MinSizeAttr>())
762 B.addAttribute(llvm::Attribute::MinSize);
764 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
765 B.addAttribute(llvm::Attribute::StackProtect);
766 else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
767 B.addAttribute(llvm::Attribute::StackProtectStrong);
768 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
769 B.addAttribute(llvm::Attribute::StackProtectReq);
771 F->addAttributes(llvm::AttributeSet::FunctionIndex,
772 llvm::AttributeSet::get(
773 F->getContext(), llvm::AttributeSet::FunctionIndex, B));
775 if (D->hasAttr<OptimizeNoneAttr>()) {
776 // OptimizeNone implies noinline; we should not be inlining such functions.
777 F->addFnAttr(llvm::Attribute::OptimizeNone);
778 F->addFnAttr(llvm::Attribute::NoInline);
780 // OptimizeNone wins over OptimizeForSize, MinSize, AlwaysInline.
781 assert(!F->hasFnAttribute(llvm::Attribute::OptimizeForSize) &&
782 "OptimizeNone and OptimizeForSize on same function!");
783 assert(!F->hasFnAttribute(llvm::Attribute::MinSize) &&
784 "OptimizeNone and MinSize on same function!");
785 assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
786 "OptimizeNone and AlwaysInline on same function!");
788 // Attribute 'inlinehint' has no effect on 'optnone' functions.
789 // Explicitly remove it from the set of function attributes.
790 F->removeFnAttr(llvm::Attribute::InlineHint);
793 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
794 F->setUnnamedAddr(true);
795 else if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
797 F->setUnnamedAddr(true);
799 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
801 F->setAlignment(alignment);
803 // C++ ABI requires 2-byte alignment for member functions.
804 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
808 void CodeGenModule::SetCommonAttributes(const Decl *D,
809 llvm::GlobalValue *GV) {
810 if (const auto *ND = dyn_cast<NamedDecl>(D))
811 setGlobalVisibility(GV, ND);
813 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
815 if (D->hasAttr<UsedAttr>())
819 void CodeGenModule::setAliasAttributes(const Decl *D,
820 llvm::GlobalValue *GV) {
821 SetCommonAttributes(D, GV);
823 // Process the dllexport attribute based on whether the original definition
824 // (not necessarily the aliasee) was exported.
825 if (D->hasAttr<DLLExportAttr>())
826 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
829 void CodeGenModule::setNonAliasAttributes(const Decl *D,
830 llvm::GlobalObject *GO) {
831 SetCommonAttributes(D, GO);
833 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
834 GO->setSection(SA->getName());
836 getTargetCodeGenInfo().setTargetAttributes(D, GO, *this);
839 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
841 const CGFunctionInfo &FI) {
842 SetLLVMFunctionAttributes(D, FI, F);
843 SetLLVMFunctionAttributesForDefinition(D, F);
845 F->setLinkage(llvm::Function::InternalLinkage);
847 setNonAliasAttributes(D, F);
850 static void setLinkageAndVisibilityForGV(llvm::GlobalValue *GV,
851 const NamedDecl *ND) {
852 // Set linkage and visibility in case we never see a definition.
853 LinkageInfo LV = ND->getLinkageAndVisibility();
854 if (LV.getLinkage() != ExternalLinkage) {
855 // Don't set internal linkage on declarations.
857 if (ND->hasAttr<DLLImportAttr>()) {
858 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
859 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
860 } else if (ND->hasAttr<DLLExportAttr>()) {
861 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
862 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
863 } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) {
864 // "extern_weak" is overloaded in LLVM; we probably should have
865 // separate linkage types for this.
866 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
869 // Set visibility on a declaration only if it's explicit.
870 if (LV.isVisibilityExplicit())
871 GV->setVisibility(CodeGenModule::GetLLVMVisibility(LV.getVisibility()));
875 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
876 bool IsIncompleteFunction,
878 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
879 // If this is an intrinsic function, set the function's attributes
880 // to the intrinsic's attributes.
881 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
885 const auto *FD = cast<FunctionDecl>(GD.getDecl());
887 if (!IsIncompleteFunction)
888 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
890 // Add the Returned attribute for "this", except for iOS 5 and earlier
891 // where substantial code, including the libstdc++ dylib, was compiled with
892 // GCC and does not actually return "this".
893 if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
894 !(getTarget().getTriple().isiOS() &&
895 getTarget().getTriple().isOSVersionLT(6))) {
896 assert(!F->arg_empty() &&
897 F->arg_begin()->getType()
898 ->canLosslesslyBitCastTo(F->getReturnType()) &&
899 "unexpected this return");
900 F->addAttribute(1, llvm::Attribute::Returned);
903 // Only a few attributes are set on declarations; these may later be
904 // overridden by a definition.
906 setLinkageAndVisibilityForGV(F, FD);
908 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
909 F->setSection(SA->getName());
911 // A replaceable global allocation function does not act like a builtin by
912 // default, only if it is invoked by a new-expression or delete-expression.
913 if (FD->isReplaceableGlobalAllocationFunction())
914 F->addAttribute(llvm::AttributeSet::FunctionIndex,
915 llvm::Attribute::NoBuiltin);
918 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
919 assert(!GV->isDeclaration() &&
920 "Only globals with definition can force usage.");
921 LLVMUsed.emplace_back(GV);
924 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
925 assert(!GV->isDeclaration() &&
926 "Only globals with definition can force usage.");
927 LLVMCompilerUsed.emplace_back(GV);
930 static void emitUsed(CodeGenModule &CGM, StringRef Name,
931 std::vector<llvm::WeakVH> &List) {
932 // Don't create llvm.used if there is no need.
936 // Convert List to what ConstantArray needs.
937 SmallVector<llvm::Constant*, 8> UsedArray;
938 UsedArray.resize(List.size());
939 for (unsigned i = 0, e = List.size(); i != e; ++i) {
941 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
942 cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
945 if (UsedArray.empty())
947 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
949 auto *GV = new llvm::GlobalVariable(
950 CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
951 llvm::ConstantArray::get(ATy, UsedArray), Name);
953 GV->setSection("llvm.metadata");
956 void CodeGenModule::emitLLVMUsed() {
957 emitUsed(*this, "llvm.used", LLVMUsed);
958 emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
961 void CodeGenModule::AppendLinkerOptions(StringRef Opts) {
962 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
963 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
966 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
967 llvm::SmallString<32> Opt;
968 getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
969 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
970 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
973 void CodeGenModule::AddDependentLib(StringRef Lib) {
974 llvm::SmallString<24> Opt;
975 getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt);
976 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
977 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
980 /// \brief Add link options implied by the given module, including modules
981 /// it depends on, using a postorder walk.
982 static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod,
983 SmallVectorImpl<llvm::Metadata *> &Metadata,
984 llvm::SmallPtrSet<Module *, 16> &Visited) {
985 // Import this module's parent.
986 if (Mod->Parent && Visited.insert(Mod->Parent).second) {
987 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
990 // Import this module's dependencies.
991 for (unsigned I = Mod->Imports.size(); I > 0; --I) {
992 if (Visited.insert(Mod->Imports[I - 1]).second)
993 addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
996 // Add linker options to link against the libraries/frameworks
997 // described by this module.
998 llvm::LLVMContext &Context = CGM.getLLVMContext();
999 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
1000 // Link against a framework. Frameworks are currently Darwin only, so we
1001 // don't to ask TargetCodeGenInfo for the spelling of the linker option.
1002 if (Mod->LinkLibraries[I-1].IsFramework) {
1003 llvm::Metadata *Args[2] = {
1004 llvm::MDString::get(Context, "-framework"),
1005 llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)};
1007 Metadata.push_back(llvm::MDNode::get(Context, Args));
1011 // Link against a library.
1012 llvm::SmallString<24> Opt;
1013 CGM.getTargetCodeGenInfo().getDependentLibraryOption(
1014 Mod->LinkLibraries[I-1].Library, Opt);
1015 auto *OptString = llvm::MDString::get(Context, Opt);
1016 Metadata.push_back(llvm::MDNode::get(Context, OptString));
1020 void CodeGenModule::EmitModuleLinkOptions() {
1021 // Collect the set of all of the modules we want to visit to emit link
1022 // options, which is essentially the imported modules and all of their
1023 // non-explicit child modules.
1024 llvm::SetVector<clang::Module *> LinkModules;
1025 llvm::SmallPtrSet<clang::Module *, 16> Visited;
1026 SmallVector<clang::Module *, 16> Stack;
1028 // Seed the stack with imported modules.
1029 for (Module *M : ImportedModules)
1030 if (Visited.insert(M).second)
1033 // Find all of the modules to import, making a little effort to prune
1034 // non-leaf modules.
1035 while (!Stack.empty()) {
1036 clang::Module *Mod = Stack.pop_back_val();
1038 bool AnyChildren = false;
1040 // Visit the submodules of this module.
1041 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
1042 SubEnd = Mod->submodule_end();
1043 Sub != SubEnd; ++Sub) {
1044 // Skip explicit children; they need to be explicitly imported to be
1046 if ((*Sub)->IsExplicit)
1049 if (Visited.insert(*Sub).second) {
1050 Stack.push_back(*Sub);
1055 // We didn't find any children, so add this module to the list of
1056 // modules to link against.
1058 LinkModules.insert(Mod);
1062 // Add link options for all of the imported modules in reverse topological
1063 // order. We don't do anything to try to order import link flags with respect
1064 // to linker options inserted by things like #pragma comment().
1065 SmallVector<llvm::Metadata *, 16> MetadataArgs;
1067 for (Module *M : LinkModules)
1068 if (Visited.insert(M).second)
1069 addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
1070 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
1071 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
1073 // Add the linker options metadata flag.
1074 getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
1075 llvm::MDNode::get(getLLVMContext(),
1076 LinkerOptionsMetadata));
1079 void CodeGenModule::EmitDeferred() {
1080 // Emit code for any potentially referenced deferred decls. Since a
1081 // previously unused static decl may become used during the generation of code
1082 // for a static function, iterate until no changes are made.
1084 if (!DeferredVTables.empty()) {
1085 EmitDeferredVTables();
1087 // Emitting a v-table doesn't directly cause more v-tables to
1088 // become deferred, although it can cause functions to be
1089 // emitted that then need those v-tables.
1090 assert(DeferredVTables.empty());
1093 // Stop if we're out of both deferred v-tables and deferred declarations.
1094 if (DeferredDeclsToEmit.empty())
1097 // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
1098 // work, it will not interfere with this.
1099 std::vector<DeferredGlobal> CurDeclsToEmit;
1100 CurDeclsToEmit.swap(DeferredDeclsToEmit);
1102 for (DeferredGlobal &G : CurDeclsToEmit) {
1103 GlobalDecl D = G.GD;
1104 llvm::GlobalValue *GV = G.GV;
1107 assert(!GV || GV == GetGlobalValue(getMangledName(D)));
1109 GV = GetGlobalValue(getMangledName(D));
1111 // Check to see if we've already emitted this. This is necessary
1112 // for a couple of reasons: first, decls can end up in the
1113 // deferred-decls queue multiple times, and second, decls can end
1114 // up with definitions in unusual ways (e.g. by an extern inline
1115 // function acquiring a strong function redefinition). Just
1116 // ignore these cases.
1117 if (GV && !GV->isDeclaration())
1120 // Otherwise, emit the definition and move on to the next one.
1121 EmitGlobalDefinition(D, GV);
1123 // If we found out that we need to emit more decls, do that recursively.
1124 // This has the advantage that the decls are emitted in a DFS and related
1125 // ones are close together, which is convenient for testing.
1126 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
1128 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
1133 void CodeGenModule::EmitGlobalAnnotations() {
1134 if (Annotations.empty())
1137 // Create a new global variable for the ConstantStruct in the Module.
1138 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
1139 Annotations[0]->getType(), Annotations.size()), Annotations);
1140 auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
1141 llvm::GlobalValue::AppendingLinkage,
1142 Array, "llvm.global.annotations");
1143 gv->setSection(AnnotationSection);
1146 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
1147 llvm::Constant *&AStr = AnnotationStrings[Str];
1151 // Not found yet, create a new global.
1152 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
1154 new llvm::GlobalVariable(getModule(), s->getType(), true,
1155 llvm::GlobalValue::PrivateLinkage, s, ".str");
1156 gv->setSection(AnnotationSection);
1157 gv->setUnnamedAddr(true);
1162 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
1163 SourceManager &SM = getContext().getSourceManager();
1164 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
1166 return EmitAnnotationString(PLoc.getFilename());
1167 return EmitAnnotationString(SM.getBufferName(Loc));
1170 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
1171 SourceManager &SM = getContext().getSourceManager();
1172 PresumedLoc PLoc = SM.getPresumedLoc(L);
1173 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1174 SM.getExpansionLineNumber(L);
1175 return llvm::ConstantInt::get(Int32Ty, LineNo);
1178 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
1179 const AnnotateAttr *AA,
1181 // Get the globals for file name, annotation, and the line number.
1182 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1183 *UnitGV = EmitAnnotationUnit(L),
1184 *LineNoCst = EmitAnnotationLineNo(L);
1186 // Create the ConstantStruct for the global annotation.
1187 llvm::Constant *Fields[4] = {
1188 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1189 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1190 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1193 return llvm::ConstantStruct::getAnon(Fields);
1196 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
1197 llvm::GlobalValue *GV) {
1198 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1199 // Get the struct elements for these annotations.
1200 for (const auto *I : D->specific_attrs<AnnotateAttr>())
1201 Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
1204 bool CodeGenModule::isInSanitizerBlacklist(llvm::Function *Fn,
1205 SourceLocation Loc) const {
1206 const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1207 // Blacklist by function name.
1208 if (SanitizerBL.isBlacklistedFunction(Fn->getName()))
1210 // Blacklist by location.
1211 if (!Loc.isInvalid())
1212 return SanitizerBL.isBlacklistedLocation(Loc);
1213 // If location is unknown, this may be a compiler-generated function. Assume
1214 // it's located in the main file.
1215 auto &SM = Context.getSourceManager();
1216 if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1217 return SanitizerBL.isBlacklistedFile(MainFile->getName());
1222 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
1223 SourceLocation Loc, QualType Ty,
1224 StringRef Category) const {
1225 // For now globals can be blacklisted only in ASan and KASan.
1226 if (!LangOpts.Sanitize.hasOneOf(
1227 SanitizerKind::Address | SanitizerKind::KernelAddress))
1229 const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1230 if (SanitizerBL.isBlacklistedGlobal(GV->getName(), Category))
1232 if (SanitizerBL.isBlacklistedLocation(Loc, Category))
1234 // Check global type.
1236 // Drill down the array types: if global variable of a fixed type is
1237 // blacklisted, we also don't instrument arrays of them.
1238 while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
1239 Ty = AT->getElementType();
1240 Ty = Ty.getCanonicalType().getUnqualifiedType();
1241 // We allow to blacklist only record types (classes, structs etc.)
1242 if (Ty->isRecordType()) {
1243 std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
1244 if (SanitizerBL.isBlacklistedType(TypeStr, Category))
1251 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
1252 // Never defer when EmitAllDecls is specified.
1253 if (LangOpts.EmitAllDecls)
1256 return getContext().DeclMustBeEmitted(Global);
1259 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
1260 if (const auto *FD = dyn_cast<FunctionDecl>(Global))
1261 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1262 // Implicit template instantiations may change linkage if they are later
1263 // explicitly instantiated, so they should not be emitted eagerly.
1265 // If OpenMP is enabled and threadprivates must be generated like TLS, delay
1266 // codegen for global variables, because they may be marked as threadprivate.
1267 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
1268 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global))
1274 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
1275 const CXXUuidofExpr* E) {
1276 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
1278 StringRef Uuid = E->getUuidAsStringRef(Context);
1279 std::string Name = "_GUID_" + Uuid.lower();
1280 std::replace(Name.begin(), Name.end(), '-', '_');
1282 // Look for an existing global.
1283 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
1286 llvm::Constant *Init = EmitUuidofInitializer(Uuid);
1287 assert(Init && "failed to initialize as constant");
1289 auto *GV = new llvm::GlobalVariable(
1290 getModule(), Init->getType(),
1291 /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
1292 if (supportsCOMDAT())
1293 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
1297 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
1298 const AliasAttr *AA = VD->getAttr<AliasAttr>();
1299 assert(AA && "No alias?");
1301 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
1303 // See if there is already something with the target's name in the module.
1304 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
1306 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1307 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1310 llvm::Constant *Aliasee;
1311 if (isa<llvm::FunctionType>(DeclTy))
1312 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1313 GlobalDecl(cast<FunctionDecl>(VD)),
1314 /*ForVTable=*/false);
1316 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1317 llvm::PointerType::getUnqual(DeclTy),
1320 auto *F = cast<llvm::GlobalValue>(Aliasee);
1321 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1322 WeakRefReferences.insert(F);
1327 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
1328 const auto *Global = cast<ValueDecl>(GD.getDecl());
1330 // Weak references don't produce any output by themselves.
1331 if (Global->hasAttr<WeakRefAttr>())
1334 // If this is an alias definition (which otherwise looks like a declaration)
1336 if (Global->hasAttr<AliasAttr>())
1337 return EmitAliasDefinition(GD);
1339 // If this is CUDA, be selective about which declarations we emit.
1340 if (LangOpts.CUDA) {
1341 if (LangOpts.CUDAIsDevice) {
1342 if (!Global->hasAttr<CUDADeviceAttr>() &&
1343 !Global->hasAttr<CUDAGlobalAttr>() &&
1344 !Global->hasAttr<CUDAConstantAttr>() &&
1345 !Global->hasAttr<CUDASharedAttr>())
1348 if (!Global->hasAttr<CUDAHostAttr>() && (
1349 Global->hasAttr<CUDADeviceAttr>() ||
1350 Global->hasAttr<CUDAConstantAttr>() ||
1351 Global->hasAttr<CUDASharedAttr>()))
1356 // Ignore declarations, they will be emitted on their first use.
1357 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
1358 // Forward declarations are emitted lazily on first use.
1359 if (!FD->doesThisDeclarationHaveABody()) {
1360 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1363 StringRef MangledName = getMangledName(GD);
1365 // Compute the function info and LLVM type.
1366 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
1367 llvm::Type *Ty = getTypes().GetFunctionType(FI);
1369 GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
1370 /*DontDefer=*/false);
1374 const auto *VD = cast<VarDecl>(Global);
1375 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1377 if (VD->isThisDeclarationADefinition() != VarDecl::Definition &&
1378 !Context.isMSStaticDataMemberInlineDefinition(VD))
1382 // Defer code generation to first use when possible, e.g. if this is an inline
1383 // function. If the global must always be emitted, do it eagerly if possible
1384 // to benefit from cache locality.
1385 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
1386 // Emit the definition if it can't be deferred.
1387 EmitGlobalDefinition(GD);
1391 // If we're deferring emission of a C++ variable with an
1392 // initializer, remember the order in which it appeared in the file.
1393 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
1394 cast<VarDecl>(Global)->hasInit()) {
1395 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1396 CXXGlobalInits.push_back(nullptr);
1399 StringRef MangledName = getMangledName(GD);
1400 if (llvm::GlobalValue *GV = GetGlobalValue(MangledName)) {
1401 // The value has already been used and should therefore be emitted.
1402 addDeferredDeclToEmit(GV, GD);
1403 } else if (MustBeEmitted(Global)) {
1404 // The value must be emitted, but cannot be emitted eagerly.
1405 assert(!MayBeEmittedEagerly(Global));
1406 addDeferredDeclToEmit(/*GV=*/nullptr, GD);
1408 // Otherwise, remember that we saw a deferred decl with this name. The
1409 // first use of the mangled name will cause it to move into
1410 // DeferredDeclsToEmit.
1411 DeferredDecls[MangledName] = GD;
1416 struct FunctionIsDirectlyRecursive :
1417 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1418 const StringRef Name;
1419 const Builtin::Context &BI;
1421 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1422 Name(N), BI(C), Result(false) {
1424 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1426 bool TraverseCallExpr(CallExpr *E) {
1427 const FunctionDecl *FD = E->getDirectCallee();
1430 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1431 if (Attr && Name == Attr->getLabel()) {
1435 unsigned BuiltinID = FD->getBuiltinID();
1436 if (!BuiltinID || !BI.isLibFunction(BuiltinID))
1438 StringRef BuiltinName = BI.GetName(BuiltinID);
1439 if (BuiltinName.startswith("__builtin_") &&
1440 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
1449 // isTriviallyRecursive - Check if this function calls another
1450 // decl that, because of the asm attribute or the other decl being a builtin,
1451 // ends up pointing to itself.
1453 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1455 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
1456 // asm labels are a special kind of mangling we have to support.
1457 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1460 Name = Attr->getLabel();
1462 Name = FD->getName();
1465 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1466 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
1467 return Walker.Result;
1471 CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
1472 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
1474 const auto *F = cast<FunctionDecl>(GD.getDecl());
1475 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
1477 // PR9614. Avoid cases where the source code is lying to us. An available
1478 // externally function should have an equivalent function somewhere else,
1479 // but a function that calls itself is clearly not equivalent to the real
1481 // This happens in glibc's btowc and in some configure checks.
1482 return !isTriviallyRecursive(F);
1485 /// If the type for the method's class was generated by
1486 /// CGDebugInfo::createContextChain(), the cache contains only a
1487 /// limited DIType without any declarations. Since EmitFunctionStart()
1488 /// needs to find the canonical declaration for each method, we need
1489 /// to construct the complete type prior to emitting the method.
1490 void CodeGenModule::CompleteDIClassType(const CXXMethodDecl* D) {
1491 if (!D->isInstance())
1494 if (CGDebugInfo *DI = getModuleDebugInfo())
1495 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) {
1496 const auto *ThisPtr = cast<PointerType>(D->getThisType(getContext()));
1497 DI->getOrCreateRecordType(ThisPtr->getPointeeType(), D->getLocation());
1501 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
1502 const auto *D = cast<ValueDecl>(GD.getDecl());
1504 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
1505 Context.getSourceManager(),
1506 "Generating code for declaration");
1508 if (isa<FunctionDecl>(D)) {
1509 // At -O0, don't generate IR for functions with available_externally
1511 if (!shouldEmitFunction(GD))
1514 if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
1515 CompleteDIClassType(Method);
1516 // Make sure to emit the definition(s) before we emit the thunks.
1517 // This is necessary for the generation of certain thunks.
1518 if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method))
1519 ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType()));
1520 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method))
1521 ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType()));
1523 EmitGlobalFunctionDefinition(GD, GV);
1525 if (Method->isVirtual())
1526 getVTables().EmitThunks(GD);
1531 return EmitGlobalFunctionDefinition(GD, GV);
1534 if (const auto *VD = dyn_cast<VarDecl>(D))
1535 return EmitGlobalVarDefinition(VD);
1537 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
1540 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1541 /// module, create and return an llvm Function with the specified type. If there
1542 /// is something in the module with the specified name, return it potentially
1543 /// bitcasted to the right type.
1545 /// If D is non-null, it specifies a decl that correspond to this. This is used
1546 /// to set the attributes on the function when it is first created.
1548 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
1550 GlobalDecl GD, bool ForVTable,
1551 bool DontDefer, bool IsThunk,
1552 llvm::AttributeSet ExtraAttrs) {
1553 const Decl *D = GD.getDecl();
1555 // Lookup the entry, lazily creating it if necessary.
1556 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1558 if (WeakRefReferences.erase(Entry)) {
1559 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
1560 if (FD && !FD->hasAttr<WeakAttr>())
1561 Entry->setLinkage(llvm::Function::ExternalLinkage);
1564 // Handle dropped DLL attributes.
1565 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
1566 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
1568 if (Entry->getType()->getElementType() == Ty)
1571 // Make sure the result is of the correct type.
1572 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
1575 // This function doesn't have a complete type (for example, the return
1576 // type is an incomplete struct). Use a fake type instead, and make
1577 // sure not to try to set attributes.
1578 bool IsIncompleteFunction = false;
1580 llvm::FunctionType *FTy;
1581 if (isa<llvm::FunctionType>(Ty)) {
1582 FTy = cast<llvm::FunctionType>(Ty);
1584 FTy = llvm::FunctionType::get(VoidTy, false);
1585 IsIncompleteFunction = true;
1588 llvm::Function *F = llvm::Function::Create(FTy,
1589 llvm::Function::ExternalLinkage,
1590 MangledName, &getModule());
1591 assert(F->getName() == MangledName && "name was uniqued!");
1593 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
1594 if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) {
1595 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex);
1596 F->addAttributes(llvm::AttributeSet::FunctionIndex,
1597 llvm::AttributeSet::get(VMContext,
1598 llvm::AttributeSet::FunctionIndex,
1603 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
1604 // each other bottoming out with the base dtor. Therefore we emit non-base
1605 // dtors on usage, even if there is no dtor definition in the TU.
1606 if (D && isa<CXXDestructorDecl>(D) &&
1607 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
1609 addDeferredDeclToEmit(F, GD);
1611 // This is the first use or definition of a mangled name. If there is a
1612 // deferred decl with this name, remember that we need to emit it at the end
1614 auto DDI = DeferredDecls.find(MangledName);
1615 if (DDI != DeferredDecls.end()) {
1616 // Move the potentially referenced deferred decl to the
1617 // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
1618 // don't need it anymore).
1619 addDeferredDeclToEmit(F, DDI->second);
1620 DeferredDecls.erase(DDI);
1622 // Otherwise, there are cases we have to worry about where we're
1623 // using a declaration for which we must emit a definition but where
1624 // we might not find a top-level definition:
1625 // - member functions defined inline in their classes
1626 // - friend functions defined inline in some class
1627 // - special member functions with implicit definitions
1628 // If we ever change our AST traversal to walk into class methods,
1629 // this will be unnecessary.
1631 // We also don't emit a definition for a function if it's going to be an
1632 // entry in a vtable, unless it's already marked as used.
1633 } else if (getLangOpts().CPlusPlus && D) {
1634 // Look for a declaration that's lexically in a record.
1635 for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
1636 FD = FD->getPreviousDecl()) {
1637 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
1638 if (FD->doesThisDeclarationHaveABody()) {
1639 addDeferredDeclToEmit(F, GD.getWithDecl(FD));
1647 // Make sure the result is of the requested type.
1648 if (!IsIncompleteFunction) {
1649 assert(F->getType()->getElementType() == Ty);
1653 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
1654 return llvm::ConstantExpr::getBitCast(F, PTy);
1657 /// GetAddrOfFunction - Return the address of the given function. If Ty is
1658 /// non-null, then this function will use the specified type if it has to
1659 /// create it (this occurs when we see a definition of the function).
1660 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
1664 // If there was no specific requested type, just convert it now.
1666 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
1668 StringRef MangledName = getMangledName(GD);
1669 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer);
1672 /// CreateRuntimeFunction - Create a new runtime function with the specified
1675 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
1677 llvm::AttributeSet ExtraAttrs) {
1679 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1680 /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
1681 if (auto *F = dyn_cast<llvm::Function>(C))
1683 F->setCallingConv(getRuntimeCC());
1687 /// CreateBuiltinFunction - Create a new builtin function with the specified
1690 CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy,
1692 llvm::AttributeSet ExtraAttrs) {
1694 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1695 /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
1696 if (auto *F = dyn_cast<llvm::Function>(C))
1698 F->setCallingConv(getBuiltinCC());
1702 /// isTypeConstant - Determine whether an object of this type can be emitted
1705 /// If ExcludeCtor is true, the duration when the object's constructor runs
1706 /// will not be considered. The caller will need to verify that the object is
1707 /// not written to during its construction.
1708 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1709 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
1712 if (Context.getLangOpts().CPlusPlus) {
1713 if (const CXXRecordDecl *Record
1714 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1715 return ExcludeCtor && !Record->hasMutableFields() &&
1716 Record->hasTrivialDestructor();
1722 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1723 /// create and return an llvm GlobalVariable with the specified type. If there
1724 /// is something in the module with the specified name, return it potentially
1725 /// bitcasted to the right type.
1727 /// If D is non-null, it specifies a decl that correspond to this. This is used
1728 /// to set the attributes on the global when it is first created.
1730 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
1731 llvm::PointerType *Ty,
1733 // Lookup the entry, lazily creating it if necessary.
1734 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1736 if (WeakRefReferences.erase(Entry)) {
1737 if (D && !D->hasAttr<WeakAttr>())
1738 Entry->setLinkage(llvm::Function::ExternalLinkage);
1741 // Handle dropped DLL attributes.
1742 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
1743 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
1745 if (Entry->getType() == Ty)
1748 // Make sure the result is of the correct type.
1749 if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
1750 return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
1752 return llvm::ConstantExpr::getBitCast(Entry, Ty);
1755 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
1756 auto *GV = new llvm::GlobalVariable(
1757 getModule(), Ty->getElementType(), false,
1758 llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr,
1759 llvm::GlobalVariable::NotThreadLocal, AddrSpace);
1761 // This is the first use or definition of a mangled name. If there is a
1762 // deferred decl with this name, remember that we need to emit it at the end
1764 auto DDI = DeferredDecls.find(MangledName);
1765 if (DDI != DeferredDecls.end()) {
1766 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1767 // list, and remove it from DeferredDecls (since we don't need it anymore).
1768 addDeferredDeclToEmit(GV, DDI->second);
1769 DeferredDecls.erase(DDI);
1772 // Handle things which are present even on external declarations.
1774 // FIXME: This code is overly simple and should be merged with other global
1776 GV->setConstant(isTypeConstant(D->getType(), false));
1778 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
1780 setLinkageAndVisibilityForGV(GV, D);
1782 if (D->getTLSKind()) {
1783 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
1784 CXXThreadLocals.push_back(std::make_pair(D, GV));
1788 // If required by the ABI, treat declarations of static data members with
1789 // inline initializers as definitions.
1790 if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
1791 EmitGlobalVarDefinition(D);
1794 // Handle XCore specific ABI requirements.
1795 if (getTarget().getTriple().getArch() == llvm::Triple::xcore &&
1796 D->getLanguageLinkage() == CLanguageLinkage &&
1797 D->getType().isConstant(Context) &&
1798 isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
1799 GV->setSection(".cp.rodata");
1802 if (AddrSpace != Ty->getAddressSpace())
1803 return llvm::ConstantExpr::getAddrSpaceCast(GV, Ty);
1809 llvm::GlobalVariable *
1810 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
1812 llvm::GlobalValue::LinkageTypes Linkage) {
1813 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1814 llvm::GlobalVariable *OldGV = nullptr;
1817 // Check if the variable has the right type.
1818 if (GV->getType()->getElementType() == Ty)
1821 // Because C++ name mangling, the only way we can end up with an already
1822 // existing global with the same name is if it has been declared extern "C".
1823 assert(GV->isDeclaration() && "Declaration has wrong type!");
1827 // Create a new variable.
1828 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1829 Linkage, nullptr, Name);
1832 // Replace occurrences of the old variable if needed.
1833 GV->takeName(OldGV);
1835 if (!OldGV->use_empty()) {
1836 llvm::Constant *NewPtrForOldDecl =
1837 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1838 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1841 OldGV->eraseFromParent();
1844 if (supportsCOMDAT() && GV->isWeakForLinker() &&
1845 !GV->hasAvailableExternallyLinkage())
1846 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
1851 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1852 /// given global variable. If Ty is non-null and if the global doesn't exist,
1853 /// then it will be created with the specified type instead of whatever the
1854 /// normal requested type would be.
1855 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
1857 assert(D->hasGlobalStorage() && "Not a global variable");
1858 QualType ASTTy = D->getType();
1860 Ty = getTypes().ConvertTypeForMem(ASTTy);
1862 llvm::PointerType *PTy =
1863 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
1865 StringRef MangledName = getMangledName(D);
1866 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
1869 /// CreateRuntimeVariable - Create a new runtime global variable with the
1870 /// specified type and name.
1872 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
1874 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
1877 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1878 assert(!D->getInit() && "Cannot emit definite definitions here!");
1880 if (!MustBeEmitted(D)) {
1881 // If we have not seen a reference to this variable yet, place it
1882 // into the deferred declarations table to be emitted if needed
1884 StringRef MangledName = getMangledName(D);
1885 if (!GetGlobalValue(MangledName)) {
1886 DeferredDecls[MangledName] = D;
1891 // The tentative definition is the only definition.
1892 EmitGlobalVarDefinition(D);
1895 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
1896 return Context.toCharUnitsFromBits(
1897 TheDataLayout.getTypeStoreSizeInBits(Ty));
1900 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1901 unsigned AddrSpace) {
1902 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
1903 if (D->hasAttr<CUDAConstantAttr>())
1904 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1905 else if (D->hasAttr<CUDASharedAttr>())
1906 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1908 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1914 template<typename SomeDecl>
1915 void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D,
1916 llvm::GlobalValue *GV) {
1917 if (!getLangOpts().CPlusPlus)
1920 // Must have 'used' attribute, or else inline assembly can't rely on
1921 // the name existing.
1922 if (!D->template hasAttr<UsedAttr>())
1925 // Must have internal linkage and an ordinary name.
1926 if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
1929 // Must be in an extern "C" context. Entities declared directly within
1930 // a record are not extern "C" even if the record is in such a context.
1931 const SomeDecl *First = D->getFirstDecl();
1932 if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
1935 // OK, this is an internal linkage entity inside an extern "C" linkage
1936 // specification. Make a note of that so we can give it the "expected"
1937 // mangled name if nothing else is using that name.
1938 std::pair<StaticExternCMap::iterator, bool> R =
1939 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
1941 // If we have multiple internal linkage entities with the same name
1942 // in extern "C" regions, none of them gets that name.
1944 R.first->second = nullptr;
1947 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
1948 if (!CGM.supportsCOMDAT())
1951 if (D.hasAttr<SelectAnyAttr>())
1955 if (auto *VD = dyn_cast<VarDecl>(&D))
1956 Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
1958 Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
1962 case GVA_AvailableExternally:
1963 case GVA_StrongExternal:
1965 case GVA_DiscardableODR:
1969 llvm_unreachable("No such linkage");
1972 void CodeGenModule::maybeSetTrivialComdat(const Decl &D,
1973 llvm::GlobalObject &GO) {
1974 if (!shouldBeInCOMDAT(*this, D))
1976 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
1979 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1980 llvm::Constant *Init = nullptr;
1981 QualType ASTTy = D->getType();
1982 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1983 bool NeedsGlobalCtor = false;
1984 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
1986 const VarDecl *InitDecl;
1987 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
1990 // This is a tentative definition; tentative definitions are
1991 // implicitly initialized with { 0 }.
1993 // Note that tentative definitions are only emitted at the end of
1994 // a translation unit, so they should never have incomplete
1995 // type. In addition, EmitTentativeDefinition makes sure that we
1996 // never attempt to emit a tentative definition if a real one
1997 // exists. A use may still exists, however, so we still may need
1999 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
2000 Init = EmitNullConstant(D->getType());
2002 initializedGlobalDecl = GlobalDecl(D);
2003 Init = EmitConstantInit(*InitDecl);
2006 QualType T = InitExpr->getType();
2007 if (D->getType()->isReferenceType())
2010 if (getLangOpts().CPlusPlus) {
2011 Init = EmitNullConstant(T);
2012 NeedsGlobalCtor = true;
2014 ErrorUnsupported(D, "static initializer");
2015 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
2018 // We don't need an initializer, so remove the entry for the delayed
2019 // initializer position (just in case this entry was delayed) if we
2020 // also don't need to register a destructor.
2021 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
2022 DelayedCXXInitPosition.erase(D);
2026 llvm::Type* InitType = Init->getType();
2027 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
2029 // Strip off a bitcast if we got one back.
2030 if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2031 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
2032 CE->getOpcode() == llvm::Instruction::AddrSpaceCast ||
2033 // All zero index gep.
2034 CE->getOpcode() == llvm::Instruction::GetElementPtr);
2035 Entry = CE->getOperand(0);
2038 // Entry is now either a Function or GlobalVariable.
2039 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
2041 // We have a definition after a declaration with the wrong type.
2042 // We must make a new GlobalVariable* and update everything that used OldGV
2043 // (a declaration or tentative definition) with the new GlobalVariable*
2044 // (which will be a definition).
2046 // This happens if there is a prototype for a global (e.g.
2047 // "extern int x[];") and then a definition of a different type (e.g.
2048 // "int x[10];"). This also happens when an initializer has a different type
2049 // from the type of the global (this happens with unions).
2051 GV->getType()->getElementType() != InitType ||
2052 GV->getType()->getAddressSpace() !=
2053 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
2055 // Move the old entry aside so that we'll create a new one.
2056 Entry->setName(StringRef());
2058 // Make a new global with the correct type, this is now guaranteed to work.
2059 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
2061 // Replace all uses of the old global with the new global
2062 llvm::Constant *NewPtrForOldDecl =
2063 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
2064 Entry->replaceAllUsesWith(NewPtrForOldDecl);
2066 // Erase the old global, since it is no longer used.
2067 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
2070 MaybeHandleStaticInExternC(D, GV);
2072 if (D->hasAttr<AnnotateAttr>())
2073 AddGlobalAnnotations(D, GV);
2075 GV->setInitializer(Init);
2077 // If it is safe to mark the global 'constant', do so now.
2078 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
2079 isTypeConstant(D->getType(), true));
2081 // If it is in a read-only section, mark it 'constant'.
2082 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
2083 const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
2084 if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
2085 GV->setConstant(true);
2088 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
2090 // Set the llvm linkage type as appropriate.
2091 llvm::GlobalValue::LinkageTypes Linkage =
2092 getLLVMLinkageVarDefinition(D, GV->isConstant());
2094 // On Darwin, the backing variable for a C++11 thread_local variable always
2095 // has internal linkage; all accesses should just be calls to the
2096 // Itanium-specified entry point, which has the normal linkage of the
2098 if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
2099 Context.getTargetInfo().getTriple().isMacOSX())
2100 Linkage = llvm::GlobalValue::InternalLinkage;
2102 GV->setLinkage(Linkage);
2103 if (D->hasAttr<DLLImportAttr>())
2104 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2105 else if (D->hasAttr<DLLExportAttr>())
2106 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
2108 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
2110 if (Linkage == llvm::GlobalVariable::CommonLinkage)
2111 // common vars aren't constant even if declared const.
2112 GV->setConstant(false);
2114 setNonAliasAttributes(D, GV);
2116 if (D->getTLSKind() && !GV->isThreadLocal()) {
2117 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
2118 CXXThreadLocals.push_back(std::make_pair(D, GV));
2122 maybeSetTrivialComdat(*D, *GV);
2124 // Emit the initializer function if necessary.
2125 if (NeedsGlobalCtor || NeedsGlobalDtor)
2126 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
2128 SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
2130 // Emit global variable debug information.
2131 if (CGDebugInfo *DI = getModuleDebugInfo())
2132 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2133 DI->EmitGlobalVariable(GV, D);
2136 static bool isVarDeclStrongDefinition(const ASTContext &Context,
2137 CodeGenModule &CGM, const VarDecl *D,
2139 // Don't give variables common linkage if -fno-common was specified unless it
2140 // was overridden by a NoCommon attribute.
2141 if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
2145 // A declaration of an identifier for an object that has file scope without
2146 // an initializer, and without a storage-class specifier or with the
2147 // storage-class specifier static, constitutes a tentative definition.
2148 if (D->getInit() || D->hasExternalStorage())
2151 // A variable cannot be both common and exist in a section.
2152 if (D->hasAttr<SectionAttr>())
2155 // Thread local vars aren't considered common linkage.
2156 if (D->getTLSKind())
2159 // Tentative definitions marked with WeakImportAttr are true definitions.
2160 if (D->hasAttr<WeakImportAttr>())
2163 // A variable cannot be both common and exist in a comdat.
2164 if (shouldBeInCOMDAT(CGM, *D))
2167 // Declarations with a required alignment do not have common linakge in MSVC
2169 if (Context.getLangOpts().MSVCCompat) {
2170 if (D->hasAttr<AlignedAttr>())
2172 QualType VarType = D->getType();
2173 if (Context.isAlignmentRequired(VarType))
2176 if (const auto *RT = VarType->getAs<RecordType>()) {
2177 const RecordDecl *RD = RT->getDecl();
2178 for (const FieldDecl *FD : RD->fields()) {
2179 if (FD->isBitField())
2181 if (FD->hasAttr<AlignedAttr>())
2183 if (Context.isAlignmentRequired(FD->getType()))
2192 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(
2193 const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) {
2194 if (Linkage == GVA_Internal)
2195 return llvm::Function::InternalLinkage;
2197 if (D->hasAttr<WeakAttr>()) {
2198 if (IsConstantVariable)
2199 return llvm::GlobalVariable::WeakODRLinkage;
2201 return llvm::GlobalVariable::WeakAnyLinkage;
2204 // We are guaranteed to have a strong definition somewhere else,
2205 // so we can use available_externally linkage.
2206 if (Linkage == GVA_AvailableExternally)
2207 return llvm::Function::AvailableExternallyLinkage;
2209 // Note that Apple's kernel linker doesn't support symbol
2210 // coalescing, so we need to avoid linkonce and weak linkages there.
2211 // Normally, this means we just map to internal, but for explicit
2212 // instantiations we'll map to external.
2214 // In C++, the compiler has to emit a definition in every translation unit
2215 // that references the function. We should use linkonce_odr because
2216 // a) if all references in this translation unit are optimized away, we
2217 // don't need to codegen it. b) if the function persists, it needs to be
2218 // merged with other definitions. c) C++ has the ODR, so we know the
2219 // definition is dependable.
2220 if (Linkage == GVA_DiscardableODR)
2221 return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
2222 : llvm::Function::InternalLinkage;
2224 // An explicit instantiation of a template has weak linkage, since
2225 // explicit instantiations can occur in multiple translation units
2226 // and must all be equivalent. However, we are not allowed to
2227 // throw away these explicit instantiations.
2228 if (Linkage == GVA_StrongODR)
2229 return !Context.getLangOpts().AppleKext ? llvm::Function::WeakODRLinkage
2230 : llvm::Function::ExternalLinkage;
2232 // C++ doesn't have tentative definitions and thus cannot have common
2234 if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
2235 !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D),
2236 CodeGenOpts.NoCommon))
2237 return llvm::GlobalVariable::CommonLinkage;
2239 // selectany symbols are externally visible, so use weak instead of
2240 // linkonce. MSVC optimizes away references to const selectany globals, so
2241 // all definitions should be the same and ODR linkage should be used.
2242 // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
2243 if (D->hasAttr<SelectAnyAttr>())
2244 return llvm::GlobalVariable::WeakODRLinkage;
2246 // Otherwise, we have strong external linkage.
2247 assert(Linkage == GVA_StrongExternal);
2248 return llvm::GlobalVariable::ExternalLinkage;
2251 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(
2252 const VarDecl *VD, bool IsConstant) {
2253 GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD);
2254 return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant);
2257 /// Replace the uses of a function that was declared with a non-proto type.
2258 /// We want to silently drop extra arguments from call sites
2259 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
2260 llvm::Function *newFn) {
2262 if (old->use_empty()) return;
2264 llvm::Type *newRetTy = newFn->getReturnType();
2265 SmallVector<llvm::Value*, 4> newArgs;
2267 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
2269 llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
2270 llvm::User *user = use->getUser();
2272 // Recognize and replace uses of bitcasts. Most calls to
2273 // unprototyped functions will use bitcasts.
2274 if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
2275 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
2276 replaceUsesOfNonProtoConstant(bitcast, newFn);
2280 // Recognize calls to the function.
2281 llvm::CallSite callSite(user);
2282 if (!callSite) continue;
2283 if (!callSite.isCallee(&*use)) continue;
2285 // If the return types don't match exactly, then we can't
2286 // transform this call unless it's dead.
2287 if (callSite->getType() != newRetTy && !callSite->use_empty())
2290 // Get the call site's attribute list.
2291 SmallVector<llvm::AttributeSet, 8> newAttrs;
2292 llvm::AttributeSet oldAttrs = callSite.getAttributes();
2294 // Collect any return attributes from the call.
2295 if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex))
2297 llvm::AttributeSet::get(newFn->getContext(),
2298 oldAttrs.getRetAttributes()));
2300 // If the function was passed too few arguments, don't transform.
2301 unsigned newNumArgs = newFn->arg_size();
2302 if (callSite.arg_size() < newNumArgs) continue;
2304 // If extra arguments were passed, we silently drop them.
2305 // If any of the types mismatch, we don't transform.
2307 bool dontTransform = false;
2308 for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
2309 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
2310 if (callSite.getArgument(argNo)->getType() != ai->getType()) {
2311 dontTransform = true;
2315 // Add any parameter attributes.
2316 if (oldAttrs.hasAttributes(argNo + 1))
2319 AttributeSet::get(newFn->getContext(),
2320 oldAttrs.getParamAttributes(argNo + 1)));
2325 if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex))
2326 newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(),
2327 oldAttrs.getFnAttributes()));
2329 // Okay, we can transform this. Create the new call instruction and copy
2330 // over the required information.
2331 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
2333 llvm::CallSite newCall;
2334 if (callSite.isCall()) {
2335 newCall = llvm::CallInst::Create(newFn, newArgs, "",
2336 callSite.getInstruction());
2338 auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction());
2339 newCall = llvm::InvokeInst::Create(newFn,
2340 oldInvoke->getNormalDest(),
2341 oldInvoke->getUnwindDest(),
2343 callSite.getInstruction());
2345 newArgs.clear(); // for the next iteration
2347 if (!newCall->getType()->isVoidTy())
2348 newCall->takeName(callSite.getInstruction());
2349 newCall.setAttributes(
2350 llvm::AttributeSet::get(newFn->getContext(), newAttrs));
2351 newCall.setCallingConv(callSite.getCallingConv());
2353 // Finally, remove the old call, replacing any uses with the new one.
2354 if (!callSite->use_empty())
2355 callSite->replaceAllUsesWith(newCall.getInstruction());
2357 // Copy debug location attached to CI.
2358 if (callSite->getDebugLoc())
2359 newCall->setDebugLoc(callSite->getDebugLoc());
2360 callSite->eraseFromParent();
2364 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
2365 /// implement a function with no prototype, e.g. "int foo() {}". If there are
2366 /// existing call uses of the old function in the module, this adjusts them to
2367 /// call the new function directly.
2369 /// This is not just a cleanup: the always_inline pass requires direct calls to
2370 /// functions to be able to inline them. If there is a bitcast in the way, it
2371 /// won't inline them. Instcombine normally deletes these calls, but it isn't
2373 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2374 llvm::Function *NewFn) {
2375 // If we're redefining a global as a function, don't transform it.
2376 if (!isa<llvm::Function>(Old)) return;
2378 replaceUsesOfNonProtoConstant(Old, NewFn);
2381 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
2382 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
2383 // If we have a definition, this might be a deferred decl. If the
2384 // instantiation is explicit, make sure we emit it at the end.
2385 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
2386 GetAddrOfGlobalVar(VD);
2388 EmitTopLevelDecl(VD);
2391 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
2392 llvm::GlobalValue *GV) {
2393 const auto *D = cast<FunctionDecl>(GD.getDecl());
2395 // Compute the function info and LLVM type.
2396 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2397 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2399 // Get or create the prototype for the function.
2402 GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer*/ true);
2404 // Strip off a bitcast if we got one back.
2405 if (auto *CE = dyn_cast<llvm::ConstantExpr>(C)) {
2406 assert(CE->getOpcode() == llvm::Instruction::BitCast);
2407 GV = cast<llvm::GlobalValue>(CE->getOperand(0));
2409 GV = cast<llvm::GlobalValue>(C);
2413 if (!GV->isDeclaration()) {
2414 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name);
2415 GlobalDecl OldGD = Manglings.lookup(GV->getName());
2416 if (auto *Prev = OldGD.getDecl())
2417 getDiags().Report(Prev->getLocation(), diag::note_previous_definition);
2421 if (GV->getType()->getElementType() != Ty) {
2422 // If the types mismatch then we have to rewrite the definition.
2423 assert(GV->isDeclaration() && "Shouldn't replace non-declaration");
2425 // F is the Function* for the one with the wrong type, we must make a new
2426 // Function* and update everything that used F (a declaration) with the new
2427 // Function* (which will be a definition).
2429 // This happens if there is a prototype for a function
2430 // (e.g. "int f()") and then a definition of a different type
2431 // (e.g. "int f(int x)"). Move the old function aside so that it
2432 // doesn't interfere with GetAddrOfFunction.
2433 GV->setName(StringRef());
2434 auto *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
2436 // This might be an implementation of a function without a
2437 // prototype, in which case, try to do special replacement of
2438 // calls which match the new prototype. The really key thing here
2439 // is that we also potentially drop arguments from the call site
2440 // so as to make a direct call, which makes the inliner happier
2441 // and suppresses a number of optimizer warnings (!) about
2442 // dropping arguments.
2443 if (!GV->use_empty()) {
2444 ReplaceUsesOfNonProtoTypeWithRealFunction(GV, NewFn);
2445 GV->removeDeadConstantUsers();
2448 // Replace uses of F with the Function we will endow with a body.
2449 if (!GV->use_empty()) {
2450 llvm::Constant *NewPtrForOldDecl =
2451 llvm::ConstantExpr::getBitCast(NewFn, GV->getType());
2452 GV->replaceAllUsesWith(NewPtrForOldDecl);
2455 // Ok, delete the old function now, which is dead.
2456 GV->eraseFromParent();
2461 // We need to set linkage and visibility on the function before
2462 // generating code for it because various parts of IR generation
2463 // want to propagate this information down (e.g. to local static
2465 auto *Fn = cast<llvm::Function>(GV);
2466 setFunctionLinkage(GD, Fn);
2467 setFunctionDLLStorageClass(GD, Fn);
2469 // FIXME: this is redundant with part of setFunctionDefinitionAttributes
2470 setGlobalVisibility(Fn, D);
2472 MaybeHandleStaticInExternC(D, Fn);
2474 maybeSetTrivialComdat(*D, *Fn);
2476 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
2478 setFunctionDefinitionAttributes(D, Fn);
2479 SetLLVMFunctionAttributesForDefinition(D, Fn);
2481 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
2482 AddGlobalCtor(Fn, CA->getPriority());
2483 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
2484 AddGlobalDtor(Fn, DA->getPriority());
2485 if (D->hasAttr<AnnotateAttr>())
2486 AddGlobalAnnotations(D, Fn);
2489 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2490 const auto *D = cast<ValueDecl>(GD.getDecl());
2491 const AliasAttr *AA = D->getAttr<AliasAttr>();
2492 assert(AA && "Not an alias?");
2494 StringRef MangledName = getMangledName(GD);
2496 // If there is a definition in the module, then it wins over the alias.
2497 // This is dubious, but allow it to be safe. Just ignore the alias.
2498 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2499 if (Entry && !Entry->isDeclaration())
2502 Aliases.push_back(GD);
2504 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
2506 // Create a reference to the named value. This ensures that it is emitted
2507 // if a deferred decl.
2508 llvm::Constant *Aliasee;
2509 if (isa<llvm::FunctionType>(DeclTy))
2510 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
2511 /*ForVTable=*/false);
2513 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2514 llvm::PointerType::getUnqual(DeclTy),
2517 // Create the new alias itself, but don't set a name yet.
2518 auto *GA = llvm::GlobalAlias::create(
2519 cast<llvm::PointerType>(Aliasee->getType()),
2520 llvm::Function::ExternalLinkage, "", Aliasee, &getModule());
2523 if (GA->getAliasee() == Entry) {
2524 Diags.Report(AA->getLocation(), diag::err_cyclic_alias);
2528 assert(Entry->isDeclaration());
2530 // If there is a declaration in the module, then we had an extern followed
2531 // by the alias, as in:
2532 // extern int test6();
2534 // int test6() __attribute__((alias("test7")));
2536 // Remove it and replace uses of it with the alias.
2537 GA->takeName(Entry);
2539 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
2541 Entry->eraseFromParent();
2543 GA->setName(MangledName);
2546 // Set attributes which are particular to an alias; this is a
2547 // specialization of the attributes which may be set on a global
2548 // variable/function.
2549 if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
2550 D->isWeakImported()) {
2551 GA->setLinkage(llvm::Function::WeakAnyLinkage);
2554 if (const auto *VD = dyn_cast<VarDecl>(D))
2555 if (VD->getTLSKind())
2556 setTLSMode(GA, *VD);
2558 setAliasAttributes(D, GA);
2561 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
2562 ArrayRef<llvm::Type*> Tys) {
2563 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
2567 static llvm::StringMapEntry<llvm::GlobalVariable *> &
2568 GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
2569 const StringLiteral *Literal, bool TargetIsLSB,
2570 bool &IsUTF16, unsigned &StringLength) {
2571 StringRef String = Literal->getString();
2572 unsigned NumBytes = String.size();
2574 // Check for simple case.
2575 if (!Literal->containsNonAsciiOrNull()) {
2576 StringLength = NumBytes;
2577 return *Map.insert(std::make_pair(String, nullptr)).first;
2580 // Otherwise, convert the UTF8 literals into a string of shorts.
2583 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
2584 const UTF8 *FromPtr = (const UTF8 *)String.data();
2585 UTF16 *ToPtr = &ToBuf[0];
2587 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2588 &ToPtr, ToPtr + NumBytes,
2591 // ConvertUTF8toUTF16 returns the length in ToPtr.
2592 StringLength = ToPtr - &ToBuf[0];
2594 // Add an explicit null.
2596 return *Map.insert(std::make_pair(
2597 StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2598 (StringLength + 1) * 2),
2602 static llvm::StringMapEntry<llvm::GlobalVariable *> &
2603 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
2604 const StringLiteral *Literal, unsigned &StringLength) {
2605 StringRef String = Literal->getString();
2606 StringLength = String.size();
2607 return *Map.insert(std::make_pair(String, nullptr)).first;
2611 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2612 unsigned StringLength = 0;
2613 bool isUTF16 = false;
2614 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2615 GetConstantCFStringEntry(CFConstantStringMap, Literal,
2616 getDataLayout().isLittleEndian(), isUTF16,
2619 if (auto *C = Entry.second)
2622 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2623 llvm::Constant *Zeros[] = { Zero, Zero };
2626 // If we don't already have it, get __CFConstantStringClassReference.
2627 if (!CFConstantStringClassRef) {
2628 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2629 Ty = llvm::ArrayType::get(Ty, 0);
2630 llvm::Constant *GV = CreateRuntimeVariable(Ty,
2631 "__CFConstantStringClassReference");
2632 // Decay array -> ptr
2633 V = llvm::ConstantExpr::getGetElementPtr(Ty, GV, Zeros);
2634 CFConstantStringClassRef = V;
2637 V = CFConstantStringClassRef;
2639 QualType CFTy = getContext().getCFConstantStringType();
2641 auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2643 llvm::Constant *Fields[4];
2646 Fields[0] = cast<llvm::ConstantExpr>(V);
2649 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2650 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
2651 llvm::ConstantInt::get(Ty, 0x07C8);
2654 llvm::Constant *C = nullptr;
2656 ArrayRef<uint16_t> Arr = llvm::makeArrayRef<uint16_t>(
2657 reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
2658 Entry.first().size() / 2);
2659 C = llvm::ConstantDataArray::get(VMContext, Arr);
2661 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
2664 // Note: -fwritable-strings doesn't make the backing store strings of
2665 // CFStrings writable. (See <rdar://problem/10657500>)
2667 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2668 llvm::GlobalValue::PrivateLinkage, C, ".str");
2669 GV->setUnnamedAddr(true);
2670 // Don't enforce the target's minimum global alignment, since the only use
2671 // of the string is via this class initializer.
2672 // FIXME: We set the section explicitly to avoid a bug in ld64 224.1. Without
2673 // it LLVM can merge the string with a non unnamed_addr one during LTO. Doing
2674 // that changes the section it ends in, which surprises ld64.
2676 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2677 GV->setAlignment(Align.getQuantity());
2678 GV->setSection("__TEXT,__ustring");
2680 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2681 GV->setAlignment(Align.getQuantity());
2682 GV->setSection("__TEXT,__cstring,cstring_literals");
2687 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
2690 // Cast the UTF16 string to the correct type.
2691 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2694 Ty = getTypes().ConvertType(getContext().LongTy);
2695 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
2698 C = llvm::ConstantStruct::get(STy, Fields);
2699 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2700 llvm::GlobalVariable::PrivateLinkage, C,
2701 "_unnamed_cfstring_");
2702 GV->setSection("__DATA,__cfstring");
2708 llvm::GlobalVariable *
2709 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
2710 unsigned StringLength = 0;
2711 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2712 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
2714 if (auto *C = Entry.second)
2717 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2718 llvm::Constant *Zeros[] = { Zero, Zero };
2720 // If we don't already have it, get _NSConstantStringClassReference.
2721 if (!ConstantStringClassRef) {
2722 std::string StringClass(getLangOpts().ObjCConstantStringClass);
2723 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2725 if (LangOpts.ObjCRuntime.isNonFragile()) {
2727 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2728 : "OBJC_CLASS_$_" + StringClass;
2729 GV = getObjCRuntime().GetClassGlobal(str);
2730 // Make sure the result is of the correct type.
2731 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2732 V = llvm::ConstantExpr::getBitCast(GV, PTy);
2733 ConstantStringClassRef = V;
2736 StringClass.empty() ? "_NSConstantStringClassReference"
2737 : "_" + StringClass + "ClassReference";
2738 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
2739 GV = CreateRuntimeVariable(PTy, str);
2740 // Decay array -> ptr
2741 V = llvm::ConstantExpr::getGetElementPtr(PTy, GV, Zeros);
2742 ConstantStringClassRef = V;
2745 V = ConstantStringClassRef;
2747 if (!NSConstantStringType) {
2748 // Construct the type for a constant NSString.
2749 RecordDecl *D = Context.buildImplicitRecord("__builtin_NSString");
2750 D->startDefinition();
2752 QualType FieldTypes[3];
2755 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2757 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2758 // unsigned int length;
2759 FieldTypes[2] = Context.UnsignedIntTy;
2762 for (unsigned i = 0; i < 3; ++i) {
2763 FieldDecl *Field = FieldDecl::Create(Context, D,
2765 SourceLocation(), nullptr,
2766 FieldTypes[i], /*TInfo=*/nullptr,
2767 /*BitWidth=*/nullptr,
2770 Field->setAccess(AS_public);
2774 D->completeDefinition();
2775 QualType NSTy = Context.getTagDeclType(D);
2776 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2779 llvm::Constant *Fields[3];
2782 Fields[0] = cast<llvm::ConstantExpr>(V);
2786 llvm::ConstantDataArray::getString(VMContext, Entry.first());
2788 llvm::GlobalValue::LinkageTypes Linkage;
2790 Linkage = llvm::GlobalValue::PrivateLinkage;
2791 isConstant = !LangOpts.WritableStrings;
2793 auto *GV = new llvm::GlobalVariable(getModule(), C->getType(), isConstant,
2794 Linkage, C, ".str");
2795 GV->setUnnamedAddr(true);
2796 // Don't enforce the target's minimum global alignment, since the only use
2797 // of the string is via this class initializer.
2798 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2799 GV->setAlignment(Align.getQuantity());
2801 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
2804 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2805 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2808 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
2809 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2810 llvm::GlobalVariable::PrivateLinkage, C,
2811 "_unnamed_nsstring_");
2812 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2813 const char *NSStringNonFragileABISection =
2814 "__DATA,__objc_stringobj,regular,no_dead_strip";
2815 // FIXME. Fix section.
2816 GV->setSection(LangOpts.ObjCRuntime.isNonFragile()
2817 ? NSStringNonFragileABISection
2824 QualType CodeGenModule::getObjCFastEnumerationStateType() {
2825 if (ObjCFastEnumerationStateType.isNull()) {
2826 RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
2827 D->startDefinition();
2829 QualType FieldTypes[] = {
2830 Context.UnsignedLongTy,
2831 Context.getPointerType(Context.getObjCIdType()),
2832 Context.getPointerType(Context.UnsignedLongTy),
2833 Context.getConstantArrayType(Context.UnsignedLongTy,
2834 llvm::APInt(32, 5), ArrayType::Normal, 0)
2837 for (size_t i = 0; i < 4; ++i) {
2838 FieldDecl *Field = FieldDecl::Create(Context,
2841 SourceLocation(), nullptr,
2842 FieldTypes[i], /*TInfo=*/nullptr,
2843 /*BitWidth=*/nullptr,
2846 Field->setAccess(AS_public);
2850 D->completeDefinition();
2851 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2854 return ObjCFastEnumerationStateType;
2858 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2859 assert(!E->getType()->isPointerType() && "Strings are always arrays");
2861 // Don't emit it as the address of the string, emit the string data itself
2862 // as an inline array.
2863 if (E->getCharByteWidth() == 1) {
2864 SmallString<64> Str(E->getString());
2866 // Resize the string to the right size, which is indicated by its type.
2867 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2868 Str.resize(CAT->getSize().getZExtValue());
2869 return llvm::ConstantDataArray::getString(VMContext, Str, false);
2872 auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2873 llvm::Type *ElemTy = AType->getElementType();
2874 unsigned NumElements = AType->getNumElements();
2876 // Wide strings have either 2-byte or 4-byte elements.
2877 if (ElemTy->getPrimitiveSizeInBits() == 16) {
2878 SmallVector<uint16_t, 32> Elements;
2879 Elements.reserve(NumElements);
2881 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2882 Elements.push_back(E->getCodeUnit(i));
2883 Elements.resize(NumElements);
2884 return llvm::ConstantDataArray::get(VMContext, Elements);
2887 assert(ElemTy->getPrimitiveSizeInBits() == 32);
2888 SmallVector<uint32_t, 32> Elements;
2889 Elements.reserve(NumElements);
2891 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2892 Elements.push_back(E->getCodeUnit(i));
2893 Elements.resize(NumElements);
2894 return llvm::ConstantDataArray::get(VMContext, Elements);
2897 static llvm::GlobalVariable *
2898 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
2899 CodeGenModule &CGM, StringRef GlobalName,
2900 unsigned Alignment) {
2901 // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
2902 unsigned AddrSpace = 0;
2903 if (CGM.getLangOpts().OpenCL)
2904 AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant);
2906 llvm::Module &M = CGM.getModule();
2907 // Create a global variable for this string
2908 auto *GV = new llvm::GlobalVariable(
2909 M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
2910 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
2911 GV->setAlignment(Alignment);
2912 GV->setUnnamedAddr(true);
2913 if (GV->isWeakForLinker()) {
2914 assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
2915 GV->setComdat(M.getOrInsertComdat(GV->getName()));
2921 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2922 /// constant array for the given string literal.
2923 llvm::GlobalVariable *
2924 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
2927 getContext().getAlignOfGlobalVarInChars(S->getType()).getQuantity();
2929 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2930 llvm::GlobalVariable **Entry = nullptr;
2931 if (!LangOpts.WritableStrings) {
2932 Entry = &ConstantStringMap[C];
2933 if (auto GV = *Entry) {
2934 if (Alignment > GV->getAlignment())
2935 GV->setAlignment(Alignment);
2940 SmallString<256> MangledNameBuffer;
2941 StringRef GlobalVariableName;
2942 llvm::GlobalValue::LinkageTypes LT;
2944 // Mangle the string literal if the ABI allows for it. However, we cannot
2945 // do this if we are compiling with ASan or -fwritable-strings because they
2946 // rely on strings having normal linkage.
2947 if (!LangOpts.WritableStrings &&
2948 !LangOpts.Sanitize.has(SanitizerKind::Address) &&
2949 getCXXABI().getMangleContext().shouldMangleStringLiteral(S)) {
2950 llvm::raw_svector_ostream Out(MangledNameBuffer);
2951 getCXXABI().getMangleContext().mangleStringLiteral(S, Out);
2954 LT = llvm::GlobalValue::LinkOnceODRLinkage;
2955 GlobalVariableName = MangledNameBuffer;
2957 LT = llvm::GlobalValue::PrivateLinkage;
2958 GlobalVariableName = Name;
2961 auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
2965 SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
2970 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2971 /// array for the given ObjCEncodeExpr node.
2972 llvm::GlobalVariable *
2973 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2975 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
2977 return GetAddrOfConstantCString(Str);
2980 /// GetAddrOfConstantCString - Returns a pointer to a character array containing
2981 /// the literal and a terminating '\0' character.
2982 /// The result has pointer to array type.
2983 llvm::GlobalVariable *CodeGenModule::GetAddrOfConstantCString(
2984 const std::string &Str, const char *GlobalName, unsigned Alignment) {
2985 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
2986 if (Alignment == 0) {
2987 Alignment = getContext()
2988 .getAlignOfGlobalVarInChars(getContext().CharTy)
2993 llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
2995 // Don't share any string literals if strings aren't constant.
2996 llvm::GlobalVariable **Entry = nullptr;
2997 if (!LangOpts.WritableStrings) {
2998 Entry = &ConstantStringMap[C];
2999 if (auto GV = *Entry) {
3000 if (Alignment > GV->getAlignment())
3001 GV->setAlignment(Alignment);
3006 // Get the default prefix if a name wasn't specified.
3008 GlobalName = ".str";
3009 // Create a global variable for this.
3010 auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
3011 GlobalName, Alignment);
3017 llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary(
3018 const MaterializeTemporaryExpr *E, const Expr *Init) {
3019 assert((E->getStorageDuration() == SD_Static ||
3020 E->getStorageDuration() == SD_Thread) && "not a global temporary");
3021 const auto *VD = cast<VarDecl>(E->getExtendingDecl());
3023 // If we're not materializing a subobject of the temporary, keep the
3024 // cv-qualifiers from the type of the MaterializeTemporaryExpr.
3025 QualType MaterializedType = Init->getType();
3026 if (Init == E->GetTemporaryExpr())
3027 MaterializedType = E->getType();
3029 llvm::Constant *&Slot = MaterializedGlobalTemporaryMap[E];
3033 // FIXME: If an externally-visible declaration extends multiple temporaries,
3034 // we need to give each temporary the same name in every translation unit (and
3035 // we also need to make the temporaries externally-visible).
3036 SmallString<256> Name;
3037 llvm::raw_svector_ostream Out(Name);
3038 getCXXABI().getMangleContext().mangleReferenceTemporary(
3039 VD, E->getManglingNumber(), Out);
3042 APValue *Value = nullptr;
3043 if (E->getStorageDuration() == SD_Static) {
3044 // We might have a cached constant initializer for this temporary. Note
3045 // that this might have a different value from the value computed by
3046 // evaluating the initializer if the surrounding constant expression
3047 // modifies the temporary.
3048 Value = getContext().getMaterializedTemporaryValue(E, false);
3049 if (Value && Value->isUninit())
3053 // Try evaluating it now, it might have a constant initializer.
3054 Expr::EvalResult EvalResult;
3055 if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
3056 !EvalResult.hasSideEffects())
3057 Value = &EvalResult.Val;
3059 llvm::Constant *InitialValue = nullptr;
3060 bool Constant = false;
3063 // The temporary has a constant initializer, use it.
3064 InitialValue = EmitConstantValue(*Value, MaterializedType, nullptr);
3065 Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
3066 Type = InitialValue->getType();
3068 // No initializer, the initialization will be provided when we
3069 // initialize the declaration which performed lifetime extension.
3070 Type = getTypes().ConvertTypeForMem(MaterializedType);
3073 // Create a global variable for this lifetime-extended temporary.
3074 llvm::GlobalValue::LinkageTypes Linkage =
3075 getLLVMLinkageVarDefinition(VD, Constant);
3076 if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
3077 const VarDecl *InitVD;
3078 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
3079 isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
3080 // Temporaries defined inside a class get linkonce_odr linkage because the
3081 // class can be defined in multipe translation units.
3082 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
3084 // There is no need for this temporary to have external linkage if the
3085 // VarDecl has external linkage.
3086 Linkage = llvm::GlobalVariable::InternalLinkage;
3089 unsigned AddrSpace = GetGlobalVarAddressSpace(
3090 VD, getContext().getTargetAddressSpace(MaterializedType));
3091 auto *GV = new llvm::GlobalVariable(
3092 getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
3093 /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal,
3095 setGlobalVisibility(GV, VD);
3097 getContext().getTypeAlignInChars(MaterializedType).getQuantity());
3098 if (supportsCOMDAT() && GV->isWeakForLinker())
3099 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3100 if (VD->getTLSKind())
3101 setTLSMode(GV, *VD);
3106 /// EmitObjCPropertyImplementations - Emit information for synthesized
3107 /// properties for an implementation.
3108 void CodeGenModule::EmitObjCPropertyImplementations(const
3109 ObjCImplementationDecl *D) {
3110 for (const auto *PID : D->property_impls()) {
3111 // Dynamic is just for type-checking.
3112 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3113 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3115 // Determine which methods need to be implemented, some may have
3116 // been overridden. Note that ::isPropertyAccessor is not the method
3117 // we want, that just indicates if the decl came from a
3118 // property. What we want to know is if the method is defined in
3119 // this implementation.
3120 if (!D->getInstanceMethod(PD->getGetterName()))
3121 CodeGenFunction(*this).GenerateObjCGetter(
3122 const_cast<ObjCImplementationDecl *>(D), PID);
3123 if (!PD->isReadOnly() &&
3124 !D->getInstanceMethod(PD->getSetterName()))
3125 CodeGenFunction(*this).GenerateObjCSetter(
3126 const_cast<ObjCImplementationDecl *>(D), PID);
3131 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
3132 const ObjCInterfaceDecl *iface = impl->getClassInterface();
3133 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
3134 ivar; ivar = ivar->getNextIvar())
3135 if (ivar->getType().isDestructedType())
3141 static bool AllTrivialInitializers(CodeGenModule &CGM,
3142 ObjCImplementationDecl *D) {
3143 CodeGenFunction CGF(CGM);
3144 for (ObjCImplementationDecl::init_iterator B = D->init_begin(),
3145 E = D->init_end(); B != E; ++B) {
3146 CXXCtorInitializer *CtorInitExp = *B;
3147 Expr *Init = CtorInitExp->getInit();
3148 if (!CGF.isTrivialInitializer(Init))
3154 /// EmitObjCIvarInitializations - Emit information for ivar initialization
3155 /// for an implementation.
3156 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
3157 // We might need a .cxx_destruct even if we don't have any ivar initializers.
3158 if (needsDestructMethod(D)) {
3159 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
3160 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
3161 ObjCMethodDecl *DTORMethod =
3162 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
3163 cxxSelector, getContext().VoidTy, nullptr, D,
3164 /*isInstance=*/true, /*isVariadic=*/false,
3165 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
3166 /*isDefined=*/false, ObjCMethodDecl::Required);
3167 D->addInstanceMethod(DTORMethod);
3168 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
3169 D->setHasDestructors(true);
3172 // If the implementation doesn't have any ivar initializers, we don't need
3173 // a .cxx_construct.
3174 if (D->getNumIvarInitializers() == 0 ||
3175 AllTrivialInitializers(*this, D))
3178 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
3179 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
3180 // The constructor returns 'self'.
3181 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
3185 getContext().getObjCIdType(),
3186 nullptr, D, /*isInstance=*/true,
3187 /*isVariadic=*/false,
3188 /*isPropertyAccessor=*/true,
3189 /*isImplicitlyDeclared=*/true,
3190 /*isDefined=*/false,
3191 ObjCMethodDecl::Required);
3192 D->addInstanceMethod(CTORMethod);
3193 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
3194 D->setHasNonZeroConstructors(true);
3197 /// EmitNamespace - Emit all declarations in a namespace.
3198 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
3199 for (auto *I : ND->decls()) {
3200 if (const auto *VD = dyn_cast<VarDecl>(I))
3201 if (VD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
3202 VD->getTemplateSpecializationKind() != TSK_Undeclared)
3204 EmitTopLevelDecl(I);
3208 // EmitLinkageSpec - Emit all declarations in a linkage spec.
3209 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
3210 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
3211 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
3212 ErrorUnsupported(LSD, "linkage spec");
3216 for (auto *I : LSD->decls()) {
3217 // Meta-data for ObjC class includes references to implemented methods.
3218 // Generate class's method definitions first.
3219 if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
3220 for (auto *M : OID->methods())
3221 EmitTopLevelDecl(M);
3223 EmitTopLevelDecl(I);
3227 /// EmitTopLevelDecl - Emit code for a single top level declaration.
3228 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
3229 // Ignore dependent declarations.
3230 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
3233 switch (D->getKind()) {
3234 case Decl::CXXConversion:
3235 case Decl::CXXMethod:
3236 case Decl::Function:
3237 // Skip function templates
3238 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
3239 cast<FunctionDecl>(D)->isLateTemplateParsed())
3242 EmitGlobal(cast<FunctionDecl>(D));
3243 // Always provide some coverage mapping
3244 // even for the functions that aren't emitted.
3245 AddDeferredUnusedCoverageMapping(D);
3249 // Skip variable templates
3250 if (cast<VarDecl>(D)->getDescribedVarTemplate())
3252 case Decl::VarTemplateSpecialization:
3253 EmitGlobal(cast<VarDecl>(D));
3256 // Indirect fields from global anonymous structs and unions can be
3257 // ignored; only the actual variable requires IR gen support.
3258 case Decl::IndirectField:
3262 case Decl::Namespace:
3263 EmitNamespace(cast<NamespaceDecl>(D));
3265 // No code generation needed.
3266 case Decl::UsingShadow:
3267 case Decl::ClassTemplate:
3268 case Decl::VarTemplate:
3269 case Decl::VarTemplatePartialSpecialization:
3270 case Decl::FunctionTemplate:
3271 case Decl::TypeAliasTemplate:
3275 case Decl::Using: // using X; [C++]
3276 if (CGDebugInfo *DI = getModuleDebugInfo())
3277 DI->EmitUsingDecl(cast<UsingDecl>(*D));
3279 case Decl::NamespaceAlias:
3280 if (CGDebugInfo *DI = getModuleDebugInfo())
3281 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
3283 case Decl::UsingDirective: // using namespace X; [C++]
3284 if (CGDebugInfo *DI = getModuleDebugInfo())
3285 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
3287 case Decl::CXXConstructor:
3288 // Skip function templates
3289 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
3290 cast<FunctionDecl>(D)->isLateTemplateParsed())
3293 getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
3295 case Decl::CXXDestructor:
3296 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
3298 getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
3301 case Decl::StaticAssert:
3305 // Objective-C Decls
3307 // Forward declarations, no (immediate) code generation.
3308 case Decl::ObjCInterface:
3309 case Decl::ObjCCategory:
3312 case Decl::ObjCProtocol: {
3313 auto *Proto = cast<ObjCProtocolDecl>(D);
3314 if (Proto->isThisDeclarationADefinition())
3315 ObjCRuntime->GenerateProtocol(Proto);
3319 case Decl::ObjCCategoryImpl:
3320 // Categories have properties but don't support synthesize so we
3321 // can ignore them here.
3322 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
3325 case Decl::ObjCImplementation: {
3326 auto *OMD = cast<ObjCImplementationDecl>(D);
3327 EmitObjCPropertyImplementations(OMD);
3328 EmitObjCIvarInitializations(OMD);
3329 ObjCRuntime->GenerateClass(OMD);
3330 // Emit global variable debug information.
3331 if (CGDebugInfo *DI = getModuleDebugInfo())
3332 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
3333 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
3334 OMD->getClassInterface()), OMD->getLocation());
3337 case Decl::ObjCMethod: {
3338 auto *OMD = cast<ObjCMethodDecl>(D);
3339 // If this is not a prototype, emit the body.
3341 CodeGenFunction(*this).GenerateObjCMethod(OMD);
3344 case Decl::ObjCCompatibleAlias:
3345 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
3348 case Decl::LinkageSpec:
3349 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
3352 case Decl::FileScopeAsm: {
3353 // File-scope asm is ignored during device-side CUDA compilation.
3354 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
3356 auto *AD = cast<FileScopeAsmDecl>(D);
3357 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
3361 case Decl::Import: {
3362 auto *Import = cast<ImportDecl>(D);
3364 // Ignore import declarations that come from imported modules.
3365 if (clang::Module *Owner = Import->getImportedOwningModule()) {
3366 if (getLangOpts().CurrentModule.empty() ||
3367 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
3370 if (CGDebugInfo *DI = getModuleDebugInfo())
3371 DI->EmitImportDecl(*Import);
3373 ImportedModules.insert(Import->getImportedModule());
3377 case Decl::OMPThreadPrivate:
3378 EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D));
3381 case Decl::ClassTemplateSpecialization: {
3382 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
3384 Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
3385 Spec->hasDefinition())
3386 DebugInfo->completeTemplateDefinition(*Spec);
3391 // Make sure we handled everything we should, every other kind is a
3392 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
3393 // function. Need to recode Decl::Kind to do that easily.
3394 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
3399 void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) {
3400 // Do we need to generate coverage mapping?
3401 if (!CodeGenOpts.CoverageMapping)
3403 switch (D->getKind()) {
3404 case Decl::CXXConversion:
3405 case Decl::CXXMethod:
3406 case Decl::Function:
3407 case Decl::ObjCMethod:
3408 case Decl::CXXConstructor:
3409 case Decl::CXXDestructor: {
3410 if (!cast<FunctionDecl>(D)->hasBody())
3412 auto I = DeferredEmptyCoverageMappingDecls.find(D);
3413 if (I == DeferredEmptyCoverageMappingDecls.end())
3414 DeferredEmptyCoverageMappingDecls[D] = true;
3422 void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) {
3423 // Do we need to generate coverage mapping?
3424 if (!CodeGenOpts.CoverageMapping)
3426 if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
3427 if (Fn->isTemplateInstantiation())
3428 ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
3430 auto I = DeferredEmptyCoverageMappingDecls.find(D);
3431 if (I == DeferredEmptyCoverageMappingDecls.end())
3432 DeferredEmptyCoverageMappingDecls[D] = false;
3437 void CodeGenModule::EmitDeferredUnusedCoverageMappings() {
3438 std::vector<const Decl *> DeferredDecls;
3439 for (const auto &I : DeferredEmptyCoverageMappingDecls) {
3442 DeferredDecls.push_back(I.first);
3444 // Sort the declarations by their location to make sure that the tests get a
3445 // predictable order for the coverage mapping for the unused declarations.
3446 if (CodeGenOpts.DumpCoverageMapping)
3447 std::sort(DeferredDecls.begin(), DeferredDecls.end(),
3448 [] (const Decl *LHS, const Decl *RHS) {
3449 return LHS->getLocStart() < RHS->getLocStart();
3451 for (const auto *D : DeferredDecls) {
3452 switch (D->getKind()) {
3453 case Decl::CXXConversion:
3454 case Decl::CXXMethod:
3455 case Decl::Function:
3456 case Decl::ObjCMethod: {
3457 CodeGenPGO PGO(*this);
3458 GlobalDecl GD(cast<FunctionDecl>(D));
3459 PGO.emitEmptyCounterMapping(D, getMangledName(GD),
3460 getFunctionLinkage(GD));
3463 case Decl::CXXConstructor: {
3464 CodeGenPGO PGO(*this);
3465 GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
3466 PGO.emitEmptyCounterMapping(D, getMangledName(GD),
3467 getFunctionLinkage(GD));
3470 case Decl::CXXDestructor: {
3471 CodeGenPGO PGO(*this);
3472 GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
3473 PGO.emitEmptyCounterMapping(D, getMangledName(GD),
3474 getFunctionLinkage(GD));
3483 /// Turns the given pointer into a constant.
3484 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
3486 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
3487 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
3488 return llvm::ConstantInt::get(i64, PtrInt);
3491 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
3492 llvm::NamedMDNode *&GlobalMetadata,
3494 llvm::GlobalValue *Addr) {
3495 if (!GlobalMetadata)
3497 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
3499 // TODO: should we report variant information for ctors/dtors?
3500 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
3501 llvm::ConstantAsMetadata::get(GetPointerConstant(
3502 CGM.getLLVMContext(), D.getDecl()))};
3503 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
3506 /// For each function which is declared within an extern "C" region and marked
3507 /// as 'used', but has internal linkage, create an alias from the unmangled
3508 /// name to the mangled name if possible. People expect to be able to refer
3509 /// to such functions with an unmangled name from inline assembly within the
3510 /// same translation unit.
3511 void CodeGenModule::EmitStaticExternCAliases() {
3512 for (auto &I : StaticExternCValues) {
3513 IdentifierInfo *Name = I.first;
3514 llvm::GlobalValue *Val = I.second;
3515 if (Val && !getModule().getNamedValue(Name->getName()))
3516 addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val));
3520 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName,
3521 GlobalDecl &Result) const {
3522 auto Res = Manglings.find(MangledName);
3523 if (Res == Manglings.end())
3525 Result = Res->getValue();
3529 /// Emits metadata nodes associating all the global values in the
3530 /// current module with the Decls they came from. This is useful for
3531 /// projects using IR gen as a subroutine.
3533 /// Since there's currently no way to associate an MDNode directly
3534 /// with an llvm::GlobalValue, we create a global named metadata
3535 /// with the name 'clang.global.decl.ptrs'.
3536 void CodeGenModule::EmitDeclMetadata() {
3537 llvm::NamedMDNode *GlobalMetadata = nullptr;
3539 // StaticLocalDeclMap
3540 for (auto &I : MangledDeclNames) {
3541 llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
3542 EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
3546 /// Emits metadata nodes for all the local variables in the current
3548 void CodeGenFunction::EmitDeclMetadata() {
3549 if (LocalDeclMap.empty()) return;
3551 llvm::LLVMContext &Context = getLLVMContext();
3553 // Find the unique metadata ID for this name.
3554 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
3556 llvm::NamedMDNode *GlobalMetadata = nullptr;
3558 for (auto &I : LocalDeclMap) {
3559 const Decl *D = I.first;
3560 llvm::Value *Addr = I.second;
3561 if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
3562 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
3563 Alloca->setMetadata(
3564 DeclPtrKind, llvm::MDNode::get(
3565 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
3566 } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
3567 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
3568 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
3573 void CodeGenModule::EmitVersionIdentMetadata() {
3574 llvm::NamedMDNode *IdentMetadata =
3575 TheModule.getOrInsertNamedMetadata("llvm.ident");
3576 std::string Version = getClangFullVersion();
3577 llvm::LLVMContext &Ctx = TheModule.getContext();
3579 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
3580 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
3583 void CodeGenModule::EmitTargetMetadata() {
3584 // Warning, new MangledDeclNames may be appended within this loop.
3585 // We rely on MapVector insertions adding new elements to the end
3586 // of the container.
3587 // FIXME: Move this loop into the one target that needs it, and only
3588 // loop over those declarations for which we couldn't emit the target
3589 // metadata when we emitted the declaration.
3590 for (unsigned I = 0; I != MangledDeclNames.size(); ++I) {
3591 auto Val = *(MangledDeclNames.begin() + I);
3592 const Decl *D = Val.first.getDecl()->getMostRecentDecl();
3593 llvm::GlobalValue *GV = GetGlobalValue(Val.second);
3594 getTargetCodeGenInfo().emitTargetMD(D, GV, *this);
3598 void CodeGenModule::EmitCoverageFile() {
3599 if (!getCodeGenOpts().CoverageFile.empty()) {
3600 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
3601 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
3602 llvm::LLVMContext &Ctx = TheModule.getContext();
3603 llvm::MDString *CoverageFile =
3604 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
3605 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
3606 llvm::MDNode *CU = CUNode->getOperand(i);
3607 llvm::Metadata *Elts[] = {CoverageFile, CU};
3608 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
3614 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
3615 // Sema has checked that all uuid strings are of the form
3616 // "12345678-1234-1234-1234-1234567890ab".
3617 assert(Uuid.size() == 36);
3618 for (unsigned i = 0; i < 36; ++i) {
3619 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-');
3620 else assert(isHexDigit(Uuid[i]));
3623 // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab".
3624 const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
3626 llvm::Constant *Field3[8];
3627 for (unsigned Idx = 0; Idx < 8; ++Idx)
3628 Field3[Idx] = llvm::ConstantInt::get(
3629 Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
3631 llvm::Constant *Fields[4] = {
3632 llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16),
3633 llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16),
3634 llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
3635 llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3)
3638 return llvm::ConstantStruct::getAnon(Fields);
3642 CodeGenModule::getAddrOfCXXCatchHandlerType(QualType Ty,
3643 QualType CatchHandlerType) {
3644 return getCXXABI().getAddrOfCXXCatchHandlerType(Ty, CatchHandlerType);
3647 llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty,
3649 // Return a bogus pointer if RTTI is disabled, unless it's for EH.
3650 // FIXME: should we even be calling this method if RTTI is disabled
3651 // and it's not for EH?
3652 if (!ForEH && !getLangOpts().RTTI)
3653 return llvm::Constant::getNullValue(Int8PtrTy);
3655 if (ForEH && Ty->isObjCObjectPointerType() &&
3656 LangOpts.ObjCRuntime.isGNUFamily())
3657 return ObjCRuntime->GetEHType(Ty);
3659 return getCXXABI().getAddrOfRTTIDescriptor(Ty);
3662 void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
3663 for (auto RefExpr : D->varlists()) {
3664 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
3666 VD->getAnyInitializer() &&
3667 !VD->getAnyInitializer()->isConstantInitializer(getContext(),
3669 if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition(
3670 VD, GetAddrOfGlobalVar(VD), RefExpr->getLocStart(), PerformInit))
3671 CXXGlobalInits.push_back(InitFunction);
3675 llvm::MDTuple *CodeGenModule::CreateVTableBitSetEntry(
3676 llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD) {
3677 std::string OutName;
3678 llvm::raw_string_ostream Out(OutName);
3679 getCXXABI().getMangleContext().mangleCXXVTableBitSet(RD, Out);
3681 llvm::Metadata *BitsetOps[] = {
3682 llvm::MDString::get(getLLVMContext(), Out.str()),
3683 llvm::ConstantAsMetadata::get(VTable),
3684 llvm::ConstantAsMetadata::get(
3685 llvm::ConstantInt::get(Int64Ty, Offset.getQuantity()))};
3686 return llvm::MDTuple::get(getLLVMContext(), BitsetOps);