xref: /llvm-project/clang/lib/CodeGen/CodeGenModule.cpp (revision 311c832fdace67a6906be39afcb9f220acf56518)
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 "CGDebugInfo.h"
16 #include "CodeGenFunction.h"
17 #include "CodeGenTBAA.h"
18 #include "CGCall.h"
19 #include "CGCUDARuntime.h"
20 #include "CGCXXABI.h"
21 #include "CGObjCRuntime.h"
22 #include "CGOpenCLRuntime.h"
23 #include "TargetInfo.h"
24 #include "clang/Frontend/CodeGenOptions.h"
25 #include "clang/AST/ASTContext.h"
26 #include "clang/AST/CharUnits.h"
27 #include "clang/AST/DeclObjC.h"
28 #include "clang/AST/DeclCXX.h"
29 #include "clang/AST/DeclTemplate.h"
30 #include "clang/AST/Mangle.h"
31 #include "clang/AST/RecordLayout.h"
32 #include "clang/AST/RecursiveASTVisitor.h"
33 #include "clang/Basic/Builtins.h"
34 #include "clang/Basic/Diagnostic.h"
35 #include "clang/Basic/SourceManager.h"
36 #include "clang/Basic/TargetInfo.h"
37 #include "clang/Basic/ConvertUTF.h"
38 #include "llvm/CallingConv.h"
39 #include "llvm/Module.h"
40 #include "llvm/Intrinsics.h"
41 #include "llvm/LLVMContext.h"
42 #include "llvm/ADT/APSInt.h"
43 #include "llvm/ADT/Triple.h"
44 #include "llvm/Target/Mangler.h"
45 #include "llvm/DataLayout.h"
46 #include "llvm/Support/CallSite.h"
47 #include "llvm/Support/ErrorHandling.h"
48 using namespace clang;
49 using namespace CodeGen;
50 
51 static const char AnnotationSection[] = "llvm.metadata";
52 
53 static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
54   switch (CGM.getContext().getTargetInfo().getCXXABI()) {
55   case CXXABI_ARM: return *CreateARMCXXABI(CGM);
56   case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM);
57   case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM);
58   }
59 
60   llvm_unreachable("invalid C++ ABI kind");
61 }
62 
63 
64 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
65                              llvm::Module &M, const llvm::DataLayout &TD,
66                              DiagnosticsEngine &diags)
67   : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M),
68     TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags),
69     ABI(createCXXABI(*this)),
70     Types(*this),
71     TBAA(0),
72     VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0),
73     DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0),
74     RRData(0), CFConstantStringClassRef(0),
75     ConstantStringClassRef(0), NSConstantStringType(0),
76     VMContext(M.getContext()),
77     NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
78     BlockObjectAssign(0), BlockObjectDispose(0),
79     BlockDescriptorType(0), GenericBlockLiteralType(0) {
80 
81   // Initialize the type cache.
82   llvm::LLVMContext &LLVMContext = M.getContext();
83   VoidTy = llvm::Type::getVoidTy(LLVMContext);
84   Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
85   Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
86   Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
87   Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
88   FloatTy = llvm::Type::getFloatTy(LLVMContext);
89   DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
90   PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
91   PointerAlignInBytes =
92   C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
93   IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
94   IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
95   Int8PtrTy = Int8Ty->getPointerTo(0);
96   Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
97 
98   if (LangOpts.ObjC1)
99     createObjCRuntime();
100   if (LangOpts.OpenCL)
101     createOpenCLRuntime();
102   if (LangOpts.CUDA)
103     createCUDARuntime();
104 
105   // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
106   if (LangOpts.ThreadSanitizer ||
107       (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
108     TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
109                            ABI.getMangleContext());
110 
111   // If debug info or coverage generation is enabled, create the CGDebugInfo
112   // object.
113   if (CodeGenOpts.DebugInfo != CodeGenOptions::NoDebugInfo ||
114       CodeGenOpts.EmitGcovArcs ||
115       CodeGenOpts.EmitGcovNotes)
116     DebugInfo = new CGDebugInfo(*this);
117 
118   Block.GlobalUniqueCount = 0;
119 
120   if (C.getLangOpts().ObjCAutoRefCount)
121     ARCData = new ARCEntrypoints();
122   RRData = new RREntrypoints();
123 }
124 
125 CodeGenModule::~CodeGenModule() {
126   delete ObjCRuntime;
127   delete OpenCLRuntime;
128   delete CUDARuntime;
129   delete TheTargetCodeGenInfo;
130   delete &ABI;
131   delete TBAA;
132   delete DebugInfo;
133   delete ARCData;
134   delete RRData;
135 }
136 
137 void CodeGenModule::createObjCRuntime() {
138   // This is just isGNUFamily(), but we want to force implementors of
139   // new ABIs to decide how best to do this.
140   switch (LangOpts.ObjCRuntime.getKind()) {
141   case ObjCRuntime::GNUstep:
142   case ObjCRuntime::GCC:
143   case ObjCRuntime::ObjFW:
144     ObjCRuntime = CreateGNUObjCRuntime(*this);
145     return;
146 
147   case ObjCRuntime::FragileMacOSX:
148   case ObjCRuntime::MacOSX:
149   case ObjCRuntime::iOS:
150     ObjCRuntime = CreateMacObjCRuntime(*this);
151     return;
152   }
153   llvm_unreachable("bad runtime kind");
154 }
155 
156 void CodeGenModule::createOpenCLRuntime() {
157   OpenCLRuntime = new CGOpenCLRuntime(*this);
158 }
159 
160 void CodeGenModule::createCUDARuntime() {
161   CUDARuntime = CreateNVCUDARuntime(*this);
162 }
163 
164 void CodeGenModule::Release() {
165   EmitDeferred();
166   EmitCXXGlobalInitFunc();
167   EmitCXXGlobalDtorFunc();
168   if (ObjCRuntime)
169     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
170       AddGlobalCtor(ObjCInitFunction);
171   EmitCtorList(GlobalCtors, "llvm.global_ctors");
172   EmitCtorList(GlobalDtors, "llvm.global_dtors");
173   EmitGlobalAnnotations();
174   EmitLLVMUsed();
175 
176   SimplifyPersonality();
177 
178   if (getCodeGenOpts().EmitDeclMetadata)
179     EmitDeclMetadata();
180 
181   if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
182     EmitCoverageFile();
183 
184   if (DebugInfo)
185     DebugInfo->finalize();
186 }
187 
188 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
189   // Make sure that this type is translated.
190   Types.UpdateCompletedType(TD);
191 }
192 
193 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
194   if (!TBAA)
195     return 0;
196   return TBAA->getTBAAInfo(QTy);
197 }
198 
199 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
200   if (!TBAA)
201     return 0;
202   return TBAA->getTBAAInfoForVTablePtr();
203 }
204 
205 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
206   if (!TBAA)
207     return 0;
208   return TBAA->getTBAAStructInfo(QTy);
209 }
210 
211 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
212                                         llvm::MDNode *TBAAInfo) {
213   Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
214 }
215 
216 bool CodeGenModule::isTargetDarwin() const {
217   return getContext().getTargetInfo().getTriple().isOSDarwin();
218 }
219 
220 void CodeGenModule::Error(SourceLocation loc, StringRef error) {
221   unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
222   getDiags().Report(Context.getFullLoc(loc), diagID);
223 }
224 
225 /// ErrorUnsupported - Print out an error that codegen doesn't support the
226 /// specified stmt yet.
227 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
228                                      bool OmitOnError) {
229   if (OmitOnError && getDiags().hasErrorOccurred())
230     return;
231   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
232                                                "cannot compile this %0 yet");
233   std::string Msg = Type;
234   getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
235     << Msg << S->getSourceRange();
236 }
237 
238 /// ErrorUnsupported - Print out an error that codegen doesn't support the
239 /// specified decl yet.
240 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
241                                      bool OmitOnError) {
242   if (OmitOnError && getDiags().hasErrorOccurred())
243     return;
244   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
245                                                "cannot compile this %0 yet");
246   std::string Msg = Type;
247   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
248 }
249 
250 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
251   return llvm::ConstantInt::get(SizeTy, size.getQuantity());
252 }
253 
254 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
255                                         const NamedDecl *D) const {
256   // Internal definitions always have default visibility.
257   if (GV->hasLocalLinkage()) {
258     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
259     return;
260   }
261 
262   // Set visibility for definitions.
263   NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
264   if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage())
265     GV->setVisibility(GetLLVMVisibility(LV.visibility()));
266 }
267 
268 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
269   return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
270       .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
271       .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
272       .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
273       .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
274 }
275 
276 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
277     CodeGenOptions::TLSModel M) {
278   switch (M) {
279   case CodeGenOptions::GeneralDynamicTLSModel:
280     return llvm::GlobalVariable::GeneralDynamicTLSModel;
281   case CodeGenOptions::LocalDynamicTLSModel:
282     return llvm::GlobalVariable::LocalDynamicTLSModel;
283   case CodeGenOptions::InitialExecTLSModel:
284     return llvm::GlobalVariable::InitialExecTLSModel;
285   case CodeGenOptions::LocalExecTLSModel:
286     return llvm::GlobalVariable::LocalExecTLSModel;
287   }
288   llvm_unreachable("Invalid TLS model!");
289 }
290 
291 void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
292                                const VarDecl &D) const {
293   assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!");
294 
295   llvm::GlobalVariable::ThreadLocalMode TLM;
296   TLM = GetLLVMTLSModel(CodeGenOpts.DefaultTLSModel);
297 
298   // Override the TLS model if it is explicitly specified.
299   if (D.hasAttr<TLSModelAttr>()) {
300     const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
301     TLM = GetLLVMTLSModel(Attr->getModel());
302   }
303 
304   GV->setThreadLocalMode(TLM);
305 }
306 
307 /// Set the symbol visibility of type information (vtable and RTTI)
308 /// associated with the given type.
309 void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
310                                       const CXXRecordDecl *RD,
311                                       TypeVisibilityKind TVK) const {
312   setGlobalVisibility(GV, RD);
313 
314   if (!CodeGenOpts.HiddenWeakVTables)
315     return;
316 
317   // We never want to drop the visibility for RTTI names.
318   if (TVK == TVK_ForRTTIName)
319     return;
320 
321   // We want to drop the visibility to hidden for weak type symbols.
322   // This isn't possible if there might be unresolved references
323   // elsewhere that rely on this symbol being visible.
324 
325   // This should be kept roughly in sync with setThunkVisibility
326   // in CGVTables.cpp.
327 
328   // Preconditions.
329   if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
330       GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
331     return;
332 
333   // Don't override an explicit visibility attribute.
334   if (RD->getExplicitVisibility())
335     return;
336 
337   switch (RD->getTemplateSpecializationKind()) {
338   // We have to disable the optimization if this is an EI definition
339   // because there might be EI declarations in other shared objects.
340   case TSK_ExplicitInstantiationDefinition:
341   case TSK_ExplicitInstantiationDeclaration:
342     return;
343 
344   // Every use of a non-template class's type information has to emit it.
345   case TSK_Undeclared:
346     break;
347 
348   // In theory, implicit instantiations can ignore the possibility of
349   // an explicit instantiation declaration because there necessarily
350   // must be an EI definition somewhere with default visibility.  In
351   // practice, it's possible to have an explicit instantiation for
352   // an arbitrary template class, and linkers aren't necessarily able
353   // to deal with mixed-visibility symbols.
354   case TSK_ExplicitSpecialization:
355   case TSK_ImplicitInstantiation:
356     if (!CodeGenOpts.HiddenWeakTemplateVTables)
357       return;
358     break;
359   }
360 
361   // If there's a key function, there may be translation units
362   // that don't have the key function's definition.  But ignore
363   // this if we're emitting RTTI under -fno-rtti.
364   if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
365     if (Context.getKeyFunction(RD))
366       return;
367   }
368 
369   // Otherwise, drop the visibility to hidden.
370   GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
371   GV->setUnnamedAddr(true);
372 }
373 
374 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
375   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
376 
377   StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
378   if (!Str.empty())
379     return Str;
380 
381   if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
382     IdentifierInfo *II = ND->getIdentifier();
383     assert(II && "Attempt to mangle unnamed decl.");
384 
385     Str = II->getName();
386     return Str;
387   }
388 
389   SmallString<256> Buffer;
390   llvm::raw_svector_ostream Out(Buffer);
391   if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
392     getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
393   else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
394     getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
395   else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
396     getCXXABI().getMangleContext().mangleBlock(BD, Out,
397       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
398   else
399     getCXXABI().getMangleContext().mangleName(ND, Out);
400 
401   // Allocate space for the mangled name.
402   Out.flush();
403   size_t Length = Buffer.size();
404   char *Name = MangledNamesAllocator.Allocate<char>(Length);
405   std::copy(Buffer.begin(), Buffer.end(), Name);
406 
407   Str = StringRef(Name, Length);
408 
409   return Str;
410 }
411 
412 void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
413                                         const BlockDecl *BD) {
414   MangleContext &MangleCtx = getCXXABI().getMangleContext();
415   const Decl *D = GD.getDecl();
416   llvm::raw_svector_ostream Out(Buffer.getBuffer());
417   if (D == 0)
418     MangleCtx.mangleGlobalBlock(BD,
419       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
420   else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
421     MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
422   else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
423     MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
424   else
425     MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
426 }
427 
428 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
429   return getModule().getNamedValue(Name);
430 }
431 
432 /// AddGlobalCtor - Add a function to the list that will be called before
433 /// main() runs.
434 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
435   // FIXME: Type coercion of void()* types.
436   GlobalCtors.push_back(std::make_pair(Ctor, Priority));
437 }
438 
439 /// AddGlobalDtor - Add a function to the list that will be called
440 /// when the module is unloaded.
441 void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
442   // FIXME: Type coercion of void()* types.
443   GlobalDtors.push_back(std::make_pair(Dtor, Priority));
444 }
445 
446 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
447   // Ctor function type is void()*.
448   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
449   llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
450 
451   // Get the type of a ctor entry, { i32, void ()* }.
452   llvm::StructType *CtorStructTy =
453     llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
454 
455   // Construct the constructor and destructor arrays.
456   SmallVector<llvm::Constant*, 8> Ctors;
457   for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
458     llvm::Constant *S[] = {
459       llvm::ConstantInt::get(Int32Ty, I->second, false),
460       llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
461     };
462     Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
463   }
464 
465   if (!Ctors.empty()) {
466     llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
467     new llvm::GlobalVariable(TheModule, AT, false,
468                              llvm::GlobalValue::AppendingLinkage,
469                              llvm::ConstantArray::get(AT, Ctors),
470                              GlobalName);
471   }
472 }
473 
474 llvm::GlobalValue::LinkageTypes
475 CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
476   GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
477 
478   if (Linkage == GVA_Internal)
479     return llvm::Function::InternalLinkage;
480 
481   if (D->hasAttr<DLLExportAttr>())
482     return llvm::Function::DLLExportLinkage;
483 
484   if (D->hasAttr<WeakAttr>())
485     return llvm::Function::WeakAnyLinkage;
486 
487   // In C99 mode, 'inline' functions are guaranteed to have a strong
488   // definition somewhere else, so we can use available_externally linkage.
489   if (Linkage == GVA_C99Inline)
490     return llvm::Function::AvailableExternallyLinkage;
491 
492   // Note that Apple's kernel linker doesn't support symbol
493   // coalescing, so we need to avoid linkonce and weak linkages there.
494   // Normally, this means we just map to internal, but for explicit
495   // instantiations we'll map to external.
496 
497   // In C++, the compiler has to emit a definition in every translation unit
498   // that references the function.  We should use linkonce_odr because
499   // a) if all references in this translation unit are optimized away, we
500   // don't need to codegen it.  b) if the function persists, it needs to be
501   // merged with other definitions. c) C++ has the ODR, so we know the
502   // definition is dependable.
503   if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
504     return !Context.getLangOpts().AppleKext
505              ? llvm::Function::LinkOnceODRLinkage
506              : llvm::Function::InternalLinkage;
507 
508   // An explicit instantiation of a template has weak linkage, since
509   // explicit instantiations can occur in multiple translation units
510   // and must all be equivalent. However, we are not allowed to
511   // throw away these explicit instantiations.
512   if (Linkage == GVA_ExplicitTemplateInstantiation)
513     return !Context.getLangOpts().AppleKext
514              ? llvm::Function::WeakODRLinkage
515              : llvm::Function::ExternalLinkage;
516 
517   // Otherwise, we have strong external linkage.
518   assert(Linkage == GVA_StrongExternal);
519   return llvm::Function::ExternalLinkage;
520 }
521 
522 
523 /// SetFunctionDefinitionAttributes - Set attributes for a global.
524 ///
525 /// FIXME: This is currently only done for aliases and functions, but not for
526 /// variables (these details are set in EmitGlobalVarDefinition for variables).
527 void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
528                                                     llvm::GlobalValue *GV) {
529   SetCommonAttributes(D, GV);
530 }
531 
532 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
533                                               const CGFunctionInfo &Info,
534                                               llvm::Function *F) {
535   unsigned CallingConv;
536   AttributeListType AttributeList;
537   ConstructAttributeList(Info, D, AttributeList, CallingConv);
538   F->setAttributes(llvm::AttrListPtr::get(AttributeList));
539   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
540 }
541 
542 /// Determines whether the language options require us to model
543 /// unwind exceptions.  We treat -fexceptions as mandating this
544 /// except under the fragile ObjC ABI with only ObjC exceptions
545 /// enabled.  This means, for example, that C with -fexceptions
546 /// enables this.
547 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
548   // If exceptions are completely disabled, obviously this is false.
549   if (!LangOpts.Exceptions) return false;
550 
551   // If C++ exceptions are enabled, this is true.
552   if (LangOpts.CXXExceptions) return true;
553 
554   // If ObjC exceptions are enabled, this depends on the ABI.
555   if (LangOpts.ObjCExceptions) {
556     return LangOpts.ObjCRuntime.hasUnwindExceptions();
557   }
558 
559   return true;
560 }
561 
562 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
563                                                            llvm::Function *F) {
564   if (CodeGenOpts.UnwindTables)
565     F->setHasUWTable();
566 
567   if (!hasUnwindExceptions(LangOpts))
568     F->addFnAttr(llvm::Attributes::NoUnwind);
569 
570   if (D->hasAttr<NakedAttr>()) {
571     // Naked implies noinline: we should not be inlining such functions.
572     F->addFnAttr(llvm::Attributes::Naked);
573     F->addFnAttr(llvm::Attributes::NoInline);
574   }
575 
576   if (D->hasAttr<NoInlineAttr>())
577     F->addFnAttr(llvm::Attributes::NoInline);
578 
579   // (noinline wins over always_inline, and we can't specify both in IR)
580   if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) &&
581       !F->getFnAttributes().hasAttribute(llvm::Attributes::NoInline))
582     F->addFnAttr(llvm::Attributes::AlwaysInline);
583 
584   // FIXME: Communicate hot and cold attributes to LLVM more directly.
585   if (D->hasAttr<ColdAttr>())
586     F->addFnAttr(llvm::Attributes::OptimizeForSize);
587 
588   if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
589     F->setUnnamedAddr(true);
590 
591   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
592     if (MD->isVirtual())
593       F->setUnnamedAddr(true);
594 
595   if (LangOpts.getStackProtector() == LangOptions::SSPOn)
596     F->addFnAttr(llvm::Attributes::StackProtect);
597   else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
598     F->addFnAttr(llvm::Attributes::StackProtectReq);
599 
600   if (LangOpts.AddressSanitizer) {
601     // When AddressSanitizer is enabled, set AddressSafety attribute
602     // unless __attribute__((no_address_safety_analysis)) is used.
603     if (!D->hasAttr<NoAddressSafetyAnalysisAttr>())
604       F->addFnAttr(llvm::Attributes::AddressSafety);
605   }
606 
607   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
608   if (alignment)
609     F->setAlignment(alignment);
610 
611   // C++ ABI requires 2-byte alignment for member functions.
612   if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
613     F->setAlignment(2);
614 }
615 
616 void CodeGenModule::SetCommonAttributes(const Decl *D,
617                                         llvm::GlobalValue *GV) {
618   if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
619     setGlobalVisibility(GV, ND);
620   else
621     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
622 
623   if (D->hasAttr<UsedAttr>())
624     AddUsedGlobal(GV);
625 
626   if (const SectionAttr *SA = D->getAttr<SectionAttr>())
627     GV->setSection(SA->getName());
628 
629   getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
630 }
631 
632 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
633                                                   llvm::Function *F,
634                                                   const CGFunctionInfo &FI) {
635   SetLLVMFunctionAttributes(D, FI, F);
636   SetLLVMFunctionAttributesForDefinition(D, F);
637 
638   F->setLinkage(llvm::Function::InternalLinkage);
639 
640   SetCommonAttributes(D, F);
641 }
642 
643 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
644                                           llvm::Function *F,
645                                           bool IsIncompleteFunction) {
646   if (unsigned IID = F->getIntrinsicID()) {
647     // If this is an intrinsic function, set the function's attributes
648     // to the intrinsic's attributes.
649     F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
650                                                     (llvm::Intrinsic::ID)IID));
651     return;
652   }
653 
654   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
655 
656   if (!IsIncompleteFunction)
657     SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
658 
659   // Only a few attributes are set on declarations; these may later be
660   // overridden by a definition.
661 
662   if (FD->hasAttr<DLLImportAttr>()) {
663     F->setLinkage(llvm::Function::DLLImportLinkage);
664   } else if (FD->hasAttr<WeakAttr>() ||
665              FD->isWeakImported()) {
666     // "extern_weak" is overloaded in LLVM; we probably should have
667     // separate linkage types for this.
668     F->setLinkage(llvm::Function::ExternalWeakLinkage);
669   } else {
670     F->setLinkage(llvm::Function::ExternalLinkage);
671 
672     NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility();
673     if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) {
674       F->setVisibility(GetLLVMVisibility(LV.visibility()));
675     }
676   }
677 
678   if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
679     F->setSection(SA->getName());
680 }
681 
682 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
683   assert(!GV->isDeclaration() &&
684          "Only globals with definition can force usage.");
685   LLVMUsed.push_back(GV);
686 }
687 
688 void CodeGenModule::EmitLLVMUsed() {
689   // Don't create llvm.used if there is no need.
690   if (LLVMUsed.empty())
691     return;
692 
693   // Convert LLVMUsed to what ConstantArray needs.
694   SmallVector<llvm::Constant*, 8> UsedArray;
695   UsedArray.resize(LLVMUsed.size());
696   for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
697     UsedArray[i] =
698      llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
699                                     Int8PtrTy);
700   }
701 
702   if (UsedArray.empty())
703     return;
704   llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
705 
706   llvm::GlobalVariable *GV =
707     new llvm::GlobalVariable(getModule(), ATy, false,
708                              llvm::GlobalValue::AppendingLinkage,
709                              llvm::ConstantArray::get(ATy, UsedArray),
710                              "llvm.used");
711 
712   GV->setSection("llvm.metadata");
713 }
714 
715 void CodeGenModule::EmitDeferred() {
716   // Emit code for any potentially referenced deferred decls.  Since a
717   // previously unused static decl may become used during the generation of code
718   // for a static function, iterate until no changes are made.
719 
720   while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
721     if (!DeferredVTables.empty()) {
722       const CXXRecordDecl *RD = DeferredVTables.back();
723       DeferredVTables.pop_back();
724       getCXXABI().EmitVTables(RD);
725       continue;
726     }
727 
728     GlobalDecl D = DeferredDeclsToEmit.back();
729     DeferredDeclsToEmit.pop_back();
730 
731     // Check to see if we've already emitted this.  This is necessary
732     // for a couple of reasons: first, decls can end up in the
733     // deferred-decls queue multiple times, and second, decls can end
734     // up with definitions in unusual ways (e.g. by an extern inline
735     // function acquiring a strong function redefinition).  Just
736     // ignore these cases.
737     //
738     // TODO: That said, looking this up multiple times is very wasteful.
739     StringRef Name = getMangledName(D);
740     llvm::GlobalValue *CGRef = GetGlobalValue(Name);
741     assert(CGRef && "Deferred decl wasn't referenced?");
742 
743     if (!CGRef->isDeclaration())
744       continue;
745 
746     // GlobalAlias::isDeclaration() defers to the aliasee, but for our
747     // purposes an alias counts as a definition.
748     if (isa<llvm::GlobalAlias>(CGRef))
749       continue;
750 
751     // Otherwise, emit the definition and move on to the next one.
752     EmitGlobalDefinition(D);
753   }
754 }
755 
756 void CodeGenModule::EmitGlobalAnnotations() {
757   if (Annotations.empty())
758     return;
759 
760   // Create a new global variable for the ConstantStruct in the Module.
761   llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
762     Annotations[0]->getType(), Annotations.size()), Annotations);
763   llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
764     Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
765     "llvm.global.annotations");
766   gv->setSection(AnnotationSection);
767 }
768 
769 llvm::Constant *CodeGenModule::EmitAnnotationString(llvm::StringRef Str) {
770   llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
771   if (i != AnnotationStrings.end())
772     return i->second;
773 
774   // Not found yet, create a new global.
775   llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
776   llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
777     true, llvm::GlobalValue::PrivateLinkage, s, ".str");
778   gv->setSection(AnnotationSection);
779   gv->setUnnamedAddr(true);
780   AnnotationStrings[Str] = gv;
781   return gv;
782 }
783 
784 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
785   SourceManager &SM = getContext().getSourceManager();
786   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
787   if (PLoc.isValid())
788     return EmitAnnotationString(PLoc.getFilename());
789   return EmitAnnotationString(SM.getBufferName(Loc));
790 }
791 
792 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
793   SourceManager &SM = getContext().getSourceManager();
794   PresumedLoc PLoc = SM.getPresumedLoc(L);
795   unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
796     SM.getExpansionLineNumber(L);
797   return llvm::ConstantInt::get(Int32Ty, LineNo);
798 }
799 
800 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
801                                                 const AnnotateAttr *AA,
802                                                 SourceLocation L) {
803   // Get the globals for file name, annotation, and the line number.
804   llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
805                  *UnitGV = EmitAnnotationUnit(L),
806                  *LineNoCst = EmitAnnotationLineNo(L);
807 
808   // Create the ConstantStruct for the global annotation.
809   llvm::Constant *Fields[4] = {
810     llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
811     llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
812     llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
813     LineNoCst
814   };
815   return llvm::ConstantStruct::getAnon(Fields);
816 }
817 
818 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
819                                          llvm::GlobalValue *GV) {
820   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
821   // Get the struct elements for these annotations.
822   for (specific_attr_iterator<AnnotateAttr>
823        ai = D->specific_attr_begin<AnnotateAttr>(),
824        ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
825     Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
826 }
827 
828 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
829   // Never defer when EmitAllDecls is specified.
830   if (LangOpts.EmitAllDecls)
831     return false;
832 
833   return !getContext().DeclMustBeEmitted(Global);
834 }
835 
836 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
837     const CXXUuidofExpr* E) {
838   // Sema has verified that IIDSource has a __declspec(uuid()), and that its
839   // well-formed.
840   StringRef Uuid;
841   if (E->isTypeOperand())
842     Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid();
843   else {
844     // Special case: __uuidof(0) means an all-zero GUID.
845     Expr *Op = E->getExprOperand();
846     if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
847       Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid();
848     else
849       Uuid = "00000000-0000-0000-0000-000000000000";
850   }
851   std::string Name = "__uuid_" + Uuid.str();
852 
853   // Look for an existing global.
854   if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
855     return GV;
856 
857   llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
858   assert(Init && "failed to initialize as constant");
859 
860   // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
861   // first field is declared as "long", which for many targets is 8 bytes.
862   // Those architectures are not supported. (With the MS abi, long is always 4
863   // bytes.)
864   llvm::Type *GuidType = getTypes().ConvertType(E->getType());
865   if (Init->getType() != GuidType) {
866     DiagnosticsEngine &Diags = getDiags();
867     unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
868         "__uuidof codegen is not supported on this architecture");
869     Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
870     Init = llvm::UndefValue::get(GuidType);
871   }
872 
873   llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
874       /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name);
875   GV->setUnnamedAddr(true);
876   return GV;
877 }
878 
879 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
880   const AliasAttr *AA = VD->getAttr<AliasAttr>();
881   assert(AA && "No alias?");
882 
883   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
884 
885   // See if there is already something with the target's name in the module.
886   llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
887 
888   llvm::Constant *Aliasee;
889   if (isa<llvm::FunctionType>(DeclTy))
890     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
891                                       GlobalDecl(cast<FunctionDecl>(VD)),
892                                       /*ForVTable=*/false);
893   else
894     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
895                                     llvm::PointerType::getUnqual(DeclTy), 0);
896   if (!Entry) {
897     llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
898     F->setLinkage(llvm::Function::ExternalWeakLinkage);
899     WeakRefReferences.insert(F);
900   }
901 
902   return Aliasee;
903 }
904 
905 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
906   const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
907 
908   // Weak references don't produce any output by themselves.
909   if (Global->hasAttr<WeakRefAttr>())
910     return;
911 
912   // If this is an alias definition (which otherwise looks like a declaration)
913   // emit it now.
914   if (Global->hasAttr<AliasAttr>())
915     return EmitAliasDefinition(GD);
916 
917   // If this is CUDA, be selective about which declarations we emit.
918   if (LangOpts.CUDA) {
919     if (CodeGenOpts.CUDAIsDevice) {
920       if (!Global->hasAttr<CUDADeviceAttr>() &&
921           !Global->hasAttr<CUDAGlobalAttr>() &&
922           !Global->hasAttr<CUDAConstantAttr>() &&
923           !Global->hasAttr<CUDASharedAttr>())
924         return;
925     } else {
926       if (!Global->hasAttr<CUDAHostAttr>() && (
927             Global->hasAttr<CUDADeviceAttr>() ||
928             Global->hasAttr<CUDAConstantAttr>() ||
929             Global->hasAttr<CUDASharedAttr>()))
930         return;
931     }
932   }
933 
934   // Ignore declarations, they will be emitted on their first use.
935   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
936     // Forward declarations are emitted lazily on first use.
937     if (!FD->doesThisDeclarationHaveABody()) {
938       if (!FD->doesDeclarationForceExternallyVisibleDefinition())
939         return;
940 
941       const FunctionDecl *InlineDefinition = 0;
942       FD->getBody(InlineDefinition);
943 
944       StringRef MangledName = getMangledName(GD);
945       DeferredDecls.erase(MangledName);
946       EmitGlobalDefinition(InlineDefinition);
947       return;
948     }
949   } else {
950     const VarDecl *VD = cast<VarDecl>(Global);
951     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
952 
953     if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
954       return;
955   }
956 
957   // Defer code generation when possible if this is a static definition, inline
958   // function etc.  These we only want to emit if they are used.
959   if (!MayDeferGeneration(Global)) {
960     // Emit the definition if it can't be deferred.
961     EmitGlobalDefinition(GD);
962     return;
963   }
964 
965   // If we're deferring emission of a C++ variable with an
966   // initializer, remember the order in which it appeared in the file.
967   if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
968       cast<VarDecl>(Global)->hasInit()) {
969     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
970     CXXGlobalInits.push_back(0);
971   }
972 
973   // If the value has already been used, add it directly to the
974   // DeferredDeclsToEmit list.
975   StringRef MangledName = getMangledName(GD);
976   if (GetGlobalValue(MangledName))
977     DeferredDeclsToEmit.push_back(GD);
978   else {
979     // Otherwise, remember that we saw a deferred decl with this name.  The
980     // first use of the mangled name will cause it to move into
981     // DeferredDeclsToEmit.
982     DeferredDecls[MangledName] = GD;
983   }
984 }
985 
986 namespace {
987   struct FunctionIsDirectlyRecursive :
988     public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
989     const StringRef Name;
990     const Builtin::Context &BI;
991     bool Result;
992     FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
993       Name(N), BI(C), Result(false) {
994     }
995     typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
996 
997     bool TraverseCallExpr(CallExpr *E) {
998       const FunctionDecl *FD = E->getDirectCallee();
999       if (!FD)
1000         return true;
1001       AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1002       if (Attr && Name == Attr->getLabel()) {
1003         Result = true;
1004         return false;
1005       }
1006       unsigned BuiltinID = FD->getBuiltinID();
1007       if (!BuiltinID)
1008         return true;
1009       StringRef BuiltinName = BI.GetName(BuiltinID);
1010       if (BuiltinName.startswith("__builtin_") &&
1011           Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
1012         Result = true;
1013         return false;
1014       }
1015       return true;
1016     }
1017   };
1018 }
1019 
1020 // isTriviallyRecursive - Check if this function calls another
1021 // decl that, because of the asm attribute or the other decl being a builtin,
1022 // ends up pointing to itself.
1023 bool
1024 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1025   StringRef Name;
1026   if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
1027     // asm labels are a special kind of mangling we have to support.
1028     AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1029     if (!Attr)
1030       return false;
1031     Name = Attr->getLabel();
1032   } else {
1033     Name = FD->getName();
1034   }
1035 
1036   FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1037   Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
1038   return Walker.Result;
1039 }
1040 
1041 bool
1042 CodeGenModule::shouldEmitFunction(const FunctionDecl *F) {
1043   if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage)
1044     return true;
1045   if (CodeGenOpts.OptimizationLevel == 0 &&
1046       !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
1047     return false;
1048   // PR9614. Avoid cases where the source code is lying to us. An available
1049   // externally function should have an equivalent function somewhere else,
1050   // but a function that calls itself is clearly not equivalent to the real
1051   // implementation.
1052   // This happens in glibc's btowc and in some configure checks.
1053   return !isTriviallyRecursive(F);
1054 }
1055 
1056 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
1057   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
1058 
1059   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
1060                                  Context.getSourceManager(),
1061                                  "Generating code for declaration");
1062 
1063   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1064     // At -O0, don't generate IR for functions with available_externally
1065     // linkage.
1066     if (!shouldEmitFunction(Function))
1067       return;
1068 
1069     if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1070       // Make sure to emit the definition(s) before we emit the thunks.
1071       // This is necessary for the generation of certain thunks.
1072       if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1073         EmitCXXConstructor(CD, GD.getCtorType());
1074       else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1075         EmitCXXDestructor(DD, GD.getDtorType());
1076       else
1077         EmitGlobalFunctionDefinition(GD);
1078 
1079       if (Method->isVirtual())
1080         getVTables().EmitThunks(GD);
1081 
1082       return;
1083     }
1084 
1085     return EmitGlobalFunctionDefinition(GD);
1086   }
1087 
1088   if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1089     return EmitGlobalVarDefinition(VD);
1090 
1091   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
1092 }
1093 
1094 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1095 /// module, create and return an llvm Function with the specified type. If there
1096 /// is something in the module with the specified name, return it potentially
1097 /// bitcasted to the right type.
1098 ///
1099 /// If D is non-null, it specifies a decl that correspond to this.  This is used
1100 /// to set the attributes on the function when it is first created.
1101 llvm::Constant *
1102 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
1103                                        llvm::Type *Ty,
1104                                        GlobalDecl D, bool ForVTable,
1105                                        llvm::Attributes ExtraAttrs) {
1106   // Lookup the entry, lazily creating it if necessary.
1107   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1108   if (Entry) {
1109     if (WeakRefReferences.erase(Entry)) {
1110       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
1111       if (FD && !FD->hasAttr<WeakAttr>())
1112         Entry->setLinkage(llvm::Function::ExternalLinkage);
1113     }
1114 
1115     if (Entry->getType()->getElementType() == Ty)
1116       return Entry;
1117 
1118     // Make sure the result is of the correct type.
1119     return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
1120   }
1121 
1122   // This function doesn't have a complete type (for example, the return
1123   // type is an incomplete struct). Use a fake type instead, and make
1124   // sure not to try to set attributes.
1125   bool IsIncompleteFunction = false;
1126 
1127   llvm::FunctionType *FTy;
1128   if (isa<llvm::FunctionType>(Ty)) {
1129     FTy = cast<llvm::FunctionType>(Ty);
1130   } else {
1131     FTy = llvm::FunctionType::get(VoidTy, false);
1132     IsIncompleteFunction = true;
1133   }
1134 
1135   llvm::Function *F = llvm::Function::Create(FTy,
1136                                              llvm::Function::ExternalLinkage,
1137                                              MangledName, &getModule());
1138   assert(F->getName() == MangledName && "name was uniqued!");
1139   if (D.getDecl())
1140     SetFunctionAttributes(D, F, IsIncompleteFunction);
1141   if (ExtraAttrs.hasAttributes())
1142     F->addAttribute(~0, ExtraAttrs);
1143 
1144   // This is the first use or definition of a mangled name.  If there is a
1145   // deferred decl with this name, remember that we need to emit it at the end
1146   // of the file.
1147   llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
1148   if (DDI != DeferredDecls.end()) {
1149     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1150     // list, and remove it from DeferredDecls (since we don't need it anymore).
1151     DeferredDeclsToEmit.push_back(DDI->second);
1152     DeferredDecls.erase(DDI);
1153 
1154   // Otherwise, there are cases we have to worry about where we're
1155   // using a declaration for which we must emit a definition but where
1156   // we might not find a top-level definition:
1157   //   - member functions defined inline in their classes
1158   //   - friend functions defined inline in some class
1159   //   - special member functions with implicit definitions
1160   // If we ever change our AST traversal to walk into class methods,
1161   // this will be unnecessary.
1162   //
1163   // We also don't emit a definition for a function if it's going to be an entry
1164   // in a vtable, unless it's already marked as used.
1165   } else if (getLangOpts().CPlusPlus && D.getDecl()) {
1166     // Look for a declaration that's lexically in a record.
1167     const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
1168     FD = FD->getMostRecentDecl();
1169     do {
1170       if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
1171         if (FD->isImplicit() && !ForVTable) {
1172           assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
1173           DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
1174           break;
1175         } else if (FD->doesThisDeclarationHaveABody()) {
1176           DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
1177           break;
1178         }
1179       }
1180       FD = FD->getPreviousDecl();
1181     } while (FD);
1182   }
1183 
1184   // Make sure the result is of the requested type.
1185   if (!IsIncompleteFunction) {
1186     assert(F->getType()->getElementType() == Ty);
1187     return F;
1188   }
1189 
1190   llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
1191   return llvm::ConstantExpr::getBitCast(F, PTy);
1192 }
1193 
1194 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
1195 /// non-null, then this function will use the specified type if it has to
1196 /// create it (this occurs when we see a definition of the function).
1197 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
1198                                                  llvm::Type *Ty,
1199                                                  bool ForVTable) {
1200   // If there was no specific requested type, just convert it now.
1201   if (!Ty)
1202     Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
1203 
1204   StringRef MangledName = getMangledName(GD);
1205   return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
1206 }
1207 
1208 /// CreateRuntimeFunction - Create a new runtime function with the specified
1209 /// type and name.
1210 llvm::Constant *
1211 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
1212                                      StringRef Name,
1213                                      llvm::Attributes ExtraAttrs) {
1214   return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1215                                  ExtraAttrs);
1216 }
1217 
1218 /// isTypeConstant - Determine whether an object of this type can be emitted
1219 /// as a constant.
1220 ///
1221 /// If ExcludeCtor is true, the duration when the object's constructor runs
1222 /// will not be considered. The caller will need to verify that the object is
1223 /// not written to during its construction.
1224 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1225   if (!Ty.isConstant(Context) && !Ty->isReferenceType())
1226     return false;
1227 
1228   if (Context.getLangOpts().CPlusPlus) {
1229     if (const CXXRecordDecl *Record
1230           = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1231       return ExcludeCtor && !Record->hasMutableFields() &&
1232              Record->hasTrivialDestructor();
1233   }
1234 
1235   return true;
1236 }
1237 
1238 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1239 /// create and return an llvm GlobalVariable with the specified type.  If there
1240 /// is something in the module with the specified name, return it potentially
1241 /// bitcasted to the right type.
1242 ///
1243 /// If D is non-null, it specifies a decl that correspond to this.  This is used
1244 /// to set the attributes on the global when it is first created.
1245 llvm::Constant *
1246 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
1247                                      llvm::PointerType *Ty,
1248                                      const VarDecl *D,
1249                                      bool UnnamedAddr) {
1250   // Lookup the entry, lazily creating it if necessary.
1251   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1252   if (Entry) {
1253     if (WeakRefReferences.erase(Entry)) {
1254       if (D && !D->hasAttr<WeakAttr>())
1255         Entry->setLinkage(llvm::Function::ExternalLinkage);
1256     }
1257 
1258     if (UnnamedAddr)
1259       Entry->setUnnamedAddr(true);
1260 
1261     if (Entry->getType() == Ty)
1262       return Entry;
1263 
1264     // Make sure the result is of the correct type.
1265     return llvm::ConstantExpr::getBitCast(Entry, Ty);
1266   }
1267 
1268   // This is the first use or definition of a mangled name.  If there is a
1269   // deferred decl with this name, remember that we need to emit it at the end
1270   // of the file.
1271   llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
1272   if (DDI != DeferredDecls.end()) {
1273     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1274     // list, and remove it from DeferredDecls (since we don't need it anymore).
1275     DeferredDeclsToEmit.push_back(DDI->second);
1276     DeferredDecls.erase(DDI);
1277   }
1278 
1279   unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
1280   llvm::GlobalVariable *GV =
1281     new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
1282                              llvm::GlobalValue::ExternalLinkage,
1283                              0, MangledName, 0,
1284                              llvm::GlobalVariable::NotThreadLocal, AddrSpace);
1285 
1286   // Handle things which are present even on external declarations.
1287   if (D) {
1288     // FIXME: This code is overly simple and should be merged with other global
1289     // handling.
1290     GV->setConstant(isTypeConstant(D->getType(), false));
1291 
1292     // Set linkage and visibility in case we never see a definition.
1293     NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
1294     if (LV.linkage() != ExternalLinkage) {
1295       // Don't set internal linkage on declarations.
1296     } else {
1297       if (D->hasAttr<DLLImportAttr>())
1298         GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
1299       else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
1300         GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1301 
1302       // Set visibility on a declaration only if it's explicit.
1303       if (LV.visibilityExplicit())
1304         GV->setVisibility(GetLLVMVisibility(LV.visibility()));
1305     }
1306 
1307     if (D->isThreadSpecified())
1308       setTLSMode(GV, *D);
1309   }
1310 
1311   if (AddrSpace != Ty->getAddressSpace())
1312     return llvm::ConstantExpr::getBitCast(GV, Ty);
1313   else
1314     return GV;
1315 }
1316 
1317 
1318 llvm::GlobalVariable *
1319 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
1320                                       llvm::Type *Ty,
1321                                       llvm::GlobalValue::LinkageTypes Linkage) {
1322   llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1323   llvm::GlobalVariable *OldGV = 0;
1324 
1325 
1326   if (GV) {
1327     // Check if the variable has the right type.
1328     if (GV->getType()->getElementType() == Ty)
1329       return GV;
1330 
1331     // Because C++ name mangling, the only way we can end up with an already
1332     // existing global with the same name is if it has been declared extern "C".
1333     assert(GV->isDeclaration() && "Declaration has wrong type!");
1334     OldGV = GV;
1335   }
1336 
1337   // Create a new variable.
1338   GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1339                                 Linkage, 0, Name);
1340 
1341   if (OldGV) {
1342     // Replace occurrences of the old variable if needed.
1343     GV->takeName(OldGV);
1344 
1345     if (!OldGV->use_empty()) {
1346       llvm::Constant *NewPtrForOldDecl =
1347       llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1348       OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1349     }
1350 
1351     OldGV->eraseFromParent();
1352   }
1353 
1354   return GV;
1355 }
1356 
1357 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1358 /// given global variable.  If Ty is non-null and if the global doesn't exist,
1359 /// then it will be created with the specified type instead of whatever the
1360 /// normal requested type would be.
1361 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
1362                                                   llvm::Type *Ty) {
1363   assert(D->hasGlobalStorage() && "Not a global variable");
1364   QualType ASTTy = D->getType();
1365   if (Ty == 0)
1366     Ty = getTypes().ConvertTypeForMem(ASTTy);
1367 
1368   llvm::PointerType *PTy =
1369     llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
1370 
1371   StringRef MangledName = getMangledName(D);
1372   return GetOrCreateLLVMGlobal(MangledName, PTy, D);
1373 }
1374 
1375 /// CreateRuntimeVariable - Create a new runtime global variable with the
1376 /// specified type and name.
1377 llvm::Constant *
1378 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
1379                                      StringRef Name) {
1380   return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
1381                                true);
1382 }
1383 
1384 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1385   assert(!D->getInit() && "Cannot emit definite definitions here!");
1386 
1387   if (MayDeferGeneration(D)) {
1388     // If we have not seen a reference to this variable yet, place it
1389     // into the deferred declarations table to be emitted if needed
1390     // later.
1391     StringRef MangledName = getMangledName(D);
1392     if (!GetGlobalValue(MangledName)) {
1393       DeferredDecls[MangledName] = D;
1394       return;
1395     }
1396   }
1397 
1398   // The tentative definition is the only definition.
1399   EmitGlobalVarDefinition(D);
1400 }
1401 
1402 void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1403   if (DefinitionRequired)
1404     getCXXABI().EmitVTables(Class);
1405 }
1406 
1407 llvm::GlobalVariable::LinkageTypes
1408 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
1409   if (RD->getLinkage() != ExternalLinkage)
1410     return llvm::GlobalVariable::InternalLinkage;
1411 
1412   if (const CXXMethodDecl *KeyFunction
1413                                     = RD->getASTContext().getKeyFunction(RD)) {
1414     // If this class has a key function, use that to determine the linkage of
1415     // the vtable.
1416     const FunctionDecl *Def = 0;
1417     if (KeyFunction->hasBody(Def))
1418       KeyFunction = cast<CXXMethodDecl>(Def);
1419 
1420     switch (KeyFunction->getTemplateSpecializationKind()) {
1421       case TSK_Undeclared:
1422       case TSK_ExplicitSpecialization:
1423         // When compiling with optimizations turned on, we emit all vtables,
1424         // even if the key function is not defined in the current translation
1425         // unit. If this is the case, use available_externally linkage.
1426         if (!Def && CodeGenOpts.OptimizationLevel)
1427           return llvm::GlobalVariable::AvailableExternallyLinkage;
1428 
1429         if (KeyFunction->isInlined())
1430           return !Context.getLangOpts().AppleKext ?
1431                    llvm::GlobalVariable::LinkOnceODRLinkage :
1432                    llvm::Function::InternalLinkage;
1433 
1434         return llvm::GlobalVariable::ExternalLinkage;
1435 
1436       case TSK_ImplicitInstantiation:
1437         return !Context.getLangOpts().AppleKext ?
1438                  llvm::GlobalVariable::LinkOnceODRLinkage :
1439                  llvm::Function::InternalLinkage;
1440 
1441       case TSK_ExplicitInstantiationDefinition:
1442         return !Context.getLangOpts().AppleKext ?
1443                  llvm::GlobalVariable::WeakODRLinkage :
1444                  llvm::Function::InternalLinkage;
1445 
1446       case TSK_ExplicitInstantiationDeclaration:
1447         // FIXME: Use available_externally linkage. However, this currently
1448         // breaks LLVM's build due to undefined symbols.
1449         //      return llvm::GlobalVariable::AvailableExternallyLinkage;
1450         return !Context.getLangOpts().AppleKext ?
1451                  llvm::GlobalVariable::LinkOnceODRLinkage :
1452                  llvm::Function::InternalLinkage;
1453     }
1454   }
1455 
1456   if (Context.getLangOpts().AppleKext)
1457     return llvm::Function::InternalLinkage;
1458 
1459   switch (RD->getTemplateSpecializationKind()) {
1460   case TSK_Undeclared:
1461   case TSK_ExplicitSpecialization:
1462   case TSK_ImplicitInstantiation:
1463     // FIXME: Use available_externally linkage. However, this currently
1464     // breaks LLVM's build due to undefined symbols.
1465     //   return llvm::GlobalVariable::AvailableExternallyLinkage;
1466   case TSK_ExplicitInstantiationDeclaration:
1467     return llvm::GlobalVariable::LinkOnceODRLinkage;
1468 
1469   case TSK_ExplicitInstantiationDefinition:
1470       return llvm::GlobalVariable::WeakODRLinkage;
1471   }
1472 
1473   llvm_unreachable("Invalid TemplateSpecializationKind!");
1474 }
1475 
1476 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
1477     return Context.toCharUnitsFromBits(
1478       TheDataLayout.getTypeStoreSizeInBits(Ty));
1479 }
1480 
1481 llvm::Constant *
1482 CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
1483                                                        const Expr *rawInit) {
1484   ArrayRef<ExprWithCleanups::CleanupObject> cleanups;
1485   if (const ExprWithCleanups *withCleanups =
1486           dyn_cast<ExprWithCleanups>(rawInit)) {
1487     cleanups = withCleanups->getObjects();
1488     rawInit = withCleanups->getSubExpr();
1489   }
1490 
1491   const InitListExpr *init = dyn_cast<InitListExpr>(rawInit);
1492   if (!init || !init->initializesStdInitializerList() ||
1493       init->getNumInits() == 0)
1494     return 0;
1495 
1496   ASTContext &ctx = getContext();
1497   unsigned numInits = init->getNumInits();
1498   // FIXME: This check is here because we would otherwise silently miscompile
1499   // nested global std::initializer_lists. Better would be to have a real
1500   // implementation.
1501   for (unsigned i = 0; i < numInits; ++i) {
1502     const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i));
1503     if (inner && inner->initializesStdInitializerList()) {
1504       ErrorUnsupported(inner, "nested global std::initializer_list");
1505       return 0;
1506     }
1507   }
1508 
1509   // Synthesize a fake VarDecl for the array and initialize that.
1510   QualType elementType = init->getInit(0)->getType();
1511   llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits);
1512   QualType arrayType = ctx.getConstantArrayType(elementType, numElements,
1513                                                 ArrayType::Normal, 0);
1514 
1515   IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist");
1516   TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo(
1517                                               arrayType, D->getLocation());
1518   VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>(
1519                                                           D->getDeclContext()),
1520                                           D->getLocStart(), D->getLocation(),
1521                                           name, arrayType, sourceInfo,
1522                                           SC_Static, SC_Static);
1523 
1524   // Now clone the InitListExpr to initialize the array instead.
1525   // Incredible hack: we want to use the existing InitListExpr here, so we need
1526   // to tell it that it no longer initializes a std::initializer_list.
1527   ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(),
1528                         init->getNumInits());
1529   Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits,
1530                                            init->getRBraceLoc());
1531   arrayInit->setType(arrayType);
1532 
1533   if (!cleanups.empty())
1534     arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups);
1535 
1536   backingArray->setInit(arrayInit);
1537 
1538   // Emit the definition of the array.
1539   EmitGlobalVarDefinition(backingArray);
1540 
1541   // Inspect the initializer list to validate it and determine its type.
1542   // FIXME: doing this every time is probably inefficient; caching would be nice
1543   RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl();
1544   RecordDecl::field_iterator field = record->field_begin();
1545   if (field == record->field_end()) {
1546     ErrorUnsupported(D, "weird std::initializer_list");
1547     return 0;
1548   }
1549   QualType elementPtr = ctx.getPointerType(elementType.withConst());
1550   // Start pointer.
1551   if (!ctx.hasSameType(field->getType(), elementPtr)) {
1552     ErrorUnsupported(D, "weird std::initializer_list");
1553     return 0;
1554   }
1555   ++field;
1556   if (field == record->field_end()) {
1557     ErrorUnsupported(D, "weird std::initializer_list");
1558     return 0;
1559   }
1560   bool isStartEnd = false;
1561   if (ctx.hasSameType(field->getType(), elementPtr)) {
1562     // End pointer.
1563     isStartEnd = true;
1564   } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) {
1565     ErrorUnsupported(D, "weird std::initializer_list");
1566     return 0;
1567   }
1568 
1569   // Now build an APValue representing the std::initializer_list.
1570   APValue initListValue(APValue::UninitStruct(), 0, 2);
1571   APValue &startField = initListValue.getStructField(0);
1572   APValue::LValuePathEntry startOffsetPathEntry;
1573   startOffsetPathEntry.ArrayIndex = 0;
1574   startField = APValue(APValue::LValueBase(backingArray),
1575                        CharUnits::fromQuantity(0),
1576                        llvm::makeArrayRef(startOffsetPathEntry),
1577                        /*IsOnePastTheEnd=*/false, 0);
1578 
1579   if (isStartEnd) {
1580     APValue &endField = initListValue.getStructField(1);
1581     APValue::LValuePathEntry endOffsetPathEntry;
1582     endOffsetPathEntry.ArrayIndex = numInits;
1583     endField = APValue(APValue::LValueBase(backingArray),
1584                        ctx.getTypeSizeInChars(elementType) * numInits,
1585                        llvm::makeArrayRef(endOffsetPathEntry),
1586                        /*IsOnePastTheEnd=*/true, 0);
1587   } else {
1588     APValue &sizeField = initListValue.getStructField(1);
1589     sizeField = APValue(llvm::APSInt(numElements));
1590   }
1591 
1592   // Emit the constant for the initializer_list.
1593   llvm::Constant *llvmInit =
1594       EmitConstantValueForMemory(initListValue, D->getType());
1595   assert(llvmInit && "failed to initialize as constant");
1596   return llvmInit;
1597 }
1598 
1599 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1600                                                  unsigned AddrSpace) {
1601   if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1602     if (D->hasAttr<CUDAConstantAttr>())
1603       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1604     else if (D->hasAttr<CUDASharedAttr>())
1605       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1606     else
1607       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1608   }
1609 
1610   return AddrSpace;
1611 }
1612 
1613 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1614   llvm::Constant *Init = 0;
1615   QualType ASTTy = D->getType();
1616   CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1617   bool NeedsGlobalCtor = false;
1618   bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
1619 
1620   const VarDecl *InitDecl;
1621   const Expr *InitExpr = D->getAnyInitializer(InitDecl);
1622 
1623   if (!InitExpr) {
1624     // This is a tentative definition; tentative definitions are
1625     // implicitly initialized with { 0 }.
1626     //
1627     // Note that tentative definitions are only emitted at the end of
1628     // a translation unit, so they should never have incomplete
1629     // type. In addition, EmitTentativeDefinition makes sure that we
1630     // never attempt to emit a tentative definition if a real one
1631     // exists. A use may still exists, however, so we still may need
1632     // to do a RAUW.
1633     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
1634     Init = EmitNullConstant(D->getType());
1635   } else {
1636     // If this is a std::initializer_list, emit the special initializer.
1637     Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr);
1638     // An empty init list will perform zero-initialization, which happens
1639     // to be exactly what we want.
1640     // FIXME: It does so in a global constructor, which is *not* what we
1641     // want.
1642 
1643     if (!Init) {
1644       initializedGlobalDecl = GlobalDecl(D);
1645       Init = EmitConstantInit(*InitDecl);
1646     }
1647     if (!Init) {
1648       QualType T = InitExpr->getType();
1649       if (D->getType()->isReferenceType())
1650         T = D->getType();
1651 
1652       if (getLangOpts().CPlusPlus) {
1653         Init = EmitNullConstant(T);
1654         NeedsGlobalCtor = true;
1655       } else {
1656         ErrorUnsupported(D, "static initializer");
1657         Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1658       }
1659     } else {
1660       // We don't need an initializer, so remove the entry for the delayed
1661       // initializer position (just in case this entry was delayed) if we
1662       // also don't need to register a destructor.
1663       if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
1664         DelayedCXXInitPosition.erase(D);
1665     }
1666   }
1667 
1668   llvm::Type* InitType = Init->getType();
1669   llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
1670 
1671   // Strip off a bitcast if we got one back.
1672   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1673     assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1674            // all zero index gep.
1675            CE->getOpcode() == llvm::Instruction::GetElementPtr);
1676     Entry = CE->getOperand(0);
1677   }
1678 
1679   // Entry is now either a Function or GlobalVariable.
1680   llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
1681 
1682   // We have a definition after a declaration with the wrong type.
1683   // We must make a new GlobalVariable* and update everything that used OldGV
1684   // (a declaration or tentative definition) with the new GlobalVariable*
1685   // (which will be a definition).
1686   //
1687   // This happens if there is a prototype for a global (e.g.
1688   // "extern int x[];") and then a definition of a different type (e.g.
1689   // "int x[10];"). This also happens when an initializer has a different type
1690   // from the type of the global (this happens with unions).
1691   if (GV == 0 ||
1692       GV->getType()->getElementType() != InitType ||
1693       GV->getType()->getAddressSpace() !=
1694        GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
1695 
1696     // Move the old entry aside so that we'll create a new one.
1697     Entry->setName(StringRef());
1698 
1699     // Make a new global with the correct type, this is now guaranteed to work.
1700     GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
1701 
1702     // Replace all uses of the old global with the new global
1703     llvm::Constant *NewPtrForOldDecl =
1704         llvm::ConstantExpr::getBitCast(GV, Entry->getType());
1705     Entry->replaceAllUsesWith(NewPtrForOldDecl);
1706 
1707     // Erase the old global, since it is no longer used.
1708     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
1709   }
1710 
1711   if (D->hasAttr<AnnotateAttr>())
1712     AddGlobalAnnotations(D, GV);
1713 
1714   GV->setInitializer(Init);
1715 
1716   // If it is safe to mark the global 'constant', do so now.
1717   GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1718                   isTypeConstant(D->getType(), true));
1719 
1720   GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
1721 
1722   // Set the llvm linkage type as appropriate.
1723   llvm::GlobalValue::LinkageTypes Linkage =
1724     GetLLVMLinkageVarDefinition(D, GV);
1725   GV->setLinkage(Linkage);
1726   if (Linkage == llvm::GlobalVariable::CommonLinkage)
1727     // common vars aren't constant even if declared const.
1728     GV->setConstant(false);
1729 
1730   SetCommonAttributes(D, GV);
1731 
1732   // Emit the initializer function if necessary.
1733   if (NeedsGlobalCtor || NeedsGlobalDtor)
1734     EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
1735 
1736   // If we are compiling with ASan, add metadata indicating dynamically
1737   // initialized globals.
1738   if (LangOpts.AddressSanitizer && NeedsGlobalCtor) {
1739     llvm::Module &M = getModule();
1740 
1741     llvm::NamedMDNode *DynamicInitializers =
1742         M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals");
1743     llvm::Value *GlobalToAdd[] = { GV };
1744     llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd);
1745     DynamicInitializers->addOperand(ThisGlobal);
1746   }
1747 
1748   // Emit global variable debug information.
1749   if (CGDebugInfo *DI = getModuleDebugInfo())
1750     if (getCodeGenOpts().DebugInfo >= CodeGenOptions::LimitedDebugInfo)
1751       DI->EmitGlobalVariable(GV, D);
1752 }
1753 
1754 llvm::GlobalValue::LinkageTypes
1755 CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1756                                            llvm::GlobalVariable *GV) {
1757   GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1758   if (Linkage == GVA_Internal)
1759     return llvm::Function::InternalLinkage;
1760   else if (D->hasAttr<DLLImportAttr>())
1761     return llvm::Function::DLLImportLinkage;
1762   else if (D->hasAttr<DLLExportAttr>())
1763     return llvm::Function::DLLExportLinkage;
1764   else if (D->hasAttr<WeakAttr>()) {
1765     if (GV->isConstant())
1766       return llvm::GlobalVariable::WeakODRLinkage;
1767     else
1768       return llvm::GlobalVariable::WeakAnyLinkage;
1769   } else if (Linkage == GVA_TemplateInstantiation ||
1770              Linkage == GVA_ExplicitTemplateInstantiation)
1771     return llvm::GlobalVariable::WeakODRLinkage;
1772   else if (!getLangOpts().CPlusPlus &&
1773            ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1774              D->getAttr<CommonAttr>()) &&
1775            !D->hasExternalStorage() && !D->getInit() &&
1776            !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1777            !D->getAttr<WeakImportAttr>()) {
1778     // Thread local vars aren't considered common linkage.
1779     return llvm::GlobalVariable::CommonLinkage;
1780   }
1781   return llvm::GlobalVariable::ExternalLinkage;
1782 }
1783 
1784 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1785 /// implement a function with no prototype, e.g. "int foo() {}".  If there are
1786 /// existing call uses of the old function in the module, this adjusts them to
1787 /// call the new function directly.
1788 ///
1789 /// This is not just a cleanup: the always_inline pass requires direct calls to
1790 /// functions to be able to inline them.  If there is a bitcast in the way, it
1791 /// won't inline them.  Instcombine normally deletes these calls, but it isn't
1792 /// run at -O0.
1793 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1794                                                       llvm::Function *NewFn) {
1795   // If we're redefining a global as a function, don't transform it.
1796   llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1797   if (OldFn == 0) return;
1798 
1799   llvm::Type *NewRetTy = NewFn->getReturnType();
1800   SmallVector<llvm::Value*, 4> ArgList;
1801 
1802   for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
1803        UI != E; ) {
1804     // TODO: Do invokes ever occur in C code?  If so, we should handle them too.
1805     llvm::Value::use_iterator I = UI++; // Increment before the CI is erased.
1806     llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I);
1807     if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I)
1808     llvm::CallSite CS(CI);
1809     if (!CI || !CS.isCallee(I)) continue;
1810 
1811     // If the return types don't match exactly, and if the call isn't dead, then
1812     // we can't transform this call.
1813     if (CI->getType() != NewRetTy && !CI->use_empty())
1814       continue;
1815 
1816     // Get the attribute list.
1817     llvm::SmallVector<llvm::AttributeWithIndex, 8> AttrVec;
1818     llvm::AttrListPtr AttrList = CI->getAttributes();
1819 
1820     // Get any return attributes.
1821     llvm::Attributes RAttrs = AttrList.getRetAttributes();
1822 
1823     // Add the return attributes.
1824     if (RAttrs.hasAttributes())
1825       AttrVec.push_back(llvm::AttributeWithIndex::get(0, RAttrs));
1826 
1827     // If the function was passed too few arguments, don't transform.  If extra
1828     // arguments were passed, we silently drop them.  If any of the types
1829     // mismatch, we don't transform.
1830     unsigned ArgNo = 0;
1831     bool DontTransform = false;
1832     for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1833          E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
1834       if (CS.arg_size() == ArgNo ||
1835           CS.getArgument(ArgNo)->getType() != AI->getType()) {
1836         DontTransform = true;
1837         break;
1838       }
1839 
1840       // Add any parameter attributes.
1841       llvm::Attributes PAttrs = AttrList.getParamAttributes(ArgNo + 1);
1842       if (PAttrs.hasAttributes())
1843         AttrVec.push_back(llvm::AttributeWithIndex::get(ArgNo + 1, PAttrs));
1844     }
1845     if (DontTransform)
1846       continue;
1847 
1848     llvm::Attributes FnAttrs =  AttrList.getFnAttributes();
1849     if (FnAttrs.hasAttributes())
1850       AttrVec.push_back(llvm::AttributeWithIndex::get(~0, FnAttrs));
1851 
1852     // Okay, we can transform this.  Create the new call instruction and copy
1853     // over the required information.
1854     ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo);
1855     llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList, "", CI);
1856     ArgList.clear();
1857     if (!NewCall->getType()->isVoidTy())
1858       NewCall->takeName(CI);
1859     NewCall->setAttributes(llvm::AttrListPtr::get(AttrVec));
1860     NewCall->setCallingConv(CI->getCallingConv());
1861 
1862     // Finally, remove the old call, replacing any uses with the new one.
1863     if (!CI->use_empty())
1864       CI->replaceAllUsesWith(NewCall);
1865 
1866     // Copy debug location attached to CI.
1867     if (!CI->getDebugLoc().isUnknown())
1868       NewCall->setDebugLoc(CI->getDebugLoc());
1869     CI->eraseFromParent();
1870   }
1871 }
1872 
1873 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
1874   TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
1875   // If we have a definition, this might be a deferred decl. If the
1876   // instantiation is explicit, make sure we emit it at the end.
1877   if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
1878     GetAddrOfGlobalVar(VD);
1879 }
1880 
1881 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
1882   const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
1883 
1884   // Compute the function info and LLVM type.
1885   const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
1886   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
1887 
1888   // Get or create the prototype for the function.
1889   llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
1890 
1891   // Strip off a bitcast if we got one back.
1892   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1893     assert(CE->getOpcode() == llvm::Instruction::BitCast);
1894     Entry = CE->getOperand(0);
1895   }
1896 
1897 
1898   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
1899     llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
1900 
1901     // If the types mismatch then we have to rewrite the definition.
1902     assert(OldFn->isDeclaration() &&
1903            "Shouldn't replace non-declaration");
1904 
1905     // F is the Function* for the one with the wrong type, we must make a new
1906     // Function* and update everything that used F (a declaration) with the new
1907     // Function* (which will be a definition).
1908     //
1909     // This happens if there is a prototype for a function
1910     // (e.g. "int f()") and then a definition of a different type
1911     // (e.g. "int f(int x)").  Move the old function aside so that it
1912     // doesn't interfere with GetAddrOfFunction.
1913     OldFn->setName(StringRef());
1914     llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
1915 
1916     // If this is an implementation of a function without a prototype, try to
1917     // replace any existing uses of the function (which may be calls) with uses
1918     // of the new function
1919     if (D->getType()->isFunctionNoProtoType()) {
1920       ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
1921       OldFn->removeDeadConstantUsers();
1922     }
1923 
1924     // Replace uses of F with the Function we will endow with a body.
1925     if (!Entry->use_empty()) {
1926       llvm::Constant *NewPtrForOldDecl =
1927         llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
1928       Entry->replaceAllUsesWith(NewPtrForOldDecl);
1929     }
1930 
1931     // Ok, delete the old function now, which is dead.
1932     OldFn->eraseFromParent();
1933 
1934     Entry = NewFn;
1935   }
1936 
1937   // We need to set linkage and visibility on the function before
1938   // generating code for it because various parts of IR generation
1939   // want to propagate this information down (e.g. to local static
1940   // declarations).
1941   llvm::Function *Fn = cast<llvm::Function>(Entry);
1942   setFunctionLinkage(D, Fn);
1943 
1944   // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
1945   setGlobalVisibility(Fn, D);
1946 
1947   CodeGenFunction(*this).GenerateCode(D, Fn, FI);
1948 
1949   SetFunctionDefinitionAttributes(D, Fn);
1950   SetLLVMFunctionAttributesForDefinition(D, Fn);
1951 
1952   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
1953     AddGlobalCtor(Fn, CA->getPriority());
1954   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
1955     AddGlobalDtor(Fn, DA->getPriority());
1956   if (D->hasAttr<AnnotateAttr>())
1957     AddGlobalAnnotations(D, Fn);
1958 }
1959 
1960 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
1961   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
1962   const AliasAttr *AA = D->getAttr<AliasAttr>();
1963   assert(AA && "Not an alias?");
1964 
1965   StringRef MangledName = getMangledName(GD);
1966 
1967   // If there is a definition in the module, then it wins over the alias.
1968   // This is dubious, but allow it to be safe.  Just ignore the alias.
1969   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1970   if (Entry && !Entry->isDeclaration())
1971     return;
1972 
1973   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
1974 
1975   // Create a reference to the named value.  This ensures that it is emitted
1976   // if a deferred decl.
1977   llvm::Constant *Aliasee;
1978   if (isa<llvm::FunctionType>(DeclTy))
1979     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
1980                                       /*ForVTable=*/false);
1981   else
1982     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1983                                     llvm::PointerType::getUnqual(DeclTy), 0);
1984 
1985   // Create the new alias itself, but don't set a name yet.
1986   llvm::GlobalValue *GA =
1987     new llvm::GlobalAlias(Aliasee->getType(),
1988                           llvm::Function::ExternalLinkage,
1989                           "", Aliasee, &getModule());
1990 
1991   if (Entry) {
1992     assert(Entry->isDeclaration());
1993 
1994     // If there is a declaration in the module, then we had an extern followed
1995     // by the alias, as in:
1996     //   extern int test6();
1997     //   ...
1998     //   int test6() __attribute__((alias("test7")));
1999     //
2000     // Remove it and replace uses of it with the alias.
2001     GA->takeName(Entry);
2002 
2003     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
2004                                                           Entry->getType()));
2005     Entry->eraseFromParent();
2006   } else {
2007     GA->setName(MangledName);
2008   }
2009 
2010   // Set attributes which are particular to an alias; this is a
2011   // specialization of the attributes which may be set on a global
2012   // variable/function.
2013   if (D->hasAttr<DLLExportAttr>()) {
2014     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2015       // The dllexport attribute is ignored for undefined symbols.
2016       if (FD->hasBody())
2017         GA->setLinkage(llvm::Function::DLLExportLinkage);
2018     } else {
2019       GA->setLinkage(llvm::Function::DLLExportLinkage);
2020     }
2021   } else if (D->hasAttr<WeakAttr>() ||
2022              D->hasAttr<WeakRefAttr>() ||
2023              D->isWeakImported()) {
2024     GA->setLinkage(llvm::Function::WeakAnyLinkage);
2025   }
2026 
2027   SetCommonAttributes(D, GA);
2028 }
2029 
2030 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
2031                                             ArrayRef<llvm::Type*> Tys) {
2032   return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
2033                                          Tys);
2034 }
2035 
2036 static llvm::StringMapEntry<llvm::Constant*> &
2037 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2038                          const StringLiteral *Literal,
2039                          bool TargetIsLSB,
2040                          bool &IsUTF16,
2041                          unsigned &StringLength) {
2042   StringRef String = Literal->getString();
2043   unsigned NumBytes = String.size();
2044 
2045   // Check for simple case.
2046   if (!Literal->containsNonAsciiOrNull()) {
2047     StringLength = NumBytes;
2048     return Map.GetOrCreateValue(String);
2049   }
2050 
2051   // Otherwise, convert the UTF8 literals into a string of shorts.
2052   IsUTF16 = true;
2053 
2054   SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
2055   const UTF8 *FromPtr = (const UTF8 *)String.data();
2056   UTF16 *ToPtr = &ToBuf[0];
2057 
2058   (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2059                            &ToPtr, ToPtr + NumBytes,
2060                            strictConversion);
2061 
2062   // ConvertUTF8toUTF16 returns the length in ToPtr.
2063   StringLength = ToPtr - &ToBuf[0];
2064 
2065   // Add an explicit null.
2066   *ToPtr = 0;
2067   return Map.
2068     GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2069                                (StringLength + 1) * 2));
2070 }
2071 
2072 static llvm::StringMapEntry<llvm::Constant*> &
2073 GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2074                        const StringLiteral *Literal,
2075                        unsigned &StringLength) {
2076   StringRef String = Literal->getString();
2077   StringLength = String.size();
2078   return Map.GetOrCreateValue(String);
2079 }
2080 
2081 llvm::Constant *
2082 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2083   unsigned StringLength = 0;
2084   bool isUTF16 = false;
2085   llvm::StringMapEntry<llvm::Constant*> &Entry =
2086     GetConstantCFStringEntry(CFConstantStringMap, Literal,
2087                              getDataLayout().isLittleEndian(),
2088                              isUTF16, StringLength);
2089 
2090   if (llvm::Constant *C = Entry.getValue())
2091     return C;
2092 
2093   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2094   llvm::Constant *Zeros[] = { Zero, Zero };
2095 
2096   // If we don't already have it, get __CFConstantStringClassReference.
2097   if (!CFConstantStringClassRef) {
2098     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2099     Ty = llvm::ArrayType::get(Ty, 0);
2100     llvm::Constant *GV = CreateRuntimeVariable(Ty,
2101                                            "__CFConstantStringClassReference");
2102     // Decay array -> ptr
2103     CFConstantStringClassRef =
2104       llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2105   }
2106 
2107   QualType CFTy = getContext().getCFConstantStringType();
2108 
2109   llvm::StructType *STy =
2110     cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2111 
2112   llvm::Constant *Fields[4];
2113 
2114   // Class pointer.
2115   Fields[0] = CFConstantStringClassRef;
2116 
2117   // Flags.
2118   llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2119   Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
2120     llvm::ConstantInt::get(Ty, 0x07C8);
2121 
2122   // String pointer.
2123   llvm::Constant *C = 0;
2124   if (isUTF16) {
2125     ArrayRef<uint16_t> Arr =
2126       llvm::makeArrayRef<uint16_t>((uint16_t*)Entry.getKey().data(),
2127                                    Entry.getKey().size() / 2);
2128     C = llvm::ConstantDataArray::get(VMContext, Arr);
2129   } else {
2130     C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2131   }
2132 
2133   llvm::GlobalValue::LinkageTypes Linkage;
2134   if (isUTF16)
2135     // FIXME: why do utf strings get "_" labels instead of "L" labels?
2136     Linkage = llvm::GlobalValue::InternalLinkage;
2137   else
2138     // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2139     // when using private linkage. It is not clear if this is a bug in ld
2140     // or a reasonable new restriction.
2141     Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
2142 
2143   // Note: -fwritable-strings doesn't make the backing store strings of
2144   // CFStrings writable. (See <rdar://problem/10657500>)
2145   llvm::GlobalVariable *GV =
2146     new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2147                              Linkage, C, ".str");
2148   GV->setUnnamedAddr(true);
2149   if (isUTF16) {
2150     CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2151     GV->setAlignment(Align.getQuantity());
2152   } else {
2153     CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2154     GV->setAlignment(Align.getQuantity());
2155   }
2156 
2157   // String.
2158   Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2159 
2160   if (isUTF16)
2161     // Cast the UTF16 string to the correct type.
2162     Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2163 
2164   // String length.
2165   Ty = getTypes().ConvertType(getContext().LongTy);
2166   Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
2167 
2168   // The struct.
2169   C = llvm::ConstantStruct::get(STy, Fields);
2170   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2171                                 llvm::GlobalVariable::PrivateLinkage, C,
2172                                 "_unnamed_cfstring_");
2173   if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
2174     GV->setSection(Sect);
2175   Entry.setValue(GV);
2176 
2177   return GV;
2178 }
2179 
2180 static RecordDecl *
2181 CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2182                  DeclContext *DC, IdentifierInfo *Id) {
2183   SourceLocation Loc;
2184   if (Ctx.getLangOpts().CPlusPlus)
2185     return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2186   else
2187     return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2188 }
2189 
2190 llvm::Constant *
2191 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
2192   unsigned StringLength = 0;
2193   llvm::StringMapEntry<llvm::Constant*> &Entry =
2194     GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
2195 
2196   if (llvm::Constant *C = Entry.getValue())
2197     return C;
2198 
2199   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2200   llvm::Constant *Zeros[] = { Zero, Zero };
2201 
2202   // If we don't already have it, get _NSConstantStringClassReference.
2203   if (!ConstantStringClassRef) {
2204     std::string StringClass(getLangOpts().ObjCConstantStringClass);
2205     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2206     llvm::Constant *GV;
2207     if (LangOpts.ObjCRuntime.isNonFragile()) {
2208       std::string str =
2209         StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2210                             : "OBJC_CLASS_$_" + StringClass;
2211       GV = getObjCRuntime().GetClassGlobal(str);
2212       // Make sure the result is of the correct type.
2213       llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2214       ConstantStringClassRef =
2215         llvm::ConstantExpr::getBitCast(GV, PTy);
2216     } else {
2217       std::string str =
2218         StringClass.empty() ? "_NSConstantStringClassReference"
2219                             : "_" + StringClass + "ClassReference";
2220       llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
2221       GV = CreateRuntimeVariable(PTy, str);
2222       // Decay array -> ptr
2223       ConstantStringClassRef =
2224         llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2225     }
2226   }
2227 
2228   if (!NSConstantStringType) {
2229     // Construct the type for a constant NSString.
2230     RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2231                                      Context.getTranslationUnitDecl(),
2232                                    &Context.Idents.get("__builtin_NSString"));
2233     D->startDefinition();
2234 
2235     QualType FieldTypes[3];
2236 
2237     // const int *isa;
2238     FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2239     // const char *str;
2240     FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2241     // unsigned int length;
2242     FieldTypes[2] = Context.UnsignedIntTy;
2243 
2244     // Create fields
2245     for (unsigned i = 0; i < 3; ++i) {
2246       FieldDecl *Field = FieldDecl::Create(Context, D,
2247                                            SourceLocation(),
2248                                            SourceLocation(), 0,
2249                                            FieldTypes[i], /*TInfo=*/0,
2250                                            /*BitWidth=*/0,
2251                                            /*Mutable=*/false,
2252                                            ICIS_NoInit);
2253       Field->setAccess(AS_public);
2254       D->addDecl(Field);
2255     }
2256 
2257     D->completeDefinition();
2258     QualType NSTy = Context.getTagDeclType(D);
2259     NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2260   }
2261 
2262   llvm::Constant *Fields[3];
2263 
2264   // Class pointer.
2265   Fields[0] = ConstantStringClassRef;
2266 
2267   // String pointer.
2268   llvm::Constant *C =
2269     llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2270 
2271   llvm::GlobalValue::LinkageTypes Linkage;
2272   bool isConstant;
2273   Linkage = llvm::GlobalValue::PrivateLinkage;
2274   isConstant = !LangOpts.WritableStrings;
2275 
2276   llvm::GlobalVariable *GV =
2277   new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2278                            ".str");
2279   GV->setUnnamedAddr(true);
2280   CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2281   GV->setAlignment(Align.getQuantity());
2282   Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2283 
2284   // String length.
2285   llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2286   Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2287 
2288   // The struct.
2289   C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
2290   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2291                                 llvm::GlobalVariable::PrivateLinkage, C,
2292                                 "_unnamed_nsstring_");
2293   // FIXME. Fix section.
2294   if (const char *Sect =
2295         LangOpts.ObjCRuntime.isNonFragile()
2296           ? getContext().getTargetInfo().getNSStringNonFragileABISection()
2297           : getContext().getTargetInfo().getNSStringSection())
2298     GV->setSection(Sect);
2299   Entry.setValue(GV);
2300 
2301   return GV;
2302 }
2303 
2304 QualType CodeGenModule::getObjCFastEnumerationStateType() {
2305   if (ObjCFastEnumerationStateType.isNull()) {
2306     RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2307                                      Context.getTranslationUnitDecl(),
2308                       &Context.Idents.get("__objcFastEnumerationState"));
2309     D->startDefinition();
2310 
2311     QualType FieldTypes[] = {
2312       Context.UnsignedLongTy,
2313       Context.getPointerType(Context.getObjCIdType()),
2314       Context.getPointerType(Context.UnsignedLongTy),
2315       Context.getConstantArrayType(Context.UnsignedLongTy,
2316                            llvm::APInt(32, 5), ArrayType::Normal, 0)
2317     };
2318 
2319     for (size_t i = 0; i < 4; ++i) {
2320       FieldDecl *Field = FieldDecl::Create(Context,
2321                                            D,
2322                                            SourceLocation(),
2323                                            SourceLocation(), 0,
2324                                            FieldTypes[i], /*TInfo=*/0,
2325                                            /*BitWidth=*/0,
2326                                            /*Mutable=*/false,
2327                                            ICIS_NoInit);
2328       Field->setAccess(AS_public);
2329       D->addDecl(Field);
2330     }
2331 
2332     D->completeDefinition();
2333     ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2334   }
2335 
2336   return ObjCFastEnumerationStateType;
2337 }
2338 
2339 llvm::Constant *
2340 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2341   assert(!E->getType()->isPointerType() && "Strings are always arrays");
2342 
2343   // Don't emit it as the address of the string, emit the string data itself
2344   // as an inline array.
2345   if (E->getCharByteWidth() == 1) {
2346     SmallString<64> Str(E->getString());
2347 
2348     // Resize the string to the right size, which is indicated by its type.
2349     const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2350     Str.resize(CAT->getSize().getZExtValue());
2351     return llvm::ConstantDataArray::getString(VMContext, Str, false);
2352   }
2353 
2354   llvm::ArrayType *AType =
2355     cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2356   llvm::Type *ElemTy = AType->getElementType();
2357   unsigned NumElements = AType->getNumElements();
2358 
2359   // Wide strings have either 2-byte or 4-byte elements.
2360   if (ElemTy->getPrimitiveSizeInBits() == 16) {
2361     SmallVector<uint16_t, 32> Elements;
2362     Elements.reserve(NumElements);
2363 
2364     for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2365       Elements.push_back(E->getCodeUnit(i));
2366     Elements.resize(NumElements);
2367     return llvm::ConstantDataArray::get(VMContext, Elements);
2368   }
2369 
2370   assert(ElemTy->getPrimitiveSizeInBits() == 32);
2371   SmallVector<uint32_t, 32> Elements;
2372   Elements.reserve(NumElements);
2373 
2374   for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2375     Elements.push_back(E->getCodeUnit(i));
2376   Elements.resize(NumElements);
2377   return llvm::ConstantDataArray::get(VMContext, Elements);
2378 }
2379 
2380 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2381 /// constant array for the given string literal.
2382 llvm::Constant *
2383 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
2384   CharUnits Align = getContext().getTypeAlignInChars(S->getType());
2385   if (S->isAscii() || S->isUTF8()) {
2386     SmallString<64> Str(S->getString());
2387 
2388     // Resize the string to the right size, which is indicated by its type.
2389     const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2390     Str.resize(CAT->getSize().getZExtValue());
2391     return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
2392   }
2393 
2394   // FIXME: the following does not memoize wide strings.
2395   llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2396   llvm::GlobalVariable *GV =
2397     new llvm::GlobalVariable(getModule(),C->getType(),
2398                              !LangOpts.WritableStrings,
2399                              llvm::GlobalValue::PrivateLinkage,
2400                              C,".str");
2401 
2402   GV->setAlignment(Align.getQuantity());
2403   GV->setUnnamedAddr(true);
2404   return GV;
2405 }
2406 
2407 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2408 /// array for the given ObjCEncodeExpr node.
2409 llvm::Constant *
2410 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2411   std::string Str;
2412   getContext().getObjCEncodingForType(E->getEncodedType(), Str);
2413 
2414   return GetAddrOfConstantCString(Str);
2415 }
2416 
2417 
2418 /// GenerateWritableString -- Creates storage for a string literal.
2419 static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
2420                                              bool constant,
2421                                              CodeGenModule &CGM,
2422                                              const char *GlobalName,
2423                                              unsigned Alignment) {
2424   // Create Constant for this string literal. Don't add a '\0'.
2425   llvm::Constant *C =
2426       llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
2427 
2428   // Create a global variable for this string
2429   llvm::GlobalVariable *GV =
2430     new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2431                              llvm::GlobalValue::PrivateLinkage,
2432                              C, GlobalName);
2433   GV->setAlignment(Alignment);
2434   GV->setUnnamedAddr(true);
2435   return GV;
2436 }
2437 
2438 /// GetAddrOfConstantString - Returns a pointer to a character array
2439 /// containing the literal. This contents are exactly that of the
2440 /// given string, i.e. it will not be null terminated automatically;
2441 /// see GetAddrOfConstantCString. Note that whether the result is
2442 /// actually a pointer to an LLVM constant depends on
2443 /// Feature.WriteableStrings.
2444 ///
2445 /// The result has pointer to array type.
2446 llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
2447                                                        const char *GlobalName,
2448                                                        unsigned Alignment) {
2449   // Get the default prefix if a name wasn't specified.
2450   if (!GlobalName)
2451     GlobalName = ".str";
2452 
2453   // Don't share any string literals if strings aren't constant.
2454   if (LangOpts.WritableStrings)
2455     return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
2456 
2457   llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2458     ConstantStringMap.GetOrCreateValue(Str);
2459 
2460   if (llvm::GlobalVariable *GV = Entry.getValue()) {
2461     if (Alignment > GV->getAlignment()) {
2462       GV->setAlignment(Alignment);
2463     }
2464     return GV;
2465   }
2466 
2467   // Create a global variable for this.
2468   llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2469                                                    Alignment);
2470   Entry.setValue(GV);
2471   return GV;
2472 }
2473 
2474 /// GetAddrOfConstantCString - Returns a pointer to a character
2475 /// array containing the literal and a terminating '\0'
2476 /// character. The result has pointer to array type.
2477 llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
2478                                                         const char *GlobalName,
2479                                                         unsigned Alignment) {
2480   StringRef StrWithNull(Str.c_str(), Str.size() + 1);
2481   return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
2482 }
2483 
2484 /// EmitObjCPropertyImplementations - Emit information for synthesized
2485 /// properties for an implementation.
2486 void CodeGenModule::EmitObjCPropertyImplementations(const
2487                                                     ObjCImplementationDecl *D) {
2488   for (ObjCImplementationDecl::propimpl_iterator
2489          i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
2490     ObjCPropertyImplDecl *PID = *i;
2491 
2492     // Dynamic is just for type-checking.
2493     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2494       ObjCPropertyDecl *PD = PID->getPropertyDecl();
2495 
2496       // Determine which methods need to be implemented, some may have
2497       // been overridden. Note that ::isPropertyAccessor is not the method
2498       // we want, that just indicates if the decl came from a
2499       // property. What we want to know is if the method is defined in
2500       // this implementation.
2501       if (!D->getInstanceMethod(PD->getGetterName()))
2502         CodeGenFunction(*this).GenerateObjCGetter(
2503                                  const_cast<ObjCImplementationDecl *>(D), PID);
2504       if (!PD->isReadOnly() &&
2505           !D->getInstanceMethod(PD->getSetterName()))
2506         CodeGenFunction(*this).GenerateObjCSetter(
2507                                  const_cast<ObjCImplementationDecl *>(D), PID);
2508     }
2509   }
2510 }
2511 
2512 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
2513   const ObjCInterfaceDecl *iface = impl->getClassInterface();
2514   for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
2515        ivar; ivar = ivar->getNextIvar())
2516     if (ivar->getType().isDestructedType())
2517       return true;
2518 
2519   return false;
2520 }
2521 
2522 /// EmitObjCIvarInitializations - Emit information for ivar initialization
2523 /// for an implementation.
2524 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
2525   // We might need a .cxx_destruct even if we don't have any ivar initializers.
2526   if (needsDestructMethod(D)) {
2527     IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2528     Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2529     ObjCMethodDecl *DTORMethod =
2530       ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
2531                              cxxSelector, getContext().VoidTy, 0, D,
2532                              /*isInstance=*/true, /*isVariadic=*/false,
2533                           /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
2534                              /*isDefined=*/false, ObjCMethodDecl::Required);
2535     D->addInstanceMethod(DTORMethod);
2536     CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
2537     D->setHasCXXStructors(true);
2538   }
2539 
2540   // If the implementation doesn't have any ivar initializers, we don't need
2541   // a .cxx_construct.
2542   if (D->getNumIvarInitializers() == 0)
2543     return;
2544 
2545   IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2546   Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2547   // The constructor returns 'self'.
2548   ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2549                                                 D->getLocation(),
2550                                                 D->getLocation(),
2551                                                 cxxSelector,
2552                                                 getContext().getObjCIdType(), 0,
2553                                                 D, /*isInstance=*/true,
2554                                                 /*isVariadic=*/false,
2555                                                 /*isPropertyAccessor=*/true,
2556                                                 /*isImplicitlyDeclared=*/true,
2557                                                 /*isDefined=*/false,
2558                                                 ObjCMethodDecl::Required);
2559   D->addInstanceMethod(CTORMethod);
2560   CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
2561   D->setHasCXXStructors(true);
2562 }
2563 
2564 /// EmitNamespace - Emit all declarations in a namespace.
2565 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
2566   for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
2567        I != E; ++I)
2568     EmitTopLevelDecl(*I);
2569 }
2570 
2571 // EmitLinkageSpec - Emit all declarations in a linkage spec.
2572 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
2573   if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2574       LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
2575     ErrorUnsupported(LSD, "linkage spec");
2576     return;
2577   }
2578 
2579   for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
2580        I != E; ++I)
2581     EmitTopLevelDecl(*I);
2582 }
2583 
2584 /// EmitTopLevelDecl - Emit code for a single top level declaration.
2585 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2586   // If an error has occurred, stop code generation, but continue
2587   // parsing and semantic analysis (to ensure all warnings and errors
2588   // are emitted).
2589   if (Diags.hasErrorOccurred())
2590     return;
2591 
2592   // Ignore dependent declarations.
2593   if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2594     return;
2595 
2596   switch (D->getKind()) {
2597   case Decl::CXXConversion:
2598   case Decl::CXXMethod:
2599   case Decl::Function:
2600     // Skip function templates
2601     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2602         cast<FunctionDecl>(D)->isLateTemplateParsed())
2603       return;
2604 
2605     EmitGlobal(cast<FunctionDecl>(D));
2606     break;
2607 
2608   case Decl::Var:
2609     EmitGlobal(cast<VarDecl>(D));
2610     break;
2611 
2612   // Indirect fields from global anonymous structs and unions can be
2613   // ignored; only the actual variable requires IR gen support.
2614   case Decl::IndirectField:
2615     break;
2616 
2617   // C++ Decls
2618   case Decl::Namespace:
2619     EmitNamespace(cast<NamespaceDecl>(D));
2620     break;
2621     // No code generation needed.
2622   case Decl::UsingShadow:
2623   case Decl::Using:
2624   case Decl::UsingDirective:
2625   case Decl::ClassTemplate:
2626   case Decl::FunctionTemplate:
2627   case Decl::TypeAliasTemplate:
2628   case Decl::NamespaceAlias:
2629   case Decl::Block:
2630   case Decl::Import:
2631     break;
2632   case Decl::CXXConstructor:
2633     // Skip function templates
2634     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2635         cast<FunctionDecl>(D)->isLateTemplateParsed())
2636       return;
2637 
2638     EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2639     break;
2640   case Decl::CXXDestructor:
2641     if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2642       return;
2643     EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2644     break;
2645 
2646   case Decl::StaticAssert:
2647     // Nothing to do.
2648     break;
2649 
2650   // Objective-C Decls
2651 
2652   // Forward declarations, no (immediate) code generation.
2653   case Decl::ObjCInterface:
2654   case Decl::ObjCCategory:
2655     break;
2656 
2657   case Decl::ObjCProtocol: {
2658     ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2659     if (Proto->isThisDeclarationADefinition())
2660       ObjCRuntime->GenerateProtocol(Proto);
2661     break;
2662   }
2663 
2664   case Decl::ObjCCategoryImpl:
2665     // Categories have properties but don't support synthesize so we
2666     // can ignore them here.
2667     ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
2668     break;
2669 
2670   case Decl::ObjCImplementation: {
2671     ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2672     EmitObjCPropertyImplementations(OMD);
2673     EmitObjCIvarInitializations(OMD);
2674     ObjCRuntime->GenerateClass(OMD);
2675     // Emit global variable debug information.
2676     if (CGDebugInfo *DI = getModuleDebugInfo())
2677       DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(OMD->getClassInterface()),
2678 				   OMD->getLocation());
2679 
2680     break;
2681   }
2682   case Decl::ObjCMethod: {
2683     ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2684     // If this is not a prototype, emit the body.
2685     if (OMD->getBody())
2686       CodeGenFunction(*this).GenerateObjCMethod(OMD);
2687     break;
2688   }
2689   case Decl::ObjCCompatibleAlias:
2690     ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
2691     break;
2692 
2693   case Decl::LinkageSpec:
2694     EmitLinkageSpec(cast<LinkageSpecDecl>(D));
2695     break;
2696 
2697   case Decl::FileScopeAsm: {
2698     FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
2699     StringRef AsmString = AD->getAsmString()->getString();
2700 
2701     const std::string &S = getModule().getModuleInlineAsm();
2702     if (S.empty())
2703       getModule().setModuleInlineAsm(AsmString);
2704     else if (S.end()[-1] == '\n')
2705       getModule().setModuleInlineAsm(S + AsmString.str());
2706     else
2707       getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
2708     break;
2709   }
2710 
2711   default:
2712     // Make sure we handled everything we should, every other kind is a
2713     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
2714     // function. Need to recode Decl::Kind to do that easily.
2715     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2716   }
2717 }
2718 
2719 /// Turns the given pointer into a constant.
2720 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2721                                           const void *Ptr) {
2722   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
2723   llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
2724   return llvm::ConstantInt::get(i64, PtrInt);
2725 }
2726 
2727 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2728                                    llvm::NamedMDNode *&GlobalMetadata,
2729                                    GlobalDecl D,
2730                                    llvm::GlobalValue *Addr) {
2731   if (!GlobalMetadata)
2732     GlobalMetadata =
2733       CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2734 
2735   // TODO: should we report variant information for ctors/dtors?
2736   llvm::Value *Ops[] = {
2737     Addr,
2738     GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2739   };
2740   GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
2741 }
2742 
2743 /// Emits metadata nodes associating all the global values in the
2744 /// current module with the Decls they came from.  This is useful for
2745 /// projects using IR gen as a subroutine.
2746 ///
2747 /// Since there's currently no way to associate an MDNode directly
2748 /// with an llvm::GlobalValue, we create a global named metadata
2749 /// with the name 'clang.global.decl.ptrs'.
2750 void CodeGenModule::EmitDeclMetadata() {
2751   llvm::NamedMDNode *GlobalMetadata = 0;
2752 
2753   // StaticLocalDeclMap
2754   for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
2755          I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2756        I != E; ++I) {
2757     llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2758     EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2759   }
2760 }
2761 
2762 /// Emits metadata nodes for all the local variables in the current
2763 /// function.
2764 void CodeGenFunction::EmitDeclMetadata() {
2765   if (LocalDeclMap.empty()) return;
2766 
2767   llvm::LLVMContext &Context = getLLVMContext();
2768 
2769   // Find the unique metadata ID for this name.
2770   unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2771 
2772   llvm::NamedMDNode *GlobalMetadata = 0;
2773 
2774   for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2775          I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2776     const Decl *D = I->first;
2777     llvm::Value *Addr = I->second;
2778 
2779     if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2780       llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
2781       Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
2782     } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2783       GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2784       EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2785     }
2786   }
2787 }
2788 
2789 void CodeGenModule::EmitCoverageFile() {
2790   if (!getCodeGenOpts().CoverageFile.empty()) {
2791     if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2792       llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2793       llvm::LLVMContext &Ctx = TheModule.getContext();
2794       llvm::MDString *CoverageFile =
2795           llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
2796       for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2797         llvm::MDNode *CU = CUNode->getOperand(i);
2798         llvm::Value *node[] = { CoverageFile, CU };
2799         llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2800         GCov->addOperand(N);
2801       }
2802     }
2803   }
2804 }
2805 
2806 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
2807                                                      QualType GuidType) {
2808   // Sema has checked that all uuid strings are of the form
2809   // "12345678-1234-1234-1234-1234567890ab".
2810   assert(Uuid.size() == 36);
2811   const char *Uuidstr = Uuid.data();
2812   for (int i = 0; i < 36; ++i) {
2813     if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
2814     else                                         assert(isxdigit(Uuidstr[i]));
2815   }
2816 
2817   llvm::APInt Field0(32, StringRef(Uuidstr     , 8), 16);
2818   llvm::APInt Field1(16, StringRef(Uuidstr +  9, 4), 16);
2819   llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
2820   int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
2821 
2822   APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
2823   InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
2824   InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
2825   InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
2826   APValue& Arr = InitStruct.getStructField(3);
2827   Arr = APValue(APValue::UninitArray(), 8, 8);
2828   for (int t = 0; t < 8; ++t)
2829     Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
2830           llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
2831 
2832   return EmitConstantValue(InitStruct, GuidType);
2833 }
2834