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