xref: /llvm-project/clang/lib/CodeGen/CodeGenModule.cpp (revision f37f3d35eb4f3bf4a69cfc4eedaea1caa43d096c)
1 //===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This coordinates the per-module state used while generating code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenModule.h"
15 #include "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 "CodeGenFunction.h"
23 #include "CodeGenPGO.h"
24 #include "CodeGenTBAA.h"
25 #include "CoverageMappingGen.h"
26 #include "TargetInfo.h"
27 #include "clang/AST/ASTContext.h"
28 #include "clang/AST/CharUnits.h"
29 #include "clang/AST/DeclCXX.h"
30 #include "clang/AST/DeclObjC.h"
31 #include "clang/AST/DeclTemplate.h"
32 #include "clang/AST/Mangle.h"
33 #include "clang/AST/RecordLayout.h"
34 #include "clang/AST/RecursiveASTVisitor.h"
35 #include "clang/Basic/Builtins.h"
36 #include "clang/Basic/CharInfo.h"
37 #include "clang/Basic/Diagnostic.h"
38 #include "clang/Basic/Module.h"
39 #include "clang/Basic/SourceManager.h"
40 #include "clang/Basic/TargetInfo.h"
41 #include "clang/Basic/Version.h"
42 #include "clang/Frontend/CodeGenOptions.h"
43 #include "clang/Sema/SemaDiagnostic.h"
44 #include "llvm/ADT/APSInt.h"
45 #include "llvm/ADT/Triple.h"
46 #include "llvm/IR/CallSite.h"
47 #include "llvm/IR/CallingConv.h"
48 #include "llvm/IR/DataLayout.h"
49 #include "llvm/IR/Intrinsics.h"
50 #include "llvm/IR/LLVMContext.h"
51 #include "llvm/IR/Module.h"
52 #include "llvm/ProfileData/InstrProfReader.h"
53 #include "llvm/Support/ConvertUTF.h"
54 #include "llvm/Support/ErrorHandling.h"
55 
56 using namespace clang;
57 using namespace CodeGen;
58 
59 static const char AnnotationSection[] = "llvm.metadata";
60 
61 static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
62   switch (CGM.getTarget().getCXXABI().getKind()) {
63   case TargetCXXABI::GenericAArch64:
64   case TargetCXXABI::GenericARM:
65   case TargetCXXABI::iOS:
66   case TargetCXXABI::iOS64:
67   case TargetCXXABI::GenericItanium:
68     return CreateItaniumCXXABI(CGM);
69   case TargetCXXABI::Microsoft:
70     return CreateMicrosoftCXXABI(CGM);
71   }
72 
73   llvm_unreachable("invalid C++ ABI kind");
74 }
75 
76 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
77                              llvm::Module &M, const llvm::DataLayout &TD,
78                              DiagnosticsEngine &diags,
79                              CoverageSourceInfo *CoverageInfo)
80     : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M),
81       Diags(diags), TheDataLayout(TD), Target(C.getTargetInfo()),
82       ABI(createCXXABI(*this)), VMContext(M.getContext()), TBAA(nullptr),
83       TheTargetCodeGenInfo(nullptr), Types(*this), VTables(*this),
84       ObjCRuntime(nullptr), OpenCLRuntime(nullptr), OpenMPRuntime(nullptr),
85       CUDARuntime(nullptr), DebugInfo(nullptr), ARCData(nullptr),
86       NoObjCARCExceptionsMetadata(nullptr), RRData(nullptr), PGOReader(nullptr),
87       CFConstantStringClassRef(nullptr), ConstantStringClassRef(nullptr),
88       NSConstantStringType(nullptr), NSConcreteGlobalBlock(nullptr),
89       NSConcreteStackBlock(nullptr), BlockObjectAssign(nullptr),
90       BlockObjectDispose(nullptr), BlockDescriptorType(nullptr),
91       GenericBlockLiteralType(nullptr), LifetimeStartFn(nullptr),
92       LifetimeEndFn(nullptr), SanitizerMD(new SanitizerMetadata(*this)) {
93 
94   // Initialize the type cache.
95   llvm::LLVMContext &LLVMContext = M.getContext();
96   VoidTy = llvm::Type::getVoidTy(LLVMContext);
97   Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
98   Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
99   Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
100   Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
101   FloatTy = llvm::Type::getFloatTy(LLVMContext);
102   DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
103   PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
104   PointerAlignInBytes =
105   C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
106   IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
107   IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
108   Int8PtrTy = Int8Ty->getPointerTo(0);
109   Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
110 
111   RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
112   BuiltinCC = getTargetCodeGenInfo().getABIInfo().getBuiltinCC();
113 
114   if (LangOpts.ObjC1)
115     createObjCRuntime();
116   if (LangOpts.OpenCL)
117     createOpenCLRuntime();
118   if (LangOpts.OpenMP)
119     createOpenMPRuntime();
120   if (LangOpts.CUDA)
121     createCUDARuntime();
122 
123   // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
124   if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
125       (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
126     TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
127                            getCXXABI().getMangleContext());
128 
129   // If debug info or coverage generation is enabled, create the CGDebugInfo
130   // object.
131   if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
132       CodeGenOpts.EmitGcovArcs ||
133       CodeGenOpts.EmitGcovNotes)
134     DebugInfo = new CGDebugInfo(*this);
135 
136   Block.GlobalUniqueCount = 0;
137 
138   if (C.getLangOpts().ObjCAutoRefCount)
139     ARCData = new ARCEntrypoints();
140   RRData = new RREntrypoints();
141 
142   if (!CodeGenOpts.InstrProfileInput.empty()) {
143     if (std::error_code EC = llvm::IndexedInstrProfReader::create(
144             CodeGenOpts.InstrProfileInput, PGOReader)) {
145       unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
146                                               "Could not read profile: %0");
147       getDiags().Report(DiagID) << EC.message();
148     }
149   }
150 
151   // If coverage mapping generation is enabled, create the
152   // CoverageMappingModuleGen object.
153   if (CodeGenOpts.CoverageMapping)
154     CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
155 }
156 
157 CodeGenModule::~CodeGenModule() {
158   delete ObjCRuntime;
159   delete OpenCLRuntime;
160   delete OpenMPRuntime;
161   delete CUDARuntime;
162   delete TheTargetCodeGenInfo;
163   delete TBAA;
164   delete DebugInfo;
165   delete ARCData;
166   delete RRData;
167 }
168 
169 void CodeGenModule::createObjCRuntime() {
170   // This is just isGNUFamily(), but we want to force implementors of
171   // new ABIs to decide how best to do this.
172   switch (LangOpts.ObjCRuntime.getKind()) {
173   case ObjCRuntime::GNUstep:
174   case ObjCRuntime::GCC:
175   case ObjCRuntime::ObjFW:
176     ObjCRuntime = CreateGNUObjCRuntime(*this);
177     return;
178 
179   case ObjCRuntime::FragileMacOSX:
180   case ObjCRuntime::MacOSX:
181   case ObjCRuntime::iOS:
182     ObjCRuntime = CreateMacObjCRuntime(*this);
183     return;
184   }
185   llvm_unreachable("bad runtime kind");
186 }
187 
188 void CodeGenModule::createOpenCLRuntime() {
189   OpenCLRuntime = new CGOpenCLRuntime(*this);
190 }
191 
192 void CodeGenModule::createOpenMPRuntime() {
193   OpenMPRuntime = new CGOpenMPRuntime(*this);
194 }
195 
196 void CodeGenModule::createCUDARuntime() {
197   CUDARuntime = CreateNVCUDARuntime(*this);
198 }
199 
200 void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
201   Replacements[Name] = C;
202 }
203 
204 void CodeGenModule::applyReplacements() {
205   for (ReplacementsTy::iterator I = Replacements.begin(),
206                                 E = Replacements.end();
207        I != E; ++I) {
208     StringRef MangledName = I->first();
209     llvm::Constant *Replacement = I->second;
210     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
211     if (!Entry)
212       continue;
213     auto *OldF = cast<llvm::Function>(Entry);
214     auto *NewF = dyn_cast<llvm::Function>(Replacement);
215     if (!NewF) {
216       if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
217         NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
218       } else {
219         auto *CE = cast<llvm::ConstantExpr>(Replacement);
220         assert(CE->getOpcode() == llvm::Instruction::BitCast ||
221                CE->getOpcode() == llvm::Instruction::GetElementPtr);
222         NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
223       }
224     }
225 
226     // Replace old with new, but keep the old order.
227     OldF->replaceAllUsesWith(Replacement);
228     if (NewF) {
229       NewF->removeFromParent();
230       OldF->getParent()->getFunctionList().insertAfter(OldF, NewF);
231     }
232     OldF->eraseFromParent();
233   }
234 }
235 
236 // This is only used in aliases that we created and we know they have a
237 // linear structure.
238 static const llvm::GlobalObject *getAliasedGlobal(const llvm::GlobalAlias &GA) {
239   llvm::SmallPtrSet<const llvm::GlobalAlias*, 4> Visited;
240   const llvm::Constant *C = &GA;
241   for (;;) {
242     C = C->stripPointerCasts();
243     if (auto *GO = dyn_cast<llvm::GlobalObject>(C))
244       return GO;
245     // stripPointerCasts will not walk over weak aliases.
246     auto *GA2 = dyn_cast<llvm::GlobalAlias>(C);
247     if (!GA2)
248       return nullptr;
249     if (!Visited.insert(GA2).second)
250       return nullptr;
251     C = GA2->getAliasee();
252   }
253 }
254 
255 void CodeGenModule::checkAliases() {
256   // Check if the constructed aliases are well formed. It is really unfortunate
257   // that we have to do this in CodeGen, but we only construct mangled names
258   // and aliases during codegen.
259   bool Error = false;
260   DiagnosticsEngine &Diags = getDiags();
261   for (std::vector<GlobalDecl>::iterator I = Aliases.begin(),
262          E = Aliases.end(); I != E; ++I) {
263     const GlobalDecl &GD = *I;
264     const auto *D = cast<ValueDecl>(GD.getDecl());
265     const AliasAttr *AA = D->getAttr<AliasAttr>();
266     StringRef MangledName = getMangledName(GD);
267     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
268     auto *Alias = cast<llvm::GlobalAlias>(Entry);
269     const llvm::GlobalValue *GV = getAliasedGlobal(*Alias);
270     if (!GV) {
271       Error = true;
272       Diags.Report(AA->getLocation(), diag::err_cyclic_alias);
273     } else if (GV->isDeclaration()) {
274       Error = true;
275       Diags.Report(AA->getLocation(), diag::err_alias_to_undefined);
276     }
277 
278     llvm::Constant *Aliasee = Alias->getAliasee();
279     llvm::GlobalValue *AliaseeGV;
280     if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
281       AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
282     else
283       AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
284 
285     if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
286       StringRef AliasSection = SA->getName();
287       if (AliasSection != AliaseeGV->getSection())
288         Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
289             << AliasSection;
290     }
291 
292     // We have to handle alias to weak aliases in here. LLVM itself disallows
293     // this since the object semantics would not match the IL one. For
294     // compatibility with gcc we implement it by just pointing the alias
295     // to its aliasee's aliasee. We also warn, since the user is probably
296     // expecting the link to be weak.
297     if (auto GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
298       if (GA->mayBeOverridden()) {
299         Diags.Report(AA->getLocation(), diag::warn_alias_to_weak_alias)
300             << GV->getName() << GA->getName();
301         Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
302             GA->getAliasee(), Alias->getType());
303         Alias->setAliasee(Aliasee);
304       }
305     }
306   }
307   if (!Error)
308     return;
309 
310   for (std::vector<GlobalDecl>::iterator I = Aliases.begin(),
311          E = Aliases.end(); I != E; ++I) {
312     const GlobalDecl &GD = *I;
313     StringRef MangledName = getMangledName(GD);
314     llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
315     auto *Alias = cast<llvm::GlobalAlias>(Entry);
316     Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
317     Alias->eraseFromParent();
318   }
319 }
320 
321 void CodeGenModule::clear() {
322   DeferredDeclsToEmit.clear();
323 }
324 
325 void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags,
326                                        StringRef MainFile) {
327   if (!hasDiagnostics())
328     return;
329   if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
330     if (MainFile.empty())
331       MainFile = "<stdin>";
332     Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
333   } else
334     Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Missing
335                                                       << Mismatched;
336 }
337 
338 void CodeGenModule::Release() {
339   EmitDeferred();
340   applyReplacements();
341   checkAliases();
342   EmitCXXGlobalInitFunc();
343   EmitCXXGlobalDtorFunc();
344   EmitCXXThreadLocalInitFunc();
345   if (ObjCRuntime)
346     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
347       AddGlobalCtor(ObjCInitFunction);
348   if (PGOReader && PGOStats.hasDiagnostics())
349     PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
350   EmitCtorList(GlobalCtors, "llvm.global_ctors");
351   EmitCtorList(GlobalDtors, "llvm.global_dtors");
352   EmitGlobalAnnotations();
353   EmitStaticExternCAliases();
354   EmitDeferredUnusedCoverageMappings();
355   if (CoverageMapping)
356     CoverageMapping->emit();
357   emitLLVMUsed();
358 
359   if (CodeGenOpts.Autolink &&
360       (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
361     EmitModuleLinkOptions();
362   }
363   if (CodeGenOpts.DwarfVersion)
364     // We actually want the latest version when there are conflicts.
365     // We can change from Warning to Latest if such mode is supported.
366     getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
367                               CodeGenOpts.DwarfVersion);
368   if (DebugInfo)
369     // We support a single version in the linked module. The LLVM
370     // parser will drop debug info with a different version number
371     // (and warn about it, too).
372     getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
373                               llvm::DEBUG_METADATA_VERSION);
374 
375   // We need to record the widths of enums and wchar_t, so that we can generate
376   // the correct build attributes in the ARM backend.
377   llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
378   if (   Arch == llvm::Triple::arm
379       || Arch == llvm::Triple::armeb
380       || Arch == llvm::Triple::thumb
381       || Arch == llvm::Triple::thumbeb) {
382     // Width of wchar_t in bytes
383     uint64_t WCharWidth =
384         Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
385     getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
386 
387     // The minimum width of an enum in bytes
388     uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
389     getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
390   }
391 
392   if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
393     llvm::PICLevel::Level PL = llvm::PICLevel::Default;
394     switch (PLevel) {
395     case 0: break;
396     case 1: PL = llvm::PICLevel::Small; break;
397     case 2: PL = llvm::PICLevel::Large; break;
398     default: llvm_unreachable("Invalid PIC Level");
399     }
400 
401     getModule().setPICLevel(PL);
402   }
403 
404   SimplifyPersonality();
405 
406   if (getCodeGenOpts().EmitDeclMetadata)
407     EmitDeclMetadata();
408 
409   if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
410     EmitCoverageFile();
411 
412   if (DebugInfo)
413     DebugInfo->finalize();
414 
415   EmitVersionIdentMetadata();
416 
417   EmitTargetMetadata();
418 }
419 
420 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
421   // Make sure that this type is translated.
422   Types.UpdateCompletedType(TD);
423 }
424 
425 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
426   if (!TBAA)
427     return nullptr;
428   return TBAA->getTBAAInfo(QTy);
429 }
430 
431 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
432   if (!TBAA)
433     return nullptr;
434   return TBAA->getTBAAInfoForVTablePtr();
435 }
436 
437 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
438   if (!TBAA)
439     return nullptr;
440   return TBAA->getTBAAStructInfo(QTy);
441 }
442 
443 llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) {
444   if (!TBAA)
445     return nullptr;
446   return TBAA->getTBAAStructTypeInfo(QTy);
447 }
448 
449 llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy,
450                                                   llvm::MDNode *AccessN,
451                                                   uint64_t O) {
452   if (!TBAA)
453     return nullptr;
454   return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O);
455 }
456 
457 /// Decorate the instruction with a TBAA tag. For both scalar TBAA
458 /// and struct-path aware TBAA, the tag has the same format:
459 /// base type, access type and offset.
460 /// When ConvertTypeToTag is true, we create a tag based on the scalar type.
461 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
462                                         llvm::MDNode *TBAAInfo,
463                                         bool ConvertTypeToTag) {
464   if (ConvertTypeToTag && TBAA)
465     Inst->setMetadata(llvm::LLVMContext::MD_tbaa,
466                       TBAA->getTBAAScalarTagInfo(TBAAInfo));
467   else
468     Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
469 }
470 
471 void CodeGenModule::Error(SourceLocation loc, StringRef message) {
472   unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
473   getDiags().Report(Context.getFullLoc(loc), diagID) << message;
474 }
475 
476 /// ErrorUnsupported - Print out an error that codegen doesn't support the
477 /// specified stmt yet.
478 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
479   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
480                                                "cannot compile this %0 yet");
481   std::string Msg = Type;
482   getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
483     << Msg << S->getSourceRange();
484 }
485 
486 /// ErrorUnsupported - Print out an error that codegen doesn't support the
487 /// specified decl yet.
488 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
489   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
490                                                "cannot compile this %0 yet");
491   std::string Msg = Type;
492   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
493 }
494 
495 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
496   return llvm::ConstantInt::get(SizeTy, size.getQuantity());
497 }
498 
499 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
500                                         const NamedDecl *D) const {
501   // Internal definitions always have default visibility.
502   if (GV->hasLocalLinkage()) {
503     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
504     return;
505   }
506 
507   // Set visibility for definitions.
508   LinkageInfo LV = D->getLinkageAndVisibility();
509   if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
510     GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
511 }
512 
513 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
514   return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
515       .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
516       .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
517       .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
518       .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
519 }
520 
521 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
522     CodeGenOptions::TLSModel M) {
523   switch (M) {
524   case CodeGenOptions::GeneralDynamicTLSModel:
525     return llvm::GlobalVariable::GeneralDynamicTLSModel;
526   case CodeGenOptions::LocalDynamicTLSModel:
527     return llvm::GlobalVariable::LocalDynamicTLSModel;
528   case CodeGenOptions::InitialExecTLSModel:
529     return llvm::GlobalVariable::InitialExecTLSModel;
530   case CodeGenOptions::LocalExecTLSModel:
531     return llvm::GlobalVariable::LocalExecTLSModel;
532   }
533   llvm_unreachable("Invalid TLS model!");
534 }
535 
536 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
537   assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
538 
539   llvm::GlobalValue::ThreadLocalMode TLM;
540   TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
541 
542   // Override the TLS model if it is explicitly specified.
543   if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
544     TLM = GetLLVMTLSModel(Attr->getModel());
545   }
546 
547   GV->setThreadLocalMode(TLM);
548 }
549 
550 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
551   StringRef &FoundStr = MangledDeclNames[GD.getCanonicalDecl()];
552   if (!FoundStr.empty())
553     return FoundStr;
554 
555   const auto *ND = cast<NamedDecl>(GD.getDecl());
556   SmallString<256> Buffer;
557   StringRef Str;
558   if (getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
559     llvm::raw_svector_ostream Out(Buffer);
560     if (const auto *D = dyn_cast<CXXConstructorDecl>(ND))
561       getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
562     else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND))
563       getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
564     else
565       getCXXABI().getMangleContext().mangleName(ND, Out);
566     Str = Out.str();
567   } else {
568     IdentifierInfo *II = ND->getIdentifier();
569     assert(II && "Attempt to mangle unnamed decl.");
570     Str = II->getName();
571   }
572 
573   // Keep the first result in the case of a mangling collision.
574   auto Result = Manglings.insert(std::make_pair(Str, GD));
575   return FoundStr = Result.first->first();
576 }
577 
578 StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD,
579                                              const BlockDecl *BD) {
580   MangleContext &MangleCtx = getCXXABI().getMangleContext();
581   const Decl *D = GD.getDecl();
582 
583   SmallString<256> Buffer;
584   llvm::raw_svector_ostream Out(Buffer);
585   if (!D)
586     MangleCtx.mangleGlobalBlock(BD,
587       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
588   else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
589     MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
590   else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
591     MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
592   else
593     MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
594 
595   auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
596   return Result.first->first();
597 }
598 
599 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
600   return getModule().getNamedValue(Name);
601 }
602 
603 /// AddGlobalCtor - Add a function to the list that will be called before
604 /// main() runs.
605 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
606                                   llvm::Constant *AssociatedData) {
607   // FIXME: Type coercion of void()* types.
608   GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
609 }
610 
611 /// AddGlobalDtor - Add a function to the list that will be called
612 /// when the module is unloaded.
613 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
614   // FIXME: Type coercion of void()* types.
615   GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
616 }
617 
618 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
619   // Ctor function type is void()*.
620   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
621   llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
622 
623   // Get the type of a ctor entry, { i32, void ()*, i8* }.
624   llvm::StructType *CtorStructTy = llvm::StructType::get(
625       Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy, nullptr);
626 
627   // Construct the constructor and destructor arrays.
628   SmallVector<llvm::Constant*, 8> Ctors;
629   for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
630     llvm::Constant *S[] = {
631       llvm::ConstantInt::get(Int32Ty, I->Priority, false),
632       llvm::ConstantExpr::getBitCast(I->Initializer, CtorPFTy),
633       (I->AssociatedData
634            ? llvm::ConstantExpr::getBitCast(I->AssociatedData, VoidPtrTy)
635            : llvm::Constant::getNullValue(VoidPtrTy))
636     };
637     Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
638   }
639 
640   if (!Ctors.empty()) {
641     llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
642     new llvm::GlobalVariable(TheModule, AT, false,
643                              llvm::GlobalValue::AppendingLinkage,
644                              llvm::ConstantArray::get(AT, Ctors),
645                              GlobalName);
646   }
647 }
648 
649 llvm::GlobalValue::LinkageTypes
650 CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
651   const auto *D = cast<FunctionDecl>(GD.getDecl());
652 
653   GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
654 
655   if (isa<CXXDestructorDecl>(D) &&
656       getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
657                                          GD.getDtorType())) {
658     // Destructor variants in the Microsoft C++ ABI are always internal or
659     // linkonce_odr thunks emitted on an as-needed basis.
660     return Linkage == GVA_Internal ? llvm::GlobalValue::InternalLinkage
661                                    : llvm::GlobalValue::LinkOnceODRLinkage;
662   }
663 
664   return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false);
665 }
666 
667 void CodeGenModule::setFunctionDefinitionAttributes(const FunctionDecl *D,
668                                                     llvm::Function *F) {
669   setNonAliasAttributes(D, F);
670 }
671 
672 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
673                                               const CGFunctionInfo &Info,
674                                               llvm::Function *F) {
675   unsigned CallingConv;
676   AttributeListType AttributeList;
677   ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
678   F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
679   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
680 }
681 
682 /// Determines whether the language options require us to model
683 /// unwind exceptions.  We treat -fexceptions as mandating this
684 /// except under the fragile ObjC ABI with only ObjC exceptions
685 /// enabled.  This means, for example, that C with -fexceptions
686 /// enables this.
687 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
688   // If exceptions are completely disabled, obviously this is false.
689   if (!LangOpts.Exceptions) return false;
690 
691   // If C++ exceptions are enabled, this is true.
692   if (LangOpts.CXXExceptions) return true;
693 
694   // If ObjC exceptions are enabled, this depends on the ABI.
695   if (LangOpts.ObjCExceptions) {
696     return LangOpts.ObjCRuntime.hasUnwindExceptions();
697   }
698 
699   return true;
700 }
701 
702 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
703                                                            llvm::Function *F) {
704   llvm::AttrBuilder B;
705 
706   if (CodeGenOpts.UnwindTables)
707     B.addAttribute(llvm::Attribute::UWTable);
708 
709   if (!hasUnwindExceptions(LangOpts))
710     B.addAttribute(llvm::Attribute::NoUnwind);
711 
712   if (D->hasAttr<NakedAttr>()) {
713     // Naked implies noinline: we should not be inlining such functions.
714     B.addAttribute(llvm::Attribute::Naked);
715     B.addAttribute(llvm::Attribute::NoInline);
716   } else if (D->hasAttr<NoDuplicateAttr>()) {
717     B.addAttribute(llvm::Attribute::NoDuplicate);
718   } else if (D->hasAttr<NoInlineAttr>()) {
719     B.addAttribute(llvm::Attribute::NoInline);
720   } else if (D->hasAttr<AlwaysInlineAttr>() &&
721              !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
722                                               llvm::Attribute::NoInline)) {
723     // (noinline wins over always_inline, and we can't specify both in IR)
724     B.addAttribute(llvm::Attribute::AlwaysInline);
725   }
726 
727   if (D->hasAttr<ColdAttr>()) {
728     if (!D->hasAttr<OptimizeNoneAttr>())
729       B.addAttribute(llvm::Attribute::OptimizeForSize);
730     B.addAttribute(llvm::Attribute::Cold);
731   }
732 
733   if (D->hasAttr<MinSizeAttr>())
734     B.addAttribute(llvm::Attribute::MinSize);
735 
736   if (LangOpts.getStackProtector() == LangOptions::SSPOn)
737     B.addAttribute(llvm::Attribute::StackProtect);
738   else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
739     B.addAttribute(llvm::Attribute::StackProtectStrong);
740   else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
741     B.addAttribute(llvm::Attribute::StackProtectReq);
742 
743   // Add sanitizer attributes if function is not blacklisted.
744   if (!isInSanitizerBlacklist(F, D->getLocation())) {
745     // When AddressSanitizer is enabled, set SanitizeAddress attribute
746     // unless __attribute__((no_sanitize_address)) is used.
747     if (LangOpts.Sanitize.has(SanitizerKind::Address) &&
748         !D->hasAttr<NoSanitizeAddressAttr>())
749       B.addAttribute(llvm::Attribute::SanitizeAddress);
750     // Same for ThreadSanitizer and __attribute__((no_sanitize_thread))
751     if (LangOpts.Sanitize.has(SanitizerKind::Thread) &&
752         !D->hasAttr<NoSanitizeThreadAttr>())
753       B.addAttribute(llvm::Attribute::SanitizeThread);
754     // Same for MemorySanitizer and __attribute__((no_sanitize_memory))
755     if (LangOpts.Sanitize.has(SanitizerKind::Memory) &&
756         !D->hasAttr<NoSanitizeMemoryAttr>())
757       B.addAttribute(llvm::Attribute::SanitizeMemory);
758   }
759 
760   F->addAttributes(llvm::AttributeSet::FunctionIndex,
761                    llvm::AttributeSet::get(
762                        F->getContext(), llvm::AttributeSet::FunctionIndex, B));
763 
764   if (D->hasAttr<OptimizeNoneAttr>()) {
765     // OptimizeNone implies noinline; we should not be inlining such functions.
766     F->addFnAttr(llvm::Attribute::OptimizeNone);
767     F->addFnAttr(llvm::Attribute::NoInline);
768 
769     // OptimizeNone wins over OptimizeForSize, MinSize, AlwaysInline.
770     assert(!F->hasFnAttribute(llvm::Attribute::OptimizeForSize) &&
771            "OptimizeNone and OptimizeForSize on same function!");
772     assert(!F->hasFnAttribute(llvm::Attribute::MinSize) &&
773            "OptimizeNone and MinSize on same function!");
774     assert(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
775            "OptimizeNone and AlwaysInline on same function!");
776 
777     // Attribute 'inlinehint' has no effect on 'optnone' functions.
778     // Explicitly remove it from the set of function attributes.
779     F->removeFnAttr(llvm::Attribute::InlineHint);
780   }
781 
782   if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
783     F->setUnnamedAddr(true);
784   else if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
785     if (MD->isVirtual())
786       F->setUnnamedAddr(true);
787 
788   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
789   if (alignment)
790     F->setAlignment(alignment);
791 
792   // C++ ABI requires 2-byte alignment for member functions.
793   if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
794     F->setAlignment(2);
795 }
796 
797 void CodeGenModule::SetCommonAttributes(const Decl *D,
798                                         llvm::GlobalValue *GV) {
799   if (const auto *ND = dyn_cast<NamedDecl>(D))
800     setGlobalVisibility(GV, ND);
801   else
802     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
803 
804   if (D->hasAttr<UsedAttr>())
805     addUsedGlobal(GV);
806 }
807 
808 void CodeGenModule::setAliasAttributes(const Decl *D,
809                                        llvm::GlobalValue *GV) {
810   SetCommonAttributes(D, GV);
811 
812   // Process the dllexport attribute based on whether the original definition
813   // (not necessarily the aliasee) was exported.
814   if (D->hasAttr<DLLExportAttr>())
815     GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
816 }
817 
818 void CodeGenModule::setNonAliasAttributes(const Decl *D,
819                                           llvm::GlobalObject *GO) {
820   SetCommonAttributes(D, GO);
821 
822   if (const SectionAttr *SA = D->getAttr<SectionAttr>())
823     GO->setSection(SA->getName());
824 
825   getTargetCodeGenInfo().SetTargetAttributes(D, GO, *this);
826 }
827 
828 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
829                                                   llvm::Function *F,
830                                                   const CGFunctionInfo &FI) {
831   SetLLVMFunctionAttributes(D, FI, F);
832   SetLLVMFunctionAttributesForDefinition(D, F);
833 
834   F->setLinkage(llvm::Function::InternalLinkage);
835 
836   setNonAliasAttributes(D, F);
837 }
838 
839 static void setLinkageAndVisibilityForGV(llvm::GlobalValue *GV,
840                                          const NamedDecl *ND) {
841   // Set linkage and visibility in case we never see a definition.
842   LinkageInfo LV = ND->getLinkageAndVisibility();
843   if (LV.getLinkage() != ExternalLinkage) {
844     // Don't set internal linkage on declarations.
845   } else {
846     if (ND->hasAttr<DLLImportAttr>()) {
847       GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
848       GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
849     } else if (ND->hasAttr<DLLExportAttr>()) {
850       GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
851       GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
852     } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) {
853       // "extern_weak" is overloaded in LLVM; we probably should have
854       // separate linkage types for this.
855       GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
856     }
857 
858     // Set visibility on a declaration only if it's explicit.
859     if (LV.isVisibilityExplicit())
860       GV->setVisibility(CodeGenModule::GetLLVMVisibility(LV.getVisibility()));
861   }
862 }
863 
864 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
865                                           bool IsIncompleteFunction,
866                                           bool IsThunk) {
867   if (unsigned IID = F->getIntrinsicID()) {
868     // If this is an intrinsic function, set the function's attributes
869     // to the intrinsic's attributes.
870     F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
871                                                     (llvm::Intrinsic::ID)IID));
872     return;
873   }
874 
875   const auto *FD = cast<FunctionDecl>(GD.getDecl());
876 
877   if (!IsIncompleteFunction)
878     SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
879 
880   // Add the Returned attribute for "this", except for iOS 5 and earlier
881   // where substantial code, including the libstdc++ dylib, was compiled with
882   // GCC and does not actually return "this".
883   if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
884       !(getTarget().getTriple().isiOS() &&
885         getTarget().getTriple().isOSVersionLT(6))) {
886     assert(!F->arg_empty() &&
887            F->arg_begin()->getType()
888              ->canLosslesslyBitCastTo(F->getReturnType()) &&
889            "unexpected this return");
890     F->addAttribute(1, llvm::Attribute::Returned);
891   }
892 
893   // Only a few attributes are set on declarations; these may later be
894   // overridden by a definition.
895 
896   setLinkageAndVisibilityForGV(F, FD);
897 
898   if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) {
899     if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) {
900       // Don't dllexport/import destructor thunks.
901       F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
902     }
903   }
904 
905   if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
906     F->setSection(SA->getName());
907 
908   // A replaceable global allocation function does not act like a builtin by
909   // default, only if it is invoked by a new-expression or delete-expression.
910   if (FD->isReplaceableGlobalAllocationFunction())
911     F->addAttribute(llvm::AttributeSet::FunctionIndex,
912                     llvm::Attribute::NoBuiltin);
913 }
914 
915 void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
916   assert(!GV->isDeclaration() &&
917          "Only globals with definition can force usage.");
918   LLVMUsed.push_back(GV);
919 }
920 
921 void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
922   assert(!GV->isDeclaration() &&
923          "Only globals with definition can force usage.");
924   LLVMCompilerUsed.push_back(GV);
925 }
926 
927 static void emitUsed(CodeGenModule &CGM, StringRef Name,
928                      std::vector<llvm::WeakVH> &List) {
929   // Don't create llvm.used if there is no need.
930   if (List.empty())
931     return;
932 
933   // Convert List to what ConstantArray needs.
934   SmallVector<llvm::Constant*, 8> UsedArray;
935   UsedArray.resize(List.size());
936   for (unsigned i = 0, e = List.size(); i != e; ++i) {
937     UsedArray[i] =
938         llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
939             cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
940   }
941 
942   if (UsedArray.empty())
943     return;
944   llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
945 
946   auto *GV = new llvm::GlobalVariable(
947       CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
948       llvm::ConstantArray::get(ATy, UsedArray), Name);
949 
950   GV->setSection("llvm.metadata");
951 }
952 
953 void CodeGenModule::emitLLVMUsed() {
954   emitUsed(*this, "llvm.used", LLVMUsed);
955   emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
956 }
957 
958 void CodeGenModule::AppendLinkerOptions(StringRef Opts) {
959   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
960   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
961 }
962 
963 void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
964   llvm::SmallString<32> Opt;
965   getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
966   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
967   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
968 }
969 
970 void CodeGenModule::AddDependentLib(StringRef Lib) {
971   llvm::SmallString<24> Opt;
972   getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt);
973   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
974   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
975 }
976 
977 /// \brief Add link options implied by the given module, including modules
978 /// it depends on, using a postorder walk.
979 static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod,
980                                     SmallVectorImpl<llvm::Metadata *> &Metadata,
981                                     llvm::SmallPtrSet<Module *, 16> &Visited) {
982   // Import this module's parent.
983   if (Mod->Parent && Visited.insert(Mod->Parent).second) {
984     addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
985   }
986 
987   // Import this module's dependencies.
988   for (unsigned I = Mod->Imports.size(); I > 0; --I) {
989     if (Visited.insert(Mod->Imports[I - 1]).second)
990       addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
991   }
992 
993   // Add linker options to link against the libraries/frameworks
994   // described by this module.
995   llvm::LLVMContext &Context = CGM.getLLVMContext();
996   for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
997     // Link against a framework.  Frameworks are currently Darwin only, so we
998     // don't to ask TargetCodeGenInfo for the spelling of the linker option.
999     if (Mod->LinkLibraries[I-1].IsFramework) {
1000       llvm::Metadata *Args[2] = {
1001           llvm::MDString::get(Context, "-framework"),
1002           llvm::MDString::get(Context, Mod->LinkLibraries[I - 1].Library)};
1003 
1004       Metadata.push_back(llvm::MDNode::get(Context, Args));
1005       continue;
1006     }
1007 
1008     // Link against a library.
1009     llvm::SmallString<24> Opt;
1010     CGM.getTargetCodeGenInfo().getDependentLibraryOption(
1011       Mod->LinkLibraries[I-1].Library, Opt);
1012     auto *OptString = llvm::MDString::get(Context, Opt);
1013     Metadata.push_back(llvm::MDNode::get(Context, OptString));
1014   }
1015 }
1016 
1017 void CodeGenModule::EmitModuleLinkOptions() {
1018   // Collect the set of all of the modules we want to visit to emit link
1019   // options, which is essentially the imported modules and all of their
1020   // non-explicit child modules.
1021   llvm::SetVector<clang::Module *> LinkModules;
1022   llvm::SmallPtrSet<clang::Module *, 16> Visited;
1023   SmallVector<clang::Module *, 16> Stack;
1024 
1025   // Seed the stack with imported modules.
1026   for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(),
1027                                                MEnd = ImportedModules.end();
1028        M != MEnd; ++M) {
1029     if (Visited.insert(*M).second)
1030       Stack.push_back(*M);
1031   }
1032 
1033   // Find all of the modules to import, making a little effort to prune
1034   // non-leaf modules.
1035   while (!Stack.empty()) {
1036     clang::Module *Mod = Stack.pop_back_val();
1037 
1038     bool AnyChildren = false;
1039 
1040     // Visit the submodules of this module.
1041     for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
1042                                         SubEnd = Mod->submodule_end();
1043          Sub != SubEnd; ++Sub) {
1044       // Skip explicit children; they need to be explicitly imported to be
1045       // linked against.
1046       if ((*Sub)->IsExplicit)
1047         continue;
1048 
1049       if (Visited.insert(*Sub).second) {
1050         Stack.push_back(*Sub);
1051         AnyChildren = true;
1052       }
1053     }
1054 
1055     // We didn't find any children, so add this module to the list of
1056     // modules to link against.
1057     if (!AnyChildren) {
1058       LinkModules.insert(Mod);
1059     }
1060   }
1061 
1062   // Add link options for all of the imported modules in reverse topological
1063   // order.  We don't do anything to try to order import link flags with respect
1064   // to linker options inserted by things like #pragma comment().
1065   SmallVector<llvm::Metadata *, 16> MetadataArgs;
1066   Visited.clear();
1067   for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(),
1068                                                MEnd = LinkModules.end();
1069        M != MEnd; ++M) {
1070     if (Visited.insert(*M).second)
1071       addLinkOptionsPostorder(*this, *M, MetadataArgs, Visited);
1072   }
1073   std::reverse(MetadataArgs.begin(), MetadataArgs.end());
1074   LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
1075 
1076   // Add the linker options metadata flag.
1077   getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
1078                             llvm::MDNode::get(getLLVMContext(),
1079                                               LinkerOptionsMetadata));
1080 }
1081 
1082 void CodeGenModule::EmitDeferred() {
1083   // Emit code for any potentially referenced deferred decls.  Since a
1084   // previously unused static decl may become used during the generation of code
1085   // for a static function, iterate until no changes are made.
1086 
1087   if (!DeferredVTables.empty()) {
1088     EmitDeferredVTables();
1089 
1090     // Emitting a v-table doesn't directly cause more v-tables to
1091     // become deferred, although it can cause functions to be
1092     // emitted that then need those v-tables.
1093     assert(DeferredVTables.empty());
1094   }
1095 
1096   // Stop if we're out of both deferred v-tables and deferred declarations.
1097   if (DeferredDeclsToEmit.empty())
1098     return;
1099 
1100   // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
1101   // work, it will not interfere with this.
1102   std::vector<DeferredGlobal> CurDeclsToEmit;
1103   CurDeclsToEmit.swap(DeferredDeclsToEmit);
1104 
1105   for (DeferredGlobal &G : CurDeclsToEmit) {
1106     GlobalDecl D = G.GD;
1107     llvm::GlobalValue *GV = G.GV;
1108     G.GV = nullptr;
1109 
1110     assert(!GV || GV == GetGlobalValue(getMangledName(D)));
1111     if (!GV)
1112       GV = GetGlobalValue(getMangledName(D));
1113 
1114     // Check to see if we've already emitted this.  This is necessary
1115     // for a couple of reasons: first, decls can end up in the
1116     // deferred-decls queue multiple times, and second, decls can end
1117     // up with definitions in unusual ways (e.g. by an extern inline
1118     // function acquiring a strong function redefinition).  Just
1119     // ignore these cases.
1120     if (GV && !GV->isDeclaration())
1121       continue;
1122 
1123     // Otherwise, emit the definition and move on to the next one.
1124     EmitGlobalDefinition(D, GV);
1125 
1126     // If we found out that we need to emit more decls, do that recursively.
1127     // This has the advantage that the decls are emitted in a DFS and related
1128     // ones are close together, which is convenient for testing.
1129     if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
1130       EmitDeferred();
1131       assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
1132     }
1133   }
1134 }
1135 
1136 void CodeGenModule::EmitGlobalAnnotations() {
1137   if (Annotations.empty())
1138     return;
1139 
1140   // Create a new global variable for the ConstantStruct in the Module.
1141   llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
1142     Annotations[0]->getType(), Annotations.size()), Annotations);
1143   auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
1144                                       llvm::GlobalValue::AppendingLinkage,
1145                                       Array, "llvm.global.annotations");
1146   gv->setSection(AnnotationSection);
1147 }
1148 
1149 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
1150   llvm::Constant *&AStr = AnnotationStrings[Str];
1151   if (AStr)
1152     return AStr;
1153 
1154   // Not found yet, create a new global.
1155   llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
1156   auto *gv =
1157       new llvm::GlobalVariable(getModule(), s->getType(), true,
1158                                llvm::GlobalValue::PrivateLinkage, s, ".str");
1159   gv->setSection(AnnotationSection);
1160   gv->setUnnamedAddr(true);
1161   AStr = gv;
1162   return gv;
1163 }
1164 
1165 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
1166   SourceManager &SM = getContext().getSourceManager();
1167   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
1168   if (PLoc.isValid())
1169     return EmitAnnotationString(PLoc.getFilename());
1170   return EmitAnnotationString(SM.getBufferName(Loc));
1171 }
1172 
1173 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
1174   SourceManager &SM = getContext().getSourceManager();
1175   PresumedLoc PLoc = SM.getPresumedLoc(L);
1176   unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1177     SM.getExpansionLineNumber(L);
1178   return llvm::ConstantInt::get(Int32Ty, LineNo);
1179 }
1180 
1181 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
1182                                                 const AnnotateAttr *AA,
1183                                                 SourceLocation L) {
1184   // Get the globals for file name, annotation, and the line number.
1185   llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1186                  *UnitGV = EmitAnnotationUnit(L),
1187                  *LineNoCst = EmitAnnotationLineNo(L);
1188 
1189   // Create the ConstantStruct for the global annotation.
1190   llvm::Constant *Fields[4] = {
1191     llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1192     llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1193     llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1194     LineNoCst
1195   };
1196   return llvm::ConstantStruct::getAnon(Fields);
1197 }
1198 
1199 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
1200                                          llvm::GlobalValue *GV) {
1201   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1202   // Get the struct elements for these annotations.
1203   for (const auto *I : D->specific_attrs<AnnotateAttr>())
1204     Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
1205 }
1206 
1207 bool CodeGenModule::isInSanitizerBlacklist(llvm::Function *Fn,
1208                                            SourceLocation Loc) const {
1209   const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1210   // Blacklist by function name.
1211   if (SanitizerBL.isBlacklistedFunction(Fn->getName()))
1212     return true;
1213   // Blacklist by location.
1214   if (!Loc.isInvalid())
1215     return SanitizerBL.isBlacklistedLocation(Loc);
1216   // If location is unknown, this may be a compiler-generated function. Assume
1217   // it's located in the main file.
1218   auto &SM = Context.getSourceManager();
1219   if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1220     return SanitizerBL.isBlacklistedFile(MainFile->getName());
1221   }
1222   return false;
1223 }
1224 
1225 bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
1226                                            SourceLocation Loc, QualType Ty,
1227                                            StringRef Category) const {
1228   // For now globals can be blacklisted only in ASan.
1229   if (!LangOpts.Sanitize.has(SanitizerKind::Address))
1230     return false;
1231   const auto &SanitizerBL = getContext().getSanitizerBlacklist();
1232   if (SanitizerBL.isBlacklistedGlobal(GV->getName(), Category))
1233     return true;
1234   if (SanitizerBL.isBlacklistedLocation(Loc, Category))
1235     return true;
1236   // Check global type.
1237   if (!Ty.isNull()) {
1238     // Drill down the array types: if global variable of a fixed type is
1239     // blacklisted, we also don't instrument arrays of them.
1240     while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
1241       Ty = AT->getElementType();
1242     Ty = Ty.getCanonicalType().getUnqualifiedType();
1243     // We allow to blacklist only record types (classes, structs etc.)
1244     if (Ty->isRecordType()) {
1245       std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
1246       if (SanitizerBL.isBlacklistedType(TypeStr, Category))
1247         return true;
1248     }
1249   }
1250   return false;
1251 }
1252 
1253 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
1254   // Never defer when EmitAllDecls is specified.
1255   if (LangOpts.EmitAllDecls)
1256     return true;
1257 
1258   return getContext().DeclMustBeEmitted(Global);
1259 }
1260 
1261 bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
1262   if (const auto *FD = dyn_cast<FunctionDecl>(Global))
1263     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1264       // Implicit template instantiations may change linkage if they are later
1265       // explicitly instantiated, so they should not be emitted eagerly.
1266       return false;
1267 
1268   return true;
1269 }
1270 
1271 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
1272     const CXXUuidofExpr* E) {
1273   // Sema has verified that IIDSource has a __declspec(uuid()), and that its
1274   // well-formed.
1275   StringRef Uuid = E->getUuidAsStringRef(Context);
1276   std::string Name = "_GUID_" + Uuid.lower();
1277   std::replace(Name.begin(), Name.end(), '-', '_');
1278 
1279   // Look for an existing global.
1280   if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
1281     return GV;
1282 
1283   llvm::Constant *Init = EmitUuidofInitializer(Uuid);
1284   assert(Init && "failed to initialize as constant");
1285 
1286   auto *GV = new llvm::GlobalVariable(
1287       getModule(), Init->getType(),
1288       /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
1289   if (supportsCOMDAT())
1290     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
1291   return GV;
1292 }
1293 
1294 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
1295   const AliasAttr *AA = VD->getAttr<AliasAttr>();
1296   assert(AA && "No alias?");
1297 
1298   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
1299 
1300   // See if there is already something with the target's name in the module.
1301   llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
1302   if (Entry) {
1303     unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1304     return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1305   }
1306 
1307   llvm::Constant *Aliasee;
1308   if (isa<llvm::FunctionType>(DeclTy))
1309     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1310                                       GlobalDecl(cast<FunctionDecl>(VD)),
1311                                       /*ForVTable=*/false);
1312   else
1313     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1314                                     llvm::PointerType::getUnqual(DeclTy),
1315                                     nullptr);
1316 
1317   auto *F = cast<llvm::GlobalValue>(Aliasee);
1318   F->setLinkage(llvm::Function::ExternalWeakLinkage);
1319   WeakRefReferences.insert(F);
1320 
1321   return Aliasee;
1322 }
1323 
1324 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
1325   const auto *Global = cast<ValueDecl>(GD.getDecl());
1326 
1327   // Weak references don't produce any output by themselves.
1328   if (Global->hasAttr<WeakRefAttr>())
1329     return;
1330 
1331   // If this is an alias definition (which otherwise looks like a declaration)
1332   // emit it now.
1333   if (Global->hasAttr<AliasAttr>())
1334     return EmitAliasDefinition(GD);
1335 
1336   // If this is CUDA, be selective about which declarations we emit.
1337   if (LangOpts.CUDA) {
1338     if (CodeGenOpts.CUDAIsDevice) {
1339       if (!Global->hasAttr<CUDADeviceAttr>() &&
1340           !Global->hasAttr<CUDAGlobalAttr>() &&
1341           !Global->hasAttr<CUDAConstantAttr>() &&
1342           !Global->hasAttr<CUDASharedAttr>())
1343         return;
1344     } else {
1345       if (!Global->hasAttr<CUDAHostAttr>() && (
1346             Global->hasAttr<CUDADeviceAttr>() ||
1347             Global->hasAttr<CUDAConstantAttr>() ||
1348             Global->hasAttr<CUDASharedAttr>()))
1349         return;
1350     }
1351   }
1352 
1353   // Ignore declarations, they will be emitted on their first use.
1354   if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
1355     // Forward declarations are emitted lazily on first use.
1356     if (!FD->doesThisDeclarationHaveABody()) {
1357       if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1358         return;
1359 
1360       StringRef MangledName = getMangledName(GD);
1361 
1362       // Compute the function info and LLVM type.
1363       const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
1364       llvm::Type *Ty = getTypes().GetFunctionType(FI);
1365 
1366       GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
1367                               /*DontDefer=*/false);
1368       return;
1369     }
1370   } else {
1371     const auto *VD = cast<VarDecl>(Global);
1372     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1373 
1374     if (VD->isThisDeclarationADefinition() != VarDecl::Definition &&
1375         !Context.isMSStaticDataMemberInlineDefinition(VD))
1376       return;
1377   }
1378 
1379   // Defer code generation to first use when possible, e.g. if this is an inline
1380   // function. If the global must always be emitted, do it eagerly if possible
1381   // to benefit from cache locality.
1382   if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
1383     // Emit the definition if it can't be deferred.
1384     EmitGlobalDefinition(GD);
1385     return;
1386   }
1387 
1388   // If we're deferring emission of a C++ variable with an
1389   // initializer, remember the order in which it appeared in the file.
1390   if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
1391       cast<VarDecl>(Global)->hasInit()) {
1392     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1393     CXXGlobalInits.push_back(nullptr);
1394   }
1395 
1396   StringRef MangledName = getMangledName(GD);
1397   if (llvm::GlobalValue *GV = GetGlobalValue(MangledName)) {
1398     // The value has already been used and should therefore be emitted.
1399     addDeferredDeclToEmit(GV, GD);
1400   } else if (MustBeEmitted(Global)) {
1401     // The value must be emitted, but cannot be emitted eagerly.
1402     assert(!MayBeEmittedEagerly(Global));
1403     addDeferredDeclToEmit(/*GV=*/nullptr, GD);
1404   } else {
1405     // Otherwise, remember that we saw a deferred decl with this name.  The
1406     // first use of the mangled name will cause it to move into
1407     // DeferredDeclsToEmit.
1408     DeferredDecls[MangledName] = GD;
1409   }
1410 }
1411 
1412 namespace {
1413   struct FunctionIsDirectlyRecursive :
1414     public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1415     const StringRef Name;
1416     const Builtin::Context &BI;
1417     bool Result;
1418     FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1419       Name(N), BI(C), Result(false) {
1420     }
1421     typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1422 
1423     bool TraverseCallExpr(CallExpr *E) {
1424       const FunctionDecl *FD = E->getDirectCallee();
1425       if (!FD)
1426         return true;
1427       AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1428       if (Attr && Name == Attr->getLabel()) {
1429         Result = true;
1430         return false;
1431       }
1432       unsigned BuiltinID = FD->getBuiltinID();
1433       if (!BuiltinID)
1434         return true;
1435       StringRef BuiltinName = BI.GetName(BuiltinID);
1436       if (BuiltinName.startswith("__builtin_") &&
1437           Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
1438         Result = true;
1439         return false;
1440       }
1441       return true;
1442     }
1443   };
1444 }
1445 
1446 // isTriviallyRecursive - Check if this function calls another
1447 // decl that, because of the asm attribute or the other decl being a builtin,
1448 // ends up pointing to itself.
1449 bool
1450 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1451   StringRef Name;
1452   if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
1453     // asm labels are a special kind of mangling we have to support.
1454     AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1455     if (!Attr)
1456       return false;
1457     Name = Attr->getLabel();
1458   } else {
1459     Name = FD->getName();
1460   }
1461 
1462   FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1463   Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
1464   return Walker.Result;
1465 }
1466 
1467 bool
1468 CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
1469   if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
1470     return true;
1471   const auto *F = cast<FunctionDecl>(GD.getDecl());
1472   if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
1473     return false;
1474   // PR9614. Avoid cases where the source code is lying to us. An available
1475   // externally function should have an equivalent function somewhere else,
1476   // but a function that calls itself is clearly not equivalent to the real
1477   // implementation.
1478   // This happens in glibc's btowc and in some configure checks.
1479   return !isTriviallyRecursive(F);
1480 }
1481 
1482 /// If the type for the method's class was generated by
1483 /// CGDebugInfo::createContextChain(), the cache contains only a
1484 /// limited DIType without any declarations. Since EmitFunctionStart()
1485 /// needs to find the canonical declaration for each method, we need
1486 /// to construct the complete type prior to emitting the method.
1487 void CodeGenModule::CompleteDIClassType(const CXXMethodDecl* D) {
1488   if (!D->isInstance())
1489     return;
1490 
1491   if (CGDebugInfo *DI = getModuleDebugInfo())
1492     if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) {
1493       const auto *ThisPtr = cast<PointerType>(D->getThisType(getContext()));
1494       DI->getOrCreateRecordType(ThisPtr->getPointeeType(), D->getLocation());
1495     }
1496 }
1497 
1498 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
1499   const auto *D = cast<ValueDecl>(GD.getDecl());
1500 
1501   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
1502                                  Context.getSourceManager(),
1503                                  "Generating code for declaration");
1504 
1505   if (isa<FunctionDecl>(D)) {
1506     // At -O0, don't generate IR for functions with available_externally
1507     // linkage.
1508     if (!shouldEmitFunction(GD))
1509       return;
1510 
1511     if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
1512       CompleteDIClassType(Method);
1513       // Make sure to emit the definition(s) before we emit the thunks.
1514       // This is necessary for the generation of certain thunks.
1515       if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method))
1516         ABI->emitCXXStructor(CD, getFromCtorType(GD.getCtorType()));
1517       else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method))
1518         ABI->emitCXXStructor(DD, getFromDtorType(GD.getDtorType()));
1519       else
1520         EmitGlobalFunctionDefinition(GD, GV);
1521 
1522       if (Method->isVirtual())
1523         getVTables().EmitThunks(GD);
1524 
1525       return;
1526     }
1527 
1528     return EmitGlobalFunctionDefinition(GD, GV);
1529   }
1530 
1531   if (const auto *VD = dyn_cast<VarDecl>(D))
1532     return EmitGlobalVarDefinition(VD);
1533 
1534   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
1535 }
1536 
1537 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1538 /// module, create and return an llvm Function with the specified type. If there
1539 /// is something in the module with the specified name, return it potentially
1540 /// bitcasted to the right type.
1541 ///
1542 /// If D is non-null, it specifies a decl that correspond to this.  This is used
1543 /// to set the attributes on the function when it is first created.
1544 llvm::Constant *
1545 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
1546                                        llvm::Type *Ty,
1547                                        GlobalDecl GD, bool ForVTable,
1548                                        bool DontDefer, bool IsThunk,
1549                                        llvm::AttributeSet ExtraAttrs) {
1550   const Decl *D = GD.getDecl();
1551 
1552   // Lookup the entry, lazily creating it if necessary.
1553   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1554   if (Entry) {
1555     if (WeakRefReferences.erase(Entry)) {
1556       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
1557       if (FD && !FD->hasAttr<WeakAttr>())
1558         Entry->setLinkage(llvm::Function::ExternalLinkage);
1559     }
1560 
1561     // Handle dropped DLL attributes.
1562     if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
1563       Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
1564 
1565     if (Entry->getType()->getElementType() == Ty)
1566       return Entry;
1567 
1568     // Make sure the result is of the correct type.
1569     return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
1570   }
1571 
1572   // This function doesn't have a complete type (for example, the return
1573   // type is an incomplete struct). Use a fake type instead, and make
1574   // sure not to try to set attributes.
1575   bool IsIncompleteFunction = false;
1576 
1577   llvm::FunctionType *FTy;
1578   if (isa<llvm::FunctionType>(Ty)) {
1579     FTy = cast<llvm::FunctionType>(Ty);
1580   } else {
1581     FTy = llvm::FunctionType::get(VoidTy, false);
1582     IsIncompleteFunction = true;
1583   }
1584 
1585   llvm::Function *F = llvm::Function::Create(FTy,
1586                                              llvm::Function::ExternalLinkage,
1587                                              MangledName, &getModule());
1588   assert(F->getName() == MangledName && "name was uniqued!");
1589   if (D)
1590     SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
1591   if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) {
1592     llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex);
1593     F->addAttributes(llvm::AttributeSet::FunctionIndex,
1594                      llvm::AttributeSet::get(VMContext,
1595                                              llvm::AttributeSet::FunctionIndex,
1596                                              B));
1597   }
1598 
1599   if (!DontDefer) {
1600     // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
1601     // each other bottoming out with the base dtor.  Therefore we emit non-base
1602     // dtors on usage, even if there is no dtor definition in the TU.
1603     if (D && isa<CXXDestructorDecl>(D) &&
1604         getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
1605                                            GD.getDtorType()))
1606       addDeferredDeclToEmit(F, GD);
1607 
1608     // This is the first use or definition of a mangled name.  If there is a
1609     // deferred decl with this name, remember that we need to emit it at the end
1610     // of the file.
1611     auto DDI = DeferredDecls.find(MangledName);
1612     if (DDI != DeferredDecls.end()) {
1613       // Move the potentially referenced deferred decl to the
1614       // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
1615       // don't need it anymore).
1616       addDeferredDeclToEmit(F, DDI->second);
1617       DeferredDecls.erase(DDI);
1618 
1619       // Otherwise, if this is a sized deallocation function, emit a weak
1620       // definition
1621       // for it at the end of the translation unit.
1622     } else if (D && cast<FunctionDecl>(D)
1623                         ->getCorrespondingUnsizedGlobalDeallocationFunction()) {
1624       addDeferredDeclToEmit(F, GD);
1625 
1626       // Otherwise, there are cases we have to worry about where we're
1627       // using a declaration for which we must emit a definition but where
1628       // we might not find a top-level definition:
1629       //   - member functions defined inline in their classes
1630       //   - friend functions defined inline in some class
1631       //   - special member functions with implicit definitions
1632       // If we ever change our AST traversal to walk into class methods,
1633       // this will be unnecessary.
1634       //
1635       // We also don't emit a definition for a function if it's going to be an
1636       // entry in a vtable, unless it's already marked as used.
1637     } else if (getLangOpts().CPlusPlus && D) {
1638       // Look for a declaration that's lexically in a record.
1639       for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
1640            FD = FD->getPreviousDecl()) {
1641         if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
1642           if (FD->doesThisDeclarationHaveABody()) {
1643             addDeferredDeclToEmit(F, GD.getWithDecl(FD));
1644             break;
1645           }
1646         }
1647       }
1648     }
1649   }
1650 
1651   // Make sure the result is of the requested type.
1652   if (!IsIncompleteFunction) {
1653     assert(F->getType()->getElementType() == Ty);
1654     return F;
1655   }
1656 
1657   llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
1658   return llvm::ConstantExpr::getBitCast(F, PTy);
1659 }
1660 
1661 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
1662 /// non-null, then this function will use the specified type if it has to
1663 /// create it (this occurs when we see a definition of the function).
1664 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
1665                                                  llvm::Type *Ty,
1666                                                  bool ForVTable,
1667                                                  bool DontDefer) {
1668   // If there was no specific requested type, just convert it now.
1669   if (!Ty)
1670     Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
1671 
1672   StringRef MangledName = getMangledName(GD);
1673   return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer);
1674 }
1675 
1676 /// CreateRuntimeFunction - Create a new runtime function with the specified
1677 /// type and name.
1678 llvm::Constant *
1679 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
1680                                      StringRef Name,
1681                                      llvm::AttributeSet ExtraAttrs) {
1682   llvm::Constant *C =
1683       GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1684                               /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
1685   if (auto *F = dyn_cast<llvm::Function>(C))
1686     if (F->empty())
1687       F->setCallingConv(getRuntimeCC());
1688   return C;
1689 }
1690 
1691 /// CreateBuiltinFunction - Create a new builtin function with the specified
1692 /// type and name.
1693 llvm::Constant *
1694 CodeGenModule::CreateBuiltinFunction(llvm::FunctionType *FTy,
1695                                      StringRef Name,
1696                                      llvm::AttributeSet ExtraAttrs) {
1697   llvm::Constant *C =
1698       GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1699                               /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
1700   if (auto *F = dyn_cast<llvm::Function>(C))
1701     if (F->empty())
1702       F->setCallingConv(getBuiltinCC());
1703   return C;
1704 }
1705 
1706 /// isTypeConstant - Determine whether an object of this type can be emitted
1707 /// as a constant.
1708 ///
1709 /// If ExcludeCtor is true, the duration when the object's constructor runs
1710 /// will not be considered. The caller will need to verify that the object is
1711 /// not written to during its construction.
1712 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1713   if (!Ty.isConstant(Context) && !Ty->isReferenceType())
1714     return false;
1715 
1716   if (Context.getLangOpts().CPlusPlus) {
1717     if (const CXXRecordDecl *Record
1718           = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1719       return ExcludeCtor && !Record->hasMutableFields() &&
1720              Record->hasTrivialDestructor();
1721   }
1722 
1723   return true;
1724 }
1725 
1726 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1727 /// create and return an llvm GlobalVariable with the specified type.  If there
1728 /// is something in the module with the specified name, return it potentially
1729 /// bitcasted to the right type.
1730 ///
1731 /// If D is non-null, it specifies a decl that correspond to this.  This is used
1732 /// to set the attributes on the global when it is first created.
1733 llvm::Constant *
1734 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
1735                                      llvm::PointerType *Ty,
1736                                      const VarDecl *D) {
1737   // Lookup the entry, lazily creating it if necessary.
1738   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1739   if (Entry) {
1740     if (WeakRefReferences.erase(Entry)) {
1741       if (D && !D->hasAttr<WeakAttr>())
1742         Entry->setLinkage(llvm::Function::ExternalLinkage);
1743     }
1744 
1745     // Handle dropped DLL attributes.
1746     if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
1747       Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
1748 
1749     if (Entry->getType() == Ty)
1750       return Entry;
1751 
1752     // Make sure the result is of the correct type.
1753     if (Entry->getType()->getAddressSpace() != Ty->getAddressSpace())
1754       return llvm::ConstantExpr::getAddrSpaceCast(Entry, Ty);
1755 
1756     return llvm::ConstantExpr::getBitCast(Entry, Ty);
1757   }
1758 
1759   unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
1760   auto *GV = new llvm::GlobalVariable(
1761       getModule(), Ty->getElementType(), false,
1762       llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr,
1763       llvm::GlobalVariable::NotThreadLocal, AddrSpace);
1764 
1765   // This is the first use or definition of a mangled name.  If there is a
1766   // deferred decl with this name, remember that we need to emit it at the end
1767   // of the file.
1768   auto DDI = DeferredDecls.find(MangledName);
1769   if (DDI != DeferredDecls.end()) {
1770     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1771     // list, and remove it from DeferredDecls (since we don't need it anymore).
1772     addDeferredDeclToEmit(GV, DDI->second);
1773     DeferredDecls.erase(DDI);
1774   }
1775 
1776   // Handle things which are present even on external declarations.
1777   if (D) {
1778     // FIXME: This code is overly simple and should be merged with other global
1779     // handling.
1780     GV->setConstant(isTypeConstant(D->getType(), false));
1781 
1782     setLinkageAndVisibilityForGV(GV, D);
1783 
1784     if (D->getTLSKind()) {
1785       if (D->getTLSKind() == VarDecl::TLS_Dynamic)
1786         CXXThreadLocals.push_back(std::make_pair(D, GV));
1787       setTLSMode(GV, *D);
1788     }
1789 
1790     // If required by the ABI, treat declarations of static data members with
1791     // inline initializers as definitions.
1792     if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
1793       EmitGlobalVarDefinition(D);
1794     }
1795 
1796     // Handle XCore specific ABI requirements.
1797     if (getTarget().getTriple().getArch() == llvm::Triple::xcore &&
1798         D->getLanguageLinkage() == CLanguageLinkage &&
1799         D->getType().isConstant(Context) &&
1800         isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
1801       GV->setSection(".cp.rodata");
1802   }
1803 
1804   if (AddrSpace != Ty->getAddressSpace())
1805     return llvm::ConstantExpr::getAddrSpaceCast(GV, Ty);
1806 
1807   return GV;
1808 }
1809 
1810 
1811 llvm::GlobalVariable *
1812 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
1813                                       llvm::Type *Ty,
1814                                       llvm::GlobalValue::LinkageTypes Linkage) {
1815   llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1816   llvm::GlobalVariable *OldGV = nullptr;
1817 
1818   if (GV) {
1819     // Check if the variable has the right type.
1820     if (GV->getType()->getElementType() == Ty)
1821       return GV;
1822 
1823     // Because C++ name mangling, the only way we can end up with an already
1824     // existing global with the same name is if it has been declared extern "C".
1825     assert(GV->isDeclaration() && "Declaration has wrong type!");
1826     OldGV = GV;
1827   }
1828 
1829   // Create a new variable.
1830   GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1831                                 Linkage, nullptr, Name);
1832 
1833   if (OldGV) {
1834     // Replace occurrences of the old variable if needed.
1835     GV->takeName(OldGV);
1836 
1837     if (!OldGV->use_empty()) {
1838       llvm::Constant *NewPtrForOldDecl =
1839       llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1840       OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1841     }
1842 
1843     OldGV->eraseFromParent();
1844   }
1845 
1846   if (supportsCOMDAT() && GV->isWeakForLinker())
1847     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
1848 
1849   return GV;
1850 }
1851 
1852 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1853 /// given global variable.  If Ty is non-null and if the global doesn't exist,
1854 /// then it will be created with the specified type instead of whatever the
1855 /// normal requested type would be.
1856 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
1857                                                   llvm::Type *Ty) {
1858   assert(D->hasGlobalStorage() && "Not a global variable");
1859   QualType ASTTy = D->getType();
1860   if (!Ty)
1861     Ty = getTypes().ConvertTypeForMem(ASTTy);
1862 
1863   llvm::PointerType *PTy =
1864     llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
1865 
1866   StringRef MangledName = getMangledName(D);
1867   return GetOrCreateLLVMGlobal(MangledName, PTy, D);
1868 }
1869 
1870 /// CreateRuntimeVariable - Create a new runtime global variable with the
1871 /// specified type and name.
1872 llvm::Constant *
1873 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
1874                                      StringRef Name) {
1875   return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr);
1876 }
1877 
1878 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1879   assert(!D->getInit() && "Cannot emit definite definitions here!");
1880 
1881   if (!MustBeEmitted(D)) {
1882     // If we have not seen a reference to this variable yet, place it
1883     // into the deferred declarations table to be emitted if needed
1884     // later.
1885     StringRef MangledName = getMangledName(D);
1886     if (!GetGlobalValue(MangledName)) {
1887       DeferredDecls[MangledName] = D;
1888       return;
1889     }
1890   }
1891 
1892   // The tentative definition is the only definition.
1893   EmitGlobalVarDefinition(D);
1894 }
1895 
1896 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
1897     return Context.toCharUnitsFromBits(
1898       TheDataLayout.getTypeStoreSizeInBits(Ty));
1899 }
1900 
1901 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1902                                                  unsigned AddrSpace) {
1903   if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1904     if (D->hasAttr<CUDAConstantAttr>())
1905       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1906     else if (D->hasAttr<CUDASharedAttr>())
1907       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1908     else
1909       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1910   }
1911 
1912   return AddrSpace;
1913 }
1914 
1915 template<typename SomeDecl>
1916 void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D,
1917                                                llvm::GlobalValue *GV) {
1918   if (!getLangOpts().CPlusPlus)
1919     return;
1920 
1921   // Must have 'used' attribute, or else inline assembly can't rely on
1922   // the name existing.
1923   if (!D->template hasAttr<UsedAttr>())
1924     return;
1925 
1926   // Must have internal linkage and an ordinary name.
1927   if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
1928     return;
1929 
1930   // Must be in an extern "C" context. Entities declared directly within
1931   // a record are not extern "C" even if the record is in such a context.
1932   const SomeDecl *First = D->getFirstDecl();
1933   if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
1934     return;
1935 
1936   // OK, this is an internal linkage entity inside an extern "C" linkage
1937   // specification. Make a note of that so we can give it the "expected"
1938   // mangled name if nothing else is using that name.
1939   std::pair<StaticExternCMap::iterator, bool> R =
1940       StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
1941 
1942   // If we have multiple internal linkage entities with the same name
1943   // in extern "C" regions, none of them gets that name.
1944   if (!R.second)
1945     R.first->second = nullptr;
1946 }
1947 
1948 static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
1949   if (!CGM.supportsCOMDAT())
1950     return false;
1951 
1952   if (D.hasAttr<SelectAnyAttr>())
1953     return true;
1954 
1955   GVALinkage Linkage;
1956   if (auto *VD = dyn_cast<VarDecl>(&D))
1957     Linkage = CGM.getContext().GetGVALinkageForVariable(VD);
1958   else
1959     Linkage = CGM.getContext().GetGVALinkageForFunction(cast<FunctionDecl>(&D));
1960 
1961   switch (Linkage) {
1962   case GVA_Internal:
1963   case GVA_AvailableExternally:
1964   case GVA_StrongExternal:
1965     return false;
1966   case GVA_DiscardableODR:
1967   case GVA_StrongODR:
1968     return true;
1969   }
1970   llvm_unreachable("No such linkage");
1971 }
1972 
1973 void CodeGenModule::maybeSetTrivialComdat(const Decl &D,
1974                                           llvm::GlobalObject &GO) {
1975   if (!shouldBeInCOMDAT(*this, D))
1976     return;
1977   GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
1978 }
1979 
1980 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1981   llvm::Constant *Init = nullptr;
1982   QualType ASTTy = D->getType();
1983   CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1984   bool NeedsGlobalCtor = false;
1985   bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
1986 
1987   const VarDecl *InitDecl;
1988   const Expr *InitExpr = D->getAnyInitializer(InitDecl);
1989 
1990   if (!InitExpr) {
1991     // This is a tentative definition; tentative definitions are
1992     // implicitly initialized with { 0 }.
1993     //
1994     // Note that tentative definitions are only emitted at the end of
1995     // a translation unit, so they should never have incomplete
1996     // type. In addition, EmitTentativeDefinition makes sure that we
1997     // never attempt to emit a tentative definition if a real one
1998     // exists. A use may still exists, however, so we still may need
1999     // to do a RAUW.
2000     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
2001     Init = EmitNullConstant(D->getType());
2002   } else {
2003     initializedGlobalDecl = GlobalDecl(D);
2004     Init = EmitConstantInit(*InitDecl);
2005 
2006     if (!Init) {
2007       QualType T = InitExpr->getType();
2008       if (D->getType()->isReferenceType())
2009         T = D->getType();
2010 
2011       if (getLangOpts().CPlusPlus) {
2012         Init = EmitNullConstant(T);
2013         NeedsGlobalCtor = true;
2014       } else {
2015         ErrorUnsupported(D, "static initializer");
2016         Init = llvm::UndefValue::get(getTypes().ConvertType(T));
2017       }
2018     } else {
2019       // We don't need an initializer, so remove the entry for the delayed
2020       // initializer position (just in case this entry was delayed) if we
2021       // also don't need to register a destructor.
2022       if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
2023         DelayedCXXInitPosition.erase(D);
2024     }
2025   }
2026 
2027   llvm::Type* InitType = Init->getType();
2028   llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
2029 
2030   // Strip off a bitcast if we got one back.
2031   if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2032     assert(CE->getOpcode() == llvm::Instruction::BitCast ||
2033            CE->getOpcode() == llvm::Instruction::AddrSpaceCast ||
2034            // All zero index gep.
2035            CE->getOpcode() == llvm::Instruction::GetElementPtr);
2036     Entry = CE->getOperand(0);
2037   }
2038 
2039   // Entry is now either a Function or GlobalVariable.
2040   auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
2041 
2042   // We have a definition after a declaration with the wrong type.
2043   // We must make a new GlobalVariable* and update everything that used OldGV
2044   // (a declaration or tentative definition) with the new GlobalVariable*
2045   // (which will be a definition).
2046   //
2047   // This happens if there is a prototype for a global (e.g.
2048   // "extern int x[];") and then a definition of a different type (e.g.
2049   // "int x[10];"). This also happens when an initializer has a different type
2050   // from the type of the global (this happens with unions).
2051   if (!GV ||
2052       GV->getType()->getElementType() != InitType ||
2053       GV->getType()->getAddressSpace() !=
2054        GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
2055 
2056     // Move the old entry aside so that we'll create a new one.
2057     Entry->setName(StringRef());
2058 
2059     // Make a new global with the correct type, this is now guaranteed to work.
2060     GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
2061 
2062     // Replace all uses of the old global with the new global
2063     llvm::Constant *NewPtrForOldDecl =
2064         llvm::ConstantExpr::getBitCast(GV, Entry->getType());
2065     Entry->replaceAllUsesWith(NewPtrForOldDecl);
2066 
2067     // Erase the old global, since it is no longer used.
2068     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
2069   }
2070 
2071   MaybeHandleStaticInExternC(D, GV);
2072 
2073   if (D->hasAttr<AnnotateAttr>())
2074     AddGlobalAnnotations(D, GV);
2075 
2076   GV->setInitializer(Init);
2077 
2078   // If it is safe to mark the global 'constant', do so now.
2079   GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
2080                   isTypeConstant(D->getType(), true));
2081 
2082   // If it is in a read-only section, mark it 'constant'.
2083   if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
2084     const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
2085     if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
2086       GV->setConstant(true);
2087   }
2088 
2089   GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
2090 
2091   // Set the llvm linkage type as appropriate.
2092   llvm::GlobalValue::LinkageTypes Linkage =
2093       getLLVMLinkageVarDefinition(D, GV->isConstant());
2094 
2095   // On Darwin, the backing variable for a C++11 thread_local variable always
2096   // has internal linkage; all accesses should just be calls to the
2097   // Itanium-specified entry point, which has the normal linkage of the
2098   // variable.
2099   if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
2100       Context.getTargetInfo().getTriple().isMacOSX())
2101     Linkage = llvm::GlobalValue::InternalLinkage;
2102 
2103   GV->setLinkage(Linkage);
2104   if (D->hasAttr<DLLImportAttr>())
2105     GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2106   else if (D->hasAttr<DLLExportAttr>())
2107     GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
2108   else
2109     GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
2110 
2111   if (Linkage == llvm::GlobalVariable::CommonLinkage)
2112     // common vars aren't constant even if declared const.
2113     GV->setConstant(false);
2114 
2115   setNonAliasAttributes(D, GV);
2116 
2117   if (D->getTLSKind() && !GV->isThreadLocal()) {
2118     if (D->getTLSKind() == VarDecl::TLS_Dynamic)
2119       CXXThreadLocals.push_back(std::make_pair(D, GV));
2120     setTLSMode(GV, *D);
2121   }
2122 
2123   maybeSetTrivialComdat(*D, *GV);
2124 
2125   // Emit the initializer function if necessary.
2126   if (NeedsGlobalCtor || NeedsGlobalDtor)
2127     EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
2128 
2129   SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
2130 
2131   // Emit global variable debug information.
2132   if (CGDebugInfo *DI = getModuleDebugInfo())
2133     if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2134       DI->EmitGlobalVariable(GV, D);
2135 }
2136 
2137 static bool isVarDeclStrongDefinition(const ASTContext &Context,
2138                                       const VarDecl *D, bool NoCommon) {
2139   // Don't give variables common linkage if -fno-common was specified unless it
2140   // was overridden by a NoCommon attribute.
2141   if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
2142     return true;
2143 
2144   // C11 6.9.2/2:
2145   //   A declaration of an identifier for an object that has file scope without
2146   //   an initializer, and without a storage-class specifier or with the
2147   //   storage-class specifier static, constitutes a tentative definition.
2148   if (D->getInit() || D->hasExternalStorage())
2149     return true;
2150 
2151   // A variable cannot be both common and exist in a section.
2152   if (D->hasAttr<SectionAttr>())
2153     return true;
2154 
2155   // Thread local vars aren't considered common linkage.
2156   if (D->getTLSKind())
2157     return true;
2158 
2159   // Tentative definitions marked with WeakImportAttr are true definitions.
2160   if (D->hasAttr<WeakImportAttr>())
2161     return true;
2162 
2163   // Declarations with a required alignment do not have common linakge in MSVC
2164   // mode.
2165   if (Context.getLangOpts().MSVCCompat &&
2166       (Context.isAlignmentRequired(D->getType()) || D->hasAttr<AlignedAttr>()))
2167     return true;
2168 
2169   return false;
2170 }
2171 
2172 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator(
2173     const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) {
2174   if (Linkage == GVA_Internal)
2175     return llvm::Function::InternalLinkage;
2176 
2177   if (D->hasAttr<WeakAttr>()) {
2178     if (IsConstantVariable)
2179       return llvm::GlobalVariable::WeakODRLinkage;
2180     else
2181       return llvm::GlobalVariable::WeakAnyLinkage;
2182   }
2183 
2184   // We are guaranteed to have a strong definition somewhere else,
2185   // so we can use available_externally linkage.
2186   if (Linkage == GVA_AvailableExternally)
2187     return llvm::Function::AvailableExternallyLinkage;
2188 
2189   // Note that Apple's kernel linker doesn't support symbol
2190   // coalescing, so we need to avoid linkonce and weak linkages there.
2191   // Normally, this means we just map to internal, but for explicit
2192   // instantiations we'll map to external.
2193 
2194   // In C++, the compiler has to emit a definition in every translation unit
2195   // that references the function.  We should use linkonce_odr because
2196   // a) if all references in this translation unit are optimized away, we
2197   // don't need to codegen it.  b) if the function persists, it needs to be
2198   // merged with other definitions. c) C++ has the ODR, so we know the
2199   // definition is dependable.
2200   if (Linkage == GVA_DiscardableODR)
2201     return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
2202                                             : llvm::Function::InternalLinkage;
2203 
2204   // An explicit instantiation of a template has weak linkage, since
2205   // explicit instantiations can occur in multiple translation units
2206   // and must all be equivalent. However, we are not allowed to
2207   // throw away these explicit instantiations.
2208   if (Linkage == GVA_StrongODR)
2209     return !Context.getLangOpts().AppleKext ? llvm::Function::WeakODRLinkage
2210                                             : llvm::Function::ExternalLinkage;
2211 
2212   // C++ doesn't have tentative definitions and thus cannot have common
2213   // linkage.
2214   if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
2215       !isVarDeclStrongDefinition(Context, cast<VarDecl>(D),
2216                                  CodeGenOpts.NoCommon))
2217     return llvm::GlobalVariable::CommonLinkage;
2218 
2219   // selectany symbols are externally visible, so use weak instead of
2220   // linkonce.  MSVC optimizes away references to const selectany globals, so
2221   // all definitions should be the same and ODR linkage should be used.
2222   // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
2223   if (D->hasAttr<SelectAnyAttr>())
2224     return llvm::GlobalVariable::WeakODRLinkage;
2225 
2226   // Otherwise, we have strong external linkage.
2227   assert(Linkage == GVA_StrongExternal);
2228   return llvm::GlobalVariable::ExternalLinkage;
2229 }
2230 
2231 llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition(
2232     const VarDecl *VD, bool IsConstant) {
2233   GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD);
2234   return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant);
2235 }
2236 
2237 /// Replace the uses of a function that was declared with a non-proto type.
2238 /// We want to silently drop extra arguments from call sites
2239 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
2240                                           llvm::Function *newFn) {
2241   // Fast path.
2242   if (old->use_empty()) return;
2243 
2244   llvm::Type *newRetTy = newFn->getReturnType();
2245   SmallVector<llvm::Value*, 4> newArgs;
2246 
2247   for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
2248          ui != ue; ) {
2249     llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
2250     llvm::User *user = use->getUser();
2251 
2252     // Recognize and replace uses of bitcasts.  Most calls to
2253     // unprototyped functions will use bitcasts.
2254     if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
2255       if (bitcast->getOpcode() == llvm::Instruction::BitCast)
2256         replaceUsesOfNonProtoConstant(bitcast, newFn);
2257       continue;
2258     }
2259 
2260     // Recognize calls to the function.
2261     llvm::CallSite callSite(user);
2262     if (!callSite) continue;
2263     if (!callSite.isCallee(&*use)) continue;
2264 
2265     // If the return types don't match exactly, then we can't
2266     // transform this call unless it's dead.
2267     if (callSite->getType() != newRetTy && !callSite->use_empty())
2268       continue;
2269 
2270     // Get the call site's attribute list.
2271     SmallVector<llvm::AttributeSet, 8> newAttrs;
2272     llvm::AttributeSet oldAttrs = callSite.getAttributes();
2273 
2274     // Collect any return attributes from the call.
2275     if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex))
2276       newAttrs.push_back(
2277         llvm::AttributeSet::get(newFn->getContext(),
2278                                 oldAttrs.getRetAttributes()));
2279 
2280     // If the function was passed too few arguments, don't transform.
2281     unsigned newNumArgs = newFn->arg_size();
2282     if (callSite.arg_size() < newNumArgs) continue;
2283 
2284     // If extra arguments were passed, we silently drop them.
2285     // If any of the types mismatch, we don't transform.
2286     unsigned argNo = 0;
2287     bool dontTransform = false;
2288     for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
2289            ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
2290       if (callSite.getArgument(argNo)->getType() != ai->getType()) {
2291         dontTransform = true;
2292         break;
2293       }
2294 
2295       // Add any parameter attributes.
2296       if (oldAttrs.hasAttributes(argNo + 1))
2297         newAttrs.
2298           push_back(llvm::
2299                     AttributeSet::get(newFn->getContext(),
2300                                       oldAttrs.getParamAttributes(argNo + 1)));
2301     }
2302     if (dontTransform)
2303       continue;
2304 
2305     if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex))
2306       newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(),
2307                                                  oldAttrs.getFnAttributes()));
2308 
2309     // Okay, we can transform this.  Create the new call instruction and copy
2310     // over the required information.
2311     newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
2312 
2313     llvm::CallSite newCall;
2314     if (callSite.isCall()) {
2315       newCall = llvm::CallInst::Create(newFn, newArgs, "",
2316                                        callSite.getInstruction());
2317     } else {
2318       auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction());
2319       newCall = llvm::InvokeInst::Create(newFn,
2320                                          oldInvoke->getNormalDest(),
2321                                          oldInvoke->getUnwindDest(),
2322                                          newArgs, "",
2323                                          callSite.getInstruction());
2324     }
2325     newArgs.clear(); // for the next iteration
2326 
2327     if (!newCall->getType()->isVoidTy())
2328       newCall->takeName(callSite.getInstruction());
2329     newCall.setAttributes(
2330                      llvm::AttributeSet::get(newFn->getContext(), newAttrs));
2331     newCall.setCallingConv(callSite.getCallingConv());
2332 
2333     // Finally, remove the old call, replacing any uses with the new one.
2334     if (!callSite->use_empty())
2335       callSite->replaceAllUsesWith(newCall.getInstruction());
2336 
2337     // Copy debug location attached to CI.
2338     if (!callSite->getDebugLoc().isUnknown())
2339       newCall->setDebugLoc(callSite->getDebugLoc());
2340     callSite->eraseFromParent();
2341   }
2342 }
2343 
2344 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
2345 /// implement a function with no prototype, e.g. "int foo() {}".  If there are
2346 /// existing call uses of the old function in the module, this adjusts them to
2347 /// call the new function directly.
2348 ///
2349 /// This is not just a cleanup: the always_inline pass requires direct calls to
2350 /// functions to be able to inline them.  If there is a bitcast in the way, it
2351 /// won't inline them.  Instcombine normally deletes these calls, but it isn't
2352 /// run at -O0.
2353 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2354                                                       llvm::Function *NewFn) {
2355   // If we're redefining a global as a function, don't transform it.
2356   if (!isa<llvm::Function>(Old)) return;
2357 
2358   replaceUsesOfNonProtoConstant(Old, NewFn);
2359 }
2360 
2361 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
2362   TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
2363   // If we have a definition, this might be a deferred decl. If the
2364   // instantiation is explicit, make sure we emit it at the end.
2365   if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
2366     GetAddrOfGlobalVar(VD);
2367 
2368   EmitTopLevelDecl(VD);
2369 }
2370 
2371 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
2372                                                  llvm::GlobalValue *GV) {
2373   const auto *D = cast<FunctionDecl>(GD.getDecl());
2374 
2375   // Compute the function info and LLVM type.
2376   const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2377   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2378 
2379   // Get or create the prototype for the function.
2380   if (!GV) {
2381     llvm::Constant *C =
2382         GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer*/ true);
2383 
2384     // Strip off a bitcast if we got one back.
2385     if (auto *CE = dyn_cast<llvm::ConstantExpr>(C)) {
2386       assert(CE->getOpcode() == llvm::Instruction::BitCast);
2387       GV = cast<llvm::GlobalValue>(CE->getOperand(0));
2388     } else {
2389       GV = cast<llvm::GlobalValue>(C);
2390     }
2391   }
2392 
2393   if (!GV->isDeclaration()) {
2394     getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name);
2395     GlobalDecl OldGD = Manglings.lookup(GV->getName());
2396     if (auto *Prev = OldGD.getDecl())
2397       getDiags().Report(Prev->getLocation(), diag::note_previous_definition);
2398     return;
2399   }
2400 
2401   if (GV->getType()->getElementType() != Ty) {
2402     // If the types mismatch then we have to rewrite the definition.
2403     assert(GV->isDeclaration() && "Shouldn't replace non-declaration");
2404 
2405     // F is the Function* for the one with the wrong type, we must make a new
2406     // Function* and update everything that used F (a declaration) with the new
2407     // Function* (which will be a definition).
2408     //
2409     // This happens if there is a prototype for a function
2410     // (e.g. "int f()") and then a definition of a different type
2411     // (e.g. "int f(int x)").  Move the old function aside so that it
2412     // doesn't interfere with GetAddrOfFunction.
2413     GV->setName(StringRef());
2414     auto *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
2415 
2416     // This might be an implementation of a function without a
2417     // prototype, in which case, try to do special replacement of
2418     // calls which match the new prototype.  The really key thing here
2419     // is that we also potentially drop arguments from the call site
2420     // so as to make a direct call, which makes the inliner happier
2421     // and suppresses a number of optimizer warnings (!) about
2422     // dropping arguments.
2423     if (!GV->use_empty()) {
2424       ReplaceUsesOfNonProtoTypeWithRealFunction(GV, NewFn);
2425       GV->removeDeadConstantUsers();
2426     }
2427 
2428     // Replace uses of F with the Function we will endow with a body.
2429     if (!GV->use_empty()) {
2430       llvm::Constant *NewPtrForOldDecl =
2431           llvm::ConstantExpr::getBitCast(NewFn, GV->getType());
2432       GV->replaceAllUsesWith(NewPtrForOldDecl);
2433     }
2434 
2435     // Ok, delete the old function now, which is dead.
2436     GV->eraseFromParent();
2437 
2438     GV = NewFn;
2439   }
2440 
2441   // We need to set linkage and visibility on the function before
2442   // generating code for it because various parts of IR generation
2443   // want to propagate this information down (e.g. to local static
2444   // declarations).
2445   auto *Fn = cast<llvm::Function>(GV);
2446   setFunctionLinkage(GD, Fn);
2447   if (D->hasAttr<DLLImportAttr>())
2448     GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
2449   else if (D->hasAttr<DLLExportAttr>())
2450     GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
2451   else
2452     GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
2453 
2454   // FIXME: this is redundant with part of setFunctionDefinitionAttributes
2455   setGlobalVisibility(Fn, D);
2456 
2457   MaybeHandleStaticInExternC(D, Fn);
2458 
2459   maybeSetTrivialComdat(*D, *Fn);
2460 
2461   CodeGenFunction(*this).GenerateCode(D, Fn, FI);
2462 
2463   setFunctionDefinitionAttributes(D, Fn);
2464   SetLLVMFunctionAttributesForDefinition(D, Fn);
2465 
2466   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
2467     AddGlobalCtor(Fn, CA->getPriority());
2468   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
2469     AddGlobalDtor(Fn, DA->getPriority());
2470   if (D->hasAttr<AnnotateAttr>())
2471     AddGlobalAnnotations(D, Fn);
2472 }
2473 
2474 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2475   const auto *D = cast<ValueDecl>(GD.getDecl());
2476   const AliasAttr *AA = D->getAttr<AliasAttr>();
2477   assert(AA && "Not an alias?");
2478 
2479   StringRef MangledName = getMangledName(GD);
2480 
2481   // If there is a definition in the module, then it wins over the alias.
2482   // This is dubious, but allow it to be safe.  Just ignore the alias.
2483   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2484   if (Entry && !Entry->isDeclaration())
2485     return;
2486 
2487   Aliases.push_back(GD);
2488 
2489   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
2490 
2491   // Create a reference to the named value.  This ensures that it is emitted
2492   // if a deferred decl.
2493   llvm::Constant *Aliasee;
2494   if (isa<llvm::FunctionType>(DeclTy))
2495     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
2496                                       /*ForVTable=*/false);
2497   else
2498     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2499                                     llvm::PointerType::getUnqual(DeclTy),
2500                                     /*D=*/nullptr);
2501 
2502   // Create the new alias itself, but don't set a name yet.
2503   auto *GA = llvm::GlobalAlias::create(
2504       cast<llvm::PointerType>(Aliasee->getType())->getElementType(), 0,
2505       llvm::Function::ExternalLinkage, "", Aliasee, &getModule());
2506 
2507   if (Entry) {
2508     if (GA->getAliasee() == Entry) {
2509       Diags.Report(AA->getLocation(), diag::err_cyclic_alias);
2510       return;
2511     }
2512 
2513     assert(Entry->isDeclaration());
2514 
2515     // If there is a declaration in the module, then we had an extern followed
2516     // by the alias, as in:
2517     //   extern int test6();
2518     //   ...
2519     //   int test6() __attribute__((alias("test7")));
2520     //
2521     // Remove it and replace uses of it with the alias.
2522     GA->takeName(Entry);
2523 
2524     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
2525                                                           Entry->getType()));
2526     Entry->eraseFromParent();
2527   } else {
2528     GA->setName(MangledName);
2529   }
2530 
2531   // Set attributes which are particular to an alias; this is a
2532   // specialization of the attributes which may be set on a global
2533   // variable/function.
2534   if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
2535       D->isWeakImported()) {
2536     GA->setLinkage(llvm::Function::WeakAnyLinkage);
2537   }
2538 
2539   if (const auto *VD = dyn_cast<VarDecl>(D))
2540     if (VD->getTLSKind())
2541       setTLSMode(GA, *VD);
2542 
2543   setAliasAttributes(D, GA);
2544 }
2545 
2546 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
2547                                             ArrayRef<llvm::Type*> Tys) {
2548   return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
2549                                          Tys);
2550 }
2551 
2552 static llvm::StringMapEntry<llvm::Constant*> &
2553 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2554                          const StringLiteral *Literal,
2555                          bool TargetIsLSB,
2556                          bool &IsUTF16,
2557                          unsigned &StringLength) {
2558   StringRef String = Literal->getString();
2559   unsigned NumBytes = String.size();
2560 
2561   // Check for simple case.
2562   if (!Literal->containsNonAsciiOrNull()) {
2563     StringLength = NumBytes;
2564     return *Map.insert(std::make_pair(String, nullptr)).first;
2565   }
2566 
2567   // Otherwise, convert the UTF8 literals into a string of shorts.
2568   IsUTF16 = true;
2569 
2570   SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
2571   const UTF8 *FromPtr = (const UTF8 *)String.data();
2572   UTF16 *ToPtr = &ToBuf[0];
2573 
2574   (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2575                            &ToPtr, ToPtr + NumBytes,
2576                            strictConversion);
2577 
2578   // ConvertUTF8toUTF16 returns the length in ToPtr.
2579   StringLength = ToPtr - &ToBuf[0];
2580 
2581   // Add an explicit null.
2582   *ToPtr = 0;
2583   return *Map.insert(std::make_pair(
2584                          StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2585                                    (StringLength + 1) * 2),
2586                          nullptr)).first;
2587 }
2588 
2589 static llvm::StringMapEntry<llvm::Constant*> &
2590 GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2591                        const StringLiteral *Literal,
2592                        unsigned &StringLength) {
2593   StringRef String = Literal->getString();
2594   StringLength = String.size();
2595   return *Map.insert(std::make_pair(String, nullptr)).first;
2596 }
2597 
2598 llvm::Constant *
2599 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2600   unsigned StringLength = 0;
2601   bool isUTF16 = false;
2602   llvm::StringMapEntry<llvm::Constant*> &Entry =
2603     GetConstantCFStringEntry(CFConstantStringMap, Literal,
2604                              getDataLayout().isLittleEndian(),
2605                              isUTF16, StringLength);
2606 
2607   if (auto *C = Entry.second)
2608     return C;
2609 
2610   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2611   llvm::Constant *Zeros[] = { Zero, Zero };
2612   llvm::Value *V;
2613 
2614   // If we don't already have it, get __CFConstantStringClassReference.
2615   if (!CFConstantStringClassRef) {
2616     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2617     Ty = llvm::ArrayType::get(Ty, 0);
2618     llvm::Constant *GV = CreateRuntimeVariable(Ty,
2619                                            "__CFConstantStringClassReference");
2620     // Decay array -> ptr
2621     V = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2622     CFConstantStringClassRef = V;
2623   }
2624   else
2625     V = CFConstantStringClassRef;
2626 
2627   QualType CFTy = getContext().getCFConstantStringType();
2628 
2629   auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2630 
2631   llvm::Constant *Fields[4];
2632 
2633   // Class pointer.
2634   Fields[0] = cast<llvm::ConstantExpr>(V);
2635 
2636   // Flags.
2637   llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2638   Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
2639     llvm::ConstantInt::get(Ty, 0x07C8);
2640 
2641   // String pointer.
2642   llvm::Constant *C = nullptr;
2643   if (isUTF16) {
2644     ArrayRef<uint16_t> Arr = llvm::makeArrayRef<uint16_t>(
2645         reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
2646         Entry.first().size() / 2);
2647     C = llvm::ConstantDataArray::get(VMContext, Arr);
2648   } else {
2649     C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
2650   }
2651 
2652   // Note: -fwritable-strings doesn't make the backing store strings of
2653   // CFStrings writable. (See <rdar://problem/10657500>)
2654   auto *GV =
2655       new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2656                                llvm::GlobalValue::PrivateLinkage, C, ".str");
2657   GV->setUnnamedAddr(true);
2658   // Don't enforce the target's minimum global alignment, since the only use
2659   // of the string is via this class initializer.
2660   // FIXME: We set the section explicitly to avoid a bug in ld64 224.1. Without
2661   // it LLVM can merge the string with a non unnamed_addr one during LTO. Doing
2662   // that changes the section it ends in, which surprises ld64.
2663   if (isUTF16) {
2664     CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2665     GV->setAlignment(Align.getQuantity());
2666     GV->setSection("__TEXT,__ustring");
2667   } else {
2668     CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2669     GV->setAlignment(Align.getQuantity());
2670     GV->setSection("__TEXT,__cstring,cstring_literals");
2671   }
2672 
2673   // String.
2674   Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2675 
2676   if (isUTF16)
2677     // Cast the UTF16 string to the correct type.
2678     Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2679 
2680   // String length.
2681   Ty = getTypes().ConvertType(getContext().LongTy);
2682   Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
2683 
2684   // The struct.
2685   C = llvm::ConstantStruct::get(STy, Fields);
2686   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2687                                 llvm::GlobalVariable::PrivateLinkage, C,
2688                                 "_unnamed_cfstring_");
2689   GV->setSection("__DATA,__cfstring");
2690   Entry.second = GV;
2691 
2692   return GV;
2693 }
2694 
2695 llvm::Constant *
2696 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
2697   unsigned StringLength = 0;
2698   llvm::StringMapEntry<llvm::Constant*> &Entry =
2699     GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
2700 
2701   if (auto *C = Entry.second)
2702     return C;
2703 
2704   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2705   llvm::Constant *Zeros[] = { Zero, Zero };
2706   llvm::Value *V;
2707   // If we don't already have it, get _NSConstantStringClassReference.
2708   if (!ConstantStringClassRef) {
2709     std::string StringClass(getLangOpts().ObjCConstantStringClass);
2710     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2711     llvm::Constant *GV;
2712     if (LangOpts.ObjCRuntime.isNonFragile()) {
2713       std::string str =
2714         StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2715                             : "OBJC_CLASS_$_" + StringClass;
2716       GV = getObjCRuntime().GetClassGlobal(str);
2717       // Make sure the result is of the correct type.
2718       llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2719       V = llvm::ConstantExpr::getBitCast(GV, PTy);
2720       ConstantStringClassRef = V;
2721     } else {
2722       std::string str =
2723         StringClass.empty() ? "_NSConstantStringClassReference"
2724                             : "_" + StringClass + "ClassReference";
2725       llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
2726       GV = CreateRuntimeVariable(PTy, str);
2727       // Decay array -> ptr
2728       V = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2729       ConstantStringClassRef = V;
2730     }
2731   }
2732   else
2733     V = ConstantStringClassRef;
2734 
2735   if (!NSConstantStringType) {
2736     // Construct the type for a constant NSString.
2737     RecordDecl *D = Context.buildImplicitRecord("__builtin_NSString");
2738     D->startDefinition();
2739 
2740     QualType FieldTypes[3];
2741 
2742     // const int *isa;
2743     FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2744     // const char *str;
2745     FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2746     // unsigned int length;
2747     FieldTypes[2] = Context.UnsignedIntTy;
2748 
2749     // Create fields
2750     for (unsigned i = 0; i < 3; ++i) {
2751       FieldDecl *Field = FieldDecl::Create(Context, D,
2752                                            SourceLocation(),
2753                                            SourceLocation(), nullptr,
2754                                            FieldTypes[i], /*TInfo=*/nullptr,
2755                                            /*BitWidth=*/nullptr,
2756                                            /*Mutable=*/false,
2757                                            ICIS_NoInit);
2758       Field->setAccess(AS_public);
2759       D->addDecl(Field);
2760     }
2761 
2762     D->completeDefinition();
2763     QualType NSTy = Context.getTagDeclType(D);
2764     NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2765   }
2766 
2767   llvm::Constant *Fields[3];
2768 
2769   // Class pointer.
2770   Fields[0] = cast<llvm::ConstantExpr>(V);
2771 
2772   // String pointer.
2773   llvm::Constant *C =
2774       llvm::ConstantDataArray::getString(VMContext, Entry.first());
2775 
2776   llvm::GlobalValue::LinkageTypes Linkage;
2777   bool isConstant;
2778   Linkage = llvm::GlobalValue::PrivateLinkage;
2779   isConstant = !LangOpts.WritableStrings;
2780 
2781   auto *GV = new llvm::GlobalVariable(getModule(), C->getType(), isConstant,
2782                                       Linkage, C, ".str");
2783   GV->setUnnamedAddr(true);
2784   // Don't enforce the target's minimum global alignment, since the only use
2785   // of the string is via this class initializer.
2786   CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2787   GV->setAlignment(Align.getQuantity());
2788   Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2789 
2790   // String length.
2791   llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2792   Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2793 
2794   // The struct.
2795   C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
2796   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2797                                 llvm::GlobalVariable::PrivateLinkage, C,
2798                                 "_unnamed_nsstring_");
2799   const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2800   const char *NSStringNonFragileABISection =
2801       "__DATA,__objc_stringobj,regular,no_dead_strip";
2802   // FIXME. Fix section.
2803   GV->setSection(LangOpts.ObjCRuntime.isNonFragile()
2804                      ? NSStringNonFragileABISection
2805                      : NSStringSection);
2806   Entry.second = GV;
2807 
2808   return GV;
2809 }
2810 
2811 QualType CodeGenModule::getObjCFastEnumerationStateType() {
2812   if (ObjCFastEnumerationStateType.isNull()) {
2813     RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
2814     D->startDefinition();
2815 
2816     QualType FieldTypes[] = {
2817       Context.UnsignedLongTy,
2818       Context.getPointerType(Context.getObjCIdType()),
2819       Context.getPointerType(Context.UnsignedLongTy),
2820       Context.getConstantArrayType(Context.UnsignedLongTy,
2821                            llvm::APInt(32, 5), ArrayType::Normal, 0)
2822     };
2823 
2824     for (size_t i = 0; i < 4; ++i) {
2825       FieldDecl *Field = FieldDecl::Create(Context,
2826                                            D,
2827                                            SourceLocation(),
2828                                            SourceLocation(), nullptr,
2829                                            FieldTypes[i], /*TInfo=*/nullptr,
2830                                            /*BitWidth=*/nullptr,
2831                                            /*Mutable=*/false,
2832                                            ICIS_NoInit);
2833       Field->setAccess(AS_public);
2834       D->addDecl(Field);
2835     }
2836 
2837     D->completeDefinition();
2838     ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2839   }
2840 
2841   return ObjCFastEnumerationStateType;
2842 }
2843 
2844 llvm::Constant *
2845 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2846   assert(!E->getType()->isPointerType() && "Strings are always arrays");
2847 
2848   // Don't emit it as the address of the string, emit the string data itself
2849   // as an inline array.
2850   if (E->getCharByteWidth() == 1) {
2851     SmallString<64> Str(E->getString());
2852 
2853     // Resize the string to the right size, which is indicated by its type.
2854     const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2855     Str.resize(CAT->getSize().getZExtValue());
2856     return llvm::ConstantDataArray::getString(VMContext, Str, false);
2857   }
2858 
2859   auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2860   llvm::Type *ElemTy = AType->getElementType();
2861   unsigned NumElements = AType->getNumElements();
2862 
2863   // Wide strings have either 2-byte or 4-byte elements.
2864   if (ElemTy->getPrimitiveSizeInBits() == 16) {
2865     SmallVector<uint16_t, 32> Elements;
2866     Elements.reserve(NumElements);
2867 
2868     for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2869       Elements.push_back(E->getCodeUnit(i));
2870     Elements.resize(NumElements);
2871     return llvm::ConstantDataArray::get(VMContext, Elements);
2872   }
2873 
2874   assert(ElemTy->getPrimitiveSizeInBits() == 32);
2875   SmallVector<uint32_t, 32> Elements;
2876   Elements.reserve(NumElements);
2877 
2878   for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2879     Elements.push_back(E->getCodeUnit(i));
2880   Elements.resize(NumElements);
2881   return llvm::ConstantDataArray::get(VMContext, Elements);
2882 }
2883 
2884 static llvm::GlobalVariable *
2885 GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
2886                       CodeGenModule &CGM, StringRef GlobalName,
2887                       unsigned Alignment) {
2888   // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
2889   unsigned AddrSpace = 0;
2890   if (CGM.getLangOpts().OpenCL)
2891     AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant);
2892 
2893   llvm::Module &M = CGM.getModule();
2894   // Create a global variable for this string
2895   auto *GV = new llvm::GlobalVariable(
2896       M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
2897       nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
2898   GV->setAlignment(Alignment);
2899   GV->setUnnamedAddr(true);
2900   if (GV->isWeakForLinker()) {
2901     assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
2902     GV->setComdat(M.getOrInsertComdat(GV->getName()));
2903   }
2904 
2905   return GV;
2906 }
2907 
2908 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2909 /// constant array for the given string literal.
2910 llvm::GlobalVariable *
2911 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
2912                                                   StringRef Name) {
2913   auto Alignment =
2914       getContext().getAlignOfGlobalVarInChars(S->getType()).getQuantity();
2915 
2916   llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2917   llvm::GlobalVariable **Entry = nullptr;
2918   if (!LangOpts.WritableStrings) {
2919     Entry = &ConstantStringMap[C];
2920     if (auto GV = *Entry) {
2921       if (Alignment > GV->getAlignment())
2922         GV->setAlignment(Alignment);
2923       return GV;
2924     }
2925   }
2926 
2927   SmallString<256> MangledNameBuffer;
2928   StringRef GlobalVariableName;
2929   llvm::GlobalValue::LinkageTypes LT;
2930 
2931   // Mangle the string literal if the ABI allows for it.  However, we cannot
2932   // do this if  we are compiling with ASan or -fwritable-strings because they
2933   // rely on strings having normal linkage.
2934   if (!LangOpts.WritableStrings &&
2935       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
2936       getCXXABI().getMangleContext().shouldMangleStringLiteral(S)) {
2937     llvm::raw_svector_ostream Out(MangledNameBuffer);
2938     getCXXABI().getMangleContext().mangleStringLiteral(S, Out);
2939     Out.flush();
2940 
2941     LT = llvm::GlobalValue::LinkOnceODRLinkage;
2942     GlobalVariableName = MangledNameBuffer;
2943   } else {
2944     LT = llvm::GlobalValue::PrivateLinkage;
2945     GlobalVariableName = Name;
2946   }
2947 
2948   auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
2949   if (Entry)
2950     *Entry = GV;
2951 
2952   SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
2953                                   QualType());
2954   return GV;
2955 }
2956 
2957 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2958 /// array for the given ObjCEncodeExpr node.
2959 llvm::GlobalVariable *
2960 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2961   std::string Str;
2962   getContext().getObjCEncodingForType(E->getEncodedType(), Str);
2963 
2964   return GetAddrOfConstantCString(Str);
2965 }
2966 
2967 /// GetAddrOfConstantCString - Returns a pointer to a character array containing
2968 /// the literal and a terminating '\0' character.
2969 /// The result has pointer to array type.
2970 llvm::GlobalVariable *CodeGenModule::GetAddrOfConstantCString(
2971     const std::string &Str, const char *GlobalName, unsigned Alignment) {
2972   StringRef StrWithNull(Str.c_str(), Str.size() + 1);
2973   if (Alignment == 0) {
2974     Alignment = getContext()
2975                     .getAlignOfGlobalVarInChars(getContext().CharTy)
2976                     .getQuantity();
2977   }
2978 
2979   llvm::Constant *C =
2980       llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
2981 
2982   // Don't share any string literals if strings aren't constant.
2983   llvm::GlobalVariable **Entry = nullptr;
2984   if (!LangOpts.WritableStrings) {
2985     Entry = &ConstantStringMap[C];
2986     if (auto GV = *Entry) {
2987       if (Alignment > GV->getAlignment())
2988         GV->setAlignment(Alignment);
2989       return GV;
2990     }
2991   }
2992 
2993   // Get the default prefix if a name wasn't specified.
2994   if (!GlobalName)
2995     GlobalName = ".str";
2996   // Create a global variable for this.
2997   auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
2998                                   GlobalName, Alignment);
2999   if (Entry)
3000     *Entry = GV;
3001   return GV;
3002 }
3003 
3004 llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary(
3005     const MaterializeTemporaryExpr *E, const Expr *Init) {
3006   assert((E->getStorageDuration() == SD_Static ||
3007           E->getStorageDuration() == SD_Thread) && "not a global temporary");
3008   const auto *VD = cast<VarDecl>(E->getExtendingDecl());
3009 
3010   // If we're not materializing a subobject of the temporary, keep the
3011   // cv-qualifiers from the type of the MaterializeTemporaryExpr.
3012   QualType MaterializedType = Init->getType();
3013   if (Init == E->GetTemporaryExpr())
3014     MaterializedType = E->getType();
3015 
3016   llvm::Constant *&Slot = MaterializedGlobalTemporaryMap[E];
3017   if (Slot)
3018     return Slot;
3019 
3020   // FIXME: If an externally-visible declaration extends multiple temporaries,
3021   // we need to give each temporary the same name in every translation unit (and
3022   // we also need to make the temporaries externally-visible).
3023   SmallString<256> Name;
3024   llvm::raw_svector_ostream Out(Name);
3025   getCXXABI().getMangleContext().mangleReferenceTemporary(
3026       VD, E->getManglingNumber(), Out);
3027   Out.flush();
3028 
3029   APValue *Value = nullptr;
3030   if (E->getStorageDuration() == SD_Static) {
3031     // We might have a cached constant initializer for this temporary. Note
3032     // that this might have a different value from the value computed by
3033     // evaluating the initializer if the surrounding constant expression
3034     // modifies the temporary.
3035     Value = getContext().getMaterializedTemporaryValue(E, false);
3036     if (Value && Value->isUninit())
3037       Value = nullptr;
3038   }
3039 
3040   // Try evaluating it now, it might have a constant initializer.
3041   Expr::EvalResult EvalResult;
3042   if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
3043       !EvalResult.hasSideEffects())
3044     Value = &EvalResult.Val;
3045 
3046   llvm::Constant *InitialValue = nullptr;
3047   bool Constant = false;
3048   llvm::Type *Type;
3049   if (Value) {
3050     // The temporary has a constant initializer, use it.
3051     InitialValue = EmitConstantValue(*Value, MaterializedType, nullptr);
3052     Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
3053     Type = InitialValue->getType();
3054   } else {
3055     // No initializer, the initialization will be provided when we
3056     // initialize the declaration which performed lifetime extension.
3057     Type = getTypes().ConvertTypeForMem(MaterializedType);
3058   }
3059 
3060   // Create a global variable for this lifetime-extended temporary.
3061   llvm::GlobalValue::LinkageTypes Linkage =
3062       getLLVMLinkageVarDefinition(VD, Constant);
3063   // There is no need for this temporary to have global linkage if the global
3064   // variable has external linkage.
3065   if (Linkage == llvm::GlobalVariable::ExternalLinkage)
3066     Linkage = llvm::GlobalVariable::PrivateLinkage;
3067   unsigned AddrSpace = GetGlobalVarAddressSpace(
3068       VD, getContext().getTargetAddressSpace(MaterializedType));
3069   auto *GV = new llvm::GlobalVariable(
3070       getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
3071       /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal,
3072       AddrSpace);
3073   setGlobalVisibility(GV, VD);
3074   GV->setAlignment(
3075       getContext().getTypeAlignInChars(MaterializedType).getQuantity());
3076   if (VD->getTLSKind())
3077     setTLSMode(GV, *VD);
3078   Slot = GV;
3079   return GV;
3080 }
3081 
3082 /// EmitObjCPropertyImplementations - Emit information for synthesized
3083 /// properties for an implementation.
3084 void CodeGenModule::EmitObjCPropertyImplementations(const
3085                                                     ObjCImplementationDecl *D) {
3086   for (const auto *PID : D->property_impls()) {
3087     // Dynamic is just for type-checking.
3088     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3089       ObjCPropertyDecl *PD = PID->getPropertyDecl();
3090 
3091       // Determine which methods need to be implemented, some may have
3092       // been overridden. Note that ::isPropertyAccessor is not the method
3093       // we want, that just indicates if the decl came from a
3094       // property. What we want to know is if the method is defined in
3095       // this implementation.
3096       if (!D->getInstanceMethod(PD->getGetterName()))
3097         CodeGenFunction(*this).GenerateObjCGetter(
3098                                  const_cast<ObjCImplementationDecl *>(D), PID);
3099       if (!PD->isReadOnly() &&
3100           !D->getInstanceMethod(PD->getSetterName()))
3101         CodeGenFunction(*this).GenerateObjCSetter(
3102                                  const_cast<ObjCImplementationDecl *>(D), PID);
3103     }
3104   }
3105 }
3106 
3107 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
3108   const ObjCInterfaceDecl *iface = impl->getClassInterface();
3109   for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
3110        ivar; ivar = ivar->getNextIvar())
3111     if (ivar->getType().isDestructedType())
3112       return true;
3113 
3114   return false;
3115 }
3116 
3117 static bool AllTrivialInitializers(CodeGenModule &CGM,
3118                                    ObjCImplementationDecl *D) {
3119   CodeGenFunction CGF(CGM);
3120   for (ObjCImplementationDecl::init_iterator B = D->init_begin(),
3121        E = D->init_end(); B != E; ++B) {
3122     CXXCtorInitializer *CtorInitExp = *B;
3123     Expr *Init = CtorInitExp->getInit();
3124     if (!CGF.isTrivialInitializer(Init))
3125       return false;
3126   }
3127   return true;
3128 }
3129 
3130 /// EmitObjCIvarInitializations - Emit information for ivar initialization
3131 /// for an implementation.
3132 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
3133   // We might need a .cxx_destruct even if we don't have any ivar initializers.
3134   if (needsDestructMethod(D)) {
3135     IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
3136     Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
3137     ObjCMethodDecl *DTORMethod =
3138       ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
3139                              cxxSelector, getContext().VoidTy, nullptr, D,
3140                              /*isInstance=*/true, /*isVariadic=*/false,
3141                           /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
3142                              /*isDefined=*/false, ObjCMethodDecl::Required);
3143     D->addInstanceMethod(DTORMethod);
3144     CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
3145     D->setHasDestructors(true);
3146   }
3147 
3148   // If the implementation doesn't have any ivar initializers, we don't need
3149   // a .cxx_construct.
3150   if (D->getNumIvarInitializers() == 0 ||
3151       AllTrivialInitializers(*this, D))
3152     return;
3153 
3154   IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
3155   Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
3156   // The constructor returns 'self'.
3157   ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
3158                                                 D->getLocation(),
3159                                                 D->getLocation(),
3160                                                 cxxSelector,
3161                                                 getContext().getObjCIdType(),
3162                                                 nullptr, D, /*isInstance=*/true,
3163                                                 /*isVariadic=*/false,
3164                                                 /*isPropertyAccessor=*/true,
3165                                                 /*isImplicitlyDeclared=*/true,
3166                                                 /*isDefined=*/false,
3167                                                 ObjCMethodDecl::Required);
3168   D->addInstanceMethod(CTORMethod);
3169   CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
3170   D->setHasNonZeroConstructors(true);
3171 }
3172 
3173 /// EmitNamespace - Emit all declarations in a namespace.
3174 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
3175   for (auto *I : ND->decls()) {
3176     if (const auto *VD = dyn_cast<VarDecl>(I))
3177       if (VD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
3178           VD->getTemplateSpecializationKind() != TSK_Undeclared)
3179         continue;
3180     EmitTopLevelDecl(I);
3181   }
3182 }
3183 
3184 // EmitLinkageSpec - Emit all declarations in a linkage spec.
3185 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
3186   if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
3187       LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
3188     ErrorUnsupported(LSD, "linkage spec");
3189     return;
3190   }
3191 
3192   for (auto *I : LSD->decls()) {
3193     // Meta-data for ObjC class includes references to implemented methods.
3194     // Generate class's method definitions first.
3195     if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
3196       for (auto *M : OID->methods())
3197         EmitTopLevelDecl(M);
3198     }
3199     EmitTopLevelDecl(I);
3200   }
3201 }
3202 
3203 /// EmitTopLevelDecl - Emit code for a single top level declaration.
3204 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
3205   // Ignore dependent declarations.
3206   if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
3207     return;
3208 
3209   switch (D->getKind()) {
3210   case Decl::CXXConversion:
3211   case Decl::CXXMethod:
3212   case Decl::Function:
3213     // Skip function templates
3214     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
3215         cast<FunctionDecl>(D)->isLateTemplateParsed())
3216       return;
3217 
3218     EmitGlobal(cast<FunctionDecl>(D));
3219     // Always provide some coverage mapping
3220     // even for the functions that aren't emitted.
3221     AddDeferredUnusedCoverageMapping(D);
3222     break;
3223 
3224   case Decl::Var:
3225     // Skip variable templates
3226     if (cast<VarDecl>(D)->getDescribedVarTemplate())
3227       return;
3228   case Decl::VarTemplateSpecialization:
3229     EmitGlobal(cast<VarDecl>(D));
3230     break;
3231 
3232   // Indirect fields from global anonymous structs and unions can be
3233   // ignored; only the actual variable requires IR gen support.
3234   case Decl::IndirectField:
3235     break;
3236 
3237   // C++ Decls
3238   case Decl::Namespace:
3239     EmitNamespace(cast<NamespaceDecl>(D));
3240     break;
3241     // No code generation needed.
3242   case Decl::UsingShadow:
3243   case Decl::ClassTemplate:
3244   case Decl::VarTemplate:
3245   case Decl::VarTemplatePartialSpecialization:
3246   case Decl::FunctionTemplate:
3247   case Decl::TypeAliasTemplate:
3248   case Decl::Block:
3249   case Decl::Empty:
3250     break;
3251   case Decl::Using:          // using X; [C++]
3252     if (CGDebugInfo *DI = getModuleDebugInfo())
3253         DI->EmitUsingDecl(cast<UsingDecl>(*D));
3254     return;
3255   case Decl::NamespaceAlias:
3256     if (CGDebugInfo *DI = getModuleDebugInfo())
3257         DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
3258     return;
3259   case Decl::UsingDirective: // using namespace X; [C++]
3260     if (CGDebugInfo *DI = getModuleDebugInfo())
3261       DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
3262     return;
3263   case Decl::CXXConstructor:
3264     // Skip function templates
3265     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
3266         cast<FunctionDecl>(D)->isLateTemplateParsed())
3267       return;
3268 
3269     getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
3270     break;
3271   case Decl::CXXDestructor:
3272     if (cast<FunctionDecl>(D)->isLateTemplateParsed())
3273       return;
3274     getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
3275     break;
3276 
3277   case Decl::StaticAssert:
3278     // Nothing to do.
3279     break;
3280 
3281   // Objective-C Decls
3282 
3283   // Forward declarations, no (immediate) code generation.
3284   case Decl::ObjCInterface:
3285   case Decl::ObjCCategory:
3286     break;
3287 
3288   case Decl::ObjCProtocol: {
3289     auto *Proto = cast<ObjCProtocolDecl>(D);
3290     if (Proto->isThisDeclarationADefinition())
3291       ObjCRuntime->GenerateProtocol(Proto);
3292     break;
3293   }
3294 
3295   case Decl::ObjCCategoryImpl:
3296     // Categories have properties but don't support synthesize so we
3297     // can ignore them here.
3298     ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
3299     break;
3300 
3301   case Decl::ObjCImplementation: {
3302     auto *OMD = cast<ObjCImplementationDecl>(D);
3303     EmitObjCPropertyImplementations(OMD);
3304     EmitObjCIvarInitializations(OMD);
3305     ObjCRuntime->GenerateClass(OMD);
3306     // Emit global variable debug information.
3307     if (CGDebugInfo *DI = getModuleDebugInfo())
3308       if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
3309         DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
3310             OMD->getClassInterface()), OMD->getLocation());
3311     break;
3312   }
3313   case Decl::ObjCMethod: {
3314     auto *OMD = cast<ObjCMethodDecl>(D);
3315     // If this is not a prototype, emit the body.
3316     if (OMD->getBody())
3317       CodeGenFunction(*this).GenerateObjCMethod(OMD);
3318     break;
3319   }
3320   case Decl::ObjCCompatibleAlias:
3321     ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
3322     break;
3323 
3324   case Decl::LinkageSpec:
3325     EmitLinkageSpec(cast<LinkageSpecDecl>(D));
3326     break;
3327 
3328   case Decl::FileScopeAsm: {
3329     auto *AD = cast<FileScopeAsmDecl>(D);
3330     StringRef AsmString = AD->getAsmString()->getString();
3331 
3332     const std::string &S = getModule().getModuleInlineAsm();
3333     if (S.empty())
3334       getModule().setModuleInlineAsm(AsmString);
3335     else if (S.end()[-1] == '\n')
3336       getModule().setModuleInlineAsm(S + AsmString.str());
3337     else
3338       getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
3339     break;
3340   }
3341 
3342   case Decl::Import: {
3343     auto *Import = cast<ImportDecl>(D);
3344 
3345     // Ignore import declarations that come from imported modules.
3346     if (clang::Module *Owner = Import->getOwningModule()) {
3347       if (getLangOpts().CurrentModule.empty() ||
3348           Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
3349         break;
3350     }
3351 
3352     ImportedModules.insert(Import->getImportedModule());
3353     break;
3354   }
3355 
3356   case Decl::OMPThreadPrivate:
3357     EmitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(D));
3358     break;
3359 
3360   case Decl::ClassTemplateSpecialization: {
3361     const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
3362     if (DebugInfo &&
3363         Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
3364         Spec->hasDefinition())
3365       DebugInfo->completeTemplateDefinition(*Spec);
3366     break;
3367   }
3368 
3369   default:
3370     // Make sure we handled everything we should, every other kind is a
3371     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
3372     // function. Need to recode Decl::Kind to do that easily.
3373     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
3374     break;
3375   }
3376 }
3377 
3378 void CodeGenModule::AddDeferredUnusedCoverageMapping(Decl *D) {
3379   // Do we need to generate coverage mapping?
3380   if (!CodeGenOpts.CoverageMapping)
3381     return;
3382   switch (D->getKind()) {
3383   case Decl::CXXConversion:
3384   case Decl::CXXMethod:
3385   case Decl::Function:
3386   case Decl::ObjCMethod:
3387   case Decl::CXXConstructor:
3388   case Decl::CXXDestructor: {
3389     if (!cast<FunctionDecl>(D)->hasBody())
3390       return;
3391     auto I = DeferredEmptyCoverageMappingDecls.find(D);
3392     if (I == DeferredEmptyCoverageMappingDecls.end())
3393       DeferredEmptyCoverageMappingDecls[D] = true;
3394     break;
3395   }
3396   default:
3397     break;
3398   };
3399 }
3400 
3401 void CodeGenModule::ClearUnusedCoverageMapping(const Decl *D) {
3402   // Do we need to generate coverage mapping?
3403   if (!CodeGenOpts.CoverageMapping)
3404     return;
3405   if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
3406     if (Fn->isTemplateInstantiation())
3407       ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
3408   }
3409   auto I = DeferredEmptyCoverageMappingDecls.find(D);
3410   if (I == DeferredEmptyCoverageMappingDecls.end())
3411     DeferredEmptyCoverageMappingDecls[D] = false;
3412   else
3413     I->second = false;
3414 }
3415 
3416 void CodeGenModule::EmitDeferredUnusedCoverageMappings() {
3417   std::vector<const Decl *> DeferredDecls;
3418   for (const auto I : DeferredEmptyCoverageMappingDecls) {
3419     if (!I.second)
3420       continue;
3421     DeferredDecls.push_back(I.first);
3422   }
3423   // Sort the declarations by their location to make sure that the tests get a
3424   // predictable order for the coverage mapping for the unused declarations.
3425   if (CodeGenOpts.DumpCoverageMapping)
3426     std::sort(DeferredDecls.begin(), DeferredDecls.end(),
3427               [] (const Decl *LHS, const Decl *RHS) {
3428       return LHS->getLocStart() < RHS->getLocStart();
3429     });
3430   for (const auto *D : DeferredDecls) {
3431     switch (D->getKind()) {
3432     case Decl::CXXConversion:
3433     case Decl::CXXMethod:
3434     case Decl::Function:
3435     case Decl::ObjCMethod: {
3436       CodeGenPGO PGO(*this);
3437       GlobalDecl GD(cast<FunctionDecl>(D));
3438       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
3439                                   getFunctionLinkage(GD));
3440       break;
3441     }
3442     case Decl::CXXConstructor: {
3443       CodeGenPGO PGO(*this);
3444       GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
3445       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
3446                                   getFunctionLinkage(GD));
3447       break;
3448     }
3449     case Decl::CXXDestructor: {
3450       CodeGenPGO PGO(*this);
3451       GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
3452       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
3453                                   getFunctionLinkage(GD));
3454       break;
3455     }
3456     default:
3457       break;
3458     };
3459   }
3460 }
3461 
3462 /// Turns the given pointer into a constant.
3463 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
3464                                           const void *Ptr) {
3465   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
3466   llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
3467   return llvm::ConstantInt::get(i64, PtrInt);
3468 }
3469 
3470 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
3471                                    llvm::NamedMDNode *&GlobalMetadata,
3472                                    GlobalDecl D,
3473                                    llvm::GlobalValue *Addr) {
3474   if (!GlobalMetadata)
3475     GlobalMetadata =
3476       CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
3477 
3478   // TODO: should we report variant information for ctors/dtors?
3479   llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
3480                            llvm::ConstantAsMetadata::get(GetPointerConstant(
3481                                CGM.getLLVMContext(), D.getDecl()))};
3482   GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
3483 }
3484 
3485 /// For each function which is declared within an extern "C" region and marked
3486 /// as 'used', but has internal linkage, create an alias from the unmangled
3487 /// name to the mangled name if possible. People expect to be able to refer
3488 /// to such functions with an unmangled name from inline assembly within the
3489 /// same translation unit.
3490 void CodeGenModule::EmitStaticExternCAliases() {
3491   for (StaticExternCMap::iterator I = StaticExternCValues.begin(),
3492                                   E = StaticExternCValues.end();
3493        I != E; ++I) {
3494     IdentifierInfo *Name = I->first;
3495     llvm::GlobalValue *Val = I->second;
3496     if (Val && !getModule().getNamedValue(Name->getName()))
3497       addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val));
3498   }
3499 }
3500 
3501 bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName,
3502                                              GlobalDecl &Result) const {
3503   auto Res = Manglings.find(MangledName);
3504   if (Res == Manglings.end())
3505     return false;
3506   Result = Res->getValue();
3507   return true;
3508 }
3509 
3510 /// Emits metadata nodes associating all the global values in the
3511 /// current module with the Decls they came from.  This is useful for
3512 /// projects using IR gen as a subroutine.
3513 ///
3514 /// Since there's currently no way to associate an MDNode directly
3515 /// with an llvm::GlobalValue, we create a global named metadata
3516 /// with the name 'clang.global.decl.ptrs'.
3517 void CodeGenModule::EmitDeclMetadata() {
3518   llvm::NamedMDNode *GlobalMetadata = nullptr;
3519 
3520   // StaticLocalDeclMap
3521   for (auto &I : MangledDeclNames) {
3522     llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
3523     EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
3524   }
3525 }
3526 
3527 /// Emits metadata nodes for all the local variables in the current
3528 /// function.
3529 void CodeGenFunction::EmitDeclMetadata() {
3530   if (LocalDeclMap.empty()) return;
3531 
3532   llvm::LLVMContext &Context = getLLVMContext();
3533 
3534   // Find the unique metadata ID for this name.
3535   unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
3536 
3537   llvm::NamedMDNode *GlobalMetadata = nullptr;
3538 
3539   for (auto &I : LocalDeclMap) {
3540     const Decl *D = I.first;
3541     llvm::Value *Addr = I.second;
3542     if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
3543       llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
3544       Alloca->setMetadata(
3545           DeclPtrKind, llvm::MDNode::get(
3546                            Context, llvm::ValueAsMetadata::getConstant(DAddr)));
3547     } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
3548       GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
3549       EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
3550     }
3551   }
3552 }
3553 
3554 void CodeGenModule::EmitVersionIdentMetadata() {
3555   llvm::NamedMDNode *IdentMetadata =
3556     TheModule.getOrInsertNamedMetadata("llvm.ident");
3557   std::string Version = getClangFullVersion();
3558   llvm::LLVMContext &Ctx = TheModule.getContext();
3559 
3560   llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
3561   IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
3562 }
3563 
3564 void CodeGenModule::EmitTargetMetadata() {
3565   // Warning, new MangledDeclNames may be appended within this loop.
3566   // We rely on MapVector insertions adding new elements to the end
3567   // of the container.
3568   // FIXME: Move this loop into the one target that needs it, and only
3569   // loop over those declarations for which we couldn't emit the target
3570   // metadata when we emitted the declaration.
3571   for (unsigned I = 0; I != MangledDeclNames.size(); ++I) {
3572     auto Val = *(MangledDeclNames.begin() + I);
3573     const Decl *D = Val.first.getDecl()->getMostRecentDecl();
3574     llvm::GlobalValue *GV = GetGlobalValue(Val.second);
3575     getTargetCodeGenInfo().emitTargetMD(D, GV, *this);
3576   }
3577 }
3578 
3579 void CodeGenModule::EmitCoverageFile() {
3580   if (!getCodeGenOpts().CoverageFile.empty()) {
3581     if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
3582       llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
3583       llvm::LLVMContext &Ctx = TheModule.getContext();
3584       llvm::MDString *CoverageFile =
3585           llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
3586       for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
3587         llvm::MDNode *CU = CUNode->getOperand(i);
3588         llvm::Metadata *Elts[] = {CoverageFile, CU};
3589         GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
3590       }
3591     }
3592   }
3593 }
3594 
3595 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid) {
3596   // Sema has checked that all uuid strings are of the form
3597   // "12345678-1234-1234-1234-1234567890ab".
3598   assert(Uuid.size() == 36);
3599   for (unsigned i = 0; i < 36; ++i) {
3600     if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuid[i] == '-');
3601     else                                         assert(isHexDigit(Uuid[i]));
3602   }
3603 
3604   // The starts of all bytes of Field3 in Uuid. Field 3 is "1234-1234567890ab".
3605   const unsigned Field3ValueOffsets[8] = { 19, 21, 24, 26, 28, 30, 32, 34 };
3606 
3607   llvm::Constant *Field3[8];
3608   for (unsigned Idx = 0; Idx < 8; ++Idx)
3609     Field3[Idx] = llvm::ConstantInt::get(
3610         Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
3611 
3612   llvm::Constant *Fields[4] = {
3613     llvm::ConstantInt::get(Int32Ty, Uuid.substr(0,  8), 16),
3614     llvm::ConstantInt::get(Int16Ty, Uuid.substr(9,  4), 16),
3615     llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
3616     llvm::ConstantArray::get(llvm::ArrayType::get(Int8Ty, 8), Field3)
3617   };
3618 
3619   return llvm::ConstantStruct::getAnon(Fields);
3620 }
3621 
3622 llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty,
3623                                                        bool ForEH) {
3624   // Return a bogus pointer if RTTI is disabled, unless it's for EH.
3625   // FIXME: should we even be calling this method if RTTI is disabled
3626   // and it's not for EH?
3627   if (!ForEH && !getLangOpts().RTTI)
3628     return llvm::Constant::getNullValue(Int8PtrTy);
3629 
3630   if (ForEH && Ty->isObjCObjectPointerType() &&
3631       LangOpts.ObjCRuntime.isGNUFamily())
3632     return ObjCRuntime->GetEHType(Ty);
3633 
3634   return getCXXABI().getAddrOfRTTIDescriptor(Ty);
3635 }
3636 
3637 void CodeGenModule::EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
3638   for (auto RefExpr : D->varlists()) {
3639     auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
3640     bool PerformInit =
3641         VD->getAnyInitializer() &&
3642         !VD->getAnyInitializer()->isConstantInitializer(getContext(),
3643                                                         /*ForRef=*/false);
3644     if (auto InitFunction =
3645             getOpenMPRuntime().EmitOMPThreadPrivateVarDefinition(
3646                 VD, GetAddrOfGlobalVar(VD), RefExpr->getLocStart(),
3647                 PerformInit))
3648       CXXGlobalInits.push_back(InitFunction);
3649   }
3650 }
3651 
3652