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