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