xref: /llvm-project/clang/lib/CodeGen/CodeGenModule.cpp (revision f353ae184877a2d78aaa1f63646709de54fa0e76)
1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This coordinates the per-module state used while generating code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenModule.h"
15 #include "CGBlocks.h"
16 #include "CGCUDARuntime.h"
17 #include "CGCXXABI.h"
18 #include "CGCall.h"
19 #include "CGDebugInfo.h"
20 #include "CGObjCRuntime.h"
21 #include "CGOpenCLRuntime.h"
22 #include "CGOpenMPRuntime.h"
23 #include "CGOpenMPRuntimeNVPTX.h"
24 #include "CodeGenFunction.h"
25 #include "CodeGenPGO.h"
26 #include "ConstantEmitter.h"
27 #include "CoverageMappingGen.h"
28 #include "TargetInfo.h"
29 #include "clang/AST/ASTContext.h"
30 #include "clang/AST/CharUnits.h"
31 #include "clang/AST/DeclCXX.h"
32 #include "clang/AST/DeclObjC.h"
33 #include "clang/AST/DeclTemplate.h"
34 #include "clang/AST/Mangle.h"
35 #include "clang/AST/RecordLayout.h"
36 #include "clang/AST/RecursiveASTVisitor.h"
37 #include "clang/Basic/Builtins.h"
38 #include "clang/Basic/CharInfo.h"
39 #include "clang/Basic/Diagnostic.h"
40 #include "clang/Basic/Module.h"
41 #include "clang/Basic/SourceManager.h"
42 #include "clang/Basic/TargetInfo.h"
43 #include "clang/Basic/Version.h"
44 #include "clang/CodeGen/ConstantInitBuilder.h"
45 #include "clang/Frontend/CodeGenOptions.h"
46 #include "clang/Sema/SemaDiagnostic.h"
47 #include "llvm/ADT/Triple.h"
48 #include "llvm/Analysis/TargetLibraryInfo.h"
49 #include "llvm/IR/CallSite.h"
50 #include "llvm/IR/CallingConv.h"
51 #include "llvm/IR/DataLayout.h"
52 #include "llvm/IR/Intrinsics.h"
53 #include "llvm/IR/LLVMContext.h"
54 #include "llvm/IR/Module.h"
55 #include "llvm/ProfileData/InstrProfReader.h"
56 #include "llvm/Support/ConvertUTF.h"
57 #include "llvm/Support/ErrorHandling.h"
58 #include "llvm/Support/MD5.h"
59 
60 using namespace clang;
61 using namespace CodeGen;
62 
63 static llvm::cl::opt<bool> LimitedCoverage(
64     "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
65     llvm::cl::desc("Emit limited coverage mapping information (experimental)"),
66     llvm::cl::init(false));
67 
68 static const char AnnotationSection[] = "llvm.metadata";
69 
70 static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
71   switch (CGM.getTarget().getCXXABI().getKind()) {
72   case TargetCXXABI::GenericAArch64:
73   case TargetCXXABI::GenericARM:
74   case TargetCXXABI::iOS:
75   case TargetCXXABI::iOS64:
76   case TargetCXXABI::WatchOS:
77   case TargetCXXABI::GenericMIPS:
78   case TargetCXXABI::GenericItanium:
79   case TargetCXXABI::WebAssembly:
80     return CreateItaniumCXXABI(CGM);
81   case TargetCXXABI::Microsoft:
82     return CreateMicrosoftCXXABI(CGM);
83   }
84 
85   llvm_unreachable("invalid C++ ABI kind");
86 }
87 
88 CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
89                              const PreprocessorOptions &PPO,
90                              const CodeGenOptions &CGO, llvm::Module &M,
91                              DiagnosticsEngine &diags,
92                              CoverageSourceInfo *CoverageInfo)
93     : Context(C), LangOpts(C.getLangOpts()), HeaderSearchOpts(HSO),
94       PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
95       Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
96       VMContext(M.getContext()), Types(*this), VTables(*this),
97       SanitizerMD(new SanitizerMetadata(*this)) {
98 
99   // Initialize the type cache.
100   llvm::LLVMContext &LLVMContext = M.getContext();
101   VoidTy = llvm::Type::getVoidTy(LLVMContext);
102   Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
103   Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
104   Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
105   Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
106   HalfTy = llvm::Type::getHalfTy(LLVMContext);
107   FloatTy = llvm::Type::getFloatTy(LLVMContext);
108   DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
109   PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
110   PointerAlignInBytes =
111     C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
112   SizeSizeInBytes =
113     C.toCharUnitsFromBits(C.getTargetInfo().getMaxPointerWidth()).getQuantity();
114   IntAlignInBytes =
115     C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity();
116   IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
117   IntPtrTy = llvm::IntegerType::get(LLVMContext,
118     C.getTargetInfo().getMaxPointerWidth());
119   Int8PtrTy = Int8Ty->getPointerTo(0);
120   Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
121   AllocaInt8PtrTy = Int8Ty->getPointerTo(
122       M.getDataLayout().getAllocaAddrSpace());
123   ASTAllocaAddressSpace = getTargetCodeGenInfo().getASTAllocaAddressSpace();
124 
125   RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
126 
127   if (LangOpts.ObjC1)
128     createObjCRuntime();
129   if (LangOpts.OpenCL)
130     createOpenCLRuntime();
131   if (LangOpts.OpenMP)
132     createOpenMPRuntime();
133   if (LangOpts.CUDA)
134     createCUDARuntime();
135 
136   // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
137   if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
138       (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
139     TBAA.reset(new CodeGenTBAA(Context, TheModule, CodeGenOpts, getLangOpts(),
140                                getCXXABI().getMangleContext()));
141 
142   // If debug info or coverage generation is enabled, create the CGDebugInfo
143   // object.
144   if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo ||
145       CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
146     DebugInfo.reset(new CGDebugInfo(*this));
147 
148   Block.GlobalUniqueCount = 0;
149 
150   if (C.getLangOpts().ObjC1)
151     ObjCData.reset(new ObjCEntrypoints());
152 
153   if (CodeGenOpts.hasProfileClangUse()) {
154     auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
155         CodeGenOpts.ProfileInstrumentUsePath);
156     if (auto E = ReaderOrErr.takeError()) {
157       unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
158                                               "Could not read profile %0: %1");
159       llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
160         getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath
161                                   << EI.message();
162       });
163     } else
164       PGOReader = std::move(ReaderOrErr.get());
165   }
166 
167   // If coverage mapping generation is enabled, create the
168   // CoverageMappingModuleGen object.
169   if (CodeGenOpts.CoverageMapping)
170     CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
171 }
172 
173 CodeGenModule::~CodeGenModule() {}
174 
175 void CodeGenModule::createObjCRuntime() {
176   // This is just isGNUFamily(), but we want to force implementors of
177   // new ABIs to decide how best to do this.
178   switch (LangOpts.ObjCRuntime.getKind()) {
179   case ObjCRuntime::GNUstep:
180   case ObjCRuntime::GCC:
181   case ObjCRuntime::ObjFW:
182     ObjCRuntime.reset(CreateGNUObjCRuntime(*this));
183     return;
184 
185   case ObjCRuntime::FragileMacOSX:
186   case ObjCRuntime::MacOSX:
187   case ObjCRuntime::iOS:
188   case ObjCRuntime::WatchOS:
189     ObjCRuntime.reset(CreateMacObjCRuntime(*this));
190     return;
191   }
192   llvm_unreachable("bad runtime kind");
193 }
194 
195 void CodeGenModule::createOpenCLRuntime() {
196   OpenCLRuntime.reset(new CGOpenCLRuntime(*this));
197 }
198 
199 void CodeGenModule::createOpenMPRuntime() {
200   // Select a specialized code generation class based on the target, if any.
201   // If it does not exist use the default implementation.
202   switch (getTriple().getArch()) {
203   case llvm::Triple::nvptx:
204   case llvm::Triple::nvptx64:
205     assert(getLangOpts().OpenMPIsDevice &&
206            "OpenMP NVPTX is only prepared to deal with device code.");
207     OpenMPRuntime.reset(new CGOpenMPRuntimeNVPTX(*this));
208     break;
209   default:
210     if (LangOpts.OpenMPSimd)
211       OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this));
212     else
213       OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
214     break;
215   }
216 }
217 
218 void CodeGenModule::createCUDARuntime() {
219   CUDARuntime.reset(CreateNVCUDARuntime(*this));
220 }
221 
222 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
223   Replacements[Name] = C;
224 }
225 
226 void CodeGenModule::applyReplacements() {
227   for (auto &I : Replacements) {
228     StringRef MangledName = I.first();
229     llvm::Constant *Replacement = I.second;
230     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
231     if (!Entry)
232       continue;
233     auto *OldF = cast<llvm::Function>(Entry);
234     auto *NewF = dyn_cast<llvm::Function>(Replacement);
235     if (!NewF) {
236       if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
237         NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
238       } else {
239         auto *CE = cast<llvm::ConstantExpr>(Replacement);
240         assert(CE->getOpcode() == llvm::Instruction::BitCast ||
241                CE->getOpcode() == llvm::Instruction::GetElementPtr);
242         NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
243       }
244     }
245 
246     // Replace old with new, but keep the old order.
247     OldF->replaceAllUsesWith(Replacement);
248     if (NewF) {
249       NewF->removeFromParent();
250       OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
251                                                        NewF);
252     }
253     OldF->eraseFromParent();
254   }
255 }
256 
257 void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
258   GlobalValReplacements.push_back(std::make_pair(GV, C));
259 }
260 
261 void CodeGenModule::applyGlobalValReplacements() {
262   for (auto &I : GlobalValReplacements) {
263     llvm::GlobalValue *GV = I.first;
264     llvm::Constant *C = I.second;
265 
266     GV->replaceAllUsesWith(C);
267     GV->eraseFromParent();
268   }
269 }
270 
271 // This is only used in aliases that we created and we know they have a
272 // linear structure.
273 static const llvm::GlobalObject *getAliasedGlobal(
274     const llvm::GlobalIndirectSymbol &GIS) {
275   llvm::SmallPtrSet<const llvm::GlobalIndirectSymbol*, 4> Visited;
276   const llvm::Constant *C = &GIS;
277   for (;;) {
278     C = C->stripPointerCasts();
279     if (auto *GO = dyn_cast<llvm::GlobalObject>(C))
280       return GO;
281     // stripPointerCasts will not walk over weak aliases.
282     auto *GIS2 = dyn_cast<llvm::GlobalIndirectSymbol>(C);
283     if (!GIS2)
284       return nullptr;
285     if (!Visited.insert(GIS2).second)
286       return nullptr;
287     C = GIS2->getIndirectSymbol();
288   }
289 }
290 
291 void CodeGenModule::checkAliases() {
292   // Check if the constructed aliases are well formed. It is really unfortunate
293   // that we have to do this in CodeGen, but we only construct mangled names
294   // and aliases during codegen.
295   bool Error = false;
296   DiagnosticsEngine &Diags = getDiags();
297   for (const GlobalDecl &GD : Aliases) {
298     const auto *D = cast<ValueDecl>(GD.getDecl());
299     SourceLocation Location;
300     bool IsIFunc = D->hasAttr<IFuncAttr>();
301     if (const Attr *A = D->getDefiningAttr())
302       Location = A->getLocation();
303     else
304       llvm_unreachable("Not an alias or ifunc?");
305     StringRef MangledName = getMangledName(GD);
306     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
307     auto *Alias  = cast<llvm::GlobalIndirectSymbol>(Entry);
308     const llvm::GlobalValue *GV = getAliasedGlobal(*Alias);
309     if (!GV) {
310       Error = true;
311       Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc;
312     } else if (GV->isDeclaration()) {
313       Error = true;
314       Diags.Report(Location, diag::err_alias_to_undefined)
315           << IsIFunc << IsIFunc;
316     } else if (IsIFunc) {
317       // Check resolver function type.
318       llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
319           GV->getType()->getPointerElementType());
320       assert(FTy);
321       if (!FTy->getReturnType()->isPointerTy())
322         Diags.Report(Location, diag::err_ifunc_resolver_return);
323       if (FTy->getNumParams())
324         Diags.Report(Location, diag::err_ifunc_resolver_params);
325     }
326 
327     llvm::Constant *Aliasee = Alias->getIndirectSymbol();
328     llvm::GlobalValue *AliaseeGV;
329     if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
330       AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
331     else
332       AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
333 
334     if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
335       StringRef AliasSection = SA->getName();
336       if (AliasSection != AliaseeGV->getSection())
337         Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
338             << AliasSection << IsIFunc << IsIFunc;
339     }
340 
341     // We have to handle alias to weak aliases in here. LLVM itself disallows
342     // this since the object semantics would not match the IL one. For
343     // compatibility with gcc we implement it by just pointing the alias
344     // to its aliasee's aliasee. We also warn, since the user is probably
345     // expecting the link to be weak.
346     if (auto GA = dyn_cast<llvm::GlobalIndirectSymbol>(AliaseeGV)) {
347       if (GA->isInterposable()) {
348         Diags.Report(Location, diag::warn_alias_to_weak_alias)
349             << GV->getName() << GA->getName() << IsIFunc;
350         Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
351             GA->getIndirectSymbol(), Alias->getType());
352         Alias->setIndirectSymbol(Aliasee);
353       }
354     }
355   }
356   if (!Error)
357     return;
358 
359   for (const GlobalDecl &GD : Aliases) {
360     StringRef MangledName = getMangledName(GD);
361     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
362     auto *Alias = dyn_cast<llvm::GlobalIndirectSymbol>(Entry);
363     Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
364     Alias->eraseFromParent();
365   }
366 }
367 
368 void CodeGenModule::clear() {
369   DeferredDeclsToEmit.clear();
370   if (OpenMPRuntime)
371     OpenMPRuntime->clear();
372 }
373 
374 void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags,
375                                        StringRef MainFile) {
376   if (!hasDiagnostics())
377     return;
378   if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
379     if (MainFile.empty())
380       MainFile = "<stdin>";
381     Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
382   } else {
383     if (Mismatched > 0)
384       Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
385 
386     if (Missing > 0)
387       Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
388   }
389 }
390 
391 void CodeGenModule::Release() {
392   EmitDeferred();
393   EmitVTablesOpportunistically();
394   applyGlobalValReplacements();
395   applyReplacements();
396   checkAliases();
397   emitMultiVersionFunctions();
398   EmitCXXGlobalInitFunc();
399   EmitCXXGlobalDtorFunc();
400   registerGlobalDtorsWithAtExit();
401   EmitCXXThreadLocalInitFunc();
402   if (ObjCRuntime)
403     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
404       AddGlobalCtor(ObjCInitFunction);
405   if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
406       CUDARuntime) {
407     if (llvm::Function *CudaCtorFunction =
408             CUDARuntime->makeModuleCtorFunction())
409       AddGlobalCtor(CudaCtorFunction);
410   }
411   if (OpenMPRuntime) {
412     if (llvm::Function *OpenMPRegistrationFunction =
413             OpenMPRuntime->emitRegistrationFunction()) {
414       auto ComdatKey = OpenMPRegistrationFunction->hasComdat() ?
415         OpenMPRegistrationFunction : nullptr;
416       AddGlobalCtor(OpenMPRegistrationFunction, 0, ComdatKey);
417     }
418     OpenMPRuntime->clear();
419   }
420   if (PGOReader) {
421     getModule().setProfileSummary(PGOReader->getSummary().getMD(VMContext));
422     if (PGOStats.hasDiagnostics())
423       PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
424   }
425   EmitCtorList(GlobalCtors, "llvm.global_ctors");
426   EmitCtorList(GlobalDtors, "llvm.global_dtors");
427   EmitGlobalAnnotations();
428   EmitStaticExternCAliases();
429   EmitDeferredUnusedCoverageMappings();
430   if (CoverageMapping)
431     CoverageMapping->emit();
432   if (CodeGenOpts.SanitizeCfiCrossDso) {
433     CodeGenFunction(*this).EmitCfiCheckFail();
434     CodeGenFunction(*this).EmitCfiCheckStub();
435   }
436   emitAtAvailableLinkGuard();
437   emitLLVMUsed();
438   if (SanStats)
439     SanStats->finish();
440 
441   if (CodeGenOpts.Autolink &&
442       (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
443     EmitModuleLinkOptions();
444   }
445 
446   // Record mregparm value now so it is visible through rest of codegen.
447   if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
448     getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
449                               CodeGenOpts.NumRegisterParameters);
450 
451   if (CodeGenOpts.DwarfVersion) {
452     // We actually want the latest version when there are conflicts.
453     // We can change from Warning to Latest if such mode is supported.
454     getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
455                               CodeGenOpts.DwarfVersion);
456   }
457   if (CodeGenOpts.EmitCodeView) {
458     // Indicate that we want CodeView in the metadata.
459     getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
460   }
461   if (CodeGenOpts.ControlFlowGuard) {
462     // We want function ID tables for Control Flow Guard.
463     getModule().addModuleFlag(llvm::Module::Warning, "cfguardtable", 1);
464   }
465   if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
466     // We don't support LTO with 2 with different StrictVTablePointers
467     // FIXME: we could support it by stripping all the information introduced
468     // by StrictVTablePointers.
469 
470     getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
471 
472     llvm::Metadata *Ops[2] = {
473               llvm::MDString::get(VMContext, "StrictVTablePointers"),
474               llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
475                   llvm::Type::getInt32Ty(VMContext), 1))};
476 
477     getModule().addModuleFlag(llvm::Module::Require,
478                               "StrictVTablePointersRequirement",
479                               llvm::MDNode::get(VMContext, Ops));
480   }
481   if (DebugInfo)
482     // We support a single version in the linked module. The LLVM
483     // parser will drop debug info with a different version number
484     // (and warn about it, too).
485     getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
486                               llvm::DEBUG_METADATA_VERSION);
487 
488   // We need to record the widths of enums and wchar_t, so that we can generate
489   // the correct build attributes in the ARM backend. wchar_size is also used by
490   // TargetLibraryInfo.
491   uint64_t WCharWidth =
492       Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
493   getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
494 
495   llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
496   if (   Arch == llvm::Triple::arm
497       || Arch == llvm::Triple::armeb
498       || Arch == llvm::Triple::thumb
499       || Arch == llvm::Triple::thumbeb) {
500     // The minimum width of an enum in bytes
501     uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
502     getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
503   }
504 
505   if (CodeGenOpts.SanitizeCfiCrossDso) {
506     // Indicate that we want cross-DSO control flow integrity checks.
507     getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
508   }
509 
510   if (CodeGenOpts.CFProtectionReturn &&
511       Target.checkCFProtectionReturnSupported(getDiags())) {
512     // Indicate that we want to instrument return control flow protection.
513     getModule().addModuleFlag(llvm::Module::Override, "cf-protection-return",
514                               1);
515   }
516 
517   if (CodeGenOpts.CFProtectionBranch &&
518       Target.checkCFProtectionBranchSupported(getDiags())) {
519     // Indicate that we want to instrument branch control flow protection.
520     getModule().addModuleFlag(llvm::Module::Override, "cf-protection-branch",
521                               1);
522   }
523 
524   if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
525     // Indicate whether __nvvm_reflect should be configured to flush denormal
526     // floating point values to 0.  (This corresponds to its "__CUDA_FTZ"
527     // property.)
528     getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
529                               CodeGenOpts.FlushDenorm ? 1 : 0);
530   }
531 
532   // Emit OpenCL specific module metadata: OpenCL/SPIR version.
533   if (LangOpts.OpenCL) {
534     EmitOpenCLMetadata();
535     // Emit SPIR version.
536     if (getTriple().getArch() == llvm::Triple::spir ||
537         getTriple().getArch() == llvm::Triple::spir64) {
538       // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the
539       // opencl.spir.version named metadata.
540       llvm::Metadata *SPIRVerElts[] = {
541           llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
542               Int32Ty, LangOpts.OpenCLVersion / 100)),
543           llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
544               Int32Ty, (LangOpts.OpenCLVersion / 100 > 1) ? 0 : 2))};
545       llvm::NamedMDNode *SPIRVerMD =
546           TheModule.getOrInsertNamedMetadata("opencl.spir.version");
547       llvm::LLVMContext &Ctx = TheModule.getContext();
548       SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
549     }
550   }
551 
552   if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
553     assert(PLevel < 3 && "Invalid PIC Level");
554     getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
555     if (Context.getLangOpts().PIE)
556       getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
557   }
558 
559   if (CodeGenOpts.NoPLT)
560     getModule().setRtLibUseGOT();
561 
562   SimplifyPersonality();
563 
564   if (getCodeGenOpts().EmitDeclMetadata)
565     EmitDeclMetadata();
566 
567   if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
568     EmitCoverageFile();
569 
570   if (DebugInfo)
571     DebugInfo->finalize();
572 
573   if (getCodeGenOpts().EmitVersionIdentMetadata)
574     EmitVersionIdentMetadata();
575 
576   EmitTargetMetadata();
577 }
578 
579 void CodeGenModule::EmitOpenCLMetadata() {
580   // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
581   // opencl.ocl.version named metadata node.
582   llvm::Metadata *OCLVerElts[] = {
583       llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
584           Int32Ty, LangOpts.OpenCLVersion / 100)),
585       llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
586           Int32Ty, (LangOpts.OpenCLVersion % 100) / 10))};
587   llvm::NamedMDNode *OCLVerMD =
588       TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
589   llvm::LLVMContext &Ctx = TheModule.getContext();
590   OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
591 }
592 
593 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
594   // Make sure that this type is translated.
595   Types.UpdateCompletedType(TD);
596 }
597 
598 void CodeGenModule::RefreshTypeCacheForClass(const CXXRecordDecl *RD) {
599   // Make sure that this type is translated.
600   Types.RefreshTypeCacheForClass(RD);
601 }
602 
603 llvm::MDNode *CodeGenModule::getTBAATypeInfo(QualType QTy) {
604   if (!TBAA)
605     return nullptr;
606   return TBAA->getTypeInfo(QTy);
607 }
608 
609 TBAAAccessInfo CodeGenModule::getTBAAAccessInfo(QualType AccessType) {
610   if (!TBAA)
611     return TBAAAccessInfo();
612   return TBAA->getAccessInfo(AccessType);
613 }
614 
615 TBAAAccessInfo
616 CodeGenModule::getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType) {
617   if (!TBAA)
618     return TBAAAccessInfo();
619   return TBAA->getVTablePtrAccessInfo(VTablePtrType);
620 }
621 
622 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
623   if (!TBAA)
624     return nullptr;
625   return TBAA->getTBAAStructInfo(QTy);
626 }
627 
628 llvm::MDNode *CodeGenModule::getTBAABaseTypeInfo(QualType QTy) {
629   if (!TBAA)
630     return nullptr;
631   return TBAA->getBaseTypeInfo(QTy);
632 }
633 
634 llvm::MDNode *CodeGenModule::getTBAAAccessTagInfo(TBAAAccessInfo Info) {
635   if (!TBAA)
636     return nullptr;
637   return TBAA->getAccessTagInfo(Info);
638 }
639 
640 TBAAAccessInfo CodeGenModule::mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo,
641                                                    TBAAAccessInfo TargetInfo) {
642   if (!TBAA)
643     return TBAAAccessInfo();
644   return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
645 }
646 
647 TBAAAccessInfo
648 CodeGenModule::mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA,
649                                                    TBAAAccessInfo InfoB) {
650   if (!TBAA)
651     return TBAAAccessInfo();
652   return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
653 }
654 
655 TBAAAccessInfo
656 CodeGenModule::mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo,
657                                               TBAAAccessInfo SrcInfo) {
658   if (!TBAA)
659     return TBAAAccessInfo();
660   return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
661 }
662 
663 void CodeGenModule::DecorateInstructionWithTBAA(llvm::Instruction *Inst,
664                                                 TBAAAccessInfo TBAAInfo) {
665   if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
666     Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
667 }
668 
669 void CodeGenModule::DecorateInstructionWithInvariantGroup(
670     llvm::Instruction *I, const CXXRecordDecl *RD) {
671   I->setMetadata(llvm::LLVMContext::MD_invariant_group,
672                  llvm::MDNode::get(getLLVMContext(), {}));
673 }
674 
675 void CodeGenModule::Error(SourceLocation loc, StringRef message) {
676   unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
677   getDiags().Report(Context.getFullLoc(loc), diagID) << message;
678 }
679 
680 /// ErrorUnsupported - Print out an error that codegen doesn't support the
681 /// specified stmt yet.
682 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
683   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
684                                                "cannot compile this %0 yet");
685   std::string Msg = Type;
686   getDiags().Report(Context.getFullLoc(S->getBeginLoc()), DiagID)
687       << Msg << S->getSourceRange();
688 }
689 
690 /// ErrorUnsupported - Print out an error that codegen doesn't support the
691 /// specified decl yet.
692 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
693   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
694                                                "cannot compile this %0 yet");
695   std::string Msg = Type;
696   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
697 }
698 
699 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
700   return llvm::ConstantInt::get(SizeTy, size.getQuantity());
701 }
702 
703 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
704                                         const NamedDecl *D) const {
705   if (GV->hasDLLImportStorageClass())
706     return;
707   // Internal definitions always have default visibility.
708   if (GV->hasLocalLinkage()) {
709     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
710     return;
711   }
712   if (!D)
713     return;
714   // Set visibility for definitions.
715   LinkageInfo LV = D->getLinkageAndVisibility();
716   if (LV.isVisibilityExplicit() || !GV->isDeclarationForLinker())
717     GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
718 }
719 
720 static bool shouldAssumeDSOLocal(const CodeGenModule &CGM,
721                                  llvm::GlobalValue *GV) {
722   if (GV->hasLocalLinkage())
723     return true;
724 
725   if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
726     return true;
727 
728   // DLLImport explicitly marks the GV as external.
729   if (GV->hasDLLImportStorageClass())
730     return false;
731 
732   const llvm::Triple &TT = CGM.getTriple();
733   if (TT.isWindowsGNUEnvironment()) {
734     // In MinGW, variables without DLLImport can still be automatically
735     // imported from a DLL by the linker; don't mark variables that
736     // potentially could come from another DLL as DSO local.
737     if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
738         !GV->isThreadLocal())
739       return false;
740   }
741   // Every other GV is local on COFF.
742   // Make an exception for windows OS in the triple: Some firmware builds use
743   // *-win32-macho triples. This (accidentally?) produced windows relocations
744   // without GOT tables in older clang versions; Keep this behaviour.
745   // FIXME: even thread local variables?
746   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
747     return true;
748 
749   // Only handle COFF and ELF for now.
750   if (!TT.isOSBinFormatELF())
751     return false;
752 
753   // If this is not an executable, don't assume anything is local.
754   const auto &CGOpts = CGM.getCodeGenOpts();
755   llvm::Reloc::Model RM = CGOpts.RelocationModel;
756   const auto &LOpts = CGM.getLangOpts();
757   if (RM != llvm::Reloc::Static && !LOpts.PIE)
758     return false;
759 
760   // A definition cannot be preempted from an executable.
761   if (!GV->isDeclarationForLinker())
762     return true;
763 
764   // Most PIC code sequences that assume that a symbol is local cannot produce a
765   // 0 if it turns out the symbol is undefined. While this is ABI and relocation
766   // depended, it seems worth it to handle it here.
767   if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
768     return false;
769 
770   // PPC has no copy relocations and cannot use a plt entry as a symbol address.
771   llvm::Triple::ArchType Arch = TT.getArch();
772   if (Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
773       Arch == llvm::Triple::ppc64le)
774     return false;
775 
776   // If we can use copy relocations we can assume it is local.
777   if (auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
778     if (!Var->isThreadLocal() &&
779         (RM == llvm::Reloc::Static || CGOpts.PIECopyRelocations))
780       return true;
781 
782   // If we can use a plt entry as the symbol address we can assume it
783   // is local.
784   // FIXME: This should work for PIE, but the gold linker doesn't support it.
785   if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
786     return true;
787 
788   // Otherwise don't assue it is local.
789   return false;
790 }
791 
792 void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const {
793   GV->setDSOLocal(shouldAssumeDSOLocal(*this, GV));
794 }
795 
796 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
797                                           GlobalDecl GD) const {
798   const auto *D = dyn_cast<NamedDecl>(GD.getDecl());
799   // C++ destructors have a few C++ ABI specific special cases.
800   if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
801     getCXXABI().setCXXDestructorDLLStorage(GV, Dtor, GD.getDtorType());
802     return;
803   }
804   setDLLImportDLLExport(GV, D);
805 }
806 
807 void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
808                                           const NamedDecl *D) const {
809   if (D && D->isExternallyVisible()) {
810     if (D->hasAttr<DLLImportAttr>())
811       GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
812     else if (D->hasAttr<DLLExportAttr>() && !GV->isDeclarationForLinker())
813       GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
814   }
815 }
816 
817 void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
818                                     GlobalDecl GD) const {
819   setDLLImportDLLExport(GV, GD);
820   setGlobalVisibilityAndLocal(GV, dyn_cast<NamedDecl>(GD.getDecl()));
821 }
822 
823 void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
824                                     const NamedDecl *D) const {
825   setDLLImportDLLExport(GV, D);
826   setGlobalVisibilityAndLocal(GV, D);
827 }
828 
829 void CodeGenModule::setGlobalVisibilityAndLocal(llvm::GlobalValue *GV,
830                                                 const NamedDecl *D) const {
831   setGlobalVisibility(GV, D);
832   setDSOLocal(GV);
833 }
834 
835 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
836   return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
837       .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
838       .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
839       .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
840       .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
841 }
842 
843 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
844     CodeGenOptions::TLSModel M) {
845   switch (M) {
846   case CodeGenOptions::GeneralDynamicTLSModel:
847     return llvm::GlobalVariable::GeneralDynamicTLSModel;
848   case CodeGenOptions::LocalDynamicTLSModel:
849     return llvm::GlobalVariable::LocalDynamicTLSModel;
850   case CodeGenOptions::InitialExecTLSModel:
851     return llvm::GlobalVariable::InitialExecTLSModel;
852   case CodeGenOptions::LocalExecTLSModel:
853     return llvm::GlobalVariable::LocalExecTLSModel;
854   }
855   llvm_unreachable("Invalid TLS model!");
856 }
857 
858 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
859   assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
860 
861   llvm::GlobalValue::ThreadLocalMode TLM;
862   TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
863 
864   // Override the TLS model if it is explicitly specified.
865   if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
866     TLM = GetLLVMTLSModel(Attr->getModel());
867   }
868 
869   GV->setThreadLocalMode(TLM);
870 }
871 
872 static std::string getCPUSpecificMangling(const CodeGenModule &CGM,
873                                           StringRef Name) {
874   const TargetInfo &Target = CGM.getTarget();
875   return (Twine('.') + Twine(Target.CPUSpecificManglingCharacter(Name))).str();
876 }
877 
878 static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM,
879                                                  const CPUSpecificAttr *Attr,
880                                                  raw_ostream &Out) {
881   // cpu_specific gets the current name, dispatch gets the resolver.
882   if (Attr)
883     Out << getCPUSpecificMangling(CGM, Attr->getCurCPUName()->getName());
884   else
885     Out << ".resolver";
886 }
887 
888 static void AppendTargetMangling(const CodeGenModule &CGM,
889                                  const TargetAttr *Attr, raw_ostream &Out) {
890   if (Attr->isDefaultVersion())
891     return;
892 
893   Out << '.';
894   const TargetInfo &Target = CGM.getTarget();
895   TargetAttr::ParsedTargetAttr Info =
896       Attr->parse([&Target](StringRef LHS, StringRef RHS) {
897         // Multiversioning doesn't allow "no-${feature}", so we can
898         // only have "+" prefixes here.
899         assert(LHS.startswith("+") && RHS.startswith("+") &&
900                "Features should always have a prefix.");
901         return Target.multiVersionSortPriority(LHS.substr(1)) >
902                Target.multiVersionSortPriority(RHS.substr(1));
903       });
904 
905   bool IsFirst = true;
906 
907   if (!Info.Architecture.empty()) {
908     IsFirst = false;
909     Out << "arch_" << Info.Architecture;
910   }
911 
912   for (StringRef Feat : Info.Features) {
913     if (!IsFirst)
914       Out << '_';
915     IsFirst = false;
916     Out << Feat.substr(1);
917   }
918 }
919 
920 static std::string getMangledNameImpl(const CodeGenModule &CGM, GlobalDecl GD,
921                                       const NamedDecl *ND,
922                                       bool OmitMultiVersionMangling = false) {
923   SmallString<256> Buffer;
924   llvm::raw_svector_ostream Out(Buffer);
925   MangleContext &MC = CGM.getCXXABI().getMangleContext();
926   if (MC.shouldMangleDeclName(ND)) {
927     llvm::raw_svector_ostream Out(Buffer);
928     if (const auto *D = dyn_cast<CXXConstructorDecl>(ND))
929       MC.mangleCXXCtor(D, GD.getCtorType(), Out);
930     else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND))
931       MC.mangleCXXDtor(D, GD.getDtorType(), Out);
932     else
933       MC.mangleName(ND, Out);
934   } else {
935     IdentifierInfo *II = ND->getIdentifier();
936     assert(II && "Attempt to mangle unnamed decl.");
937     const auto *FD = dyn_cast<FunctionDecl>(ND);
938 
939     if (FD &&
940         FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
941       llvm::raw_svector_ostream Out(Buffer);
942       Out << "__regcall3__" << II->getName();
943     } else {
944       Out << II->getName();
945     }
946   }
947 
948   if (const auto *FD = dyn_cast<FunctionDecl>(ND))
949     if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
950       if (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion())
951         AppendCPUSpecificCPUDispatchMangling(
952             CGM, FD->getAttr<CPUSpecificAttr>(), Out);
953       else
954         AppendTargetMangling(CGM, FD->getAttr<TargetAttr>(), Out);
955     }
956 
957   return Out.str();
958 }
959 
960 void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD,
961                                             const FunctionDecl *FD) {
962   if (!FD->isMultiVersion())
963     return;
964 
965   // Get the name of what this would be without the 'target' attribute.  This
966   // allows us to lookup the version that was emitted when this wasn't a
967   // multiversion function.
968   std::string NonTargetName =
969       getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
970   GlobalDecl OtherGD;
971   if (lookupRepresentativeDecl(NonTargetName, OtherGD)) {
972     assert(OtherGD.getCanonicalDecl()
973                .getDecl()
974                ->getAsFunction()
975                ->isMultiVersion() &&
976            "Other GD should now be a multiversioned function");
977     // OtherFD is the version of this function that was mangled BEFORE
978     // becoming a MultiVersion function.  It potentially needs to be updated.
979     const FunctionDecl *OtherFD =
980         OtherGD.getCanonicalDecl().getDecl()->getAsFunction();
981     std::string OtherName = getMangledNameImpl(*this, OtherGD, OtherFD);
982     // This is so that if the initial version was already the 'default'
983     // version, we don't try to update it.
984     if (OtherName != NonTargetName) {
985       // Remove instead of erase, since others may have stored the StringRef
986       // to this.
987       const auto ExistingRecord = Manglings.find(NonTargetName);
988       if (ExistingRecord != std::end(Manglings))
989         Manglings.remove(&(*ExistingRecord));
990       auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
991       MangledDeclNames[OtherGD.getCanonicalDecl()] = Result.first->first();
992       if (llvm::GlobalValue *Entry = GetGlobalValue(NonTargetName))
993         Entry->setName(OtherName);
994     }
995   }
996 }
997 
998 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
999   GlobalDecl CanonicalGD = GD.getCanonicalDecl();
1000 
1001   // Some ABIs don't have constructor variants.  Make sure that base and
1002   // complete constructors get mangled the same.
1003   if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) {
1004     if (!getTarget().getCXXABI().hasConstructorVariants()) {
1005       CXXCtorType OrigCtorType = GD.getCtorType();
1006       assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete);
1007       if (OrigCtorType == Ctor_Base)
1008         CanonicalGD = GlobalDecl(CD, Ctor_Complete);
1009     }
1010   }
1011 
1012   const auto *FD = dyn_cast<FunctionDecl>(GD.getDecl());
1013   // Since CPUSpecific can require multiple emits per decl, store the manglings
1014   // separately.
1015   if (FD &&
1016       (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion())) {
1017     const auto *SD = FD->getAttr<CPUSpecificAttr>();
1018 
1019     std::pair<GlobalDecl, unsigned> SpecCanonicalGD{
1020         CanonicalGD,
1021         SD ? SD->ActiveArgIndex : std::numeric_limits<unsigned>::max()};
1022 
1023     auto FoundName = CPUSpecificMangledDeclNames.find(SpecCanonicalGD);
1024     if (FoundName != CPUSpecificMangledDeclNames.end())
1025       return FoundName->second;
1026 
1027     auto Result = CPUSpecificManglings.insert(
1028         std::make_pair(getMangledNameImpl(*this, GD, FD), SpecCanonicalGD));
1029     return CPUSpecificMangledDeclNames[SpecCanonicalGD] = Result.first->first();
1030   }
1031 
1032   auto FoundName = MangledDeclNames.find(CanonicalGD);
1033   if (FoundName != MangledDeclNames.end())
1034     return FoundName->second;
1035 
1036   // Keep the first result in the case of a mangling collision.
1037   const auto *ND = cast<NamedDecl>(GD.getDecl());
1038   auto Result =
1039       Manglings.insert(std::make_pair(getMangledNameImpl(*this, GD, ND), GD));
1040   return MangledDeclNames[CanonicalGD] = Result.first->first();
1041 }
1042 
1043 StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD,
1044                                              const BlockDecl *BD) {
1045   MangleContext &MangleCtx = getCXXABI().getMangleContext();
1046   const Decl *D = GD.getDecl();
1047 
1048   SmallString<256> Buffer;
1049   llvm::raw_svector_ostream Out(Buffer);
1050   if (!D)
1051     MangleCtx.mangleGlobalBlock(BD,
1052       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
1053   else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1054     MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
1055   else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1056     MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
1057   else
1058     MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
1059 
1060   auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
1061   return Result.first->first();
1062 }
1063 
1064 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
1065   return getModule().getNamedValue(Name);
1066 }
1067 
1068 /// AddGlobalCtor - Add a function to the list that will be called before
1069 /// main() runs.
1070 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
1071                                   llvm::Constant *AssociatedData) {
1072   // FIXME: Type coercion of void()* types.
1073   GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
1074 }
1075 
1076 /// AddGlobalDtor - Add a function to the list that will be called
1077 /// when the module is unloaded.
1078 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
1079   if (CodeGenOpts.RegisterGlobalDtorsWithAtExit) {
1080     DtorsUsingAtExit[Priority].push_back(Dtor);
1081     return;
1082   }
1083 
1084   // FIXME: Type coercion of void()* types.
1085   GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
1086 }
1087 
1088 void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
1089   if (Fns.empty()) return;
1090 
1091   // Ctor function type is void()*.
1092   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
1093   llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
1094 
1095   // Get the type of a ctor entry, { i32, void ()*, i8* }.
1096   llvm::StructType *CtorStructTy = llvm::StructType::get(
1097       Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy);
1098 
1099   // Construct the constructor and destructor arrays.
1100   ConstantInitBuilder builder(*this);
1101   auto ctors = builder.beginArray(CtorStructTy);
1102   for (const auto &I : Fns) {
1103     auto ctor = ctors.beginStruct(CtorStructTy);
1104     ctor.addInt(Int32Ty, I.Priority);
1105     ctor.add(llvm::ConstantExpr::getBitCast(I.Initializer, CtorPFTy));
1106     if (I.AssociatedData)
1107       ctor.add(llvm::ConstantExpr::getBitCast(I.AssociatedData, VoidPtrTy));
1108     else
1109       ctor.addNullPointer(VoidPtrTy);
1110     ctor.finishAndAddTo(ctors);
1111   }
1112 
1113   auto list =
1114     ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(),
1115                                 /*constant*/ false,
1116                                 llvm::GlobalValue::AppendingLinkage);
1117 
1118   // The LTO linker doesn't seem to like it when we set an alignment
1119   // on appending variables.  Take it off as a workaround.
1120   list->setAlignment(0);
1121 
1122   Fns.clear();
1123 }
1124 
1125 llvm::GlobalValue::LinkageTypes
1126 CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
1127   const auto *D = cast<FunctionDecl>(GD.getDecl());
1128 
1129   GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
1130 
1131   if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
1132     return getCXXABI().getCXXDestructorLinkage(Linkage, Dtor, GD.getDtorType());
1133 
1134   if (isa<CXXConstructorDecl>(D) &&
1135       cast<CXXConstructorDecl>(D)->isInheritingConstructor() &&
1136       Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1137     // Our approach to inheriting constructors is fundamentally different from
1138     // that used by the MS ABI, so keep our inheriting constructor thunks
1139     // internal rather than trying to pick an unambiguous mangling for them.
1140     return llvm::GlobalValue::InternalLinkage;
1141   }
1142 
1143   return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false);
1144 }
1145 
1146 llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
1147   llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
1148   if (!MDS) return nullptr;
1149 
1150   return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
1151 }
1152 
1153 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
1154                                               const CGFunctionInfo &Info,
1155                                               llvm::Function *F) {
1156   unsigned CallingConv;
1157   llvm::AttributeList PAL;
1158   ConstructAttributeList(F->getName(), Info, D, PAL, CallingConv, false);
1159   F->setAttributes(PAL);
1160   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
1161 }
1162 
1163 /// Determines whether the language options require us to model
1164 /// unwind exceptions.  We treat -fexceptions as mandating this
1165 /// except under the fragile ObjC ABI with only ObjC exceptions
1166 /// enabled.  This means, for example, that C with -fexceptions
1167 /// enables this.
1168 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
1169   // If exceptions are completely disabled, obviously this is false.
1170   if (!LangOpts.Exceptions) return false;
1171 
1172   // If C++ exceptions are enabled, this is true.
1173   if (LangOpts.CXXExceptions) return true;
1174 
1175   // If ObjC exceptions are enabled, this depends on the ABI.
1176   if (LangOpts.ObjCExceptions) {
1177     return LangOpts.ObjCRuntime.hasUnwindExceptions();
1178   }
1179 
1180   return true;
1181 }
1182 
1183 static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM,
1184                                                       const CXXMethodDecl *MD) {
1185   // Check that the type metadata can ever actually be used by a call.
1186   if (!CGM.getCodeGenOpts().LTOUnit ||
1187       !CGM.HasHiddenLTOVisibility(MD->getParent()))
1188     return false;
1189 
1190   // Only functions whose address can be taken with a member function pointer
1191   // need this sort of type metadata.
1192   return !MD->isStatic() && !MD->isVirtual() && !isa<CXXConstructorDecl>(MD) &&
1193          !isa<CXXDestructorDecl>(MD);
1194 }
1195 
1196 std::vector<const CXXRecordDecl *>
1197 CodeGenModule::getMostBaseClasses(const CXXRecordDecl *RD) {
1198   llvm::SetVector<const CXXRecordDecl *> MostBases;
1199 
1200   std::function<void (const CXXRecordDecl *)> CollectMostBases;
1201   CollectMostBases = [&](const CXXRecordDecl *RD) {
1202     if (RD->getNumBases() == 0)
1203       MostBases.insert(RD);
1204     for (const CXXBaseSpecifier &B : RD->bases())
1205       CollectMostBases(B.getType()->getAsCXXRecordDecl());
1206   };
1207   CollectMostBases(RD);
1208   return MostBases.takeVector();
1209 }
1210 
1211 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
1212                                                            llvm::Function *F) {
1213   llvm::AttrBuilder B;
1214 
1215   if (CodeGenOpts.UnwindTables)
1216     B.addAttribute(llvm::Attribute::UWTable);
1217 
1218   if (!hasUnwindExceptions(LangOpts))
1219     B.addAttribute(llvm::Attribute::NoUnwind);
1220 
1221   if (!D || !D->hasAttr<NoStackProtectorAttr>()) {
1222     if (LangOpts.getStackProtector() == LangOptions::SSPOn)
1223       B.addAttribute(llvm::Attribute::StackProtect);
1224     else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
1225       B.addAttribute(llvm::Attribute::StackProtectStrong);
1226     else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
1227       B.addAttribute(llvm::Attribute::StackProtectReq);
1228   }
1229 
1230   if (!D) {
1231     // If we don't have a declaration to control inlining, the function isn't
1232     // explicitly marked as alwaysinline for semantic reasons, and inlining is
1233     // disabled, mark the function as noinline.
1234     if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1235         CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
1236       B.addAttribute(llvm::Attribute::NoInline);
1237 
1238     F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1239     return;
1240   }
1241 
1242   // Track whether we need to add the optnone LLVM attribute,
1243   // starting with the default for this optimization level.
1244   bool ShouldAddOptNone =
1245       !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
1246   // We can't add optnone in the following cases, it won't pass the verifier.
1247   ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
1248   ShouldAddOptNone &= !F->hasFnAttribute(llvm::Attribute::AlwaysInline);
1249   ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
1250 
1251   if (ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) {
1252     B.addAttribute(llvm::Attribute::OptimizeNone);
1253 
1254     // OptimizeNone implies noinline; we should not be inlining such functions.
1255     B.addAttribute(llvm::Attribute::NoInline);
1256     assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
1257            "OptimizeNone and AlwaysInline on same function!");
1258 
1259     // We still need to handle naked functions even though optnone subsumes
1260     // much of their semantics.
1261     if (D->hasAttr<NakedAttr>())
1262       B.addAttribute(llvm::Attribute::Naked);
1263 
1264     // OptimizeNone wins over OptimizeForSize and MinSize.
1265     F->removeFnAttr(llvm::Attribute::OptimizeForSize);
1266     F->removeFnAttr(llvm::Attribute::MinSize);
1267   } else if (D->hasAttr<NakedAttr>()) {
1268     // Naked implies noinline: we should not be inlining such functions.
1269     B.addAttribute(llvm::Attribute::Naked);
1270     B.addAttribute(llvm::Attribute::NoInline);
1271   } else if (D->hasAttr<NoDuplicateAttr>()) {
1272     B.addAttribute(llvm::Attribute::NoDuplicate);
1273   } else if (D->hasAttr<NoInlineAttr>()) {
1274     B.addAttribute(llvm::Attribute::NoInline);
1275   } else if (D->hasAttr<AlwaysInlineAttr>() &&
1276              !F->hasFnAttribute(llvm::Attribute::NoInline)) {
1277     // (noinline wins over always_inline, and we can't specify both in IR)
1278     B.addAttribute(llvm::Attribute::AlwaysInline);
1279   } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) {
1280     // If we're not inlining, then force everything that isn't always_inline to
1281     // carry an explicit noinline attribute.
1282     if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
1283       B.addAttribute(llvm::Attribute::NoInline);
1284   } else {
1285     // Otherwise, propagate the inline hint attribute and potentially use its
1286     // absence to mark things as noinline.
1287     if (auto *FD = dyn_cast<FunctionDecl>(D)) {
1288       if (any_of(FD->redecls(), [&](const FunctionDecl *Redecl) {
1289             return Redecl->isInlineSpecified();
1290           })) {
1291         B.addAttribute(llvm::Attribute::InlineHint);
1292       } else if (CodeGenOpts.getInlining() ==
1293                      CodeGenOptions::OnlyHintInlining &&
1294                  !FD->isInlined() &&
1295                  !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
1296         B.addAttribute(llvm::Attribute::NoInline);
1297       }
1298     }
1299   }
1300 
1301   // Add other optimization related attributes if we are optimizing this
1302   // function.
1303   if (!D->hasAttr<OptimizeNoneAttr>()) {
1304     if (D->hasAttr<ColdAttr>()) {
1305       if (!ShouldAddOptNone)
1306         B.addAttribute(llvm::Attribute::OptimizeForSize);
1307       B.addAttribute(llvm::Attribute::Cold);
1308     }
1309 
1310     if (D->hasAttr<MinSizeAttr>())
1311       B.addAttribute(llvm::Attribute::MinSize);
1312   }
1313 
1314   F->addAttributes(llvm::AttributeList::FunctionIndex, B);
1315 
1316   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
1317   if (alignment)
1318     F->setAlignment(alignment);
1319 
1320   if (!D->hasAttr<AlignedAttr>())
1321     if (LangOpts.FunctionAlignment)
1322       F->setAlignment(1 << LangOpts.FunctionAlignment);
1323 
1324   // Some C++ ABIs require 2-byte alignment for member functions, in order to
1325   // reserve a bit for differentiating between virtual and non-virtual member
1326   // functions. If the current target's C++ ABI requires this and this is a
1327   // member function, set its alignment accordingly.
1328   if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
1329     if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
1330       F->setAlignment(2);
1331   }
1332 
1333   // In the cross-dso CFI mode, we want !type attributes on definitions only.
1334   if (CodeGenOpts.SanitizeCfiCrossDso)
1335     if (auto *FD = dyn_cast<FunctionDecl>(D))
1336       CreateFunctionTypeMetadataForIcall(FD, F);
1337 
1338   // Emit type metadata on member functions for member function pointer checks.
1339   // These are only ever necessary on definitions; we're guaranteed that the
1340   // definition will be present in the LTO unit as a result of LTO visibility.
1341   auto *MD = dyn_cast<CXXMethodDecl>(D);
1342   if (MD && requiresMemberFunctionPointerTypeMetadata(*this, MD)) {
1343     for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) {
1344       llvm::Metadata *Id =
1345           CreateMetadataIdentifierForType(Context.getMemberPointerType(
1346               MD->getType(), Context.getRecordType(Base).getTypePtr()));
1347       F->addTypeMetadata(0, Id);
1348     }
1349   }
1350 }
1351 
1352 void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) {
1353   const Decl *D = GD.getDecl();
1354   if (dyn_cast_or_null<NamedDecl>(D))
1355     setGVProperties(GV, GD);
1356   else
1357     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1358 
1359   if (D && D->hasAttr<UsedAttr>())
1360     addUsedGlobal(GV);
1361 
1362   if (CodeGenOpts.KeepStaticConsts && D && isa<VarDecl>(D)) {
1363     const auto *VD = cast<VarDecl>(D);
1364     if (VD->getType().isConstQualified() && VD->getStorageClass() == SC_Static)
1365       addUsedGlobal(GV);
1366   }
1367 }
1368 
1369 bool CodeGenModule::GetCPUAndFeaturesAttributes(const Decl *D,
1370                                                 llvm::AttrBuilder &Attrs) {
1371   // Add target-cpu and target-features attributes to functions. If
1372   // we have a decl for the function and it has a target attribute then
1373   // parse that and add it to the feature set.
1374   StringRef TargetCPU = getTarget().getTargetOpts().CPU;
1375   std::vector<std::string> Features;
1376   const auto *FD = dyn_cast_or_null<FunctionDecl>(D);
1377   FD = FD ? FD->getMostRecentDecl() : FD;
1378   const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr;
1379   const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() : nullptr;
1380   bool AddedAttr = false;
1381   if (TD || SD) {
1382     llvm::StringMap<bool> FeatureMap;
1383     getFunctionFeatureMap(FeatureMap, FD);
1384 
1385     // Produce the canonical string for this set of features.
1386     for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
1387       Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
1388 
1389     // Now add the target-cpu and target-features to the function.
1390     // While we populated the feature map above, we still need to
1391     // get and parse the target attribute so we can get the cpu for
1392     // the function.
1393     if (TD) {
1394       TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
1395       if (ParsedAttr.Architecture != "" &&
1396           getTarget().isValidCPUName(ParsedAttr.Architecture))
1397         TargetCPU = ParsedAttr.Architecture;
1398     }
1399   } else {
1400     // Otherwise just add the existing target cpu and target features to the
1401     // function.
1402     Features = getTarget().getTargetOpts().Features;
1403   }
1404 
1405   if (TargetCPU != "") {
1406     Attrs.addAttribute("target-cpu", TargetCPU);
1407     AddedAttr = true;
1408   }
1409   if (!Features.empty()) {
1410     llvm::sort(Features.begin(), Features.end());
1411     Attrs.addAttribute("target-features", llvm::join(Features, ","));
1412     AddedAttr = true;
1413   }
1414 
1415   return AddedAttr;
1416 }
1417 
1418 void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
1419                                           llvm::GlobalObject *GO) {
1420   const Decl *D = GD.getDecl();
1421   SetCommonAttributes(GD, GO);
1422 
1423   if (D) {
1424     if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
1425       if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
1426         GV->addAttribute("bss-section", SA->getName());
1427       if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
1428         GV->addAttribute("data-section", SA->getName());
1429       if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
1430         GV->addAttribute("rodata-section", SA->getName());
1431     }
1432 
1433     if (auto *F = dyn_cast<llvm::Function>(GO)) {
1434       if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
1435         if (!D->getAttr<SectionAttr>())
1436           F->addFnAttr("implicit-section-name", SA->getName());
1437 
1438       llvm::AttrBuilder Attrs;
1439       if (GetCPUAndFeaturesAttributes(D, Attrs)) {
1440         // We know that GetCPUAndFeaturesAttributes will always have the
1441         // newest set, since it has the newest possible FunctionDecl, so the
1442         // new ones should replace the old.
1443         F->removeFnAttr("target-cpu");
1444         F->removeFnAttr("target-features");
1445         F->addAttributes(llvm::AttributeList::FunctionIndex, Attrs);
1446       }
1447     }
1448 
1449     if (const auto *CSA = D->getAttr<CodeSegAttr>())
1450       GO->setSection(CSA->getName());
1451     else if (const auto *SA = D->getAttr<SectionAttr>())
1452       GO->setSection(SA->getName());
1453   }
1454 
1455   getTargetCodeGenInfo().setTargetAttributes(D, GO, *this);
1456 }
1457 
1458 void CodeGenModule::SetInternalFunctionAttributes(GlobalDecl GD,
1459                                                   llvm::Function *F,
1460                                                   const CGFunctionInfo &FI) {
1461   const Decl *D = GD.getDecl();
1462   SetLLVMFunctionAttributes(D, FI, F);
1463   SetLLVMFunctionAttributesForDefinition(D, F);
1464 
1465   F->setLinkage(llvm::Function::InternalLinkage);
1466 
1467   setNonAliasAttributes(GD, F);
1468 }
1469 
1470 static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) {
1471   // Set linkage and visibility in case we never see a definition.
1472   LinkageInfo LV = ND->getLinkageAndVisibility();
1473   // Don't set internal linkage on declarations.
1474   // "extern_weak" is overloaded in LLVM; we probably should have
1475   // separate linkage types for this.
1476   if (isExternallyVisible(LV.getLinkage()) &&
1477       (ND->hasAttr<WeakAttr>() || ND->isWeakImported()))
1478     GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1479 }
1480 
1481 void CodeGenModule::CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD,
1482                                                        llvm::Function *F) {
1483   // Only if we are checking indirect calls.
1484   if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
1485     return;
1486 
1487   // Non-static class methods are handled via vtable or member function pointer
1488   // checks elsewhere.
1489   if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
1490     return;
1491 
1492   // Additionally, if building with cross-DSO support...
1493   if (CodeGenOpts.SanitizeCfiCrossDso) {
1494     // Skip available_externally functions. They won't be codegen'ed in the
1495     // current module anyway.
1496     if (getContext().GetGVALinkageForFunction(FD) == GVA_AvailableExternally)
1497       return;
1498   }
1499 
1500   llvm::Metadata *MD = CreateMetadataIdentifierForType(FD->getType());
1501   F->addTypeMetadata(0, MD);
1502   F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType()));
1503 
1504   // Emit a hash-based bit set entry for cross-DSO calls.
1505   if (CodeGenOpts.SanitizeCfiCrossDso)
1506     if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
1507       F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
1508 }
1509 
1510 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
1511                                           bool IsIncompleteFunction,
1512                                           bool IsThunk) {
1513 
1514   if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
1515     // If this is an intrinsic function, set the function's attributes
1516     // to the intrinsic's attributes.
1517     F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
1518     return;
1519   }
1520 
1521   const auto *FD = cast<FunctionDecl>(GD.getDecl());
1522 
1523   if (!IsIncompleteFunction) {
1524     SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
1525     // Setup target-specific attributes.
1526     if (F->isDeclaration())
1527       getTargetCodeGenInfo().setTargetAttributes(FD, F, *this);
1528   }
1529 
1530   // Add the Returned attribute for "this", except for iOS 5 and earlier
1531   // where substantial code, including the libstdc++ dylib, was compiled with
1532   // GCC and does not actually return "this".
1533   if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
1534       !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
1535     assert(!F->arg_empty() &&
1536            F->arg_begin()->getType()
1537              ->canLosslesslyBitCastTo(F->getReturnType()) &&
1538            "unexpected this return");
1539     F->addAttribute(1, llvm::Attribute::Returned);
1540   }
1541 
1542   // Only a few attributes are set on declarations; these may later be
1543   // overridden by a definition.
1544 
1545   setLinkageForGV(F, FD);
1546   setGVProperties(F, FD);
1547 
1548   if (const auto *CSA = FD->getAttr<CodeSegAttr>())
1549     F->setSection(CSA->getName());
1550   else if (const auto *SA = FD->getAttr<SectionAttr>())
1551      F->setSection(SA->getName());
1552 
1553   if (FD->isReplaceableGlobalAllocationFunction()) {
1554     // A replaceable global allocation function does not act like a builtin by
1555     // default, only if it is invoked by a new-expression or delete-expression.
1556     F->addAttribute(llvm::AttributeList::FunctionIndex,
1557                     llvm::Attribute::NoBuiltin);
1558 
1559     // A sane operator new returns a non-aliasing pointer.
1560     // FIXME: Also add NonNull attribute to the return value
1561     // for the non-nothrow forms?
1562     auto Kind = FD->getDeclName().getCXXOverloadedOperator();
1563     if (getCodeGenOpts().AssumeSaneOperatorNew &&
1564         (Kind == OO_New || Kind == OO_Array_New))
1565       F->addAttribute(llvm::AttributeList::ReturnIndex,
1566                       llvm::Attribute::NoAlias);
1567   }
1568 
1569   if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
1570     F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1571   else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1572     if (MD->isVirtual())
1573       F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1574 
1575   // Don't emit entries for function declarations in the cross-DSO mode. This
1576   // is handled with better precision by the receiving DSO.
1577   if (!CodeGenOpts.SanitizeCfiCrossDso)
1578     CreateFunctionTypeMetadataForIcall(FD, F);
1579 
1580   if (getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>())
1581     getOpenMPRuntime().emitDeclareSimdFunction(FD, F);
1582 }
1583 
1584 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
1585   assert(!GV->isDeclaration() &&
1586          "Only globals with definition can force usage.");
1587   LLVMUsed.emplace_back(GV);
1588 }
1589 
1590 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
1591   assert(!GV->isDeclaration() &&
1592          "Only globals with definition can force usage.");
1593   LLVMCompilerUsed.emplace_back(GV);
1594 }
1595 
1596 static void emitUsed(CodeGenModule &CGM, StringRef Name,
1597                      std::vector<llvm::WeakTrackingVH> &List) {
1598   // Don't create llvm.used if there is no need.
1599   if (List.empty())
1600     return;
1601 
1602   // Convert List to what ConstantArray needs.
1603   SmallVector<llvm::Constant*, 8> UsedArray;
1604   UsedArray.resize(List.size());
1605   for (unsigned i = 0, e = List.size(); i != e; ++i) {
1606     UsedArray[i] =
1607         llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1608             cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
1609   }
1610 
1611   if (UsedArray.empty())
1612     return;
1613   llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
1614 
1615   auto *GV = new llvm::GlobalVariable(
1616       CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
1617       llvm::ConstantArray::get(ATy, UsedArray), Name);
1618 
1619   GV->setSection("llvm.metadata");
1620 }
1621 
1622 void CodeGenModule::emitLLVMUsed() {
1623   emitUsed(*this, "llvm.used", LLVMUsed);
1624   emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
1625 }
1626 
1627 void CodeGenModule::AppendLinkerOptions(StringRef Opts) {
1628   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
1629   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1630 }
1631 
1632 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
1633   llvm::SmallString<32> Opt;
1634   getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
1635   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
1636   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1637 }
1638 
1639 void CodeGenModule::AddELFLibDirective(StringRef Lib) {
1640   auto &C = getLLVMContext();
1641   LinkerOptionsMetadata.push_back(llvm::MDNode::get(
1642       C, {llvm::MDString::get(C, "lib"), llvm::MDString::get(C, Lib)}));
1643 }
1644 
1645 void CodeGenModule::AddDependentLib(StringRef Lib) {
1646   llvm::SmallString<24> Opt;
1647   getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt);
1648   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
1649   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
1650 }
1651 
1652 /// Add link options implied by the given module, including modules
1653 /// it depends on, using a postorder walk.
1654 static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod,
1655                                     SmallVectorImpl<llvm::MDNode *> &Metadata,
1656                                     llvm::SmallPtrSet<Module *, 16> &Visited) {
1657   // Import this module's parent.
1658   if (Mod->Parent && Visited.insert(Mod->Parent).second) {
1659     addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
1660   }
1661 
1662   // Import this module's dependencies.
1663   for (unsigned I = Mod->Imports.size(); I > 0; --I) {
1664     if (Visited.insert(Mod->Imports[I - 1]).second)
1665       addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
1666   }
1667 
1668   // Add linker options to link against the libraries/frameworks
1669   // described by this module.
1670   llvm::LLVMContext &Context = CGM.getLLVMContext();
1671 
1672   // For modules that use export_as for linking, use that module
1673   // name instead.
1674   if (Mod->UseExportAsModuleLinkName)
1675     return;
1676 
1677   for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
1678     // Link against a framework.  Frameworks are currently Darwin only, so we
1679     // don't to ask TargetCodeGenInfo for the spelling of the linker option.
1680     if (Mod->LinkLibraries[I-1].IsFramework) {
1681       llvm::Metadata *Args[2] = {
1682           llvm::MDString::get(Context, "-framework"),
1683           llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)};
1684 
1685       Metadata.push_back(llvm::MDNode::get(Context, Args));
1686       continue;
1687     }
1688 
1689     // Link against a library.
1690     llvm::SmallString<24> Opt;
1691     CGM.getTargetCodeGenInfo().getDependentLibraryOption(
1692       Mod->LinkLibraries[I-1].Library, Opt);
1693     auto *OptString = llvm::MDString::get(Context, Opt);
1694     Metadata.push_back(llvm::MDNode::get(Context, OptString));
1695   }
1696 }
1697 
1698 void CodeGenModule::EmitModuleLinkOptions() {
1699   // Collect the set of all of the modules we want to visit to emit link
1700   // options, which is essentially the imported modules and all of their
1701   // non-explicit child modules.
1702   llvm::SetVector<clang::Module *> LinkModules;
1703   llvm::SmallPtrSet<clang::Module *, 16> Visited;
1704   SmallVector<clang::Module *, 16> Stack;
1705 
1706   // Seed the stack with imported modules.
1707   for (Module *M : ImportedModules) {
1708     // Do not add any link flags when an implementation TU of a module imports
1709     // a header of that same module.
1710     if (M->getTopLevelModuleName() == getLangOpts().CurrentModule &&
1711         !getLangOpts().isCompilingModule())
1712       continue;
1713     if (Visited.insert(M).second)
1714       Stack.push_back(M);
1715   }
1716 
1717   // Find all of the modules to import, making a little effort to prune
1718   // non-leaf modules.
1719   while (!Stack.empty()) {
1720     clang::Module *Mod = Stack.pop_back_val();
1721 
1722     bool AnyChildren = false;
1723 
1724     // Visit the submodules of this module.
1725     for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
1726                                         SubEnd = Mod->submodule_end();
1727          Sub != SubEnd; ++Sub) {
1728       // Skip explicit children; they need to be explicitly imported to be
1729       // linked against.
1730       if ((*Sub)->IsExplicit)
1731         continue;
1732 
1733       if (Visited.insert(*Sub).second) {
1734         Stack.push_back(*Sub);
1735         AnyChildren = true;
1736       }
1737     }
1738 
1739     // We didn't find any children, so add this module to the list of
1740     // modules to link against.
1741     if (!AnyChildren) {
1742       LinkModules.insert(Mod);
1743     }
1744   }
1745 
1746   // Add link options for all of the imported modules in reverse topological
1747   // order.  We don't do anything to try to order import link flags with respect
1748   // to linker options inserted by things like #pragma comment().
1749   SmallVector<llvm::MDNode *, 16> MetadataArgs;
1750   Visited.clear();
1751   for (Module *M : LinkModules)
1752     if (Visited.insert(M).second)
1753       addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
1754   std::reverse(MetadataArgs.begin(), MetadataArgs.end());
1755   LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
1756 
1757   // Add the linker options metadata flag.
1758   auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
1759   for (auto *MD : LinkerOptionsMetadata)
1760     NMD->addOperand(MD);
1761 }
1762 
1763 void CodeGenModule::EmitDeferred() {
1764   // Emit deferred declare target declarations.
1765   if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
1766     getOpenMPRuntime().emitDeferredTargetDecls();
1767 
1768   // Emit code for any potentially referenced deferred decls.  Since a
1769   // previously unused static decl may become used during the generation of code
1770   // for a static function, iterate until no changes are made.
1771 
1772   if (!DeferredVTables.empty()) {
1773     EmitDeferredVTables();
1774 
1775     // Emitting a vtable doesn't directly cause more vtables to
1776     // become deferred, although it can cause functions to be
1777     // emitted that then need those vtables.
1778     assert(DeferredVTables.empty());
1779   }
1780 
1781   // Stop if we're out of both deferred vtables and deferred declarations.
1782   if (DeferredDeclsToEmit.empty())
1783     return;
1784 
1785   // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
1786   // work, it will not interfere with this.
1787   std::vector<GlobalDecl> CurDeclsToEmit;
1788   CurDeclsToEmit.swap(DeferredDeclsToEmit);
1789 
1790   for (GlobalDecl &D : CurDeclsToEmit) {
1791     // We should call GetAddrOfGlobal with IsForDefinition set to true in order
1792     // to get GlobalValue with exactly the type we need, not something that
1793     // might had been created for another decl with the same mangled name but
1794     // different type.
1795     llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
1796         GetAddrOfGlobal(D, ForDefinition));
1797 
1798     // In case of different address spaces, we may still get a cast, even with
1799     // IsForDefinition equal to true. Query mangled names table to get
1800     // GlobalValue.
1801     if (!GV)
1802       GV = GetGlobalValue(getMangledName(D));
1803 
1804     // Make sure GetGlobalValue returned non-null.
1805     assert(GV);
1806 
1807     // Check to see if we've already emitted this.  This is necessary
1808     // for a couple of reasons: first, decls can end up in the
1809     // deferred-decls queue multiple times, and second, decls can end
1810     // up with definitions in unusual ways (e.g. by an extern inline
1811     // function acquiring a strong function redefinition).  Just
1812     // ignore these cases.
1813     if (!GV->isDeclaration())
1814       continue;
1815 
1816     // Otherwise, emit the definition and move on to the next one.
1817     EmitGlobalDefinition(D, GV);
1818 
1819     // If we found out that we need to emit more decls, do that recursively.
1820     // This has the advantage that the decls are emitted in a DFS and related
1821     // ones are close together, which is convenient for testing.
1822     if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
1823       EmitDeferred();
1824       assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
1825     }
1826   }
1827 }
1828 
1829 void CodeGenModule::EmitVTablesOpportunistically() {
1830   // Try to emit external vtables as available_externally if they have emitted
1831   // all inlined virtual functions.  It runs after EmitDeferred() and therefore
1832   // is not allowed to create new references to things that need to be emitted
1833   // lazily. Note that it also uses fact that we eagerly emitting RTTI.
1834 
1835   assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
1836          && "Only emit opportunistic vtables with optimizations");
1837 
1838   for (const CXXRecordDecl *RD : OpportunisticVTables) {
1839     assert(getVTables().isVTableExternal(RD) &&
1840            "This queue should only contain external vtables");
1841     if (getCXXABI().canSpeculativelyEmitVTable(RD))
1842       VTables.GenerateClassData(RD);
1843   }
1844   OpportunisticVTables.clear();
1845 }
1846 
1847 void CodeGenModule::EmitGlobalAnnotations() {
1848   if (Annotations.empty())
1849     return;
1850 
1851   // Create a new global variable for the ConstantStruct in the Module.
1852   llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
1853     Annotations[0]->getType(), Annotations.size()), Annotations);
1854   auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
1855                                       llvm::GlobalValue::AppendingLinkage,
1856                                       Array, "llvm.global.annotations");
1857   gv->setSection(AnnotationSection);
1858 }
1859 
1860 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
1861   llvm::Constant *&AStr = AnnotationStrings[Str];
1862   if (AStr)
1863     return AStr;
1864 
1865   // Not found yet, create a new global.
1866   llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
1867   auto *gv =
1868       new llvm::GlobalVariable(getModule(), s->getType(), true,
1869                                llvm::GlobalValue::PrivateLinkage, s, ".str");
1870   gv->setSection(AnnotationSection);
1871   gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1872   AStr = gv;
1873   return gv;
1874 }
1875 
1876 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
1877   SourceManager &SM = getContext().getSourceManager();
1878   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
1879   if (PLoc.isValid())
1880     return EmitAnnotationString(PLoc.getFilename());
1881   return EmitAnnotationString(SM.getBufferName(Loc));
1882 }
1883 
1884 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
1885   SourceManager &SM = getContext().getSourceManager();
1886   PresumedLoc PLoc = SM.getPresumedLoc(L);
1887   unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1888     SM.getExpansionLineNumber(L);
1889   return llvm::ConstantInt::get(Int32Ty, LineNo);
1890 }
1891 
1892 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
1893                                                 const AnnotateAttr *AA,
1894                                                 SourceLocation L) {
1895   // Get the globals for file name, annotation, and the line number.
1896   llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1897                  *UnitGV = EmitAnnotationUnit(L),
1898                  *LineNoCst = EmitAnnotationLineNo(L);
1899 
1900   // Create the ConstantStruct for the global annotation.
1901   llvm::Constant *Fields[4] = {
1902     llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1903     llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1904     llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1905     LineNoCst
1906   };
1907   return llvm::ConstantStruct::getAnon(Fields);
1908 }
1909 
1910 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
1911                                          llvm::GlobalValue *GV) {
1912   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1913   // Get the struct elements for these annotations.
1914   for (const auto *I : D->specific_attrs<AnnotateAttr>())
1915     Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
1916 }
1917 
1918 bool CodeGenModule::isInSanitizerBlacklist(SanitizerMask Kind,
1919                                            llvm::Function *Fn,
1920                                            SourceLocation Loc) const {
1921   const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1922   // Blacklist by function name.
1923   if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName()))
1924     return true;
1925   // Blacklist by location.
1926   if (Loc.isValid())
1927     return SanitizerBL.isBlacklistedLocation(Kind, Loc);
1928   // If location is unknown, this may be a compiler-generated function. Assume
1929   // it's located in the main file.
1930   auto &SM = Context.getSourceManager();
1931   if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1932     return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName());
1933   }
1934   return false;
1935 }
1936 
1937 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
1938                                            SourceLocation Loc, QualType Ty,
1939                                            StringRef Category) const {
1940   // For now globals can be blacklisted only in ASan and KASan.
1941   const SanitizerMask EnabledAsanMask = LangOpts.Sanitize.Mask &
1942       (SanitizerKind::Address | SanitizerKind::KernelAddress |
1943        SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress);
1944   if (!EnabledAsanMask)
1945     return false;
1946   const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1947   if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(), Category))
1948     return true;
1949   if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category))
1950     return true;
1951   // Check global type.
1952   if (!Ty.isNull()) {
1953     // Drill down the array types: if global variable of a fixed type is
1954     // blacklisted, we also don't instrument arrays of them.
1955     while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
1956       Ty = AT->getElementType();
1957     Ty = Ty.getCanonicalType().getUnqualifiedType();
1958     // We allow to blacklist only record types (classes, structs etc.)
1959     if (Ty->isRecordType()) {
1960       std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
1961       if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category))
1962         return true;
1963     }
1964   }
1965   return false;
1966 }
1967 
1968 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
1969                                    StringRef Category) const {
1970   if (!LangOpts.XRayInstrument)
1971     return false;
1972 
1973   const auto &XRayFilter = getContext().getXRayFilter();
1974   using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
1975   auto Attr = ImbueAttr::NONE;
1976   if (Loc.isValid())
1977     Attr = XRayFilter.shouldImbueLocation(Loc, Category);
1978   if (Attr == ImbueAttr::NONE)
1979     Attr = XRayFilter.shouldImbueFunction(Fn->getName());
1980   switch (Attr) {
1981   case ImbueAttr::NONE:
1982     return false;
1983   case ImbueAttr::ALWAYS:
1984     Fn->addFnAttr("function-instrument", "xray-always");
1985     break;
1986   case ImbueAttr::ALWAYS_ARG1:
1987     Fn->addFnAttr("function-instrument", "xray-always");
1988     Fn->addFnAttr("xray-log-args", "1");
1989     break;
1990   case ImbueAttr::NEVER:
1991     Fn->addFnAttr("function-instrument", "xray-never");
1992     break;
1993   }
1994   return true;
1995 }
1996 
1997 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
1998   // Never defer when EmitAllDecls is specified.
1999   if (LangOpts.EmitAllDecls)
2000     return true;
2001 
2002   if (CodeGenOpts.KeepStaticConsts) {
2003     const auto *VD = dyn_cast<VarDecl>(Global);
2004     if (VD && VD->getType().isConstQualified() &&
2005         VD->getStorageClass() == SC_Static)
2006       return true;
2007   }
2008 
2009   return getContext().DeclMustBeEmitted(Global);
2010 }
2011 
2012 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
2013   if (const auto *FD = dyn_cast<FunctionDecl>(Global))
2014     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
2015       // Implicit template instantiations may change linkage if they are later
2016       // explicitly instantiated, so they should not be emitted eagerly.
2017       return false;
2018   if (const auto *VD = dyn_cast<VarDecl>(Global))
2019     if (Context.getInlineVariableDefinitionKind(VD) ==
2020         ASTContext::InlineVariableDefinitionKind::WeakUnknown)
2021       // A definition of an inline constexpr static data member may change
2022       // linkage later if it's redeclared outside the class.
2023       return false;
2024   // If OpenMP is enabled and threadprivates must be generated like TLS, delay
2025   // codegen for global variables, because they may be marked as threadprivate.
2026   if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
2027       getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) &&
2028       !isTypeConstant(Global->getType(), false) &&
2029       !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
2030     return false;
2031 
2032   return true;
2033 }
2034 
2035 ConstantAddress CodeGenModule::GetAddrOfUuidDescriptor(
2036     const CXXUuidofExpr* E) {
2037   // Sema has verified that IIDSource has a __declspec(uuid()), and that its
2038   // well-formed.
2039   StringRef Uuid = E->getUuidStr();
2040   std::string Name = "_GUID_" + Uuid.lower();
2041   std::replace(Name.begin(), Name.end(), '-', '_');
2042 
2043   // The UUID descriptor should be pointer aligned.
2044   CharUnits Alignment = CharUnits::fromQuantity(PointerAlignInBytes);
2045 
2046   // Look for an existing global.
2047   if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
2048     return ConstantAddress(GV, Alignment);
2049 
2050   llvm::Constant *Init = EmitUuidofInitializer(Uuid);
2051   assert(Init && "failed to initialize as constant");
2052 
2053   auto *GV = new llvm::GlobalVariable(
2054       getModule(), Init->getType(),
2055       /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
2056   if (supportsCOMDAT())
2057     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
2058   setDSOLocal(GV);
2059   return ConstantAddress(GV, Alignment);
2060 }
2061 
2062 ConstantAddress CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
2063   const AliasAttr *AA = VD->getAttr<AliasAttr>();
2064   assert(AA && "No alias?");
2065 
2066   CharUnits Alignment = getContext().getDeclAlign(VD);
2067   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
2068 
2069   // See if there is already something with the target's name in the module.
2070   llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
2071   if (Entry) {
2072     unsigned AS = getContext().getTargetAddressSpace(VD->getType());
2073     auto Ptr = llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
2074     return ConstantAddress(Ptr, Alignment);
2075   }
2076 
2077   llvm::Constant *Aliasee;
2078   if (isa<llvm::FunctionType>(DeclTy))
2079     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
2080                                       GlobalDecl(cast<FunctionDecl>(VD)),
2081                                       /*ForVTable=*/false);
2082   else
2083     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2084                                     llvm::PointerType::getUnqual(DeclTy),
2085                                     nullptr);
2086 
2087   auto *F = cast<llvm::GlobalValue>(Aliasee);
2088   F->setLinkage(llvm::Function::ExternalWeakLinkage);
2089   WeakRefReferences.insert(F);
2090 
2091   return ConstantAddress(Aliasee, Alignment);
2092 }
2093 
2094 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
2095   const auto *Global = cast<ValueDecl>(GD.getDecl());
2096 
2097   // Weak references don't produce any output by themselves.
2098   if (Global->hasAttr<WeakRefAttr>())
2099     return;
2100 
2101   // If this is an alias definition (which otherwise looks like a declaration)
2102   // emit it now.
2103   if (Global->hasAttr<AliasAttr>())
2104     return EmitAliasDefinition(GD);
2105 
2106   // IFunc like an alias whose value is resolved at runtime by calling resolver.
2107   if (Global->hasAttr<IFuncAttr>())
2108     return emitIFuncDefinition(GD);
2109 
2110   // If this is a cpu_dispatch multiversion function, emit the resolver.
2111   if (Global->hasAttr<CPUDispatchAttr>())
2112     return emitCPUDispatchDefinition(GD);
2113 
2114   // If this is CUDA, be selective about which declarations we emit.
2115   if (LangOpts.CUDA) {
2116     if (LangOpts.CUDAIsDevice) {
2117       if (!Global->hasAttr<CUDADeviceAttr>() &&
2118           !Global->hasAttr<CUDAGlobalAttr>() &&
2119           !Global->hasAttr<CUDAConstantAttr>() &&
2120           !Global->hasAttr<CUDASharedAttr>())
2121         return;
2122     } else {
2123       // We need to emit host-side 'shadows' for all global
2124       // device-side variables because the CUDA runtime needs their
2125       // size and host-side address in order to provide access to
2126       // their device-side incarnations.
2127 
2128       // So device-only functions are the only things we skip.
2129       if (isa<FunctionDecl>(Global) && !Global->hasAttr<CUDAHostAttr>() &&
2130           Global->hasAttr<CUDADeviceAttr>())
2131         return;
2132 
2133       assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
2134              "Expected Variable or Function");
2135     }
2136   }
2137 
2138   if (LangOpts.OpenMP) {
2139     // If this is OpenMP device, check if it is legal to emit this global
2140     // normally.
2141     if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
2142       return;
2143     if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
2144       if (MustBeEmitted(Global))
2145         EmitOMPDeclareReduction(DRD);
2146       return;
2147     }
2148   }
2149 
2150   // Ignore declarations, they will be emitted on their first use.
2151   if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
2152     // Forward declarations are emitted lazily on first use.
2153     if (!FD->doesThisDeclarationHaveABody()) {
2154       if (!FD->doesDeclarationForceExternallyVisibleDefinition())
2155         return;
2156 
2157       StringRef MangledName = getMangledName(GD);
2158 
2159       // Compute the function info and LLVM type.
2160       const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2161       llvm::Type *Ty = getTypes().GetFunctionType(FI);
2162 
2163       GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
2164                               /*DontDefer=*/false);
2165       return;
2166     }
2167   } else {
2168     const auto *VD = cast<VarDecl>(Global);
2169     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
2170     // We need to emit device-side global CUDA variables even if a
2171     // variable does not have a definition -- we still need to define
2172     // host-side shadow for it.
2173     bool MustEmitForCuda = LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
2174                            !VD->hasDefinition() &&
2175                            (VD->hasAttr<CUDAConstantAttr>() ||
2176                             VD->hasAttr<CUDADeviceAttr>());
2177     if (!MustEmitForCuda &&
2178         VD->isThisDeclarationADefinition() != VarDecl::Definition &&
2179         !Context.isMSStaticDataMemberInlineDefinition(VD)) {
2180       if (LangOpts.OpenMP) {
2181         // Emit declaration of the must-be-emitted declare target variable.
2182         if (llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
2183                 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
2184           if (*Res == OMPDeclareTargetDeclAttr::MT_To) {
2185             (void)GetAddrOfGlobalVar(VD);
2186           } else {
2187             assert(*Res == OMPDeclareTargetDeclAttr::MT_Link &&
2188                    "link claue expected.");
2189             (void)getOpenMPRuntime().getAddrOfDeclareTargetLink(VD);
2190           }
2191           return;
2192         }
2193       }
2194       // If this declaration may have caused an inline variable definition to
2195       // change linkage, make sure that it's emitted.
2196       if (Context.getInlineVariableDefinitionKind(VD) ==
2197           ASTContext::InlineVariableDefinitionKind::Strong)
2198         GetAddrOfGlobalVar(VD);
2199       return;
2200     }
2201   }
2202 
2203   // Defer code generation to first use when possible, e.g. if this is an inline
2204   // function. If the global must always be emitted, do it eagerly if possible
2205   // to benefit from cache locality.
2206   if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
2207     // Emit the definition if it can't be deferred.
2208     EmitGlobalDefinition(GD);
2209     return;
2210   }
2211 
2212   // If we're deferring emission of a C++ variable with an
2213   // initializer, remember the order in which it appeared in the file.
2214   if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
2215       cast<VarDecl>(Global)->hasInit()) {
2216     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
2217     CXXGlobalInits.push_back(nullptr);
2218   }
2219 
2220   StringRef MangledName = getMangledName(GD);
2221   if (GetGlobalValue(MangledName) != nullptr) {
2222     // The value has already been used and should therefore be emitted.
2223     addDeferredDeclToEmit(GD);
2224   } else if (MustBeEmitted(Global)) {
2225     // The value must be emitted, but cannot be emitted eagerly.
2226     assert(!MayBeEmittedEagerly(Global));
2227     addDeferredDeclToEmit(GD);
2228   } else {
2229     // Otherwise, remember that we saw a deferred decl with this name.  The
2230     // first use of the mangled name will cause it to move into
2231     // DeferredDeclsToEmit.
2232     DeferredDecls[MangledName] = GD;
2233   }
2234 }
2235 
2236 // Check if T is a class type with a destructor that's not dllimport.
2237 static bool HasNonDllImportDtor(QualType T) {
2238   if (const auto *RT = T->getBaseElementTypeUnsafe()->getAs<RecordType>())
2239     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2240       if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
2241         return true;
2242 
2243   return false;
2244 }
2245 
2246 namespace {
2247   struct FunctionIsDirectlyRecursive :
2248     public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
2249     const StringRef Name;
2250     const Builtin::Context &BI;
2251     bool Result;
2252     FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
2253       Name(N), BI(C), Result(false) {
2254     }
2255     typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
2256 
2257     bool TraverseCallExpr(CallExpr *E) {
2258       const FunctionDecl *FD = E->getDirectCallee();
2259       if (!FD)
2260         return true;
2261       AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
2262       if (Attr && Name == Attr->getLabel()) {
2263         Result = true;
2264         return false;
2265       }
2266       unsigned BuiltinID = FD->getBuiltinID();
2267       if (!BuiltinID || !BI.isLibFunction(BuiltinID))
2268         return true;
2269       StringRef BuiltinName = BI.getName(BuiltinID);
2270       if (BuiltinName.startswith("__builtin_") &&
2271           Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
2272         Result = true;
2273         return false;
2274       }
2275       return true;
2276     }
2277   };
2278 
2279   // Make sure we're not referencing non-imported vars or functions.
2280   struct DLLImportFunctionVisitor
2281       : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
2282     bool SafeToInline = true;
2283 
2284     bool shouldVisitImplicitCode() const { return true; }
2285 
2286     bool VisitVarDecl(VarDecl *VD) {
2287       if (VD->getTLSKind()) {
2288         // A thread-local variable cannot be imported.
2289         SafeToInline = false;
2290         return SafeToInline;
2291       }
2292 
2293       // A variable definition might imply a destructor call.
2294       if (VD->isThisDeclarationADefinition())
2295         SafeToInline = !HasNonDllImportDtor(VD->getType());
2296 
2297       return SafeToInline;
2298     }
2299 
2300     bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
2301       if (const auto *D = E->getTemporary()->getDestructor())
2302         SafeToInline = D->hasAttr<DLLImportAttr>();
2303       return SafeToInline;
2304     }
2305 
2306     bool VisitDeclRefExpr(DeclRefExpr *E) {
2307       ValueDecl *VD = E->getDecl();
2308       if (isa<FunctionDecl>(VD))
2309         SafeToInline = VD->hasAttr<DLLImportAttr>();
2310       else if (VarDecl *V = dyn_cast<VarDecl>(VD))
2311         SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>();
2312       return SafeToInline;
2313     }
2314 
2315     bool VisitCXXConstructExpr(CXXConstructExpr *E) {
2316       SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
2317       return SafeToInline;
2318     }
2319 
2320     bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
2321       CXXMethodDecl *M = E->getMethodDecl();
2322       if (!M) {
2323         // Call through a pointer to member function. This is safe to inline.
2324         SafeToInline = true;
2325       } else {
2326         SafeToInline = M->hasAttr<DLLImportAttr>();
2327       }
2328       return SafeToInline;
2329     }
2330 
2331     bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2332       SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
2333       return SafeToInline;
2334     }
2335 
2336     bool VisitCXXNewExpr(CXXNewExpr *E) {
2337       SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
2338       return SafeToInline;
2339     }
2340   };
2341 }
2342 
2343 // isTriviallyRecursive - Check if this function calls another
2344 // decl that, because of the asm attribute or the other decl being a builtin,
2345 // ends up pointing to itself.
2346 bool
2347 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
2348   StringRef Name;
2349   if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
2350     // asm labels are a special kind of mangling we have to support.
2351     AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
2352     if (!Attr)
2353       return false;
2354     Name = Attr->getLabel();
2355   } else {
2356     Name = FD->getName();
2357   }
2358 
2359   FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
2360   Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
2361   return Walker.Result;
2362 }
2363 
2364 bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
2365   if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
2366     return true;
2367   const auto *F = cast<FunctionDecl>(GD.getDecl());
2368   if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
2369     return false;
2370 
2371   if (F->hasAttr<DLLImportAttr>()) {
2372     // Check whether it would be safe to inline this dllimport function.
2373     DLLImportFunctionVisitor Visitor;
2374     Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
2375     if (!Visitor.SafeToInline)
2376       return false;
2377 
2378     if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
2379       // Implicit destructor invocations aren't captured in the AST, so the
2380       // check above can't see them. Check for them manually here.
2381       for (const Decl *Member : Dtor->getParent()->decls())
2382         if (isa<FieldDecl>(Member))
2383           if (HasNonDllImportDtor(cast<FieldDecl>(Member)->getType()))
2384             return false;
2385       for (const CXXBaseSpecifier &B : Dtor->getParent()->bases())
2386         if (HasNonDllImportDtor(B.getType()))
2387           return false;
2388     }
2389   }
2390 
2391   // PR9614. Avoid cases where the source code is lying to us. An available
2392   // externally function should have an equivalent function somewhere else,
2393   // but a function that calls itself is clearly not equivalent to the real
2394   // implementation.
2395   // This happens in glibc's btowc and in some configure checks.
2396   return !isTriviallyRecursive(F);
2397 }
2398 
2399 bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
2400   return CodeGenOpts.OptimizationLevel > 0;
2401 }
2402 
2403 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
2404   const auto *D = cast<ValueDecl>(GD.getDecl());
2405 
2406   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
2407                                  Context.getSourceManager(),
2408                                  "Generating code for declaration");
2409 
2410   if (isa<FunctionDecl>(D)) {
2411     // At -O0, don't generate IR for functions with available_externally
2412     // linkage.
2413     if (!shouldEmitFunction(GD))
2414       return;
2415 
2416     if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2417       // Make sure to emit the definition(s) before we emit the thunks.
2418       // This is necessary for the generation of certain thunks.
2419       if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method))
2420         ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType()));
2421       else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method))
2422         ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType()));
2423       else
2424         EmitGlobalFunctionDefinition(GD, GV);
2425 
2426       if (Method->isVirtual())
2427         getVTables().EmitThunks(GD);
2428 
2429       return;
2430     }
2431 
2432     return EmitGlobalFunctionDefinition(GD, GV);
2433   }
2434 
2435   if (const auto *VD = dyn_cast<VarDecl>(D))
2436     return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
2437 
2438   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
2439 }
2440 
2441 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2442                                                       llvm::Function *NewFn);
2443 
2444 static unsigned
2445 TargetMVPriority(const TargetInfo &TI,
2446                  const CodeGenFunction::MultiVersionResolverOption &RO) {
2447   unsigned Priority = 0;
2448   for (StringRef Feat : RO.Conditions.Features)
2449     Priority = std::max(Priority, TI.multiVersionSortPriority(Feat));
2450 
2451   if (!RO.Conditions.Architecture.empty())
2452     Priority = std::max(
2453         Priority, TI.multiVersionSortPriority(RO.Conditions.Architecture));
2454   return Priority;
2455 }
2456 
2457 void CodeGenModule::emitMultiVersionFunctions() {
2458   for (GlobalDecl GD : MultiVersionFuncs) {
2459     SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options;
2460     const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
2461     getContext().forEachMultiversionedFunctionVersion(
2462         FD, [this, &GD, &Options](const FunctionDecl *CurFD) {
2463           GlobalDecl CurGD{
2464               (CurFD->isDefined() ? CurFD->getDefinition() : CurFD)};
2465           StringRef MangledName = getMangledName(CurGD);
2466           llvm::Constant *Func = GetGlobalValue(MangledName);
2467           if (!Func) {
2468             if (CurFD->isDefined()) {
2469               EmitGlobalFunctionDefinition(CurGD, nullptr);
2470               Func = GetGlobalValue(MangledName);
2471             } else {
2472               const CGFunctionInfo &FI =
2473                   getTypes().arrangeGlobalDeclaration(GD);
2474               llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2475               Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false,
2476                                        /*DontDefer=*/false, ForDefinition);
2477             }
2478             assert(Func && "This should have just been created");
2479           }
2480 
2481           const auto *TA = CurFD->getAttr<TargetAttr>();
2482           llvm::SmallVector<StringRef, 8> Feats;
2483           TA->getAddedFeatures(Feats);
2484 
2485           Options.emplace_back(cast<llvm::Function>(Func),
2486                                TA->getArchitecture(), Feats);
2487         });
2488 
2489     llvm::Function *ResolverFunc = cast<llvm::Function>(
2490         GetGlobalValue((getMangledName(GD) + ".resolver").str()));
2491     if (supportsCOMDAT())
2492       ResolverFunc->setComdat(
2493           getModule().getOrInsertComdat(ResolverFunc->getName()));
2494 
2495     const TargetInfo &TI = getTarget();
2496     std::stable_sort(
2497         Options.begin(), Options.end(),
2498         [&TI](const CodeGenFunction::MultiVersionResolverOption &LHS,
2499               const CodeGenFunction::MultiVersionResolverOption &RHS) {
2500           return TargetMVPriority(TI, LHS) > TargetMVPriority(TI, RHS);
2501         });
2502     CodeGenFunction CGF(*this);
2503     CGF.EmitMultiVersionResolver(ResolverFunc, Options);
2504   }
2505 }
2506 
2507 void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) {
2508   const auto *FD = cast<FunctionDecl>(GD.getDecl());
2509   assert(FD && "Not a FunctionDecl?");
2510   const auto *DD = FD->getAttr<CPUDispatchAttr>();
2511   assert(DD && "Not a cpu_dispatch Function?");
2512   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(FD->getType());
2513 
2514   StringRef ResolverName = getMangledName(GD);
2515   llvm::Type *ResolverType = llvm::FunctionType::get(
2516       llvm::PointerType::get(DeclTy,
2517                              Context.getTargetAddressSpace(FD->getType())),
2518       false);
2519   auto *ResolverFunc = cast<llvm::Function>(
2520       GetOrCreateLLVMFunction(ResolverName, ResolverType, GlobalDecl{},
2521                               /*ForVTable=*/false));
2522 
2523   SmallVector<CodeGenFunction::MultiVersionResolverOption, 10> Options;
2524   const TargetInfo &Target = getTarget();
2525   for (const IdentifierInfo *II : DD->cpus()) {
2526     // Get the name of the target function so we can look it up/create it.
2527     std::string MangledName = getMangledNameImpl(*this, GD, FD, true) +
2528                               getCPUSpecificMangling(*this, II->getName());
2529     llvm::Constant *Func = GetOrCreateLLVMFunction(
2530         MangledName, DeclTy, GD, /*ForVTable=*/false, /*DontDefer=*/false,
2531         /*IsThunk=*/false, llvm::AttributeList(), ForDefinition);
2532     llvm::SmallVector<StringRef, 32> Features;
2533     Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
2534     llvm::transform(Features, Features.begin(),
2535                     [](StringRef Str) { return Str.substr(1); });
2536     Features.erase(std::remove_if(
2537         Features.begin(), Features.end(), [&Target](StringRef Feat) {
2538           return !Target.validateCpuSupports(Feat);
2539         }), Features.end());
2540     Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features);
2541   }
2542 
2543   llvm::sort(
2544       Options.begin(), Options.end(),
2545       [](const CodeGenFunction::MultiVersionResolverOption &LHS,
2546          const CodeGenFunction::MultiVersionResolverOption &RHS) {
2547         return CodeGenFunction::GetX86CpuSupportsMask(LHS.Conditions.Features) >
2548                CodeGenFunction::GetX86CpuSupportsMask(RHS.Conditions.Features);
2549       });
2550   CodeGenFunction CGF(*this);
2551   CGF.EmitMultiVersionResolver(ResolverFunc, Options);
2552 }
2553 
2554 /// If an ifunc for the specified mangled name is not in the module, create and
2555 /// return an llvm IFunc Function with the specified type.
2556 llvm::Constant *
2557 CodeGenModule::GetOrCreateMultiVersionIFunc(GlobalDecl GD, llvm::Type *DeclTy,
2558                                             const FunctionDecl *FD) {
2559   std::string MangledName =
2560       getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
2561   std::string IFuncName = MangledName + ".ifunc";
2562   if (llvm::GlobalValue *IFuncGV = GetGlobalValue(IFuncName))
2563     return IFuncGV;
2564 
2565   // Since this is the first time we've created this IFunc, make sure
2566   // that we put this multiversioned function into the list to be
2567   // replaced later if necessary (target multiversioning only).
2568   if (!FD->isCPUDispatchMultiVersion() && !FD->isCPUSpecificMultiVersion())
2569     MultiVersionFuncs.push_back(GD);
2570 
2571   std::string ResolverName = MangledName + ".resolver";
2572   llvm::Type *ResolverType = llvm::FunctionType::get(
2573       llvm::PointerType::get(DeclTy,
2574                              Context.getTargetAddressSpace(FD->getType())),
2575       false);
2576   llvm::Constant *Resolver =
2577       GetOrCreateLLVMFunction(ResolverName, ResolverType, GlobalDecl{},
2578                               /*ForVTable=*/false);
2579   llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
2580       DeclTy, 0, llvm::Function::ExternalLinkage, "", Resolver, &getModule());
2581   GIF->setName(IFuncName);
2582   SetCommonAttributes(FD, GIF);
2583 
2584   return GIF;
2585 }
2586 
2587 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
2588 /// module, create and return an llvm Function with the specified type. If there
2589 /// is something in the module with the specified name, return it potentially
2590 /// bitcasted to the right type.
2591 ///
2592 /// If D is non-null, it specifies a decl that correspond to this.  This is used
2593 /// to set the attributes on the function when it is first created.
2594 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
2595     StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
2596     bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
2597     ForDefinition_t IsForDefinition) {
2598   const Decl *D = GD.getDecl();
2599 
2600   // Any attempts to use a MultiVersion function should result in retrieving
2601   // the iFunc instead. Name Mangling will handle the rest of the changes.
2602   if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
2603     // For the device mark the function as one that should be emitted.
2604     if (getLangOpts().OpenMPIsDevice && OpenMPRuntime &&
2605         !OpenMPRuntime->markAsGlobalTarget(GD) && FD->isDefined() &&
2606         !DontDefer && !IsForDefinition) {
2607       if (const FunctionDecl *FDDef = FD->getDefinition()) {
2608         GlobalDecl GDDef;
2609         if (const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
2610           GDDef = GlobalDecl(CD, GD.getCtorType());
2611         else if (const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
2612           GDDef = GlobalDecl(DD, GD.getDtorType());
2613         else
2614           GDDef = GlobalDecl(FDDef);
2615         EmitGlobal(GDDef);
2616       }
2617     }
2618 
2619     if (FD->isMultiVersion()) {
2620       const auto *TA = FD->getAttr<TargetAttr>();
2621       if (TA && TA->isDefaultVersion())
2622         UpdateMultiVersionNames(GD, FD);
2623       if (!IsForDefinition)
2624         return GetOrCreateMultiVersionIFunc(GD, Ty, FD);
2625     }
2626   }
2627 
2628   // Lookup the entry, lazily creating it if necessary.
2629   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2630   if (Entry) {
2631     if (WeakRefReferences.erase(Entry)) {
2632       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
2633       if (FD && !FD->hasAttr<WeakAttr>())
2634         Entry->setLinkage(llvm::Function::ExternalLinkage);
2635     }
2636 
2637     // Handle dropped DLL attributes.
2638     if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) {
2639       Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2640       setDSOLocal(Entry);
2641     }
2642 
2643     // If there are two attempts to define the same mangled name, issue an
2644     // error.
2645     if (IsForDefinition && !Entry->isDeclaration()) {
2646       GlobalDecl OtherGD;
2647       // Check that GD is not yet in DiagnosedConflictingDefinitions is required
2648       // to make sure that we issue an error only once.
2649       if (lookupRepresentativeDecl(MangledName, OtherGD) &&
2650           (GD.getCanonicalDecl().getDecl() !=
2651            OtherGD.getCanonicalDecl().getDecl()) &&
2652           DiagnosedConflictingDefinitions.insert(GD).second) {
2653         getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
2654             << MangledName;
2655         getDiags().Report(OtherGD.getDecl()->getLocation(),
2656                           diag::note_previous_definition);
2657       }
2658     }
2659 
2660     if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
2661         (Entry->getType()->getElementType() == Ty)) {
2662       return Entry;
2663     }
2664 
2665     // Make sure the result is of the correct type.
2666     // (If function is requested for a definition, we always need to create a new
2667     // function, not just return a bitcast.)
2668     if (!IsForDefinition)
2669       return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
2670   }
2671 
2672   // This function doesn't have a complete type (for example, the return
2673   // type is an incomplete struct). Use a fake type instead, and make
2674   // sure not to try to set attributes.
2675   bool IsIncompleteFunction = false;
2676 
2677   llvm::FunctionType *FTy;
2678   if (isa<llvm::FunctionType>(Ty)) {
2679     FTy = cast<llvm::FunctionType>(Ty);
2680   } else {
2681     FTy = llvm::FunctionType::get(VoidTy, false);
2682     IsIncompleteFunction = true;
2683   }
2684 
2685   llvm::Function *F =
2686       llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
2687                              Entry ? StringRef() : MangledName, &getModule());
2688 
2689   // If we already created a function with the same mangled name (but different
2690   // type) before, take its name and add it to the list of functions to be
2691   // replaced with F at the end of CodeGen.
2692   //
2693   // This happens if there is a prototype for a function (e.g. "int f()") and
2694   // then a definition of a different type (e.g. "int f(int x)").
2695   if (Entry) {
2696     F->takeName(Entry);
2697 
2698     // This might be an implementation of a function without a prototype, in
2699     // which case, try to do special replacement of calls which match the new
2700     // prototype.  The really key thing here is that we also potentially drop
2701     // arguments from the call site so as to make a direct call, which makes the
2702     // inliner happier and suppresses a number of optimizer warnings (!) about
2703     // dropping arguments.
2704     if (!Entry->use_empty()) {
2705       ReplaceUsesOfNonProtoTypeWithRealFunction(Entry, F);
2706       Entry->removeDeadConstantUsers();
2707     }
2708 
2709     llvm::Constant *BC = llvm::ConstantExpr::getBitCast(
2710         F, Entry->getType()->getElementType()->getPointerTo());
2711     addGlobalValReplacement(Entry, BC);
2712   }
2713 
2714   assert(F->getName() == MangledName && "name was uniqued!");
2715   if (D)
2716     SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
2717   if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) {
2718     llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex);
2719     F->addAttributes(llvm::AttributeList::FunctionIndex, B);
2720   }
2721 
2722   if (!DontDefer) {
2723     // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
2724     // each other bottoming out with the base dtor.  Therefore we emit non-base
2725     // dtors on usage, even if there is no dtor definition in the TU.
2726     if (D && isa<CXXDestructorDecl>(D) &&
2727         getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
2728                                            GD.getDtorType()))
2729       addDeferredDeclToEmit(GD);
2730 
2731     // This is the first use or definition of a mangled name.  If there is a
2732     // deferred decl with this name, remember that we need to emit it at the end
2733     // of the file.
2734     auto DDI = DeferredDecls.find(MangledName);
2735     if (DDI != DeferredDecls.end()) {
2736       // Move the potentially referenced deferred decl to the
2737       // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
2738       // don't need it anymore).
2739       addDeferredDeclToEmit(DDI->second);
2740       DeferredDecls.erase(DDI);
2741 
2742       // Otherwise, there are cases we have to worry about where we're
2743       // using a declaration for which we must emit a definition but where
2744       // we might not find a top-level definition:
2745       //   - member functions defined inline in their classes
2746       //   - friend functions defined inline in some class
2747       //   - special member functions with implicit definitions
2748       // If we ever change our AST traversal to walk into class methods,
2749       // this will be unnecessary.
2750       //
2751       // We also don't emit a definition for a function if it's going to be an
2752       // entry in a vtable, unless it's already marked as used.
2753     } else if (getLangOpts().CPlusPlus && D) {
2754       // Look for a declaration that's lexically in a record.
2755       for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
2756            FD = FD->getPreviousDecl()) {
2757         if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
2758           if (FD->doesThisDeclarationHaveABody()) {
2759             addDeferredDeclToEmit(GD.getWithDecl(FD));
2760             break;
2761           }
2762         }
2763       }
2764     }
2765   }
2766 
2767   // Make sure the result is of the requested type.
2768   if (!IsIncompleteFunction) {
2769     assert(F->getType()->getElementType() == Ty);
2770     return F;
2771   }
2772 
2773   llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2774   return llvm::ConstantExpr::getBitCast(F, PTy);
2775 }
2776 
2777 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
2778 /// non-null, then this function will use the specified type if it has to
2779 /// create it (this occurs when we see a definition of the function).
2780 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
2781                                                  llvm::Type *Ty,
2782                                                  bool ForVTable,
2783                                                  bool DontDefer,
2784                                               ForDefinition_t IsForDefinition) {
2785   // If there was no specific requested type, just convert it now.
2786   if (!Ty) {
2787     const auto *FD = cast<FunctionDecl>(GD.getDecl());
2788     auto CanonTy = Context.getCanonicalType(FD->getType());
2789     Ty = getTypes().ConvertFunctionType(CanonTy, FD);
2790   }
2791 
2792   // Devirtualized destructor calls may come through here instead of via
2793   // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead
2794   // of the complete destructor when necessary.
2795   if (const auto *DD = dyn_cast<CXXDestructorDecl>(GD.getDecl())) {
2796     if (getTarget().getCXXABI().isMicrosoft() &&
2797         GD.getDtorType() == Dtor_Complete &&
2798         DD->getParent()->getNumVBases() == 0)
2799       GD = GlobalDecl(DD, Dtor_Base);
2800   }
2801 
2802   StringRef MangledName = getMangledName(GD);
2803   return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
2804                                  /*IsThunk=*/false, llvm::AttributeList(),
2805                                  IsForDefinition);
2806 }
2807 
2808 static const FunctionDecl *
2809 GetRuntimeFunctionDecl(ASTContext &C, StringRef Name) {
2810   TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
2811   DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
2812 
2813   IdentifierInfo &CII = C.Idents.get(Name);
2814   for (const auto &Result : DC->lookup(&CII))
2815     if (const auto FD = dyn_cast<FunctionDecl>(Result))
2816       return FD;
2817 
2818   if (!C.getLangOpts().CPlusPlus)
2819     return nullptr;
2820 
2821   // Demangle the premangled name from getTerminateFn()
2822   IdentifierInfo &CXXII =
2823       (Name == "_ZSt9terminatev" || Name == "?terminate@@YAXXZ")
2824           ? C.Idents.get("terminate")
2825           : C.Idents.get(Name);
2826 
2827   for (const auto &N : {"__cxxabiv1", "std"}) {
2828     IdentifierInfo &NS = C.Idents.get(N);
2829     for (const auto &Result : DC->lookup(&NS)) {
2830       NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result);
2831       if (auto LSD = dyn_cast<LinkageSpecDecl>(Result))
2832         for (const auto &Result : LSD->lookup(&NS))
2833           if ((ND = dyn_cast<NamespaceDecl>(Result)))
2834             break;
2835 
2836       if (ND)
2837         for (const auto &Result : ND->lookup(&CXXII))
2838           if (const auto *FD = dyn_cast<FunctionDecl>(Result))
2839             return FD;
2840     }
2841   }
2842 
2843   return nullptr;
2844 }
2845 
2846 /// CreateRuntimeFunction - Create a new runtime function with the specified
2847 /// type and name.
2848 llvm::Constant *
2849 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
2850                                      llvm::AttributeList ExtraAttrs,
2851                                      bool Local) {
2852   llvm::Constant *C =
2853       GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
2854                               /*DontDefer=*/false, /*IsThunk=*/false,
2855                               ExtraAttrs);
2856 
2857   if (auto *F = dyn_cast<llvm::Function>(C)) {
2858     if (F->empty()) {
2859       F->setCallingConv(getRuntimeCC());
2860 
2861       if (!Local && getTriple().isOSBinFormatCOFF() &&
2862           !getCodeGenOpts().LTOVisibilityPublicStd &&
2863           !getTriple().isWindowsGNUEnvironment()) {
2864         const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name);
2865         if (!FD || FD->hasAttr<DLLImportAttr>()) {
2866           F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
2867           F->setLinkage(llvm::GlobalValue::ExternalLinkage);
2868         }
2869       }
2870       setDSOLocal(F);
2871     }
2872   }
2873 
2874   return C;
2875 }
2876 
2877 /// CreateBuiltinFunction - Create a new builtin function with the specified
2878 /// type and name.
2879 llvm::Constant *
2880 CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy, StringRef Name,
2881                                      llvm::AttributeList ExtraAttrs) {
2882   return CreateRuntimeFunction(FTy, Name, ExtraAttrs, true);
2883 }
2884 
2885 /// isTypeConstant - Determine whether an object of this type can be emitted
2886 /// as a constant.
2887 ///
2888 /// If ExcludeCtor is true, the duration when the object's constructor runs
2889 /// will not be considered. The caller will need to verify that the object is
2890 /// not written to during its construction.
2891 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
2892   if (!Ty.isConstant(Context) && !Ty->isReferenceType())
2893     return false;
2894 
2895   if (Context.getLangOpts().CPlusPlus) {
2896     if (const CXXRecordDecl *Record
2897           = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
2898       return ExcludeCtor && !Record->hasMutableFields() &&
2899              Record->hasTrivialDestructor();
2900   }
2901 
2902   return true;
2903 }
2904 
2905 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
2906 /// create and return an llvm GlobalVariable with the specified type.  If there
2907 /// is something in the module with the specified name, return it potentially
2908 /// bitcasted to the right type.
2909 ///
2910 /// If D is non-null, it specifies a decl that correspond to this.  This is used
2911 /// to set the attributes on the global when it is first created.
2912 ///
2913 /// If IsForDefinition is true, it is guaranteed that an actual global with
2914 /// type Ty will be returned, not conversion of a variable with the same
2915 /// mangled name but some other type.
2916 llvm::Constant *
2917 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
2918                                      llvm::PointerType *Ty,
2919                                      const VarDecl *D,
2920                                      ForDefinition_t IsForDefinition) {
2921   // Lookup the entry, lazily creating it if necessary.
2922   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2923   if (Entry) {
2924     if (WeakRefReferences.erase(Entry)) {
2925       if (D && !D->hasAttr<WeakAttr>())
2926         Entry->setLinkage(llvm::Function::ExternalLinkage);
2927     }
2928 
2929     // Handle dropped DLL attributes.
2930     if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
2931       Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
2932 
2933     if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
2934       getOpenMPRuntime().registerTargetGlobalVariable(D, Entry);
2935 
2936     if (Entry->getType() == Ty)
2937       return Entry;
2938 
2939     // If there are two attempts to define the same mangled name, issue an
2940     // error.
2941     if (IsForDefinition && !Entry->isDeclaration()) {
2942       GlobalDecl OtherGD;
2943       const VarDecl *OtherD;
2944 
2945       // Check that D is not yet in DiagnosedConflictingDefinitions is required
2946       // to make sure that we issue an error only once.
2947       if (D && lookupRepresentativeDecl(MangledName, OtherGD) &&
2948           (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) &&
2949           (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) &&
2950           OtherD->hasInit() &&
2951           DiagnosedConflictingDefinitions.insert(D).second) {
2952         getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
2953             << MangledName;
2954         getDiags().Report(OtherGD.getDecl()->getLocation(),
2955                           diag::note_previous_definition);
2956       }
2957     }
2958 
2959     // Make sure the result is of the correct type.
2960     if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
2961       return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
2962 
2963     // (If global is requested for a definition, we always need to create a new
2964     // global, not just return a bitcast.)
2965     if (!IsForDefinition)
2966       return llvm::ConstantExpr::getBitCast(Entry, Ty);
2967   }
2968 
2969   auto AddrSpace = GetGlobalVarAddressSpace(D);
2970   auto TargetAddrSpace = getContext().getTargetAddressSpace(AddrSpace);
2971 
2972   auto *GV = new llvm::GlobalVariable(
2973       getModule(), Ty->getElementType(), false,
2974       llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr,
2975       llvm::GlobalVariable::NotThreadLocal, TargetAddrSpace);
2976 
2977   // If we already created a global with the same mangled name (but different
2978   // type) before, take its name and remove it from its parent.
2979   if (Entry) {
2980     GV->takeName(Entry);
2981 
2982     if (!Entry->use_empty()) {
2983       llvm::Constant *NewPtrForOldDecl =
2984           llvm::ConstantExpr::getBitCast(GV, Entry->getType());
2985       Entry->replaceAllUsesWith(NewPtrForOldDecl);
2986     }
2987 
2988     Entry->eraseFromParent();
2989   }
2990 
2991   // This is the first use or definition of a mangled name.  If there is a
2992   // deferred decl with this name, remember that we need to emit it at the end
2993   // of the file.
2994   auto DDI = DeferredDecls.find(MangledName);
2995   if (DDI != DeferredDecls.end()) {
2996     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
2997     // list, and remove it from DeferredDecls (since we don't need it anymore).
2998     addDeferredDeclToEmit(DDI->second);
2999     DeferredDecls.erase(DDI);
3000   }
3001 
3002   // Handle things which are present even on external declarations.
3003   if (D) {
3004     if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
3005       getOpenMPRuntime().registerTargetGlobalVariable(D, GV);
3006 
3007     // FIXME: This code is overly simple and should be merged with other global
3008     // handling.
3009     GV->setConstant(isTypeConstant(D->getType(), false));
3010 
3011     GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
3012 
3013     setLinkageForGV(GV, D);
3014 
3015     if (D->getTLSKind()) {
3016       if (D->getTLSKind() == VarDecl::TLS_Dynamic)
3017         CXXThreadLocals.push_back(D);
3018       setTLSMode(GV, *D);
3019     }
3020 
3021     setGVProperties(GV, D);
3022 
3023     // If required by the ABI, treat declarations of static data members with
3024     // inline initializers as definitions.
3025     if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
3026       EmitGlobalVarDefinition(D);
3027     }
3028 
3029     // Emit section information for extern variables.
3030     if (D->hasExternalStorage()) {
3031       if (const SectionAttr *SA = D->getAttr<SectionAttr>())
3032         GV->setSection(SA->getName());
3033     }
3034 
3035     // Handle XCore specific ABI requirements.
3036     if (getTriple().getArch() == llvm::Triple::xcore &&
3037         D->getLanguageLinkage() == CLanguageLinkage &&
3038         D->getType().isConstant(Context) &&
3039         isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
3040       GV->setSection(".cp.rodata");
3041 
3042     // Check if we a have a const declaration with an initializer, we may be
3043     // able to emit it as available_externally to expose it's value to the
3044     // optimizer.
3045     if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
3046         D->getType().isConstQualified() && !GV->hasInitializer() &&
3047         !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
3048       const auto *Record =
3049           Context.getBaseElementType(D->getType())->getAsCXXRecordDecl();
3050       bool HasMutableFields = Record && Record->hasMutableFields();
3051       if (!HasMutableFields) {
3052         const VarDecl *InitDecl;
3053         const Expr *InitExpr = D->getAnyInitializer(InitDecl);
3054         if (InitExpr) {
3055           ConstantEmitter emitter(*this);
3056           llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
3057           if (Init) {
3058             auto *InitType = Init->getType();
3059             if (GV->getType()->getElementType() != InitType) {
3060               // The type of the initializer does not match the definition.
3061               // This happens when an initializer has a different type from
3062               // the type of the global (because of padding at the end of a
3063               // structure for instance).
3064               GV->setName(StringRef());
3065               // Make a new global with the correct type, this is now guaranteed
3066               // to work.
3067               auto *NewGV = cast<llvm::GlobalVariable>(
3068                   GetAddrOfGlobalVar(D, InitType, IsForDefinition));
3069 
3070               // Erase the old global, since it is no longer used.
3071               GV->eraseFromParent();
3072               GV = NewGV;
3073             } else {
3074               GV->setInitializer(Init);
3075               GV->setConstant(true);
3076               GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
3077             }
3078             emitter.finalize(GV);
3079           }
3080         }
3081       }
3082     }
3083   }
3084 
3085   LangAS ExpectedAS =
3086       D ? D->getType().getAddressSpace()
3087         : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
3088   assert(getContext().getTargetAddressSpace(ExpectedAS) ==
3089          Ty->getPointerAddressSpace());
3090   if (AddrSpace != ExpectedAS)
3091     return getTargetCodeGenInfo().performAddrSpaceCast(*this, GV, AddrSpace,
3092                                                        ExpectedAS, Ty);
3093 
3094   return GV;
3095 }
3096 
3097 llvm::Constant *
3098 CodeGenModule::GetAddrOfGlobal(GlobalDecl GD,
3099                                ForDefinition_t IsForDefinition) {
3100   const Decl *D = GD.getDecl();
3101   if (isa<CXXConstructorDecl>(D))
3102     return getAddrOfCXXStructor(cast<CXXConstructorDecl>(D),
3103                                 getFromCtorType(GD.getCtorType()),
3104                                 /*FnInfo=*/nullptr, /*FnType=*/nullptr,
3105                                 /*DontDefer=*/false, IsForDefinition);
3106   else if (isa<CXXDestructorDecl>(D))
3107     return getAddrOfCXXStructor(cast<CXXDestructorDecl>(D),
3108                                 getFromDtorType(GD.getDtorType()),
3109                                 /*FnInfo=*/nullptr, /*FnType=*/nullptr,
3110                                 /*DontDefer=*/false, IsForDefinition);
3111   else if (isa<CXXMethodDecl>(D)) {
3112     auto FInfo = &getTypes().arrangeCXXMethodDeclaration(
3113         cast<CXXMethodDecl>(D));
3114     auto Ty = getTypes().GetFunctionType(*FInfo);
3115     return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
3116                              IsForDefinition);
3117   } else if (isa<FunctionDecl>(D)) {
3118     const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
3119     llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
3120     return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
3121                              IsForDefinition);
3122   } else
3123     return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr,
3124                               IsForDefinition);
3125 }
3126 
3127 llvm::GlobalVariable *CodeGenModule::CreateOrReplaceCXXRuntimeVariable(
3128     StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage,
3129     unsigned Alignment) {
3130   llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
3131   llvm::GlobalVariable *OldGV = nullptr;
3132 
3133   if (GV) {
3134     // Check if the variable has the right type.
3135     if (GV->getType()->getElementType() == Ty)
3136       return GV;
3137 
3138     // Because C++ name mangling, the only way we can end up with an already
3139     // existing global with the same name is if it has been declared extern "C".
3140     assert(GV->isDeclaration() && "Declaration has wrong type!");
3141     OldGV = GV;
3142   }
3143 
3144   // Create a new variable.
3145   GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
3146                                 Linkage, nullptr, Name);
3147 
3148   if (OldGV) {
3149     // Replace occurrences of the old variable if needed.
3150     GV->takeName(OldGV);
3151 
3152     if (!OldGV->use_empty()) {
3153       llvm::Constant *NewPtrForOldDecl =
3154       llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
3155       OldGV->replaceAllUsesWith(NewPtrForOldDecl);
3156     }
3157 
3158     OldGV->eraseFromParent();
3159   }
3160 
3161   if (supportsCOMDAT() && GV->isWeakForLinker() &&
3162       !GV->hasAvailableExternallyLinkage())
3163     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3164 
3165   GV->setAlignment(Alignment);
3166 
3167   return GV;
3168 }
3169 
3170 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
3171 /// given global variable.  If Ty is non-null and if the global doesn't exist,
3172 /// then it will be created with the specified type instead of whatever the
3173 /// normal requested type would be. If IsForDefinition is true, it is guaranteed
3174 /// that an actual global with type Ty will be returned, not conversion of a
3175 /// variable with the same mangled name but some other type.
3176 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
3177                                                   llvm::Type *Ty,
3178                                            ForDefinition_t IsForDefinition) {
3179   assert(D->hasGlobalStorage() && "Not a global variable");
3180   QualType ASTTy = D->getType();
3181   if (!Ty)
3182     Ty = getTypes().ConvertTypeForMem(ASTTy);
3183 
3184   llvm::PointerType *PTy =
3185     llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
3186 
3187   StringRef MangledName = getMangledName(D);
3188   return GetOrCreateLLVMGlobal(MangledName, PTy, D, IsForDefinition);
3189 }
3190 
3191 /// CreateRuntimeVariable - Create a new runtime global variable with the
3192 /// specified type and name.
3193 llvm::Constant *
3194 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
3195                                      StringRef Name) {
3196   auto *Ret =
3197       GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
3198   setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
3199   return Ret;
3200 }
3201 
3202 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
3203   assert(!D->getInit() && "Cannot emit definite definitions here!");
3204 
3205   StringRef MangledName = getMangledName(D);
3206   llvm::GlobalValue *GV = GetGlobalValue(MangledName);
3207 
3208   // We already have a definition, not declaration, with the same mangled name.
3209   // Emitting of declaration is not required (and actually overwrites emitted
3210   // definition).
3211   if (GV && !GV->isDeclaration())
3212     return;
3213 
3214   // If we have not seen a reference to this variable yet, place it into the
3215   // deferred declarations table to be emitted if needed later.
3216   if (!MustBeEmitted(D) && !GV) {
3217       DeferredDecls[MangledName] = D;
3218       return;
3219   }
3220 
3221   // The tentative definition is the only definition.
3222   EmitGlobalVarDefinition(D);
3223 }
3224 
3225 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
3226   return Context.toCharUnitsFromBits(
3227       getDataLayout().getTypeStoreSizeInBits(Ty));
3228 }
3229 
3230 LangAS CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D) {
3231   LangAS AddrSpace = LangAS::Default;
3232   if (LangOpts.OpenCL) {
3233     AddrSpace = D ? D->getType().getAddressSpace() : LangAS::opencl_global;
3234     assert(AddrSpace == LangAS::opencl_global ||
3235            AddrSpace == LangAS::opencl_constant ||
3236            AddrSpace == LangAS::opencl_local ||
3237            AddrSpace >= LangAS::FirstTargetAddressSpace);
3238     return AddrSpace;
3239   }
3240 
3241   if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
3242     if (D && D->hasAttr<CUDAConstantAttr>())
3243       return LangAS::cuda_constant;
3244     else if (D && D->hasAttr<CUDASharedAttr>())
3245       return LangAS::cuda_shared;
3246     else if (D && D->hasAttr<CUDADeviceAttr>())
3247       return LangAS::cuda_device;
3248     else if (D && D->getType().isConstQualified())
3249       return LangAS::cuda_constant;
3250     else
3251       return LangAS::cuda_device;
3252   }
3253 
3254   return getTargetCodeGenInfo().getGlobalVarAddressSpace(*this, D);
3255 }
3256 
3257 LangAS CodeGenModule::getStringLiteralAddressSpace() const {
3258   // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
3259   if (LangOpts.OpenCL)
3260     return LangAS::opencl_constant;
3261   if (auto AS = getTarget().getConstantAddressSpace())
3262     return AS.getValue();
3263   return LangAS::Default;
3264 }
3265 
3266 // In address space agnostic languages, string literals are in default address
3267 // space in AST. However, certain targets (e.g. amdgcn) request them to be
3268 // emitted in constant address space in LLVM IR. To be consistent with other
3269 // parts of AST, string literal global variables in constant address space
3270 // need to be casted to default address space before being put into address
3271 // map and referenced by other part of CodeGen.
3272 // In OpenCL, string literals are in constant address space in AST, therefore
3273 // they should not be casted to default address space.
3274 static llvm::Constant *
3275 castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM,
3276                                        llvm::GlobalVariable *GV) {
3277   llvm::Constant *Cast = GV;
3278   if (!CGM.getLangOpts().OpenCL) {
3279     if (auto AS = CGM.getTarget().getConstantAddressSpace()) {
3280       if (AS != LangAS::Default)
3281         Cast = CGM.getTargetCodeGenInfo().performAddrSpaceCast(
3282             CGM, GV, AS.getValue(), LangAS::Default,
3283             GV->getValueType()->getPointerTo(
3284                 CGM.getContext().getTargetAddressSpace(LangAS::Default)));
3285     }
3286   }
3287   return Cast;
3288 }
3289 
3290 template<typename SomeDecl>
3291 void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D,
3292                                                llvm::GlobalValue *GV) {
3293   if (!getLangOpts().CPlusPlus)
3294     return;
3295 
3296   // Must have 'used' attribute, or else inline assembly can't rely on
3297   // the name existing.
3298   if (!D->template hasAttr<UsedAttr>())
3299     return;
3300 
3301   // Must have internal linkage and an ordinary name.
3302   if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
3303     return;
3304 
3305   // Must be in an extern "C" context. Entities declared directly within
3306   // a record are not extern "C" even if the record is in such a context.
3307   const SomeDecl *First = D->getFirstDecl();
3308   if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
3309     return;
3310 
3311   // OK, this is an internal linkage entity inside an extern "C" linkage
3312   // specification. Make a note of that so we can give it the "expected"
3313   // mangled name if nothing else is using that name.
3314   std::pair<StaticExternCMap::iterator, bool> R =
3315       StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
3316 
3317   // If we have multiple internal linkage entities with the same name
3318   // in extern "C" regions, none of them gets that name.
3319   if (!R.second)
3320     R.first->second = nullptr;
3321 }
3322 
3323 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
3324   if (!CGM.supportsCOMDAT())
3325     return false;
3326 
3327   if (D.hasAttr<SelectAnyAttr>())
3328     return true;
3329 
3330   GVALinkage Linkage;
3331   if (auto *VD = dyn_cast<VarDecl>(&D))
3332     Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
3333   else
3334     Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
3335 
3336   switch (Linkage) {
3337   case GVA_Internal:
3338   case GVA_AvailableExternally:
3339   case GVA_StrongExternal:
3340     return false;
3341   case GVA_DiscardableODR:
3342   case GVA_StrongODR:
3343     return true;
3344   }
3345   llvm_unreachable("No such linkage");
3346 }
3347 
3348 void CodeGenModule::maybeSetTrivialComdat(const Decl &D,
3349                                           llvm::GlobalObject &GO) {
3350   if (!shouldBeInCOMDAT(*this, D))
3351     return;
3352   GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
3353 }
3354 
3355 /// Pass IsTentative as true if you want to create a tentative definition.
3356 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
3357                                             bool IsTentative) {
3358   // OpenCL global variables of sampler type are translated to function calls,
3359   // therefore no need to be translated.
3360   QualType ASTTy = D->getType();
3361   if (getLangOpts().OpenCL && ASTTy->isSamplerT())
3362     return;
3363 
3364   // If this is OpenMP device, check if it is legal to emit this global
3365   // normally.
3366   if (LangOpts.OpenMPIsDevice && OpenMPRuntime &&
3367       OpenMPRuntime->emitTargetGlobalVariable(D))
3368     return;
3369 
3370   llvm::Constant *Init = nullptr;
3371   CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3372   bool NeedsGlobalCtor = false;
3373   bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
3374 
3375   const VarDecl *InitDecl;
3376   const Expr *InitExpr = D->getAnyInitializer(InitDecl);
3377 
3378   Optional<ConstantEmitter> emitter;
3379 
3380   // CUDA E.2.4.1 "__shared__ variables cannot have an initialization
3381   // as part of their declaration."  Sema has already checked for
3382   // error cases, so we just need to set Init to UndefValue.
3383   if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
3384       D->hasAttr<CUDASharedAttr>())
3385     Init = llvm::UndefValue::get(getTypes().ConvertType(ASTTy));
3386   else if (!InitExpr) {
3387     // This is a tentative definition; tentative definitions are
3388     // implicitly initialized with { 0 }.
3389     //
3390     // Note that tentative definitions are only emitted at the end of
3391     // a translation unit, so they should never have incomplete
3392     // type. In addition, EmitTentativeDefinition makes sure that we
3393     // never attempt to emit a tentative definition if a real one
3394     // exists. A use may still exists, however, so we still may need
3395     // to do a RAUW.
3396     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
3397     Init = EmitNullConstant(D->getType());
3398   } else {
3399     initializedGlobalDecl = GlobalDecl(D);
3400     emitter.emplace(*this);
3401     Init = emitter->tryEmitForInitializer(*InitDecl);
3402 
3403     if (!Init) {
3404       QualType T = InitExpr->getType();
3405       if (D->getType()->isReferenceType())
3406         T = D->getType();
3407 
3408       if (getLangOpts().CPlusPlus) {
3409         Init = EmitNullConstant(T);
3410         NeedsGlobalCtor = true;
3411       } else {
3412         ErrorUnsupported(D, "static initializer");
3413         Init = llvm::UndefValue::get(getTypes().ConvertType(T));
3414       }
3415     } else {
3416       // We don't need an initializer, so remove the entry for the delayed
3417       // initializer position (just in case this entry was delayed) if we
3418       // also don't need to register a destructor.
3419       if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
3420         DelayedCXXInitPosition.erase(D);
3421     }
3422   }
3423 
3424   llvm::Type* InitType = Init->getType();
3425   llvm::Constant *Entry =
3426       GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative));
3427 
3428   // Strip off a bitcast if we got one back.
3429   if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
3430     assert(CE->getOpcode() == llvm::Instruction::BitCast ||
3431            CE->getOpcode() == llvm::Instruction::AddrSpaceCast ||
3432            // All zero index gep.
3433            CE->getOpcode() == llvm::Instruction::GetElementPtr);
3434     Entry = CE->getOperand(0);
3435   }
3436 
3437   // Entry is now either a Function or GlobalVariable.
3438   auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
3439 
3440   // We have a definition after a declaration with the wrong type.
3441   // We must make a new GlobalVariable* and update everything that used OldGV
3442   // (a declaration or tentative definition) with the new GlobalVariable*
3443   // (which will be a definition).
3444   //
3445   // This happens if there is a prototype for a global (e.g.
3446   // "extern int x[];") and then a definition of a different type (e.g.
3447   // "int x[10];"). This also happens when an initializer has a different type
3448   // from the type of the global (this happens with unions).
3449   if (!GV || GV->getType()->getElementType() != InitType ||
3450       GV->getType()->getAddressSpace() !=
3451           getContext().getTargetAddressSpace(GetGlobalVarAddressSpace(D))) {
3452 
3453     // Move the old entry aside so that we'll create a new one.
3454     Entry->setName(StringRef());
3455 
3456     // Make a new global with the correct type, this is now guaranteed to work.
3457     GV = cast<llvm::GlobalVariable>(
3458         GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative)));
3459 
3460     // Replace all uses of the old global with the new global
3461     llvm::Constant *NewPtrForOldDecl =
3462         llvm::ConstantExpr::getBitCast(GV, Entry->getType());
3463     Entry->replaceAllUsesWith(NewPtrForOldDecl);
3464 
3465     // Erase the old global, since it is no longer used.
3466     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
3467   }
3468 
3469   MaybeHandleStaticInExternC(D, GV);
3470 
3471   if (D->hasAttr<AnnotateAttr>())
3472     AddGlobalAnnotations(D, GV);
3473 
3474   // Set the llvm linkage type as appropriate.
3475   llvm::GlobalValue::LinkageTypes Linkage =
3476       getLLVMLinkageVarDefinition(D, GV->isConstant());
3477 
3478   // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on
3479   // the device. [...]"
3480   // CUDA B.2.2 "The __constant__ qualifier, optionally used together with
3481   // __device__, declares a variable that: [...]
3482   // Is accessible from all the threads within the grid and from the host
3483   // through the runtime library (cudaGetSymbolAddress() / cudaGetSymbolSize()
3484   // / cudaMemcpyToSymbol() / cudaMemcpyFromSymbol())."
3485   if (GV && LangOpts.CUDA) {
3486     if (LangOpts.CUDAIsDevice) {
3487       if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>())
3488         GV->setExternallyInitialized(true);
3489     } else {
3490       // Host-side shadows of external declarations of device-side
3491       // global variables become internal definitions. These have to
3492       // be internal in order to prevent name conflicts with global
3493       // host variables with the same name in a different TUs.
3494       if (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()) {
3495         Linkage = llvm::GlobalValue::InternalLinkage;
3496 
3497         // Shadow variables and their properties must be registered
3498         // with CUDA runtime.
3499         unsigned Flags = 0;
3500         if (!D->hasDefinition())
3501           Flags |= CGCUDARuntime::ExternDeviceVar;
3502         if (D->hasAttr<CUDAConstantAttr>())
3503           Flags |= CGCUDARuntime::ConstantDeviceVar;
3504         getCUDARuntime().registerDeviceVar(*GV, Flags);
3505       } else if (D->hasAttr<CUDASharedAttr>())
3506         // __shared__ variables are odd. Shadows do get created, but
3507         // they are not registered with the CUDA runtime, so they
3508         // can't really be used to access their device-side
3509         // counterparts. It's not clear yet whether it's nvcc's bug or
3510         // a feature, but we've got to do the same for compatibility.
3511         Linkage = llvm::GlobalValue::InternalLinkage;
3512     }
3513   }
3514 
3515   GV->setInitializer(Init);
3516   if (emitter) emitter->finalize(GV);
3517 
3518   // If it is safe to mark the global 'constant', do so now.
3519   GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
3520                   isTypeConstant(D->getType(), true));
3521 
3522   // If it is in a read-only section, mark it 'constant'.
3523   if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
3524     const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
3525     if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
3526       GV->setConstant(true);
3527   }
3528 
3529   GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
3530 
3531 
3532   // On Darwin, if the normal linkage of a C++ thread_local variable is
3533   // LinkOnce or Weak, we keep the normal linkage to prevent multiple
3534   // copies within a linkage unit; otherwise, the backing variable has
3535   // internal linkage and all accesses should just be calls to the
3536   // Itanium-specified entry point, which has the normal linkage of the
3537   // variable. This is to preserve the ability to change the implementation
3538   // behind the scenes.
3539   if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
3540       Context.getTargetInfo().getTriple().isOSDarwin() &&
3541       !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) &&
3542       !llvm::GlobalVariable::isWeakLinkage(Linkage))
3543     Linkage = llvm::GlobalValue::InternalLinkage;
3544 
3545   GV->setLinkage(Linkage);
3546   if (D->hasAttr<DLLImportAttr>())
3547     GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
3548   else if (D->hasAttr<DLLExportAttr>())
3549     GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
3550   else
3551     GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
3552 
3553   if (Linkage == llvm::GlobalVariable::CommonLinkage) {
3554     // common vars aren't constant even if declared const.
3555     GV->setConstant(false);
3556     // Tentative definition of global variables may be initialized with
3557     // non-zero null pointers. In this case they should have weak linkage
3558     // since common linkage must have zero initializer and must not have
3559     // explicit section therefore cannot have non-zero initial value.
3560     if (!GV->getInitializer()->isNullValue())
3561       GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
3562   }
3563 
3564   setNonAliasAttributes(D, GV);
3565 
3566   if (D->getTLSKind() && !GV->isThreadLocal()) {
3567     if (D->getTLSKind() == VarDecl::TLS_Dynamic)
3568       CXXThreadLocals.push_back(D);
3569     setTLSMode(GV, *D);
3570   }
3571 
3572   maybeSetTrivialComdat(*D, *GV);
3573 
3574   // Emit the initializer function if necessary.
3575   if (NeedsGlobalCtor || NeedsGlobalDtor)
3576     EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
3577 
3578   SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
3579 
3580   // Emit global variable debug information.
3581   if (CGDebugInfo *DI = getModuleDebugInfo())
3582     if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
3583       DI->EmitGlobalVariable(GV, D);
3584 }
3585 
3586 static bool isVarDeclStrongDefinition(const ASTContext &Context,
3587                                       CodeGenModule &CGM, const VarDecl *D,
3588                                       bool NoCommon) {
3589   // Don't give variables common linkage if -fno-common was specified unless it
3590   // was overridden by a NoCommon attribute.
3591   if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
3592     return true;
3593 
3594   // C11 6.9.2/2:
3595   //   A declaration of an identifier for an object that has file scope without
3596   //   an initializer, and without a storage-class specifier or with the
3597   //   storage-class specifier static, constitutes a tentative definition.
3598   if (D->getInit() || D->hasExternalStorage())
3599     return true;
3600 
3601   // A variable cannot be both common and exist in a section.
3602   if (D->hasAttr<SectionAttr>())
3603     return true;
3604 
3605   // A variable cannot be both common and exist in a section.
3606   // We don't try to determine which is the right section in the front-end.
3607   // If no specialized section name is applicable, it will resort to default.
3608   if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
3609       D->hasAttr<PragmaClangDataSectionAttr>() ||
3610       D->hasAttr<PragmaClangRodataSectionAttr>())
3611     return true;
3612 
3613   // Thread local vars aren't considered common linkage.
3614   if (D->getTLSKind())
3615     return true;
3616 
3617   // Tentative definitions marked with WeakImportAttr are true definitions.
3618   if (D->hasAttr<WeakImportAttr>())
3619     return true;
3620 
3621   // A variable cannot be both common and exist in a comdat.
3622   if (shouldBeInCOMDAT(CGM, *D))
3623     return true;
3624 
3625   // Declarations with a required alignment do not have common linkage in MSVC
3626   // mode.
3627   if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
3628     if (D->hasAttr<AlignedAttr>())
3629       return true;
3630     QualType VarType = D->getType();
3631     if (Context.isAlignmentRequired(VarType))
3632       return true;
3633 
3634     if (const auto *RT = VarType->getAs<RecordType>()) {
3635       const RecordDecl *RD = RT->getDecl();
3636       for (const FieldDecl *FD : RD->fields()) {
3637         if (FD->isBitField())
3638           continue;
3639         if (FD->hasAttr<AlignedAttr>())
3640           return true;
3641         if (Context.isAlignmentRequired(FD->getType()))
3642           return true;
3643       }
3644     }
3645   }
3646 
3647   return false;
3648 }
3649 
3650 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(
3651     const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) {
3652   if (Linkage == GVA_Internal)
3653     return llvm::Function::InternalLinkage;
3654 
3655   if (D->hasAttr<WeakAttr>()) {
3656     if (IsConstantVariable)
3657       return llvm::GlobalVariable::WeakODRLinkage;
3658     else
3659       return llvm::GlobalVariable::WeakAnyLinkage;
3660   }
3661 
3662   // We are guaranteed to have a strong definition somewhere else,
3663   // so we can use available_externally linkage.
3664   if (Linkage == GVA_AvailableExternally)
3665     return llvm::GlobalValue::AvailableExternallyLinkage;
3666 
3667   // Note that Apple's kernel linker doesn't support symbol
3668   // coalescing, so we need to avoid linkonce and weak linkages there.
3669   // Normally, this means we just map to internal, but for explicit
3670   // instantiations we'll map to external.
3671 
3672   // In C++, the compiler has to emit a definition in every translation unit
3673   // that references the function.  We should use linkonce_odr because
3674   // a) if all references in this translation unit are optimized away, we
3675   // don't need to codegen it.  b) if the function persists, it needs to be
3676   // merged with other definitions. c) C++ has the ODR, so we know the
3677   // definition is dependable.
3678   if (Linkage == GVA_DiscardableODR)
3679     return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
3680                                             : llvm::Function::InternalLinkage;
3681 
3682   // An explicit instantiation of a template has weak linkage, since
3683   // explicit instantiations can occur in multiple translation units
3684   // and must all be equivalent. However, we are not allowed to
3685   // throw away these explicit instantiations.
3686   //
3687   // We don't currently support CUDA device code spread out across multiple TUs,
3688   // so say that CUDA templates are either external (for kernels) or internal.
3689   // This lets llvm perform aggressive inter-procedural optimizations.
3690   if (Linkage == GVA_StrongODR) {
3691     if (Context.getLangOpts().AppleKext)
3692       return llvm::Function::ExternalLinkage;
3693     if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice)
3694       return D->hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
3695                                           : llvm::Function::InternalLinkage;
3696     return llvm::Function::WeakODRLinkage;
3697   }
3698 
3699   // C++ doesn't have tentative definitions and thus cannot have common
3700   // linkage.
3701   if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
3702       !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D),
3703                                  CodeGenOpts.NoCommon))
3704     return llvm::GlobalVariable::CommonLinkage;
3705 
3706   // selectany symbols are externally visible, so use weak instead of
3707   // linkonce.  MSVC optimizes away references to const selectany globals, so
3708   // all definitions should be the same and ODR linkage should be used.
3709   // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
3710   if (D->hasAttr<SelectAnyAttr>())
3711     return llvm::GlobalVariable::WeakODRLinkage;
3712 
3713   // Otherwise, we have strong external linkage.
3714   assert(Linkage == GVA_StrongExternal);
3715   return llvm::GlobalVariable::ExternalLinkage;
3716 }
3717 
3718 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(
3719     const VarDecl *VD, bool IsConstant) {
3720   GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD);
3721   return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant);
3722 }
3723 
3724 /// Replace the uses of a function that was declared with a non-proto type.
3725 /// We want to silently drop extra arguments from call sites
3726 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
3727                                           llvm::Function *newFn) {
3728   // Fast path.
3729   if (old->use_empty()) return;
3730 
3731   llvm::Type *newRetTy = newFn->getReturnType();
3732   SmallVector<llvm::Value*, 4> newArgs;
3733   SmallVector<llvm::OperandBundleDef, 1> newBundles;
3734 
3735   for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
3736          ui != ue; ) {
3737     llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
3738     llvm::User *user = use->getUser();
3739 
3740     // Recognize and replace uses of bitcasts.  Most calls to
3741     // unprototyped functions will use bitcasts.
3742     if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
3743       if (bitcast->getOpcode() == llvm::Instruction::BitCast)
3744         replaceUsesOfNonProtoConstant(bitcast, newFn);
3745       continue;
3746     }
3747 
3748     // Recognize calls to the function.
3749     llvm::CallSite callSite(user);
3750     if (!callSite) continue;
3751     if (!callSite.isCallee(&*use)) continue;
3752 
3753     // If the return types don't match exactly, then we can't
3754     // transform this call unless it's dead.
3755     if (callSite->getType() != newRetTy && !callSite->use_empty())
3756       continue;
3757 
3758     // Get the call site's attribute list.
3759     SmallVector<llvm::AttributeSet, 8> newArgAttrs;
3760     llvm::AttributeList oldAttrs = callSite.getAttributes();
3761 
3762     // If the function was passed too few arguments, don't transform.
3763     unsigned newNumArgs = newFn->arg_size();
3764     if (callSite.arg_size() < newNumArgs) continue;
3765 
3766     // If extra arguments were passed, we silently drop them.
3767     // If any of the types mismatch, we don't transform.
3768     unsigned argNo = 0;
3769     bool dontTransform = false;
3770     for (llvm::Argument &A : newFn->args()) {
3771       if (callSite.getArgument(argNo)->getType() != A.getType()) {
3772         dontTransform = true;
3773         break;
3774       }
3775 
3776       // Add any parameter attributes.
3777       newArgAttrs.push_back(oldAttrs.getParamAttributes(argNo));
3778       argNo++;
3779     }
3780     if (dontTransform)
3781       continue;
3782 
3783     // Okay, we can transform this.  Create the new call instruction and copy
3784     // over the required information.
3785     newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
3786 
3787     // Copy over any operand bundles.
3788     callSite.getOperandBundlesAsDefs(newBundles);
3789 
3790     llvm::CallSite newCall;
3791     if (callSite.isCall()) {
3792       newCall = llvm::CallInst::Create(newFn, newArgs, newBundles, "",
3793                                        callSite.getInstruction());
3794     } else {
3795       auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction());
3796       newCall = llvm::InvokeInst::Create(newFn,
3797                                          oldInvoke->getNormalDest(),
3798                                          oldInvoke->getUnwindDest(),
3799                                          newArgs, newBundles, "",
3800                                          callSite.getInstruction());
3801     }
3802     newArgs.clear(); // for the next iteration
3803 
3804     if (!newCall->getType()->isVoidTy())
3805       newCall->takeName(callSite.getInstruction());
3806     newCall.setAttributes(llvm::AttributeList::get(
3807         newFn->getContext(), oldAttrs.getFnAttributes(),
3808         oldAttrs.getRetAttributes(), newArgAttrs));
3809     newCall.setCallingConv(callSite.getCallingConv());
3810 
3811     // Finally, remove the old call, replacing any uses with the new one.
3812     if (!callSite->use_empty())
3813       callSite->replaceAllUsesWith(newCall.getInstruction());
3814 
3815     // Copy debug location attached to CI.
3816     if (callSite->getDebugLoc())
3817       newCall->setDebugLoc(callSite->getDebugLoc());
3818 
3819     callSite->eraseFromParent();
3820   }
3821 }
3822 
3823 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
3824 /// implement a function with no prototype, e.g. "int foo() {}".  If there are
3825 /// existing call uses of the old function in the module, this adjusts them to
3826 /// call the new function directly.
3827 ///
3828 /// This is not just a cleanup: the always_inline pass requires direct calls to
3829 /// functions to be able to inline them.  If there is a bitcast in the way, it
3830 /// won't inline them.  Instcombine normally deletes these calls, but it isn't
3831 /// run at -O0.
3832 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
3833                                                       llvm::Function *NewFn) {
3834   // If we're redefining a global as a function, don't transform it.
3835   if (!isa<llvm::Function>(Old)) return;
3836 
3837   replaceUsesOfNonProtoConstant(Old, NewFn);
3838 }
3839 
3840 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
3841   auto DK = VD->isThisDeclarationADefinition();
3842   if (DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>())
3843     return;
3844 
3845   TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
3846   // If we have a definition, this might be a deferred decl. If the
3847   // instantiation is explicit, make sure we emit it at the end.
3848   if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
3849     GetAddrOfGlobalVar(VD);
3850 
3851   EmitTopLevelDecl(VD);
3852 }
3853 
3854 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
3855                                                  llvm::GlobalValue *GV) {
3856   const auto *D = cast<FunctionDecl>(GD.getDecl());
3857 
3858   // Compute the function info and LLVM type.
3859   const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
3860   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
3861 
3862   // Get or create the prototype for the function.
3863   if (!GV || (GV->getType()->getElementType() != Ty))
3864     GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
3865                                                    /*DontDefer=*/true,
3866                                                    ForDefinition));
3867 
3868   // Already emitted.
3869   if (!GV->isDeclaration())
3870     return;
3871 
3872   // We need to set linkage and visibility on the function before
3873   // generating code for it because various parts of IR generation
3874   // want to propagate this information down (e.g. to local static
3875   // declarations).
3876   auto *Fn = cast<llvm::Function>(GV);
3877   setFunctionLinkage(GD, Fn);
3878 
3879   // FIXME: this is redundant with part of setFunctionDefinitionAttributes
3880   setGVProperties(Fn, GD);
3881 
3882   MaybeHandleStaticInExternC(D, Fn);
3883 
3884 
3885   maybeSetTrivialComdat(*D, *Fn);
3886 
3887   CodeGenFunction(*this).GenerateCode(D, Fn, FI);
3888 
3889   setNonAliasAttributes(GD, Fn);
3890   SetLLVMFunctionAttributesForDefinition(D, Fn);
3891 
3892   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
3893     AddGlobalCtor(Fn, CA->getPriority());
3894   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
3895     AddGlobalDtor(Fn, DA->getPriority());
3896   if (D->hasAttr<AnnotateAttr>())
3897     AddGlobalAnnotations(D, Fn);
3898 
3899   if (D->isCPUSpecificMultiVersion()) {
3900     auto *Spec = D->getAttr<CPUSpecificAttr>();
3901     // If there is another specific version we need to emit, do so here.
3902     if (Spec->ActiveArgIndex + 1 < Spec->cpus_size()) {
3903       ++Spec->ActiveArgIndex;
3904       EmitGlobalFunctionDefinition(GD, nullptr);
3905     }
3906   }
3907 }
3908 
3909 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
3910   const auto *D = cast<ValueDecl>(GD.getDecl());
3911   const AliasAttr *AA = D->getAttr<AliasAttr>();
3912   assert(AA && "Not an alias?");
3913 
3914   StringRef MangledName = getMangledName(GD);
3915 
3916   if (AA->getAliasee() == MangledName) {
3917     Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
3918     return;
3919   }
3920 
3921   // If there is a definition in the module, then it wins over the alias.
3922   // This is dubious, but allow it to be safe.  Just ignore the alias.
3923   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3924   if (Entry && !Entry->isDeclaration())
3925     return;
3926 
3927   Aliases.push_back(GD);
3928 
3929   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
3930 
3931   // Create a reference to the named value.  This ensures that it is emitted
3932   // if a deferred decl.
3933   llvm::Constant *Aliasee;
3934   if (isa<llvm::FunctionType>(DeclTy))
3935     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
3936                                       /*ForVTable=*/false);
3937   else
3938     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
3939                                     llvm::PointerType::getUnqual(DeclTy),
3940                                     /*D=*/nullptr);
3941 
3942   // Create the new alias itself, but don't set a name yet.
3943   auto *GA = llvm::GlobalAlias::create(
3944       DeclTy, 0, llvm::Function::ExternalLinkage, "", Aliasee, &getModule());
3945 
3946   if (Entry) {
3947     if (GA->getAliasee() == Entry) {
3948       Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
3949       return;
3950     }
3951 
3952     assert(Entry->isDeclaration());
3953 
3954     // If there is a declaration in the module, then we had an extern followed
3955     // by the alias, as in:
3956     //   extern int test6();
3957     //   ...
3958     //   int test6() __attribute__((alias("test7")));
3959     //
3960     // Remove it and replace uses of it with the alias.
3961     GA->takeName(Entry);
3962 
3963     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
3964                                                           Entry->getType()));
3965     Entry->eraseFromParent();
3966   } else {
3967     GA->setName(MangledName);
3968   }
3969 
3970   // Set attributes which are particular to an alias; this is a
3971   // specialization of the attributes which may be set on a global
3972   // variable/function.
3973   if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
3974       D->isWeakImported()) {
3975     GA->setLinkage(llvm::Function::WeakAnyLinkage);
3976   }
3977 
3978   if (const auto *VD = dyn_cast<VarDecl>(D))
3979     if (VD->getTLSKind())
3980       setTLSMode(GA, *VD);
3981 
3982   SetCommonAttributes(GD, GA);
3983 }
3984 
3985 void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) {
3986   const auto *D = cast<ValueDecl>(GD.getDecl());
3987   const IFuncAttr *IFA = D->getAttr<IFuncAttr>();
3988   assert(IFA && "Not an ifunc?");
3989 
3990   StringRef MangledName = getMangledName(GD);
3991 
3992   if (IFA->getResolver() == MangledName) {
3993     Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
3994     return;
3995   }
3996 
3997   // Report an error if some definition overrides ifunc.
3998   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
3999   if (Entry && !Entry->isDeclaration()) {
4000     GlobalDecl OtherGD;
4001     if (lookupRepresentativeDecl(MangledName, OtherGD) &&
4002         DiagnosedConflictingDefinitions.insert(GD).second) {
4003       Diags.Report(D->getLocation(), diag::err_duplicate_mangled_name)
4004           << MangledName;
4005       Diags.Report(OtherGD.getDecl()->getLocation(),
4006                    diag::note_previous_definition);
4007     }
4008     return;
4009   }
4010 
4011   Aliases.push_back(GD);
4012 
4013   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
4014   llvm::Constant *Resolver =
4015       GetOrCreateLLVMFunction(IFA->getResolver(), DeclTy, GD,
4016                               /*ForVTable=*/false);
4017   llvm::GlobalIFunc *GIF =
4018       llvm::GlobalIFunc::create(DeclTy, 0, llvm::Function::ExternalLinkage,
4019                                 "", Resolver, &getModule());
4020   if (Entry) {
4021     if (GIF->getResolver() == Entry) {
4022       Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
4023       return;
4024     }
4025     assert(Entry->isDeclaration());
4026 
4027     // If there is a declaration in the module, then we had an extern followed
4028     // by the ifunc, as in:
4029     //   extern int test();
4030     //   ...
4031     //   int test() __attribute__((ifunc("resolver")));
4032     //
4033     // Remove it and replace uses of it with the ifunc.
4034     GIF->takeName(Entry);
4035 
4036     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GIF,
4037                                                           Entry->getType()));
4038     Entry->eraseFromParent();
4039   } else
4040     GIF->setName(MangledName);
4041 
4042   SetCommonAttributes(GD, GIF);
4043 }
4044 
4045 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
4046                                             ArrayRef<llvm::Type*> Tys) {
4047   return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
4048                                          Tys);
4049 }
4050 
4051 static llvm::StringMapEntry<llvm::GlobalVariable *> &
4052 GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
4053                          const StringLiteral *Literal, bool TargetIsLSB,
4054                          bool &IsUTF16, unsigned &StringLength) {
4055   StringRef String = Literal->getString();
4056   unsigned NumBytes = String.size();
4057 
4058   // Check for simple case.
4059   if (!Literal->containsNonAsciiOrNull()) {
4060     StringLength = NumBytes;
4061     return *Map.insert(std::make_pair(String, nullptr)).first;
4062   }
4063 
4064   // Otherwise, convert the UTF8 literals into a string of shorts.
4065   IsUTF16 = true;
4066 
4067   SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
4068   const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
4069   llvm::UTF16 *ToPtr = &ToBuf[0];
4070 
4071   (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
4072                                  ToPtr + NumBytes, llvm::strictConversion);
4073 
4074   // ConvertUTF8toUTF16 returns the length in ToPtr.
4075   StringLength = ToPtr - &ToBuf[0];
4076 
4077   // Add an explicit null.
4078   *ToPtr = 0;
4079   return *Map.insert(std::make_pair(
4080                          StringRef(reinterpret_cast<const char *>(ToBuf.data()),
4081                                    (StringLength + 1) * 2),
4082                          nullptr)).first;
4083 }
4084 
4085 ConstantAddress
4086 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
4087   unsigned StringLength = 0;
4088   bool isUTF16 = false;
4089   llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
4090       GetConstantCFStringEntry(CFConstantStringMap, Literal,
4091                                getDataLayout().isLittleEndian(), isUTF16,
4092                                StringLength);
4093 
4094   if (auto *C = Entry.second)
4095     return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
4096 
4097   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
4098   llvm::Constant *Zeros[] = { Zero, Zero };
4099 
4100   // If we don't already have it, get __CFConstantStringClassReference.
4101   if (!CFConstantStringClassRef) {
4102     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
4103     Ty = llvm::ArrayType::get(Ty, 0);
4104     llvm::GlobalValue *GV = cast<llvm::GlobalValue>(
4105         CreateRuntimeVariable(Ty, "__CFConstantStringClassReference"));
4106 
4107     if (getTriple().isOSBinFormatCOFF()) {
4108       IdentifierInfo &II = getContext().Idents.get(GV->getName());
4109       TranslationUnitDecl *TUDecl = getContext().getTranslationUnitDecl();
4110       DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
4111 
4112       const VarDecl *VD = nullptr;
4113       for (const auto &Result : DC->lookup(&II))
4114         if ((VD = dyn_cast<VarDecl>(Result)))
4115           break;
4116 
4117       if (!VD || !VD->hasAttr<DLLExportAttr>()) {
4118         GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4119         GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
4120       } else {
4121         GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
4122         GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
4123       }
4124     }
4125     setDSOLocal(GV);
4126 
4127     // Decay array -> ptr
4128     CFConstantStringClassRef =
4129         llvm::ConstantExpr::getGetElementPtr(Ty, GV, Zeros);
4130   }
4131 
4132   QualType CFTy = getContext().getCFConstantStringType();
4133 
4134   auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
4135 
4136   ConstantInitBuilder Builder(*this);
4137   auto Fields = Builder.beginStruct(STy);
4138 
4139   // Class pointer.
4140   Fields.add(cast<llvm::ConstantExpr>(CFConstantStringClassRef));
4141 
4142   // Flags.
4143   Fields.addInt(IntTy, isUTF16 ? 0x07d0 : 0x07C8);
4144 
4145   // String pointer.
4146   llvm::Constant *C = nullptr;
4147   if (isUTF16) {
4148     auto Arr = llvm::makeArrayRef(
4149         reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
4150         Entry.first().size() / 2);
4151     C = llvm::ConstantDataArray::get(VMContext, Arr);
4152   } else {
4153     C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
4154   }
4155 
4156   // Note: -fwritable-strings doesn't make the backing store strings of
4157   // CFStrings writable. (See <rdar://problem/10657500>)
4158   auto *GV =
4159       new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
4160                                llvm::GlobalValue::PrivateLinkage, C, ".str");
4161   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4162   // Don't enforce the target's minimum global alignment, since the only use
4163   // of the string is via this class initializer.
4164   CharUnits Align = isUTF16
4165                         ? getContext().getTypeAlignInChars(getContext().ShortTy)
4166                         : getContext().getTypeAlignInChars(getContext().CharTy);
4167   GV->setAlignment(Align.getQuantity());
4168 
4169   // FIXME: We set the section explicitly to avoid a bug in ld64 224.1.
4170   // Without it LLVM can merge the string with a non unnamed_addr one during
4171   // LTO.  Doing that changes the section it ends in, which surprises ld64.
4172   if (getTriple().isOSBinFormatMachO())
4173     GV->setSection(isUTF16 ? "__TEXT,__ustring"
4174                            : "__TEXT,__cstring,cstring_literals");
4175 
4176   // String.
4177   llvm::Constant *Str =
4178       llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
4179 
4180   if (isUTF16)
4181     // Cast the UTF16 string to the correct type.
4182     Str = llvm::ConstantExpr::getBitCast(Str, Int8PtrTy);
4183   Fields.add(Str);
4184 
4185   // String length.
4186   auto Ty = getTypes().ConvertType(getContext().LongTy);
4187   Fields.addInt(cast<llvm::IntegerType>(Ty), StringLength);
4188 
4189   CharUnits Alignment = getPointerAlign();
4190 
4191   // The struct.
4192   GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment,
4193                                     /*isConstant=*/false,
4194                                     llvm::GlobalVariable::PrivateLinkage);
4195   switch (getTriple().getObjectFormat()) {
4196   case llvm::Triple::UnknownObjectFormat:
4197     llvm_unreachable("unknown file format");
4198   case llvm::Triple::COFF:
4199   case llvm::Triple::ELF:
4200   case llvm::Triple::Wasm:
4201     GV->setSection("cfstring");
4202     break;
4203   case llvm::Triple::MachO:
4204     GV->setSection("__DATA,__cfstring");
4205     break;
4206   }
4207   Entry.second = GV;
4208 
4209   return ConstantAddress(GV, Alignment);
4210 }
4211 
4212 bool CodeGenModule::getExpressionLocationsEnabled() const {
4213   return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
4214 }
4215 
4216 QualType CodeGenModule::getObjCFastEnumerationStateType() {
4217   if (ObjCFastEnumerationStateType.isNull()) {
4218     RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
4219     D->startDefinition();
4220 
4221     QualType FieldTypes[] = {
4222       Context.UnsignedLongTy,
4223       Context.getPointerType(Context.getObjCIdType()),
4224       Context.getPointerType(Context.UnsignedLongTy),
4225       Context.getConstantArrayType(Context.UnsignedLongTy,
4226                            llvm::APInt(32, 5), ArrayType::Normal, 0)
4227     };
4228 
4229     for (size_t i = 0; i < 4; ++i) {
4230       FieldDecl *Field = FieldDecl::Create(Context,
4231                                            D,
4232                                            SourceLocation(),
4233                                            SourceLocation(), nullptr,
4234                                            FieldTypes[i], /*TInfo=*/nullptr,
4235                                            /*BitWidth=*/nullptr,
4236                                            /*Mutable=*/false,
4237                                            ICIS_NoInit);
4238       Field->setAccess(AS_public);
4239       D->addDecl(Field);
4240     }
4241 
4242     D->completeDefinition();
4243     ObjCFastEnumerationStateType = Context.getTagDeclType(D);
4244   }
4245 
4246   return ObjCFastEnumerationStateType;
4247 }
4248 
4249 llvm::Constant *
4250 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
4251   assert(!E->getType()->isPointerType() && "Strings are always arrays");
4252 
4253   // Don't emit it as the address of the string, emit the string data itself
4254   // as an inline array.
4255   if (E->getCharByteWidth() == 1) {
4256     SmallString<64> Str(E->getString());
4257 
4258     // Resize the string to the right size, which is indicated by its type.
4259     const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
4260     Str.resize(CAT->getSize().getZExtValue());
4261     return llvm::ConstantDataArray::getString(VMContext, Str, false);
4262   }
4263 
4264   auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
4265   llvm::Type *ElemTy = AType->getElementType();
4266   unsigned NumElements = AType->getNumElements();
4267 
4268   // Wide strings have either 2-byte or 4-byte elements.
4269   if (ElemTy->getPrimitiveSizeInBits() == 16) {
4270     SmallVector<uint16_t, 32> Elements;
4271     Elements.reserve(NumElements);
4272 
4273     for(unsigned i = 0, e = E->getLength(); i != e; ++i)
4274       Elements.push_back(E->getCodeUnit(i));
4275     Elements.resize(NumElements);
4276     return llvm::ConstantDataArray::get(VMContext, Elements);
4277   }
4278 
4279   assert(ElemTy->getPrimitiveSizeInBits() == 32);
4280   SmallVector<uint32_t, 32> Elements;
4281   Elements.reserve(NumElements);
4282 
4283   for(unsigned i = 0, e = E->getLength(); i != e; ++i)
4284     Elements.push_back(E->getCodeUnit(i));
4285   Elements.resize(NumElements);
4286   return llvm::ConstantDataArray::get(VMContext, Elements);
4287 }
4288 
4289 static llvm::GlobalVariable *
4290 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
4291                       CodeGenModule &CGM, StringRef GlobalName,
4292                       CharUnits Alignment) {
4293   unsigned AddrSpace = CGM.getContext().getTargetAddressSpace(
4294       CGM.getStringLiteralAddressSpace());
4295 
4296   llvm::Module &M = CGM.getModule();
4297   // Create a global variable for this string
4298   auto *GV = new llvm::GlobalVariable(
4299       M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
4300       nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
4301   GV->setAlignment(Alignment.getQuantity());
4302   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4303   if (GV->isWeakForLinker()) {
4304     assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
4305     GV->setComdat(M.getOrInsertComdat(GV->getName()));
4306   }
4307   CGM.setDSOLocal(GV);
4308 
4309   return GV;
4310 }
4311 
4312 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
4313 /// constant array for the given string literal.
4314 ConstantAddress
4315 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
4316                                                   StringRef Name) {
4317   CharUnits Alignment = getContext().getAlignOfGlobalVarInChars(S->getType());
4318 
4319   llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
4320   llvm::GlobalVariable **Entry = nullptr;
4321   if (!LangOpts.WritableStrings) {
4322     Entry = &ConstantStringMap[C];
4323     if (auto GV = *Entry) {
4324       if (Alignment.getQuantity() > GV->getAlignment())
4325         GV->setAlignment(Alignment.getQuantity());
4326       return ConstantAddress(GV, Alignment);
4327     }
4328   }
4329 
4330   SmallString<256> MangledNameBuffer;
4331   StringRef GlobalVariableName;
4332   llvm::GlobalValue::LinkageTypes LT;
4333 
4334   // Mangle the string literal if that's how the ABI merges duplicate strings.
4335   // Don't do it if they are writable, since we don't want writes in one TU to
4336   // affect strings in another.
4337   if (getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
4338       !LangOpts.WritableStrings) {
4339     llvm::raw_svector_ostream Out(MangledNameBuffer);
4340     getCXXABI().getMangleContext().mangleStringLiteral(S, Out);
4341     LT = llvm::GlobalValue::LinkOnceODRLinkage;
4342     GlobalVariableName = MangledNameBuffer;
4343   } else {
4344     LT = llvm::GlobalValue::PrivateLinkage;
4345     GlobalVariableName = Name;
4346   }
4347 
4348   auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
4349   if (Entry)
4350     *Entry = GV;
4351 
4352   SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
4353                                   QualType());
4354 
4355   return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV),
4356                          Alignment);
4357 }
4358 
4359 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
4360 /// array for the given ObjCEncodeExpr node.
4361 ConstantAddress
4362 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
4363   std::string Str;
4364   getContext().getObjCEncodingForType(E->getEncodedType(), Str);
4365 
4366   return GetAddrOfConstantCString(Str);
4367 }
4368 
4369 /// GetAddrOfConstantCString - Returns a pointer to a character array containing
4370 /// the literal and a terminating '\0' character.
4371 /// The result has pointer to array type.
4372 ConstantAddress CodeGenModule::GetAddrOfConstantCString(
4373     const std::string &Str, const char *GlobalName) {
4374   StringRef StrWithNull(Str.c_str(), Str.size() + 1);
4375   CharUnits Alignment =
4376     getContext().getAlignOfGlobalVarInChars(getContext().CharTy);
4377 
4378   llvm::Constant *C =
4379       llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
4380 
4381   // Don't share any string literals if strings aren't constant.
4382   llvm::GlobalVariable **Entry = nullptr;
4383   if (!LangOpts.WritableStrings) {
4384     Entry = &ConstantStringMap[C];
4385     if (auto GV = *Entry) {
4386       if (Alignment.getQuantity() > GV->getAlignment())
4387         GV->setAlignment(Alignment.getQuantity());
4388       return ConstantAddress(GV, Alignment);
4389     }
4390   }
4391 
4392   // Get the default prefix if a name wasn't specified.
4393   if (!GlobalName)
4394     GlobalName = ".str";
4395   // Create a global variable for this.
4396   auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
4397                                   GlobalName, Alignment);
4398   if (Entry)
4399     *Entry = GV;
4400 
4401   return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV),
4402                          Alignment);
4403 }
4404 
4405 ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
4406     const MaterializeTemporaryExpr *E, const Expr *Init) {
4407   assert((E->getStorageDuration() == SD_Static ||
4408           E->getStorageDuration() == SD_Thread) && "not a global temporary");
4409   const auto *VD = cast<VarDecl>(E->getExtendingDecl());
4410 
4411   // If we're not materializing a subobject of the temporary, keep the
4412   // cv-qualifiers from the type of the MaterializeTemporaryExpr.
4413   QualType MaterializedType = Init->getType();
4414   if (Init == E->GetTemporaryExpr())
4415     MaterializedType = E->getType();
4416 
4417   CharUnits Align = getContext().getTypeAlignInChars(MaterializedType);
4418 
4419   if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E])
4420     return ConstantAddress(Slot, Align);
4421 
4422   // FIXME: If an externally-visible declaration extends multiple temporaries,
4423   // we need to give each temporary the same name in every translation unit (and
4424   // we also need to make the temporaries externally-visible).
4425   SmallString<256> Name;
4426   llvm::raw_svector_ostream Out(Name);
4427   getCXXABI().getMangleContext().mangleReferenceTemporary(
4428       VD, E->getManglingNumber(), Out);
4429 
4430   APValue *Value = nullptr;
4431   if (E->getStorageDuration() == SD_Static) {
4432     // We might have a cached constant initializer for this temporary. Note
4433     // that this might have a different value from the value computed by
4434     // evaluating the initializer if the surrounding constant expression
4435     // modifies the temporary.
4436     Value = getContext().getMaterializedTemporaryValue(E, false);
4437     if (Value && Value->isUninit())
4438       Value = nullptr;
4439   }
4440 
4441   // Try evaluating it now, it might have a constant initializer.
4442   Expr::EvalResult EvalResult;
4443   if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
4444       !EvalResult.hasSideEffects())
4445     Value = &EvalResult.Val;
4446 
4447   LangAS AddrSpace =
4448       VD ? GetGlobalVarAddressSpace(VD) : MaterializedType.getAddressSpace();
4449 
4450   Optional<ConstantEmitter> emitter;
4451   llvm::Constant *InitialValue = nullptr;
4452   bool Constant = false;
4453   llvm::Type *Type;
4454   if (Value) {
4455     // The temporary has a constant initializer, use it.
4456     emitter.emplace(*this);
4457     InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
4458                                                MaterializedType);
4459     Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
4460     Type = InitialValue->getType();
4461   } else {
4462     // No initializer, the initialization will be provided when we
4463     // initialize the declaration which performed lifetime extension.
4464     Type = getTypes().ConvertTypeForMem(MaterializedType);
4465   }
4466 
4467   // Create a global variable for this lifetime-extended temporary.
4468   llvm::GlobalValue::LinkageTypes Linkage =
4469       getLLVMLinkageVarDefinition(VD, Constant);
4470   if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
4471     const VarDecl *InitVD;
4472     if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
4473         isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
4474       // Temporaries defined inside a class get linkonce_odr linkage because the
4475       // class can be defined in multiple translation units.
4476       Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
4477     } else {
4478       // There is no need for this temporary to have external linkage if the
4479       // VarDecl has external linkage.
4480       Linkage = llvm::GlobalVariable::InternalLinkage;
4481     }
4482   }
4483   auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);
4484   auto *GV = new llvm::GlobalVariable(
4485       getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
4486       /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
4487   if (emitter) emitter->finalize(GV);
4488   setGVProperties(GV, VD);
4489   GV->setAlignment(Align.getQuantity());
4490   if (supportsCOMDAT() && GV->isWeakForLinker())
4491     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4492   if (VD->getTLSKind())
4493     setTLSMode(GV, *VD);
4494   llvm::Constant *CV = GV;
4495   if (AddrSpace != LangAS::Default)
4496     CV = getTargetCodeGenInfo().performAddrSpaceCast(
4497         *this, GV, AddrSpace, LangAS::Default,
4498         Type->getPointerTo(
4499             getContext().getTargetAddressSpace(LangAS::Default)));
4500   MaterializedGlobalTemporaryMap[E] = CV;
4501   return ConstantAddress(CV, Align);
4502 }
4503 
4504 /// EmitObjCPropertyImplementations - Emit information for synthesized
4505 /// properties for an implementation.
4506 void CodeGenModule::EmitObjCPropertyImplementations(const
4507                                                     ObjCImplementationDecl *D) {
4508   for (const auto *PID : D->property_impls()) {
4509     // Dynamic is just for type-checking.
4510     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
4511       ObjCPropertyDecl *PD = PID->getPropertyDecl();
4512 
4513       // Determine which methods need to be implemented, some may have
4514       // been overridden. Note that ::isPropertyAccessor is not the method
4515       // we want, that just indicates if the decl came from a
4516       // property. What we want to know is if the method is defined in
4517       // this implementation.
4518       if (!D->getInstanceMethod(PD->getGetterName()))
4519         CodeGenFunction(*this).GenerateObjCGetter(
4520                                  const_cast<ObjCImplementationDecl *>(D), PID);
4521       if (!PD->isReadOnly() &&
4522           !D->getInstanceMethod(PD->getSetterName()))
4523         CodeGenFunction(*this).GenerateObjCSetter(
4524                                  const_cast<ObjCImplementationDecl *>(D), PID);
4525     }
4526   }
4527 }
4528 
4529 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
4530   const ObjCInterfaceDecl *iface = impl->getClassInterface();
4531   for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
4532        ivar; ivar = ivar->getNextIvar())
4533     if (ivar->getType().isDestructedType())
4534       return true;
4535 
4536   return false;
4537 }
4538 
4539 static bool AllTrivialInitializers(CodeGenModule &CGM,
4540                                    ObjCImplementationDecl *D) {
4541   CodeGenFunction CGF(CGM);
4542   for (ObjCImplementationDecl::init_iterator B = D->init_begin(),
4543        E = D->init_end(); B != E; ++B) {
4544     CXXCtorInitializer *CtorInitExp = *B;
4545     Expr *Init = CtorInitExp->getInit();
4546     if (!CGF.isTrivialInitializer(Init))
4547       return false;
4548   }
4549   return true;
4550 }
4551 
4552 /// EmitObjCIvarInitializations - Emit information for ivar initialization
4553 /// for an implementation.
4554 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
4555   // We might need a .cxx_destruct even if we don't have any ivar initializers.
4556   if (needsDestructMethod(D)) {
4557     IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
4558     Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
4559     ObjCMethodDecl *DTORMethod =
4560       ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
4561                              cxxSelector, getContext().VoidTy, nullptr, D,
4562                              /*isInstance=*/true, /*isVariadic=*/false,
4563                           /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
4564                              /*isDefined=*/false, ObjCMethodDecl::Required);
4565     D->addInstanceMethod(DTORMethod);
4566     CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
4567     D->setHasDestructors(true);
4568   }
4569 
4570   // If the implementation doesn't have any ivar initializers, we don't need
4571   // a .cxx_construct.
4572   if (D->getNumIvarInitializers() == 0 ||
4573       AllTrivialInitializers(*this, D))
4574     return;
4575 
4576   IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
4577   Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
4578   // The constructor returns 'self'.
4579   ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
4580                                                 D->getLocation(),
4581                                                 D->getLocation(),
4582                                                 cxxSelector,
4583                                                 getContext().getObjCIdType(),
4584                                                 nullptr, D, /*isInstance=*/true,
4585                                                 /*isVariadic=*/false,
4586                                                 /*isPropertyAccessor=*/true,
4587                                                 /*isImplicitlyDeclared=*/true,
4588                                                 /*isDefined=*/false,
4589                                                 ObjCMethodDecl::Required);
4590   D->addInstanceMethod(CTORMethod);
4591   CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
4592   D->setHasNonZeroConstructors(true);
4593 }
4594 
4595 // EmitLinkageSpec - Emit all declarations in a linkage spec.
4596 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
4597   if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
4598       LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
4599     ErrorUnsupported(LSD, "linkage spec");
4600     return;
4601   }
4602 
4603   EmitDeclContext(LSD);
4604 }
4605 
4606 void CodeGenModule::EmitDeclContext(const DeclContext *DC) {
4607   for (auto *I : DC->decls()) {
4608     // Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope
4609     // are themselves considered "top-level", so EmitTopLevelDecl on an
4610     // ObjCImplDecl does not recursively visit them. We need to do that in
4611     // case they're nested inside another construct (LinkageSpecDecl /
4612     // ExportDecl) that does stop them from being considered "top-level".
4613     if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
4614       for (auto *M : OID->methods())
4615         EmitTopLevelDecl(M);
4616     }
4617 
4618     EmitTopLevelDecl(I);
4619   }
4620 }
4621 
4622 /// EmitTopLevelDecl - Emit code for a single top level declaration.
4623 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
4624   // Ignore dependent declarations.
4625   if (D->isTemplated())
4626     return;
4627 
4628   switch (D->getKind()) {
4629   case Decl::CXXConversion:
4630   case Decl::CXXMethod:
4631   case Decl::Function:
4632     EmitGlobal(cast<FunctionDecl>(D));
4633     // Always provide some coverage mapping
4634     // even for the functions that aren't emitted.
4635     AddDeferredUnusedCoverageMapping(D);
4636     break;
4637 
4638   case Decl::CXXDeductionGuide:
4639     // Function-like, but does not result in code emission.
4640     break;
4641 
4642   case Decl::Var:
4643   case Decl::Decomposition:
4644   case Decl::VarTemplateSpecialization:
4645     EmitGlobal(cast<VarDecl>(D));
4646     if (auto *DD = dyn_cast<DecompositionDecl>(D))
4647       for (auto *B : DD->bindings())
4648         if (auto *HD = B->getHoldingVar())
4649           EmitGlobal(HD);
4650     break;
4651 
4652   // Indirect fields from global anonymous structs and unions can be
4653   // ignored; only the actual variable requires IR gen support.
4654   case Decl::IndirectField:
4655     break;
4656 
4657   // C++ Decls
4658   case Decl::Namespace:
4659     EmitDeclContext(cast<NamespaceDecl>(D));
4660     break;
4661   case Decl::ClassTemplateSpecialization: {
4662     const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
4663     if (DebugInfo &&
4664         Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
4665         Spec->hasDefinition())
4666       DebugInfo->completeTemplateDefinition(*Spec);
4667   } LLVM_FALLTHROUGH;
4668   case Decl::CXXRecord:
4669     if (DebugInfo) {
4670       if (auto *ES = D->getASTContext().getExternalSource())
4671         if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
4672           DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D));
4673     }
4674     // Emit any static data members, they may be definitions.
4675     for (auto *I : cast<CXXRecordDecl>(D)->decls())
4676       if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
4677         EmitTopLevelDecl(I);
4678     break;
4679     // No code generation needed.
4680   case Decl::UsingShadow:
4681   case Decl::ClassTemplate:
4682   case Decl::VarTemplate:
4683   case Decl::VarTemplatePartialSpecialization:
4684   case Decl::FunctionTemplate:
4685   case Decl::TypeAliasTemplate:
4686   case Decl::Block:
4687   case Decl::Empty:
4688     break;
4689   case Decl::Using:          // using X; [C++]
4690     if (CGDebugInfo *DI = getModuleDebugInfo())
4691         DI->EmitUsingDecl(cast<UsingDecl>(*D));
4692     return;
4693   case Decl::NamespaceAlias:
4694     if (CGDebugInfo *DI = getModuleDebugInfo())
4695         DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
4696     return;
4697   case Decl::UsingDirective: // using namespace X; [C++]
4698     if (CGDebugInfo *DI = getModuleDebugInfo())
4699       DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
4700     return;
4701   case Decl::CXXConstructor:
4702     getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
4703     break;
4704   case Decl::CXXDestructor:
4705     getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
4706     break;
4707 
4708   case Decl::StaticAssert:
4709     // Nothing to do.
4710     break;
4711 
4712   // Objective-C Decls
4713 
4714   // Forward declarations, no (immediate) code generation.
4715   case Decl::ObjCInterface:
4716   case Decl::ObjCCategory:
4717     break;
4718 
4719   case Decl::ObjCProtocol: {
4720     auto *Proto = cast<ObjCProtocolDecl>(D);
4721     if (Proto->isThisDeclarationADefinition())
4722       ObjCRuntime->GenerateProtocol(Proto);
4723     break;
4724   }
4725 
4726   case Decl::ObjCCategoryImpl:
4727     // Categories have properties but don't support synthesize so we
4728     // can ignore them here.
4729     ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
4730     break;
4731 
4732   case Decl::ObjCImplementation: {
4733     auto *OMD = cast<ObjCImplementationDecl>(D);
4734     EmitObjCPropertyImplementations(OMD);
4735     EmitObjCIvarInitializations(OMD);
4736     ObjCRuntime->GenerateClass(OMD);
4737     // Emit global variable debug information.
4738     if (CGDebugInfo *DI = getModuleDebugInfo())
4739       if (getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
4740         DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
4741             OMD->getClassInterface()), OMD->getLocation());
4742     break;
4743   }
4744   case Decl::ObjCMethod: {
4745     auto *OMD = cast<ObjCMethodDecl>(D);
4746     // If this is not a prototype, emit the body.
4747     if (OMD->getBody())
4748       CodeGenFunction(*this).GenerateObjCMethod(OMD);
4749     break;
4750   }
4751   case Decl::ObjCCompatibleAlias:
4752     ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
4753     break;
4754 
4755   case Decl::PragmaComment: {
4756     const auto *PCD = cast<PragmaCommentDecl>(D);
4757     switch (PCD->getCommentKind()) {
4758     case PCK_Unknown:
4759       llvm_unreachable("unexpected pragma comment kind");
4760     case PCK_Linker:
4761       AppendLinkerOptions(PCD->getArg());
4762       break;
4763     case PCK_Lib:
4764       if (getTarget().getTriple().isOSBinFormatELF() &&
4765           !getTarget().getTriple().isPS4())
4766         AddELFLibDirective(PCD->getArg());
4767       else
4768         AddDependentLib(PCD->getArg());
4769       break;
4770     case PCK_Compiler:
4771     case PCK_ExeStr:
4772     case PCK_User:
4773       break; // We ignore all of these.
4774     }
4775     break;
4776   }
4777 
4778   case Decl::PragmaDetectMismatch: {
4779     const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
4780     AddDetectMismatch(PDMD->getName(), PDMD->getValue());
4781     break;
4782   }
4783 
4784   case Decl::LinkageSpec:
4785     EmitLinkageSpec(cast<LinkageSpecDecl>(D));
4786     break;
4787 
4788   case Decl::FileScopeAsm: {
4789     // File-scope asm is ignored during device-side CUDA compilation.
4790     if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
4791       break;
4792     // File-scope asm is ignored during device-side OpenMP compilation.
4793     if (LangOpts.OpenMPIsDevice)
4794       break;
4795     auto *AD = cast<FileScopeAsmDecl>(D);
4796     getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
4797     break;
4798   }
4799 
4800   case Decl::Import: {
4801     auto *Import = cast<ImportDecl>(D);
4802 
4803     // If we've already imported this module, we're done.
4804     if (!ImportedModules.insert(Import->getImportedModule()))
4805       break;
4806 
4807     // Emit debug information for direct imports.
4808     if (!Import->getImportedOwningModule()) {
4809       if (CGDebugInfo *DI = getModuleDebugInfo())
4810         DI->EmitImportDecl(*Import);
4811     }
4812 
4813     // Find all of the submodules and emit the module initializers.
4814     llvm::SmallPtrSet<clang::Module *, 16> Visited;
4815     SmallVector<clang::Module *, 16> Stack;
4816     Visited.insert(Import->getImportedModule());
4817     Stack.push_back(Import->getImportedModule());
4818 
4819     while (!Stack.empty()) {
4820       clang::Module *Mod = Stack.pop_back_val();
4821       if (!EmittedModuleInitializers.insert(Mod).second)
4822         continue;
4823 
4824       for (auto *D : Context.getModuleInitializers(Mod))
4825         EmitTopLevelDecl(D);
4826 
4827       // Visit the submodules of this module.
4828       for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
4829                                              SubEnd = Mod->submodule_end();
4830            Sub != SubEnd; ++Sub) {
4831         // Skip explicit children; they need to be explicitly imported to emit
4832         // the initializers.
4833         if ((*Sub)->IsExplicit)
4834           continue;
4835 
4836         if (Visited.insert(*Sub).second)
4837           Stack.push_back(*Sub);
4838       }
4839     }
4840     break;
4841   }
4842 
4843   case Decl::Export:
4844     EmitDeclContext(cast<ExportDecl>(D));
4845     break;
4846 
4847   case Decl::OMPThreadPrivate:
4848     EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D));
4849     break;
4850 
4851   case Decl::OMPDeclareReduction:
4852     EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(D));
4853     break;
4854 
4855   default:
4856     // Make sure we handled everything we should, every other kind is a
4857     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
4858     // function. Need to recode Decl::Kind to do that easily.
4859     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
4860     break;
4861   }
4862 }
4863 
4864 void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) {
4865   // Do we need to generate coverage mapping?
4866   if (!CodeGenOpts.CoverageMapping)
4867     return;
4868   switch (D->getKind()) {
4869   case Decl::CXXConversion:
4870   case Decl::CXXMethod:
4871   case Decl::Function:
4872   case Decl::ObjCMethod:
4873   case Decl::CXXConstructor:
4874   case Decl::CXXDestructor: {
4875     if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
4876       return;
4877     SourceManager &SM = getContext().getSourceManager();
4878     if (LimitedCoverage && SM.getMainFileID() != SM.getFileID(D->getBeginLoc()))
4879       return;
4880     auto I = DeferredEmptyCoverageMappingDecls.find(D);
4881     if (I == DeferredEmptyCoverageMappingDecls.end())
4882       DeferredEmptyCoverageMappingDecls[D] = true;
4883     break;
4884   }
4885   default:
4886     break;
4887   };
4888 }
4889 
4890 void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) {
4891   // Do we need to generate coverage mapping?
4892   if (!CodeGenOpts.CoverageMapping)
4893     return;
4894   if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
4895     if (Fn->isTemplateInstantiation())
4896       ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
4897   }
4898   auto I = DeferredEmptyCoverageMappingDecls.find(D);
4899   if (I == DeferredEmptyCoverageMappingDecls.end())
4900     DeferredEmptyCoverageMappingDecls[D] = false;
4901   else
4902     I->second = false;
4903 }
4904 
4905 void CodeGenModule::EmitDeferredUnusedCoverageMappings() {
4906   // We call takeVector() here to avoid use-after-free.
4907   // FIXME: DeferredEmptyCoverageMappingDecls is getting mutated because
4908   // we deserialize function bodies to emit coverage info for them, and that
4909   // deserializes more declarations. How should we handle that case?
4910   for (const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
4911     if (!Entry.second)
4912       continue;
4913     const Decl *D = Entry.first;
4914     switch (D->getKind()) {
4915     case Decl::CXXConversion:
4916     case Decl::CXXMethod:
4917     case Decl::Function:
4918     case Decl::ObjCMethod: {
4919       CodeGenPGO PGO(*this);
4920       GlobalDecl GD(cast<FunctionDecl>(D));
4921       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
4922                                   getFunctionLinkage(GD));
4923       break;
4924     }
4925     case Decl::CXXConstructor: {
4926       CodeGenPGO PGO(*this);
4927       GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
4928       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
4929                                   getFunctionLinkage(GD));
4930       break;
4931     }
4932     case Decl::CXXDestructor: {
4933       CodeGenPGO PGO(*this);
4934       GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
4935       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
4936                                   getFunctionLinkage(GD));
4937       break;
4938     }
4939     default:
4940       break;
4941     };
4942   }
4943 }
4944 
4945 /// Turns the given pointer into a constant.
4946 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
4947                                           const void *Ptr) {
4948   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
4949   llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
4950   return llvm::ConstantInt::get(i64, PtrInt);
4951 }
4952 
4953 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
4954                                    llvm::NamedMDNode *&GlobalMetadata,
4955                                    GlobalDecl D,
4956                                    llvm::GlobalValue *Addr) {
4957   if (!GlobalMetadata)
4958     GlobalMetadata =
4959       CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
4960 
4961   // TODO: should we report variant information for ctors/dtors?
4962   llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
4963                            llvm::ConstantAsMetadata::get(GetPointerConstant(
4964                                CGM.getLLVMContext(), D.getDecl()))};
4965   GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
4966 }
4967 
4968 /// For each function which is declared within an extern "C" region and marked
4969 /// as 'used', but has internal linkage, create an alias from the unmangled
4970 /// name to the mangled name if possible. People expect to be able to refer
4971 /// to such functions with an unmangled name from inline assembly within the
4972 /// same translation unit.
4973 void CodeGenModule::EmitStaticExternCAliases() {
4974   if (!getTargetCodeGenInfo().shouldEmitStaticExternCAliases())
4975     return;
4976   for (auto &I : StaticExternCValues) {
4977     IdentifierInfo *Name = I.first;
4978     llvm::GlobalValue *Val = I.second;
4979     if (Val && !getModule().getNamedValue(Name->getName()))
4980       addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val));
4981   }
4982 }
4983 
4984 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName,
4985                                              GlobalDecl &Result) const {
4986   auto Res = Manglings.find(MangledName);
4987   if (Res == Manglings.end())
4988     return false;
4989   Result = Res->getValue();
4990   return true;
4991 }
4992 
4993 /// Emits metadata nodes associating all the global values in the
4994 /// current module with the Decls they came from.  This is useful for
4995 /// projects using IR gen as a subroutine.
4996 ///
4997 /// Since there's currently no way to associate an MDNode directly
4998 /// with an llvm::GlobalValue, we create a global named metadata
4999 /// with the name 'clang.global.decl.ptrs'.
5000 void CodeGenModule::EmitDeclMetadata() {
5001   llvm::NamedMDNode *GlobalMetadata = nullptr;
5002 
5003   for (auto &I : MangledDeclNames) {
5004     llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
5005     // Some mangled names don't necessarily have an associated GlobalValue
5006     // in this module, e.g. if we mangled it for DebugInfo.
5007     if (Addr)
5008       EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
5009   }
5010 }
5011 
5012 /// Emits metadata nodes for all the local variables in the current
5013 /// function.
5014 void CodeGenFunction::EmitDeclMetadata() {
5015   if (LocalDeclMap.empty()) return;
5016 
5017   llvm::LLVMContext &Context = getLLVMContext();
5018 
5019   // Find the unique metadata ID for this name.
5020   unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
5021 
5022   llvm::NamedMDNode *GlobalMetadata = nullptr;
5023 
5024   for (auto &I : LocalDeclMap) {
5025     const Decl *D = I.first;
5026     llvm::Value *Addr = I.second.getPointer();
5027     if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
5028       llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
5029       Alloca->setMetadata(
5030           DeclPtrKind, llvm::MDNode::get(
5031                            Context, llvm::ValueAsMetadata::getConstant(DAddr)));
5032     } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
5033       GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
5034       EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
5035     }
5036   }
5037 }
5038 
5039 void CodeGenModule::EmitVersionIdentMetadata() {
5040   llvm::NamedMDNode *IdentMetadata =
5041     TheModule.getOrInsertNamedMetadata("llvm.ident");
5042   std::string Version = getClangFullVersion();
5043   llvm::LLVMContext &Ctx = TheModule.getContext();
5044 
5045   llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
5046   IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
5047 }
5048 
5049 void CodeGenModule::EmitTargetMetadata() {
5050   // Warning, new MangledDeclNames may be appended within this loop.
5051   // We rely on MapVector insertions adding new elements to the end
5052   // of the container.
5053   // FIXME: Move this loop into the one target that needs it, and only
5054   // loop over those declarations for which we couldn't emit the target
5055   // metadata when we emitted the declaration.
5056   for (unsigned I = 0; I != MangledDeclNames.size(); ++I) {
5057     auto Val = *(MangledDeclNames.begin() + I);
5058     const Decl *D = Val.first.getDecl()->getMostRecentDecl();
5059     llvm::GlobalValue *GV = GetGlobalValue(Val.second);
5060     getTargetCodeGenInfo().emitTargetMD(D, GV, *this);
5061   }
5062 }
5063 
5064 void CodeGenModule::EmitCoverageFile() {
5065   if (getCodeGenOpts().CoverageDataFile.empty() &&
5066       getCodeGenOpts().CoverageNotesFile.empty())
5067     return;
5068 
5069   llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu");
5070   if (!CUNode)
5071     return;
5072 
5073   llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
5074   llvm::LLVMContext &Ctx = TheModule.getContext();
5075   auto *CoverageDataFile =
5076       llvm::MDString::get(Ctx, getCodeGenOpts().CoverageDataFile);
5077   auto *CoverageNotesFile =
5078       llvm::MDString::get(Ctx, getCodeGenOpts().CoverageNotesFile);
5079   for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
5080     llvm::MDNode *CU = CUNode->getOperand(i);
5081     llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
5082     GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
5083   }
5084 }
5085 
5086 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
5087   // Sema has checked that all uuid strings are of the form
5088   // "12345678-1234-1234-1234-1234567890ab".
5089   assert(Uuid.size() == 36);
5090   for (unsigned i = 0; i < 36; ++i) {
5091     if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-');
5092     else                                         assert(isHexDigit(Uuid[i]));
5093   }
5094 
5095   // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab".
5096   const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
5097 
5098   llvm::Constant *Field3[8];
5099   for (unsigned Idx = 0; Idx < 8; ++Idx)
5100     Field3[Idx] = llvm::ConstantInt::get(
5101         Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
5102 
5103   llvm::Constant *Fields[4] = {
5104     llvm::ConstantInt::get(Int32Ty, Uuid.substr(0,  8), 16),
5105     llvm::ConstantInt::get(Int16Ty, Uuid.substr(9,  4), 16),
5106     llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
5107     llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3)
5108   };
5109 
5110   return llvm::ConstantStruct::getAnon(Fields);
5111 }
5112 
5113 llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty,
5114                                                        bool ForEH) {
5115   // Return a bogus pointer if RTTI is disabled, unless it's for EH.
5116   // FIXME: should we even be calling this method if RTTI is disabled
5117   // and it's not for EH?
5118   if ((!ForEH && !getLangOpts().RTTI) || getLangOpts().CUDAIsDevice)
5119     return llvm::Constant::getNullValue(Int8PtrTy);
5120 
5121   if (ForEH && Ty->isObjCObjectPointerType() &&
5122       LangOpts.ObjCRuntime.isGNUFamily())
5123     return ObjCRuntime->GetEHType(Ty);
5124 
5125   return getCXXABI().getAddrOfRTTIDescriptor(Ty);
5126 }
5127 
5128 void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
5129   // Do not emit threadprivates in simd-only mode.
5130   if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
5131     return;
5132   for (auto RefExpr : D->varlists()) {
5133     auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
5134     bool PerformInit =
5135         VD->getAnyInitializer() &&
5136         !VD->getAnyInitializer()->isConstantInitializer(getContext(),
5137                                                         /*ForRef=*/false);
5138 
5139     Address Addr(GetAddrOfGlobalVar(VD), getContext().getDeclAlign(VD));
5140     if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition(
5141             VD, Addr, RefExpr->getBeginLoc(), PerformInit))
5142       CXXGlobalInits.push_back(InitFunction);
5143   }
5144 }
5145 
5146 llvm::Metadata *
5147 CodeGenModule::CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map,
5148                                             StringRef Suffix) {
5149   llvm::Metadata *&InternalId = Map[T.getCanonicalType()];
5150   if (InternalId)
5151     return InternalId;
5152 
5153   if (isExternallyVisible(T->getLinkage())) {
5154     std::string OutName;
5155     llvm::raw_string_ostream Out(OutName);
5156     getCXXABI().getMangleContext().mangleTypeName(T, Out);
5157     Out << Suffix;
5158 
5159     InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
5160   } else {
5161     InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
5162                                            llvm::ArrayRef<llvm::Metadata *>());
5163   }
5164 
5165   return InternalId;
5166 }
5167 
5168 llvm::Metadata *CodeGenModule::CreateMetadataIdentifierForType(QualType T) {
5169   return CreateMetadataIdentifierImpl(T, MetadataIdMap, "");
5170 }
5171 
5172 llvm::Metadata *
5173 CodeGenModule::CreateMetadataIdentifierForVirtualMemPtrType(QualType T) {
5174   return CreateMetadataIdentifierImpl(T, VirtualMetadataIdMap, ".virtual");
5175 }
5176 
5177 // Generalize pointer types to a void pointer with the qualifiers of the
5178 // originally pointed-to type, e.g. 'const char *' and 'char * const *'
5179 // generalize to 'const void *' while 'char *' and 'const char **' generalize to
5180 // 'void *'.
5181 static QualType GeneralizeType(ASTContext &Ctx, QualType Ty) {
5182   if (!Ty->isPointerType())
5183     return Ty;
5184 
5185   return Ctx.getPointerType(
5186       QualType(Ctx.VoidTy).withCVRQualifiers(
5187           Ty->getPointeeType().getCVRQualifiers()));
5188 }
5189 
5190 // Apply type generalization to a FunctionType's return and argument types
5191 static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty) {
5192   if (auto *FnType = Ty->getAs<FunctionProtoType>()) {
5193     SmallVector<QualType, 8> GeneralizedParams;
5194     for (auto &Param : FnType->param_types())
5195       GeneralizedParams.push_back(GeneralizeType(Ctx, Param));
5196 
5197     return Ctx.getFunctionType(
5198         GeneralizeType(Ctx, FnType->getReturnType()),
5199         GeneralizedParams, FnType->getExtProtoInfo());
5200   }
5201 
5202   if (auto *FnType = Ty->getAs<FunctionNoProtoType>())
5203     return Ctx.getFunctionNoProtoType(
5204         GeneralizeType(Ctx, FnType->getReturnType()));
5205 
5206   llvm_unreachable("Encountered unknown FunctionType");
5207 }
5208 
5209 llvm::Metadata *CodeGenModule::CreateMetadataIdentifierGeneralized(QualType T) {
5210   return CreateMetadataIdentifierImpl(GeneralizeFunctionType(getContext(), T),
5211                                       GeneralizedMetadataIdMap, ".generalized");
5212 }
5213 
5214 /// Returns whether this module needs the "all-vtables" type identifier.
5215 bool CodeGenModule::NeedAllVtablesTypeId() const {
5216   // Returns true if at least one of vtable-based CFI checkers is enabled and
5217   // is not in the trapping mode.
5218   return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
5219            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
5220           (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
5221            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
5222           (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
5223            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
5224           (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
5225            !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
5226 }
5227 
5228 void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable,
5229                                           CharUnits Offset,
5230                                           const CXXRecordDecl *RD) {
5231   llvm::Metadata *MD =
5232       CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
5233   VTable->addTypeMetadata(Offset.getQuantity(), MD);
5234 
5235   if (CodeGenOpts.SanitizeCfiCrossDso)
5236     if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
5237       VTable->addTypeMetadata(Offset.getQuantity(),
5238                               llvm::ConstantAsMetadata::get(CrossDsoTypeId));
5239 
5240   if (NeedAllVtablesTypeId()) {
5241     llvm::Metadata *MD = llvm::MDString::get(getLLVMContext(), "all-vtables");
5242     VTable->addTypeMetadata(Offset.getQuantity(), MD);
5243   }
5244 }
5245 
5246 TargetAttr::ParsedTargetAttr CodeGenModule::filterFunctionTargetAttrs(const TargetAttr *TD) {
5247   assert(TD != nullptr);
5248   TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
5249 
5250   ParsedAttr.Features.erase(
5251       llvm::remove_if(ParsedAttr.Features,
5252                       [&](const std::string &Feat) {
5253                         return !Target.isValidFeatureName(
5254                             StringRef{Feat}.substr(1));
5255                       }),
5256       ParsedAttr.Features.end());
5257   return ParsedAttr;
5258 }
5259 
5260 
5261 // Fills in the supplied string map with the set of target features for the
5262 // passed in function.
5263 void CodeGenModule::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
5264                                           const FunctionDecl *FD) {
5265   StringRef TargetCPU = Target.getTargetOpts().CPU;
5266   if (const auto *TD = FD->getAttr<TargetAttr>()) {
5267     TargetAttr::ParsedTargetAttr ParsedAttr = filterFunctionTargetAttrs(TD);
5268 
5269     // Make a copy of the features as passed on the command line into the
5270     // beginning of the additional features from the function to override.
5271     ParsedAttr.Features.insert(ParsedAttr.Features.begin(),
5272                             Target.getTargetOpts().FeaturesAsWritten.begin(),
5273                             Target.getTargetOpts().FeaturesAsWritten.end());
5274 
5275     if (ParsedAttr.Architecture != "" &&
5276         Target.isValidCPUName(ParsedAttr.Architecture))
5277       TargetCPU = ParsedAttr.Architecture;
5278 
5279     // Now populate the feature map, first with the TargetCPU which is either
5280     // the default or a new one from the target attribute string. Then we'll use
5281     // the passed in features (FeaturesAsWritten) along with the new ones from
5282     // the attribute.
5283     Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
5284                           ParsedAttr.Features);
5285   } else if (const auto *SD = FD->getAttr<CPUSpecificAttr>()) {
5286     llvm::SmallVector<StringRef, 32> FeaturesTmp;
5287     Target.getCPUSpecificCPUDispatchFeatures(SD->getCurCPUName()->getName(),
5288                                              FeaturesTmp);
5289     std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());
5290     Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU, Features);
5291   } else {
5292     Target.initFeatureMap(FeatureMap, getDiags(), TargetCPU,
5293                           Target.getTargetOpts().Features);
5294   }
5295 }
5296 
5297 llvm::SanitizerStatReport &CodeGenModule::getSanStats() {
5298   if (!SanStats)
5299     SanStats = llvm::make_unique<llvm::SanitizerStatReport>(&getModule());
5300 
5301   return *SanStats;
5302 }
5303 llvm::Value *
5304 CodeGenModule::createOpenCLIntToSamplerConversion(const Expr *E,
5305                                                   CodeGenFunction &CGF) {
5306   llvm::Constant *C = ConstantEmitter(CGF).emitAbstract(E, E->getType());
5307   auto SamplerT = getOpenCLRuntime().getSamplerType(E->getType().getTypePtr());
5308   auto FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false);
5309   return CGF.Builder.CreateCall(CreateRuntimeFunction(FTy,
5310                                 "__translate_sampler_initializer"),
5311                                 {C});
5312 }
5313