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