xref: /llvm-project/clang/lib/CodeGen/CodeGenModule.cpp (revision cdf7ef5437f2cd76bd6b0246cd11b1837d79104e)
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 "CGCXXABI.h"
20 #include "CGObjCRuntime.h"
21 #include "Mangle.h"
22 #include "TargetInfo.h"
23 #include "clang/Frontend/CodeGenOptions.h"
24 #include "clang/AST/ASTContext.h"
25 #include "clang/AST/CharUnits.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclCXX.h"
28 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/RecordLayout.h"
30 #include "clang/Basic/Builtins.h"
31 #include "clang/Basic/Diagnostic.h"
32 #include "clang/Basic/SourceManager.h"
33 #include "clang/Basic/TargetInfo.h"
34 #include "clang/Basic/ConvertUTF.h"
35 #include "llvm/CallingConv.h"
36 #include "llvm/Module.h"
37 #include "llvm/Intrinsics.h"
38 #include "llvm/LLVMContext.h"
39 #include "llvm/ADT/Triple.h"
40 #include "llvm/Target/TargetData.h"
41 #include "llvm/Support/CallSite.h"
42 #include "llvm/Support/ErrorHandling.h"
43 using namespace clang;
44 using namespace CodeGen;
45 
46 static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
47   switch (CGM.getContext().Target.getCXXABI()) {
48   case CXXABI_ARM: return *CreateARMCXXABI(CGM);
49   case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM);
50   case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM);
51   }
52 
53   llvm_unreachable("invalid C++ ABI kind");
54   return *CreateItaniumCXXABI(CGM);
55 }
56 
57 
58 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
59                              llvm::Module &M, const llvm::TargetData &TD,
60                              Diagnostic &diags)
61   : BlockModule(C, M, TD, Types, *this), Context(C),
62     Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M),
63     TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags),
64     ABI(createCXXABI(*this)),
65     Types(C, M, TD, getTargetCodeGenInfo().getABIInfo(), ABI),
66     TBAA(0),
67     VTables(*this), Runtime(0),
68     CFConstantStringClassRef(0), ConstantStringClassRef(0),
69     VMContext(M.getContext()),
70     NSConcreteGlobalBlockDecl(0), NSConcreteStackBlockDecl(0),
71     NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
72     BlockObjectAssignDecl(0), BlockObjectDisposeDecl(0),
73     BlockObjectAssign(0), BlockObjectDispose(0){
74 
75   if (!Features.ObjC1)
76     Runtime = 0;
77   else if (!Features.NeXTRuntime)
78     Runtime = CreateGNUObjCRuntime(*this);
79   else if (Features.ObjCNonFragileABI)
80     Runtime = CreateMacNonFragileABIObjCRuntime(*this);
81   else
82     Runtime = CreateMacObjCRuntime(*this);
83 
84   // Enable TBAA unless it's suppressed.
85   if (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)
86     TBAA = new CodeGenTBAA(Context, VMContext, getLangOptions(),
87                            ABI.getMangleContext());
88 
89   // If debug info generation is enabled, create the CGDebugInfo object.
90   DebugInfo = CodeGenOpts.DebugInfo ? new CGDebugInfo(*this) : 0;
91 }
92 
93 CodeGenModule::~CodeGenModule() {
94   delete Runtime;
95   delete &ABI;
96   delete TBAA;
97   delete DebugInfo;
98 }
99 
100 void CodeGenModule::createObjCRuntime() {
101   if (!Features.NeXTRuntime)
102     Runtime = CreateGNUObjCRuntime(*this);
103   else if (Features.ObjCNonFragileABI)
104     Runtime = CreateMacNonFragileABIObjCRuntime(*this);
105   else
106     Runtime = CreateMacObjCRuntime(*this);
107 }
108 
109 void CodeGenModule::Release() {
110   EmitDeferred();
111   EmitCXXGlobalInitFunc();
112   EmitCXXGlobalDtorFunc();
113   if (Runtime)
114     if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
115       AddGlobalCtor(ObjCInitFunction);
116   EmitCtorList(GlobalCtors, "llvm.global_ctors");
117   EmitCtorList(GlobalDtors, "llvm.global_dtors");
118   EmitAnnotations();
119   EmitLLVMUsed();
120 
121   SimplifyPersonality();
122 
123   if (getCodeGenOpts().EmitDeclMetadata)
124     EmitDeclMetadata();
125 }
126 
127 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
128   if (!TBAA)
129     return 0;
130   return TBAA->getTBAAInfo(QTy);
131 }
132 
133 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
134                                         llvm::MDNode *TBAAInfo) {
135   Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
136 }
137 
138 bool CodeGenModule::isTargetDarwin() const {
139   return getContext().Target.getTriple().getOS() == llvm::Triple::Darwin;
140 }
141 
142 /// ErrorUnsupported - Print out an error that codegen doesn't support the
143 /// specified stmt yet.
144 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
145                                      bool OmitOnError) {
146   if (OmitOnError && getDiags().hasErrorOccurred())
147     return;
148   unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
149                                                "cannot compile this %0 yet");
150   std::string Msg = Type;
151   getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
152     << Msg << S->getSourceRange();
153 }
154 
155 /// ErrorUnsupported - Print out an error that codegen doesn't support the
156 /// specified decl yet.
157 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
158                                      bool OmitOnError) {
159   if (OmitOnError && getDiags().hasErrorOccurred())
160     return;
161   unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
162                                                "cannot compile this %0 yet");
163   std::string Msg = Type;
164   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
165 }
166 
167 static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V) {
168   switch (V) {
169   case DefaultVisibility:   return llvm::GlobalValue::DefaultVisibility;
170   case HiddenVisibility:    return llvm::GlobalValue::HiddenVisibility;
171   case ProtectedVisibility: return llvm::GlobalValue::ProtectedVisibility;
172   }
173   llvm_unreachable("unknown visibility!");
174   return llvm::GlobalValue::DefaultVisibility;
175 }
176 
177 
178 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
179                                         const NamedDecl *D,
180                                         bool IsForDefinition) const {
181   // Internal definitions always have default visibility.
182   if (GV->hasLocalLinkage()) {
183     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
184     return;
185   }
186 
187   // Set visibility for definitions.
188   NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
189   if (LV.visibilityExplicit() ||
190       (IsForDefinition && !GV->hasAvailableExternallyLinkage()))
191     GV->setVisibility(GetLLVMVisibility(LV.visibility()));
192 }
193 
194 /// Set the symbol visibility of type information (vtable and RTTI)
195 /// associated with the given type.
196 void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
197                                       const CXXRecordDecl *RD,
198                                       bool IsForRTTI,
199                                       bool IsForDefinition) const {
200   setGlobalVisibility(GV, RD, IsForDefinition);
201 
202   if (!CodeGenOpts.HiddenWeakVTables)
203     return;
204 
205   // We want to drop the visibility to hidden for weak type symbols.
206   // This isn't possible if there might be unresolved references
207   // elsewhere that rely on this symbol being visible.
208 
209   // This should be kept roughly in sync with setThunkVisibility
210   // in CGVTables.cpp.
211 
212   // Preconditions.
213   if (GV->getLinkage() != llvm::GlobalVariable::WeakODRLinkage ||
214       GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
215     return;
216 
217   // Don't override an explicit visibility attribute.
218   if (RD->hasAttr<VisibilityAttr>())
219     return;
220 
221   switch (RD->getTemplateSpecializationKind()) {
222   // We have to disable the optimization if this is an EI definition
223   // because there might be EI declarations in other shared objects.
224   case TSK_ExplicitInstantiationDefinition:
225   case TSK_ExplicitInstantiationDeclaration:
226     return;
227 
228   // Every use of a non-template class's type information has to emit it.
229   case TSK_Undeclared:
230     break;
231 
232   // In theory, implicit instantiations can ignore the possibility of
233   // an explicit instantiation declaration because there necessarily
234   // must be an EI definition somewhere with default visibility.  In
235   // practice, it's possible to have an explicit instantiation for
236   // an arbitrary template class, and linkers aren't necessarily able
237   // to deal with mixed-visibility symbols.
238   case TSK_ExplicitSpecialization:
239   case TSK_ImplicitInstantiation:
240     if (!CodeGenOpts.HiddenWeakTemplateVTables)
241       return;
242     break;
243   }
244 
245   // If there's a key function, there may be translation units
246   // that don't have the key function's definition.  But ignore
247   // this if we're emitting RTTI under -fno-rtti.
248   if (!IsForRTTI || Features.RTTI)
249     if (Context.getKeyFunction(RD))
250       return;
251 
252   // Otherwise, drop the visibility to hidden.
253   GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
254 }
255 
256 llvm::StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
257   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
258 
259   llvm::StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
260   if (!Str.empty())
261     return Str;
262 
263   if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
264     IdentifierInfo *II = ND->getIdentifier();
265     assert(II && "Attempt to mangle unnamed decl.");
266 
267     Str = II->getName();
268     return Str;
269   }
270 
271   llvm::SmallString<256> Buffer;
272   if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
273     getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Buffer);
274   else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
275     getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Buffer);
276   else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
277     getCXXABI().getMangleContext().mangleBlock(GD, BD, Buffer);
278   else
279     getCXXABI().getMangleContext().mangleName(ND, Buffer);
280 
281   // Allocate space for the mangled name.
282   size_t Length = Buffer.size();
283   char *Name = MangledNamesAllocator.Allocate<char>(Length);
284   std::copy(Buffer.begin(), Buffer.end(), Name);
285 
286   Str = llvm::StringRef(Name, Length);
287 
288   return Str;
289 }
290 
291 void CodeGenModule::getMangledName(GlobalDecl GD, MangleBuffer &Buffer,
292                                    const BlockDecl *BD) {
293   getCXXABI().getMangleContext().mangleBlock(GD, BD, Buffer.getBuffer());
294 }
295 
296 llvm::GlobalValue *CodeGenModule::GetGlobalValue(llvm::StringRef Name) {
297   return getModule().getNamedValue(Name);
298 }
299 
300 /// AddGlobalCtor - Add a function to the list that will be called before
301 /// main() runs.
302 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
303   // FIXME: Type coercion of void()* types.
304   GlobalCtors.push_back(std::make_pair(Ctor, Priority));
305 }
306 
307 /// AddGlobalDtor - Add a function to the list that will be called
308 /// when the module is unloaded.
309 void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
310   // FIXME: Type coercion of void()* types.
311   GlobalDtors.push_back(std::make_pair(Dtor, Priority));
312 }
313 
314 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
315   // Ctor function type is void()*.
316   llvm::FunctionType* CtorFTy =
317     llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
318                             std::vector<const llvm::Type*>(),
319                             false);
320   llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
321 
322   // Get the type of a ctor entry, { i32, void ()* }.
323   llvm::StructType* CtorStructTy =
324     llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext),
325                           llvm::PointerType::getUnqual(CtorFTy), NULL);
326 
327   // Construct the constructor and destructor arrays.
328   std::vector<llvm::Constant*> Ctors;
329   for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
330     std::vector<llvm::Constant*> S;
331     S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
332                 I->second, false));
333     S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
334     Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
335   }
336 
337   if (!Ctors.empty()) {
338     llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
339     new llvm::GlobalVariable(TheModule, AT, false,
340                              llvm::GlobalValue::AppendingLinkage,
341                              llvm::ConstantArray::get(AT, Ctors),
342                              GlobalName);
343   }
344 }
345 
346 void CodeGenModule::EmitAnnotations() {
347   if (Annotations.empty())
348     return;
349 
350   // Create a new global variable for the ConstantStruct in the Module.
351   llvm::Constant *Array =
352   llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
353                                                 Annotations.size()),
354                            Annotations);
355   llvm::GlobalValue *gv =
356   new llvm::GlobalVariable(TheModule, Array->getType(), false,
357                            llvm::GlobalValue::AppendingLinkage, Array,
358                            "llvm.global.annotations");
359   gv->setSection("llvm.metadata");
360 }
361 
362 llvm::GlobalValue::LinkageTypes
363 CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
364   GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
365 
366   if (Linkage == GVA_Internal)
367     return llvm::Function::InternalLinkage;
368 
369   if (D->hasAttr<DLLExportAttr>())
370     return llvm::Function::DLLExportLinkage;
371 
372   if (D->hasAttr<WeakAttr>())
373     return llvm::Function::WeakAnyLinkage;
374 
375   // In C99 mode, 'inline' functions are guaranteed to have a strong
376   // definition somewhere else, so we can use available_externally linkage.
377   if (Linkage == GVA_C99Inline)
378     return llvm::Function::AvailableExternallyLinkage;
379 
380   // In C++, the compiler has to emit a definition in every translation unit
381   // that references the function.  We should use linkonce_odr because
382   // a) if all references in this translation unit are optimized away, we
383   // don't need to codegen it.  b) if the function persists, it needs to be
384   // merged with other definitions. c) C++ has the ODR, so we know the
385   // definition is dependable.
386   if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
387     return llvm::Function::LinkOnceODRLinkage;
388 
389   // An explicit instantiation of a template has weak linkage, since
390   // explicit instantiations can occur in multiple translation units
391   // and must all be equivalent. However, we are not allowed to
392   // throw away these explicit instantiations.
393   if (Linkage == GVA_ExplicitTemplateInstantiation)
394     return llvm::Function::WeakODRLinkage;
395 
396   // Otherwise, we have strong external linkage.
397   assert(Linkage == GVA_StrongExternal);
398   return llvm::Function::ExternalLinkage;
399 }
400 
401 
402 /// SetFunctionDefinitionAttributes - Set attributes for a global.
403 ///
404 /// FIXME: This is currently only done for aliases and functions, but not for
405 /// variables (these details are set in EmitGlobalVarDefinition for variables).
406 void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
407                                                     llvm::GlobalValue *GV) {
408   SetCommonAttributes(D, GV);
409 }
410 
411 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
412                                               const CGFunctionInfo &Info,
413                                               llvm::Function *F) {
414   unsigned CallingConv;
415   AttributeListType AttributeList;
416   ConstructAttributeList(Info, D, AttributeList, CallingConv);
417   F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
418                                           AttributeList.size()));
419   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
420 }
421 
422 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
423                                                            llvm::Function *F) {
424   if (!Features.Exceptions && !Features.ObjCNonFragileABI)
425     F->addFnAttr(llvm::Attribute::NoUnwind);
426 
427   if (D->hasAttr<AlwaysInlineAttr>())
428     F->addFnAttr(llvm::Attribute::AlwaysInline);
429 
430   if (D->hasAttr<NakedAttr>())
431     F->addFnAttr(llvm::Attribute::Naked);
432 
433   if (D->hasAttr<NoInlineAttr>())
434     F->addFnAttr(llvm::Attribute::NoInline);
435 
436   if (Features.getStackProtectorMode() == LangOptions::SSPOn)
437     F->addFnAttr(llvm::Attribute::StackProtect);
438   else if (Features.getStackProtectorMode() == LangOptions::SSPReq)
439     F->addFnAttr(llvm::Attribute::StackProtectReq);
440 
441   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
442   if (alignment)
443     F->setAlignment(alignment);
444 
445   // C++ ABI requires 2-byte alignment for member functions.
446   if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
447     F->setAlignment(2);
448 }
449 
450 void CodeGenModule::SetCommonAttributes(const Decl *D,
451                                         llvm::GlobalValue *GV) {
452   if (isa<NamedDecl>(D))
453     setGlobalVisibility(GV, cast<NamedDecl>(D), /*ForDef*/ true);
454   else
455     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
456 
457   if (D->hasAttr<UsedAttr>())
458     AddUsedGlobal(GV);
459 
460   if (const SectionAttr *SA = D->getAttr<SectionAttr>())
461     GV->setSection(SA->getName());
462 
463   getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
464 }
465 
466 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
467                                                   llvm::Function *F,
468                                                   const CGFunctionInfo &FI) {
469   SetLLVMFunctionAttributes(D, FI, F);
470   SetLLVMFunctionAttributesForDefinition(D, F);
471 
472   F->setLinkage(llvm::Function::InternalLinkage);
473 
474   SetCommonAttributes(D, F);
475 }
476 
477 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
478                                           llvm::Function *F,
479                                           bool IsIncompleteFunction) {
480   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
481 
482   if (!IsIncompleteFunction)
483     SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F);
484 
485   // Only a few attributes are set on declarations; these may later be
486   // overridden by a definition.
487 
488   if (FD->hasAttr<DLLImportAttr>()) {
489     F->setLinkage(llvm::Function::DLLImportLinkage);
490   } else if (FD->hasAttr<WeakAttr>() ||
491              FD->hasAttr<WeakImportAttr>()) {
492     // "extern_weak" is overloaded in LLVM; we probably should have
493     // separate linkage types for this.
494     F->setLinkage(llvm::Function::ExternalWeakLinkage);
495   } else {
496     F->setLinkage(llvm::Function::ExternalLinkage);
497 
498     NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility();
499     if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) {
500       F->setVisibility(GetLLVMVisibility(LV.visibility()));
501     }
502   }
503 
504   if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
505     F->setSection(SA->getName());
506 }
507 
508 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
509   assert(!GV->isDeclaration() &&
510          "Only globals with definition can force usage.");
511   LLVMUsed.push_back(GV);
512 }
513 
514 void CodeGenModule::EmitLLVMUsed() {
515   // Don't create llvm.used if there is no need.
516   if (LLVMUsed.empty())
517     return;
518 
519   const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
520 
521   // Convert LLVMUsed to what ConstantArray needs.
522   std::vector<llvm::Constant*> UsedArray;
523   UsedArray.resize(LLVMUsed.size());
524   for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
525     UsedArray[i] =
526      llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
527                                       i8PTy);
528   }
529 
530   if (UsedArray.empty())
531     return;
532   llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size());
533 
534   llvm::GlobalVariable *GV =
535     new llvm::GlobalVariable(getModule(), ATy, false,
536                              llvm::GlobalValue::AppendingLinkage,
537                              llvm::ConstantArray::get(ATy, UsedArray),
538                              "llvm.used");
539 
540   GV->setSection("llvm.metadata");
541 }
542 
543 void CodeGenModule::EmitDeferred() {
544   // Emit code for any potentially referenced deferred decls.  Since a
545   // previously unused static decl may become used during the generation of code
546   // for a static function, iterate until no  changes are made.
547 
548   while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
549     if (!DeferredVTables.empty()) {
550       const CXXRecordDecl *RD = DeferredVTables.back();
551       DeferredVTables.pop_back();
552       getVTables().GenerateClassData(getVTableLinkage(RD), RD);
553       continue;
554     }
555 
556     GlobalDecl D = DeferredDeclsToEmit.back();
557     DeferredDeclsToEmit.pop_back();
558 
559     // Check to see if we've already emitted this.  This is necessary
560     // for a couple of reasons: first, decls can end up in the
561     // deferred-decls queue multiple times, and second, decls can end
562     // up with definitions in unusual ways (e.g. by an extern inline
563     // function acquiring a strong function redefinition).  Just
564     // ignore these cases.
565     //
566     // TODO: That said, looking this up multiple times is very wasteful.
567     llvm::StringRef Name = getMangledName(D);
568     llvm::GlobalValue *CGRef = GetGlobalValue(Name);
569     assert(CGRef && "Deferred decl wasn't referenced?");
570 
571     if (!CGRef->isDeclaration())
572       continue;
573 
574     // GlobalAlias::isDeclaration() defers to the aliasee, but for our
575     // purposes an alias counts as a definition.
576     if (isa<llvm::GlobalAlias>(CGRef))
577       continue;
578 
579     // Otherwise, emit the definition and move on to the next one.
580     EmitGlobalDefinition(D);
581   }
582 }
583 
584 /// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
585 /// annotation information for a given GlobalValue.  The annotation struct is
586 /// {i8 *, i8 *, i8 *, i32}.  The first field is a constant expression, the
587 /// GlobalValue being annotated.  The second field is the constant string
588 /// created from the AnnotateAttr's annotation.  The third field is a constant
589 /// string containing the name of the translation unit.  The fourth field is
590 /// the line number in the file of the annotated value declaration.
591 ///
592 /// FIXME: this does not unique the annotation string constants, as llvm-gcc
593 ///        appears to.
594 ///
595 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
596                                                 const AnnotateAttr *AA,
597                                                 unsigned LineNo) {
598   llvm::Module *M = &getModule();
599 
600   // get [N x i8] constants for the annotation string, and the filename string
601   // which are the 2nd and 3rd elements of the global annotation structure.
602   const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext);
603   llvm::Constant *anno = llvm::ConstantArray::get(VMContext,
604                                                   AA->getAnnotation(), true);
605   llvm::Constant *unit = llvm::ConstantArray::get(VMContext,
606                                                   M->getModuleIdentifier(),
607                                                   true);
608 
609   // Get the two global values corresponding to the ConstantArrays we just
610   // created to hold the bytes of the strings.
611   llvm::GlobalValue *annoGV =
612     new llvm::GlobalVariable(*M, anno->getType(), false,
613                              llvm::GlobalValue::PrivateLinkage, anno,
614                              GV->getName());
615   // translation unit name string, emitted into the llvm.metadata section.
616   llvm::GlobalValue *unitGV =
617     new llvm::GlobalVariable(*M, unit->getType(), false,
618                              llvm::GlobalValue::PrivateLinkage, unit,
619                              ".str");
620 
621   // Create the ConstantStruct for the global annotation.
622   llvm::Constant *Fields[4] = {
623     llvm::ConstantExpr::getBitCast(GV, SBP),
624     llvm::ConstantExpr::getBitCast(annoGV, SBP),
625     llvm::ConstantExpr::getBitCast(unitGV, SBP),
626     llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo)
627   };
628   return llvm::ConstantStruct::get(VMContext, Fields, 4, false);
629 }
630 
631 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
632   // Never defer when EmitAllDecls is specified.
633   if (Features.EmitAllDecls)
634     return false;
635 
636   return !getContext().DeclMustBeEmitted(Global);
637 }
638 
639 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
640   const AliasAttr *AA = VD->getAttr<AliasAttr>();
641   assert(AA && "No alias?");
642 
643   const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
644 
645   // See if there is already something with the target's name in the module.
646   llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
647 
648   llvm::Constant *Aliasee;
649   if (isa<llvm::FunctionType>(DeclTy))
650     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl());
651   else
652     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
653                                     llvm::PointerType::getUnqual(DeclTy), 0);
654   if (!Entry) {
655     llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
656     F->setLinkage(llvm::Function::ExternalWeakLinkage);
657     WeakRefReferences.insert(F);
658   }
659 
660   return Aliasee;
661 }
662 
663 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
664   const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
665 
666   // Weak references don't produce any output by themselves.
667   if (Global->hasAttr<WeakRefAttr>())
668     return;
669 
670   // If this is an alias definition (which otherwise looks like a declaration)
671   // emit it now.
672   if (Global->hasAttr<AliasAttr>())
673     return EmitAliasDefinition(GD);
674 
675   // Ignore declarations, they will be emitted on their first use.
676   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
677     if (FD->getIdentifier()) {
678       llvm::StringRef Name = FD->getName();
679       if (Name == "_Block_object_assign") {
680         BlockObjectAssignDecl = FD;
681       } else if (Name == "_Block_object_dispose") {
682         BlockObjectDisposeDecl = FD;
683       }
684     }
685 
686     // Forward declarations are emitted lazily on first use.
687     if (!FD->isThisDeclarationADefinition())
688       return;
689   } else {
690     const VarDecl *VD = cast<VarDecl>(Global);
691     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
692 
693     if (VD->getIdentifier()) {
694       llvm::StringRef Name = VD->getName();
695       if (Name == "_NSConcreteGlobalBlock") {
696         NSConcreteGlobalBlockDecl = VD;
697       } else if (Name == "_NSConcreteStackBlock") {
698         NSConcreteStackBlockDecl = VD;
699       }
700     }
701 
702 
703     if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
704       return;
705   }
706 
707   // Defer code generation when possible if this is a static definition, inline
708   // function etc.  These we only want to emit if they are used.
709   if (!MayDeferGeneration(Global)) {
710     // Emit the definition if it can't be deferred.
711     EmitGlobalDefinition(GD);
712     return;
713   }
714 
715   // If we're deferring emission of a C++ variable with an
716   // initializer, remember the order in which it appeared in the file.
717   if (getLangOptions().CPlusPlus && isa<VarDecl>(Global) &&
718       cast<VarDecl>(Global)->hasInit()) {
719     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
720     CXXGlobalInits.push_back(0);
721   }
722 
723   // If the value has already been used, add it directly to the
724   // DeferredDeclsToEmit list.
725   llvm::StringRef MangledName = getMangledName(GD);
726   if (GetGlobalValue(MangledName))
727     DeferredDeclsToEmit.push_back(GD);
728   else {
729     // Otherwise, remember that we saw a deferred decl with this name.  The
730     // first use of the mangled name will cause it to move into
731     // DeferredDeclsToEmit.
732     DeferredDecls[MangledName] = GD;
733   }
734 }
735 
736 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
737   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
738 
739   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
740                                  Context.getSourceManager(),
741                                  "Generating code for declaration");
742 
743   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
744     // At -O0, don't generate IR for functions with available_externally
745     // linkage.
746     if (CodeGenOpts.OptimizationLevel == 0 &&
747         !Function->hasAttr<AlwaysInlineAttr>() &&
748         getFunctionLinkage(Function)
749                                   == llvm::Function::AvailableExternallyLinkage)
750       return;
751 
752     if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
753       if (Method->isVirtual())
754         getVTables().EmitThunks(GD);
755 
756       if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
757         return EmitCXXConstructor(CD, GD.getCtorType());
758 
759       if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Method))
760         return EmitCXXDestructor(DD, GD.getDtorType());
761     }
762 
763     return EmitGlobalFunctionDefinition(GD);
764   }
765 
766   if (const VarDecl *VD = dyn_cast<VarDecl>(D))
767     return EmitGlobalVarDefinition(VD);
768 
769   assert(0 && "Invalid argument to EmitGlobalDefinition()");
770 }
771 
772 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
773 /// module, create and return an llvm Function with the specified type. If there
774 /// is something in the module with the specified name, return it potentially
775 /// bitcasted to the right type.
776 ///
777 /// If D is non-null, it specifies a decl that correspond to this.  This is used
778 /// to set the attributes on the function when it is first created.
779 llvm::Constant *
780 CodeGenModule::GetOrCreateLLVMFunction(llvm::StringRef MangledName,
781                                        const llvm::Type *Ty,
782                                        GlobalDecl D) {
783   // Lookup the entry, lazily creating it if necessary.
784   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
785   if (Entry) {
786     if (WeakRefReferences.count(Entry)) {
787       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
788       if (FD && !FD->hasAttr<WeakAttr>())
789         Entry->setLinkage(llvm::Function::ExternalLinkage);
790 
791       WeakRefReferences.erase(Entry);
792     }
793 
794     if (Entry->getType()->getElementType() == Ty)
795       return Entry;
796 
797     // Make sure the result is of the correct type.
798     const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
799     return llvm::ConstantExpr::getBitCast(Entry, PTy);
800   }
801 
802   // This function doesn't have a complete type (for example, the return
803   // type is an incomplete struct). Use a fake type instead, and make
804   // sure not to try to set attributes.
805   bool IsIncompleteFunction = false;
806 
807   const llvm::FunctionType *FTy;
808   if (isa<llvm::FunctionType>(Ty)) {
809     FTy = cast<llvm::FunctionType>(Ty);
810   } else {
811     FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
812                                   std::vector<const llvm::Type*>(), false);
813     IsIncompleteFunction = true;
814   }
815 
816   llvm::Function *F = llvm::Function::Create(FTy,
817                                              llvm::Function::ExternalLinkage,
818                                              MangledName, &getModule());
819   assert(F->getName() == MangledName && "name was uniqued!");
820   if (D.getDecl())
821     SetFunctionAttributes(D, F, IsIncompleteFunction);
822 
823   // This is the first use or definition of a mangled name.  If there is a
824   // deferred decl with this name, remember that we need to emit it at the end
825   // of the file.
826   llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
827   if (DDI != DeferredDecls.end()) {
828     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
829     // list, and remove it from DeferredDecls (since we don't need it anymore).
830     DeferredDeclsToEmit.push_back(DDI->second);
831     DeferredDecls.erase(DDI);
832   } else if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl())) {
833     // If this the first reference to a C++ inline function in a class, queue up
834     // the deferred function body for emission.  These are not seen as
835     // top-level declarations.
836     if (FD->isThisDeclarationADefinition() && MayDeferGeneration(FD)) {
837       DeferredDeclsToEmit.push_back(D);
838     // A called constructor which has no definition or declaration need be
839     // synthesized.
840     } else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
841       if (CD->isImplicit()) {
842         assert(CD->isUsed() && "Sema doesn't consider constructor as used.");
843         DeferredDeclsToEmit.push_back(D);
844       }
845     } else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD)) {
846       if (DD->isImplicit()) {
847         assert(DD->isUsed() && "Sema doesn't consider destructor as used.");
848         DeferredDeclsToEmit.push_back(D);
849       }
850     } else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
851       if (MD->isImplicit() && MD->isCopyAssignmentOperator()) {
852         assert(MD->isUsed() && "Sema doesn't consider CopyAssignment as used.");
853         DeferredDeclsToEmit.push_back(D);
854       }
855     }
856   }
857 
858   // Make sure the result is of the requested type.
859   if (!IsIncompleteFunction) {
860     assert(F->getType()->getElementType() == Ty);
861     return F;
862   }
863 
864   const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
865   return llvm::ConstantExpr::getBitCast(F, PTy);
866 }
867 
868 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
869 /// non-null, then this function will use the specified type if it has to
870 /// create it (this occurs when we see a definition of the function).
871 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
872                                                  const llvm::Type *Ty) {
873   // If there was no specific requested type, just convert it now.
874   if (!Ty)
875     Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
876 
877   llvm::StringRef MangledName = getMangledName(GD);
878   return GetOrCreateLLVMFunction(MangledName, Ty, GD);
879 }
880 
881 /// CreateRuntimeFunction - Create a new runtime function with the specified
882 /// type and name.
883 llvm::Constant *
884 CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
885                                      llvm::StringRef Name) {
886   return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl());
887 }
888 
889 static bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D) {
890   if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType())
891     return false;
892   if (Context.getLangOptions().CPlusPlus &&
893       Context.getBaseElementType(D->getType())->getAs<RecordType>()) {
894     // FIXME: We should do something fancier here!
895     return false;
896   }
897   return true;
898 }
899 
900 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
901 /// create and return an llvm GlobalVariable with the specified type.  If there
902 /// is something in the module with the specified name, return it potentially
903 /// bitcasted to the right type.
904 ///
905 /// If D is non-null, it specifies a decl that correspond to this.  This is used
906 /// to set the attributes on the global when it is first created.
907 llvm::Constant *
908 CodeGenModule::GetOrCreateLLVMGlobal(llvm::StringRef MangledName,
909                                      const llvm::PointerType *Ty,
910                                      const VarDecl *D) {
911   // Lookup the entry, lazily creating it if necessary.
912   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
913   if (Entry) {
914     if (WeakRefReferences.count(Entry)) {
915       if (D && !D->hasAttr<WeakAttr>())
916         Entry->setLinkage(llvm::Function::ExternalLinkage);
917 
918       WeakRefReferences.erase(Entry);
919     }
920 
921     if (Entry->getType() == Ty)
922       return Entry;
923 
924     // Make sure the result is of the correct type.
925     return llvm::ConstantExpr::getBitCast(Entry, Ty);
926   }
927 
928   // This is the first use or definition of a mangled name.  If there is a
929   // deferred decl with this name, remember that we need to emit it at the end
930   // of the file.
931   llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
932   if (DDI != DeferredDecls.end()) {
933     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
934     // list, and remove it from DeferredDecls (since we don't need it anymore).
935     DeferredDeclsToEmit.push_back(DDI->second);
936     DeferredDecls.erase(DDI);
937   }
938 
939   llvm::GlobalVariable *GV =
940     new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
941                              llvm::GlobalValue::ExternalLinkage,
942                              0, MangledName, 0,
943                              false, Ty->getAddressSpace());
944 
945   // Handle things which are present even on external declarations.
946   if (D) {
947     // FIXME: This code is overly simple and should be merged with other global
948     // handling.
949     GV->setConstant(DeclIsConstantGlobal(Context, D));
950 
951     // Set linkage and visibility in case we never see a definition.
952     NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
953     if (LV.linkage() != ExternalLinkage) {
954       GV->setLinkage(llvm::GlobalValue::InternalLinkage);
955     } else {
956       if (D->hasAttr<DLLImportAttr>())
957         GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
958       else if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakImportAttr>())
959         GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
960 
961       // Set visibility on a declaration only if it's explicit.
962       if (LV.visibilityExplicit())
963         GV->setVisibility(GetLLVMVisibility(LV.visibility()));
964     }
965 
966     GV->setThreadLocal(D->isThreadSpecified());
967   }
968 
969   return GV;
970 }
971 
972 
973 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
974 /// given global variable.  If Ty is non-null and if the global doesn't exist,
975 /// then it will be greated with the specified type instead of whatever the
976 /// normal requested type would be.
977 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
978                                                   const llvm::Type *Ty) {
979   assert(D->hasGlobalStorage() && "Not a global variable");
980   QualType ASTTy = D->getType();
981   if (Ty == 0)
982     Ty = getTypes().ConvertTypeForMem(ASTTy);
983 
984   const llvm::PointerType *PTy =
985     llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
986 
987   llvm::StringRef MangledName = getMangledName(D);
988   return GetOrCreateLLVMGlobal(MangledName, PTy, D);
989 }
990 
991 /// CreateRuntimeVariable - Create a new runtime global variable with the
992 /// specified type and name.
993 llvm::Constant *
994 CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty,
995                                      llvm::StringRef Name) {
996   return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0);
997 }
998 
999 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1000   assert(!D->getInit() && "Cannot emit definite definitions here!");
1001 
1002   if (MayDeferGeneration(D)) {
1003     // If we have not seen a reference to this variable yet, place it
1004     // into the deferred declarations table to be emitted if needed
1005     // later.
1006     llvm::StringRef MangledName = getMangledName(D);
1007     if (!GetGlobalValue(MangledName)) {
1008       DeferredDecls[MangledName] = D;
1009       return;
1010     }
1011   }
1012 
1013   // The tentative definition is the only definition.
1014   EmitGlobalVarDefinition(D);
1015 }
1016 
1017 void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1018   if (DefinitionRequired)
1019     getVTables().GenerateClassData(getVTableLinkage(Class), Class);
1020 }
1021 
1022 llvm::GlobalVariable::LinkageTypes
1023 CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
1024   if (RD->isInAnonymousNamespace() || !RD->hasLinkage())
1025     return llvm::GlobalVariable::InternalLinkage;
1026 
1027   if (const CXXMethodDecl *KeyFunction
1028                                     = RD->getASTContext().getKeyFunction(RD)) {
1029     // If this class has a key function, use that to determine the linkage of
1030     // the vtable.
1031     const FunctionDecl *Def = 0;
1032     if (KeyFunction->hasBody(Def))
1033       KeyFunction = cast<CXXMethodDecl>(Def);
1034 
1035     switch (KeyFunction->getTemplateSpecializationKind()) {
1036       case TSK_Undeclared:
1037       case TSK_ExplicitSpecialization:
1038         if (KeyFunction->isInlined())
1039           return llvm::GlobalVariable::WeakODRLinkage;
1040 
1041         return llvm::GlobalVariable::ExternalLinkage;
1042 
1043       case TSK_ImplicitInstantiation:
1044       case TSK_ExplicitInstantiationDefinition:
1045         return llvm::GlobalVariable::WeakODRLinkage;
1046 
1047       case TSK_ExplicitInstantiationDeclaration:
1048         // FIXME: Use available_externally linkage. However, this currently
1049         // breaks LLVM's build due to undefined symbols.
1050         //      return llvm::GlobalVariable::AvailableExternallyLinkage;
1051         return llvm::GlobalVariable::WeakODRLinkage;
1052     }
1053   }
1054 
1055   switch (RD->getTemplateSpecializationKind()) {
1056   case TSK_Undeclared:
1057   case TSK_ExplicitSpecialization:
1058   case TSK_ImplicitInstantiation:
1059   case TSK_ExplicitInstantiationDefinition:
1060     return llvm::GlobalVariable::WeakODRLinkage;
1061 
1062   case TSK_ExplicitInstantiationDeclaration:
1063     // FIXME: Use available_externally linkage. However, this currently
1064     // breaks LLVM's build due to undefined symbols.
1065     //   return llvm::GlobalVariable::AvailableExternallyLinkage;
1066     return llvm::GlobalVariable::WeakODRLinkage;
1067   }
1068 
1069   // Silence GCC warning.
1070   return llvm::GlobalVariable::WeakODRLinkage;
1071 }
1072 
1073 CharUnits CodeGenModule::GetTargetTypeStoreSize(const llvm::Type *Ty) const {
1074     return CharUnits::fromQuantity(
1075       TheTargetData.getTypeStoreSizeInBits(Ty) / Context.getCharWidth());
1076 }
1077 
1078 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1079   llvm::Constant *Init = 0;
1080   QualType ASTTy = D->getType();
1081   bool NonConstInit = false;
1082 
1083   const Expr *InitExpr = D->getAnyInitializer();
1084 
1085   if (!InitExpr) {
1086     // This is a tentative definition; tentative definitions are
1087     // implicitly initialized with { 0 }.
1088     //
1089     // Note that tentative definitions are only emitted at the end of
1090     // a translation unit, so they should never have incomplete
1091     // type. In addition, EmitTentativeDefinition makes sure that we
1092     // never attempt to emit a tentative definition if a real one
1093     // exists. A use may still exists, however, so we still may need
1094     // to do a RAUW.
1095     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
1096     Init = EmitNullConstant(D->getType());
1097   } else {
1098     Init = EmitConstantExpr(InitExpr, D->getType());
1099     if (!Init) {
1100       QualType T = InitExpr->getType();
1101       if (D->getType()->isReferenceType())
1102         T = D->getType();
1103 
1104       if (getLangOptions().CPlusPlus) {
1105         Init = EmitNullConstant(T);
1106         NonConstInit = true;
1107       } else {
1108         ErrorUnsupported(D, "static initializer");
1109         Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1110       }
1111     } else {
1112       // We don't need an initializer, so remove the entry for the delayed
1113       // initializer position (just in case this entry was delayed).
1114       if (getLangOptions().CPlusPlus)
1115         DelayedCXXInitPosition.erase(D);
1116     }
1117   }
1118 
1119   const llvm::Type* InitType = Init->getType();
1120   llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
1121 
1122   // Strip off a bitcast if we got one back.
1123   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1124     assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1125            // all zero index gep.
1126            CE->getOpcode() == llvm::Instruction::GetElementPtr);
1127     Entry = CE->getOperand(0);
1128   }
1129 
1130   // Entry is now either a Function or GlobalVariable.
1131   llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
1132 
1133   // We have a definition after a declaration with the wrong type.
1134   // We must make a new GlobalVariable* and update everything that used OldGV
1135   // (a declaration or tentative definition) with the new GlobalVariable*
1136   // (which will be a definition).
1137   //
1138   // This happens if there is a prototype for a global (e.g.
1139   // "extern int x[];") and then a definition of a different type (e.g.
1140   // "int x[10];"). This also happens when an initializer has a different type
1141   // from the type of the global (this happens with unions).
1142   if (GV == 0 ||
1143       GV->getType()->getElementType() != InitType ||
1144       GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) {
1145 
1146     // Move the old entry aside so that we'll create a new one.
1147     Entry->setName(llvm::StringRef());
1148 
1149     // Make a new global with the correct type, this is now guaranteed to work.
1150     GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
1151 
1152     // Replace all uses of the old global with the new global
1153     llvm::Constant *NewPtrForOldDecl =
1154         llvm::ConstantExpr::getBitCast(GV, Entry->getType());
1155     Entry->replaceAllUsesWith(NewPtrForOldDecl);
1156 
1157     // Erase the old global, since it is no longer used.
1158     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
1159   }
1160 
1161   if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
1162     SourceManager &SM = Context.getSourceManager();
1163     AddAnnotation(EmitAnnotateAttr(GV, AA,
1164                               SM.getInstantiationLineNumber(D->getLocation())));
1165   }
1166 
1167   GV->setInitializer(Init);
1168 
1169   // If it is safe to mark the global 'constant', do so now.
1170   GV->setConstant(false);
1171   if (!NonConstInit && DeclIsConstantGlobal(Context, D))
1172     GV->setConstant(true);
1173 
1174   GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
1175 
1176   // Set the llvm linkage type as appropriate.
1177   llvm::GlobalValue::LinkageTypes Linkage =
1178     GetLLVMLinkageVarDefinition(D, GV);
1179   GV->setLinkage(Linkage);
1180   if (Linkage == llvm::GlobalVariable::CommonLinkage)
1181     // common vars aren't constant even if declared const.
1182     GV->setConstant(false);
1183 
1184   SetCommonAttributes(D, GV);
1185 
1186   // Emit the initializer function if necessary.
1187   if (NonConstInit)
1188     EmitCXXGlobalVarDeclInitFunc(D, GV);
1189 
1190   // Emit global variable debug information.
1191   if (CGDebugInfo *DI = getDebugInfo()) {
1192     DI->setLocation(D->getLocation());
1193     DI->EmitGlobalVariable(GV, D);
1194   }
1195 }
1196 
1197 llvm::GlobalValue::LinkageTypes
1198 CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1199                                            llvm::GlobalVariable *GV) {
1200   GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1201   if (Linkage == GVA_Internal)
1202     return llvm::Function::InternalLinkage;
1203   else if (D->hasAttr<DLLImportAttr>())
1204     return llvm::Function::DLLImportLinkage;
1205   else if (D->hasAttr<DLLExportAttr>())
1206     return llvm::Function::DLLExportLinkage;
1207   else if (D->hasAttr<WeakAttr>()) {
1208     if (GV->isConstant())
1209       return llvm::GlobalVariable::WeakODRLinkage;
1210     else
1211       return llvm::GlobalVariable::WeakAnyLinkage;
1212   } else if (Linkage == GVA_TemplateInstantiation ||
1213              Linkage == GVA_ExplicitTemplateInstantiation)
1214     // FIXME: It seems like we can provide more specific linkage here
1215     // (LinkOnceODR, WeakODR).
1216     return llvm::GlobalVariable::WeakAnyLinkage;
1217   else if (!getLangOptions().CPlusPlus && !CodeGenOpts.NoCommon &&
1218            !D->hasExternalStorage() && !D->getInit() &&
1219            !D->getAttr<SectionAttr>() && !D->isThreadSpecified()) {
1220     // Thread local vars aren't considered common linkage.
1221     return llvm::GlobalVariable::CommonLinkage;
1222   }
1223   return llvm::GlobalVariable::ExternalLinkage;
1224 }
1225 
1226 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1227 /// implement a function with no prototype, e.g. "int foo() {}".  If there are
1228 /// existing call uses of the old function in the module, this adjusts them to
1229 /// call the new function directly.
1230 ///
1231 /// This is not just a cleanup: the always_inline pass requires direct calls to
1232 /// functions to be able to inline them.  If there is a bitcast in the way, it
1233 /// won't inline them.  Instcombine normally deletes these calls, but it isn't
1234 /// run at -O0.
1235 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1236                                                       llvm::Function *NewFn) {
1237   // If we're redefining a global as a function, don't transform it.
1238   llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1239   if (OldFn == 0) return;
1240 
1241   const llvm::Type *NewRetTy = NewFn->getReturnType();
1242   llvm::SmallVector<llvm::Value*, 4> ArgList;
1243 
1244   for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
1245        UI != E; ) {
1246     // TODO: Do invokes ever occur in C code?  If so, we should handle them too.
1247     llvm::Value::use_iterator I = UI++; // Increment before the CI is erased.
1248     llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I);
1249     if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I)
1250     llvm::CallSite CS(CI);
1251     if (!CI || !CS.isCallee(I)) continue;
1252 
1253     // If the return types don't match exactly, and if the call isn't dead, then
1254     // we can't transform this call.
1255     if (CI->getType() != NewRetTy && !CI->use_empty())
1256       continue;
1257 
1258     // If the function was passed too few arguments, don't transform.  If extra
1259     // arguments were passed, we silently drop them.  If any of the types
1260     // mismatch, we don't transform.
1261     unsigned ArgNo = 0;
1262     bool DontTransform = false;
1263     for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1264          E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
1265       if (CS.arg_size() == ArgNo ||
1266           CS.getArgument(ArgNo)->getType() != AI->getType()) {
1267         DontTransform = true;
1268         break;
1269       }
1270     }
1271     if (DontTransform)
1272       continue;
1273 
1274     // Okay, we can transform this.  Create the new call instruction and copy
1275     // over the required information.
1276     ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo);
1277     llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(),
1278                                                      ArgList.end(), "", CI);
1279     ArgList.clear();
1280     if (!NewCall->getType()->isVoidTy())
1281       NewCall->takeName(CI);
1282     NewCall->setAttributes(CI->getAttributes());
1283     NewCall->setCallingConv(CI->getCallingConv());
1284 
1285     // Finally, remove the old call, replacing any uses with the new one.
1286     if (!CI->use_empty())
1287       CI->replaceAllUsesWith(NewCall);
1288 
1289     // Copy debug location attached to CI.
1290     if (!CI->getDebugLoc().isUnknown())
1291       NewCall->setDebugLoc(CI->getDebugLoc());
1292     CI->eraseFromParent();
1293   }
1294 }
1295 
1296 
1297 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
1298   const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
1299   const llvm::FunctionType *Ty = getTypes().GetFunctionType(GD);
1300   getCXXABI().getMangleContext().mangleInitDiscriminator();
1301   // Get or create the prototype for the function.
1302   llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
1303 
1304   // Strip off a bitcast if we got one back.
1305   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1306     assert(CE->getOpcode() == llvm::Instruction::BitCast);
1307     Entry = CE->getOperand(0);
1308   }
1309 
1310 
1311   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
1312     llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
1313 
1314     // If the types mismatch then we have to rewrite the definition.
1315     assert(OldFn->isDeclaration() &&
1316            "Shouldn't replace non-declaration");
1317 
1318     // F is the Function* for the one with the wrong type, we must make a new
1319     // Function* and update everything that used F (a declaration) with the new
1320     // Function* (which will be a definition).
1321     //
1322     // This happens if there is a prototype for a function
1323     // (e.g. "int f()") and then a definition of a different type
1324     // (e.g. "int f(int x)").  Move the old function aside so that it
1325     // doesn't interfere with GetAddrOfFunction.
1326     OldFn->setName(llvm::StringRef());
1327     llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
1328 
1329     // If this is an implementation of a function without a prototype, try to
1330     // replace any existing uses of the function (which may be calls) with uses
1331     // of the new function
1332     if (D->getType()->isFunctionNoProtoType()) {
1333       ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
1334       OldFn->removeDeadConstantUsers();
1335     }
1336 
1337     // Replace uses of F with the Function we will endow with a body.
1338     if (!Entry->use_empty()) {
1339       llvm::Constant *NewPtrForOldDecl =
1340         llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
1341       Entry->replaceAllUsesWith(NewPtrForOldDecl);
1342     }
1343 
1344     // Ok, delete the old function now, which is dead.
1345     OldFn->eraseFromParent();
1346 
1347     Entry = NewFn;
1348   }
1349 
1350   // We need to set linkage and visibility on the function before
1351   // generating code for it because various parts of IR generation
1352   // want to propagate this information down (e.g. to local static
1353   // declarations).
1354   llvm::Function *Fn = cast<llvm::Function>(Entry);
1355   setFunctionLinkage(D, Fn);
1356 
1357   // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
1358   setGlobalVisibility(Fn, D, /*ForDef*/ true);
1359 
1360   CodeGenFunction(*this).GenerateCode(D, Fn);
1361 
1362   SetFunctionDefinitionAttributes(D, Fn);
1363   SetLLVMFunctionAttributesForDefinition(D, Fn);
1364 
1365   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
1366     AddGlobalCtor(Fn, CA->getPriority());
1367   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
1368     AddGlobalDtor(Fn, DA->getPriority());
1369 }
1370 
1371 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
1372   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
1373   const AliasAttr *AA = D->getAttr<AliasAttr>();
1374   assert(AA && "Not an alias?");
1375 
1376   llvm::StringRef MangledName = getMangledName(GD);
1377 
1378   // If there is a definition in the module, then it wins over the alias.
1379   // This is dubious, but allow it to be safe.  Just ignore the alias.
1380   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1381   if (Entry && !Entry->isDeclaration())
1382     return;
1383 
1384   const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
1385 
1386   // Create a reference to the named value.  This ensures that it is emitted
1387   // if a deferred decl.
1388   llvm::Constant *Aliasee;
1389   if (isa<llvm::FunctionType>(DeclTy))
1390     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl());
1391   else
1392     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1393                                     llvm::PointerType::getUnqual(DeclTy), 0);
1394 
1395   // Create the new alias itself, but don't set a name yet.
1396   llvm::GlobalValue *GA =
1397     new llvm::GlobalAlias(Aliasee->getType(),
1398                           llvm::Function::ExternalLinkage,
1399                           "", Aliasee, &getModule());
1400 
1401   if (Entry) {
1402     assert(Entry->isDeclaration());
1403 
1404     // If there is a declaration in the module, then we had an extern followed
1405     // by the alias, as in:
1406     //   extern int test6();
1407     //   ...
1408     //   int test6() __attribute__((alias("test7")));
1409     //
1410     // Remove it and replace uses of it with the alias.
1411     GA->takeName(Entry);
1412 
1413     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
1414                                                           Entry->getType()));
1415     Entry->eraseFromParent();
1416   } else {
1417     GA->setName(MangledName);
1418   }
1419 
1420   // Set attributes which are particular to an alias; this is a
1421   // specialization of the attributes which may be set on a global
1422   // variable/function.
1423   if (D->hasAttr<DLLExportAttr>()) {
1424     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1425       // The dllexport attribute is ignored for undefined symbols.
1426       if (FD->hasBody())
1427         GA->setLinkage(llvm::Function::DLLExportLinkage);
1428     } else {
1429       GA->setLinkage(llvm::Function::DLLExportLinkage);
1430     }
1431   } else if (D->hasAttr<WeakAttr>() ||
1432              D->hasAttr<WeakRefAttr>() ||
1433              D->hasAttr<WeakImportAttr>()) {
1434     GA->setLinkage(llvm::Function::WeakAnyLinkage);
1435   }
1436 
1437   SetCommonAttributes(D, GA);
1438 }
1439 
1440 /// getBuiltinLibFunction - Given a builtin id for a function like
1441 /// "__builtin_fabsf", return a Function* for "fabsf".
1442 llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
1443                                                   unsigned BuiltinID) {
1444   assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
1445           Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
1446          "isn't a lib fn");
1447 
1448   // Get the name, skip over the __builtin_ prefix (if necessary).
1449   const char *Name = Context.BuiltinInfo.GetName(BuiltinID);
1450   if (Context.BuiltinInfo.isLibFunction(BuiltinID))
1451     Name += 10;
1452 
1453   const llvm::FunctionType *Ty =
1454     cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
1455 
1456   return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD));
1457 }
1458 
1459 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
1460                                             unsigned NumTys) {
1461   return llvm::Intrinsic::getDeclaration(&getModule(),
1462                                          (llvm::Intrinsic::ID)IID, Tys, NumTys);
1463 }
1464 
1465 
1466 llvm::Function *CodeGenModule::getMemCpyFn(const llvm::Type *DestType,
1467                                            const llvm::Type *SrcType,
1468                                            const llvm::Type *SizeType) {
1469   const llvm::Type *ArgTypes[3] = {DestType, SrcType, SizeType };
1470   return getIntrinsic(llvm::Intrinsic::memcpy, ArgTypes, 3);
1471 }
1472 
1473 llvm::Function *CodeGenModule::getMemMoveFn(const llvm::Type *DestType,
1474                                             const llvm::Type *SrcType,
1475                                             const llvm::Type *SizeType) {
1476   const llvm::Type *ArgTypes[3] = {DestType, SrcType, SizeType };
1477   return getIntrinsic(llvm::Intrinsic::memmove, ArgTypes, 3);
1478 }
1479 
1480 llvm::Function *CodeGenModule::getMemSetFn(const llvm::Type *DestType,
1481                                            const llvm::Type *SizeType) {
1482   const llvm::Type *ArgTypes[2] = { DestType, SizeType };
1483   return getIntrinsic(llvm::Intrinsic::memset, ArgTypes, 2);
1484 }
1485 
1486 static llvm::StringMapEntry<llvm::Constant*> &
1487 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
1488                          const StringLiteral *Literal,
1489                          bool TargetIsLSB,
1490                          bool &IsUTF16,
1491                          unsigned &StringLength) {
1492   llvm::StringRef String = Literal->getString();
1493   unsigned NumBytes = String.size();
1494 
1495   // Check for simple case.
1496   if (!Literal->containsNonAsciiOrNull()) {
1497     StringLength = NumBytes;
1498     return Map.GetOrCreateValue(String);
1499   }
1500 
1501   // Otherwise, convert the UTF8 literals into a byte string.
1502   llvm::SmallVector<UTF16, 128> ToBuf(NumBytes);
1503   const UTF8 *FromPtr = (UTF8 *)String.data();
1504   UTF16 *ToPtr = &ToBuf[0];
1505 
1506   (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
1507                            &ToPtr, ToPtr + NumBytes,
1508                            strictConversion);
1509 
1510   // ConvertUTF8toUTF16 returns the length in ToPtr.
1511   StringLength = ToPtr - &ToBuf[0];
1512 
1513   // Render the UTF-16 string into a byte array and convert to the target byte
1514   // order.
1515   //
1516   // FIXME: This isn't something we should need to do here.
1517   llvm::SmallString<128> AsBytes;
1518   AsBytes.reserve(StringLength * 2);
1519   for (unsigned i = 0; i != StringLength; ++i) {
1520     unsigned short Val = ToBuf[i];
1521     if (TargetIsLSB) {
1522       AsBytes.push_back(Val & 0xFF);
1523       AsBytes.push_back(Val >> 8);
1524     } else {
1525       AsBytes.push_back(Val >> 8);
1526       AsBytes.push_back(Val & 0xFF);
1527     }
1528   }
1529   // Append one extra null character, the second is automatically added by our
1530   // caller.
1531   AsBytes.push_back(0);
1532 
1533   IsUTF16 = true;
1534   return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size()));
1535 }
1536 
1537 llvm::Constant *
1538 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
1539   unsigned StringLength = 0;
1540   bool isUTF16 = false;
1541   llvm::StringMapEntry<llvm::Constant*> &Entry =
1542     GetConstantCFStringEntry(CFConstantStringMap, Literal,
1543                              getTargetData().isLittleEndian(),
1544                              isUTF16, StringLength);
1545 
1546   if (llvm::Constant *C = Entry.getValue())
1547     return C;
1548 
1549   llvm::Constant *Zero =
1550       llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
1551   llvm::Constant *Zeros[] = { Zero, Zero };
1552 
1553   // If we don't already have it, get __CFConstantStringClassReference.
1554   if (!CFConstantStringClassRef) {
1555     const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
1556     Ty = llvm::ArrayType::get(Ty, 0);
1557     llvm::Constant *GV = CreateRuntimeVariable(Ty,
1558                                            "__CFConstantStringClassReference");
1559     // Decay array -> ptr
1560     CFConstantStringClassRef =
1561       llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1562   }
1563 
1564   QualType CFTy = getContext().getCFConstantStringType();
1565 
1566   const llvm::StructType *STy =
1567     cast<llvm::StructType>(getTypes().ConvertType(CFTy));
1568 
1569   std::vector<llvm::Constant*> Fields(4);
1570 
1571   // Class pointer.
1572   Fields[0] = CFConstantStringClassRef;
1573 
1574   // Flags.
1575   const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
1576   Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
1577     llvm::ConstantInt::get(Ty, 0x07C8);
1578 
1579   // String pointer.
1580   llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1581 
1582   llvm::GlobalValue::LinkageTypes Linkage;
1583   bool isConstant;
1584   if (isUTF16) {
1585     // FIXME: why do utf strings get "_" labels instead of "L" labels?
1586     Linkage = llvm::GlobalValue::InternalLinkage;
1587     // Note: -fwritable-strings doesn't make unicode CFStrings writable, but
1588     // does make plain ascii ones writable.
1589     isConstant = true;
1590   } else {
1591     Linkage = llvm::GlobalValue::PrivateLinkage;
1592     isConstant = !Features.WritableStrings;
1593   }
1594 
1595   llvm::GlobalVariable *GV =
1596     new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1597                              ".str");
1598   if (isUTF16) {
1599     CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1600     GV->setAlignment(Align.getQuantity());
1601   }
1602   Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1603 
1604   // String length.
1605   Ty = getTypes().ConvertType(getContext().LongTy);
1606   Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
1607 
1608   // The struct.
1609   C = llvm::ConstantStruct::get(STy, Fields);
1610   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1611                                 llvm::GlobalVariable::PrivateLinkage, C,
1612                                 "_unnamed_cfstring_");
1613   if (const char *Sect = getContext().Target.getCFStringSection())
1614     GV->setSection(Sect);
1615   Entry.setValue(GV);
1616 
1617   return GV;
1618 }
1619 
1620 llvm::Constant *
1621 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
1622   unsigned StringLength = 0;
1623   bool isUTF16 = false;
1624   llvm::StringMapEntry<llvm::Constant*> &Entry =
1625     GetConstantCFStringEntry(CFConstantStringMap, Literal,
1626                              getTargetData().isLittleEndian(),
1627                              isUTF16, StringLength);
1628 
1629   if (llvm::Constant *C = Entry.getValue())
1630     return C;
1631 
1632   llvm::Constant *Zero =
1633   llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
1634   llvm::Constant *Zeros[] = { Zero, Zero };
1635 
1636   // If we don't already have it, get _NSConstantStringClassReference.
1637   if (!ConstantStringClassRef) {
1638     std::string StringClass(getLangOptions().ObjCConstantStringClass);
1639     const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
1640     Ty = llvm::ArrayType::get(Ty, 0);
1641     llvm::Constant *GV;
1642     if (StringClass.empty())
1643       GV = CreateRuntimeVariable(Ty,
1644                                  Features.ObjCNonFragileABI ?
1645                                  "OBJC_CLASS_$_NSConstantString" :
1646                                  "_NSConstantStringClassReference");
1647     else {
1648       std::string str;
1649       if (Features.ObjCNonFragileABI)
1650         str = "OBJC_CLASS_$_" + StringClass;
1651       else
1652         str = "_" + StringClass + "ClassReference";
1653       GV = CreateRuntimeVariable(Ty, str);
1654     }
1655     // Decay array -> ptr
1656     ConstantStringClassRef =
1657     llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1658   }
1659 
1660   QualType NSTy = getContext().getNSConstantStringType();
1661 
1662   const llvm::StructType *STy =
1663   cast<llvm::StructType>(getTypes().ConvertType(NSTy));
1664 
1665   std::vector<llvm::Constant*> Fields(3);
1666 
1667   // Class pointer.
1668   Fields[0] = ConstantStringClassRef;
1669 
1670   // String pointer.
1671   llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1672 
1673   llvm::GlobalValue::LinkageTypes Linkage;
1674   bool isConstant;
1675   if (isUTF16) {
1676     // FIXME: why do utf strings get "_" labels instead of "L" labels?
1677     Linkage = llvm::GlobalValue::InternalLinkage;
1678     // Note: -fwritable-strings doesn't make unicode NSStrings writable, but
1679     // does make plain ascii ones writable.
1680     isConstant = true;
1681   } else {
1682     Linkage = llvm::GlobalValue::PrivateLinkage;
1683     isConstant = !Features.WritableStrings;
1684   }
1685 
1686   llvm::GlobalVariable *GV =
1687   new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1688                            ".str");
1689   if (isUTF16) {
1690     CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1691     GV->setAlignment(Align.getQuantity());
1692   }
1693   Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1694 
1695   // String length.
1696   const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
1697   Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
1698 
1699   // The struct.
1700   C = llvm::ConstantStruct::get(STy, Fields);
1701   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1702                                 llvm::GlobalVariable::PrivateLinkage, C,
1703                                 "_unnamed_nsstring_");
1704   // FIXME. Fix section.
1705   if (const char *Sect =
1706         Features.ObjCNonFragileABI
1707           ? getContext().Target.getNSStringNonFragileABISection()
1708           : getContext().Target.getNSStringSection())
1709     GV->setSection(Sect);
1710   Entry.setValue(GV);
1711 
1712   return GV;
1713 }
1714 
1715 /// GetStringForStringLiteral - Return the appropriate bytes for a
1716 /// string literal, properly padded to match the literal type.
1717 std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
1718   const ConstantArrayType *CAT =
1719     getContext().getAsConstantArrayType(E->getType());
1720   assert(CAT && "String isn't pointer or array!");
1721 
1722   // Resize the string to the right size.
1723   uint64_t RealLen = CAT->getSize().getZExtValue();
1724 
1725   if (E->isWide())
1726     RealLen *= getContext().Target.getWCharWidth()/8;
1727 
1728   std::string Str = E->getString().str();
1729   Str.resize(RealLen, '\0');
1730 
1731   return Str;
1732 }
1733 
1734 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
1735 /// constant array for the given string literal.
1736 llvm::Constant *
1737 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
1738   // FIXME: This can be more efficient.
1739   // FIXME: We shouldn't need to bitcast the constant in the wide string case.
1740   llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S));
1741   if (S->isWide()) {
1742     llvm::Type *DestTy =
1743         llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType()));
1744     C = llvm::ConstantExpr::getBitCast(C, DestTy);
1745   }
1746   return C;
1747 }
1748 
1749 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
1750 /// array for the given ObjCEncodeExpr node.
1751 llvm::Constant *
1752 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
1753   std::string Str;
1754   getContext().getObjCEncodingForType(E->getEncodedType(), Str);
1755 
1756   return GetAddrOfConstantCString(Str);
1757 }
1758 
1759 
1760 /// GenerateWritableString -- Creates storage for a string literal.
1761 static llvm::Constant *GenerateStringLiteral(const std::string &str,
1762                                              bool constant,
1763                                              CodeGenModule &CGM,
1764                                              const char *GlobalName) {
1765   // Create Constant for this string literal. Don't add a '\0'.
1766   llvm::Constant *C =
1767       llvm::ConstantArray::get(CGM.getLLVMContext(), str, false);
1768 
1769   // Create a global variable for this string
1770   return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
1771                                   llvm::GlobalValue::PrivateLinkage,
1772                                   C, GlobalName);
1773 }
1774 
1775 /// GetAddrOfConstantString - Returns a pointer to a character array
1776 /// containing the literal. This contents are exactly that of the
1777 /// given string, i.e. it will not be null terminated automatically;
1778 /// see GetAddrOfConstantCString. Note that whether the result is
1779 /// actually a pointer to an LLVM constant depends on
1780 /// Feature.WriteableStrings.
1781 ///
1782 /// The result has pointer to array type.
1783 llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str,
1784                                                        const char *GlobalName) {
1785   bool IsConstant = !Features.WritableStrings;
1786 
1787   // Get the default prefix if a name wasn't specified.
1788   if (!GlobalName)
1789     GlobalName = ".str";
1790 
1791   // Don't share any string literals if strings aren't constant.
1792   if (!IsConstant)
1793     return GenerateStringLiteral(str, false, *this, GlobalName);
1794 
1795   llvm::StringMapEntry<llvm::Constant *> &Entry =
1796     ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
1797 
1798   if (Entry.getValue())
1799     return Entry.getValue();
1800 
1801   // Create a global variable for this.
1802   llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName);
1803   Entry.setValue(C);
1804   return C;
1805 }
1806 
1807 /// GetAddrOfConstantCString - Returns a pointer to a character
1808 /// array containing the literal and a terminating '\-'
1809 /// character. The result has pointer to array type.
1810 llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str,
1811                                                         const char *GlobalName){
1812   return GetAddrOfConstantString(str + '\0', GlobalName);
1813 }
1814 
1815 /// EmitObjCPropertyImplementations - Emit information for synthesized
1816 /// properties for an implementation.
1817 void CodeGenModule::EmitObjCPropertyImplementations(const
1818                                                     ObjCImplementationDecl *D) {
1819   for (ObjCImplementationDecl::propimpl_iterator
1820          i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
1821     ObjCPropertyImplDecl *PID = *i;
1822 
1823     // Dynamic is just for type-checking.
1824     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
1825       ObjCPropertyDecl *PD = PID->getPropertyDecl();
1826 
1827       // Determine which methods need to be implemented, some may have
1828       // been overridden. Note that ::isSynthesized is not the method
1829       // we want, that just indicates if the decl came from a
1830       // property. What we want to know is if the method is defined in
1831       // this implementation.
1832       if (!D->getInstanceMethod(PD->getGetterName()))
1833         CodeGenFunction(*this).GenerateObjCGetter(
1834                                  const_cast<ObjCImplementationDecl *>(D), PID);
1835       if (!PD->isReadOnly() &&
1836           !D->getInstanceMethod(PD->getSetterName()))
1837         CodeGenFunction(*this).GenerateObjCSetter(
1838                                  const_cast<ObjCImplementationDecl *>(D), PID);
1839     }
1840   }
1841 }
1842 
1843 /// EmitObjCIvarInitializations - Emit information for ivar initialization
1844 /// for an implementation.
1845 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
1846   if (!Features.NeXTRuntime || D->getNumIvarInitializers() == 0)
1847     return;
1848   DeclContext* DC = const_cast<DeclContext*>(dyn_cast<DeclContext>(D));
1849   assert(DC && "EmitObjCIvarInitializations - null DeclContext");
1850   IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
1851   Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
1852   ObjCMethodDecl *DTORMethod = ObjCMethodDecl::Create(getContext(),
1853                                                   D->getLocation(),
1854                                                   D->getLocation(), cxxSelector,
1855                                                   getContext().VoidTy, 0,
1856                                                   DC, true, false, true, false,
1857                                                   ObjCMethodDecl::Required);
1858   D->addInstanceMethod(DTORMethod);
1859   CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
1860 
1861   II = &getContext().Idents.get(".cxx_construct");
1862   cxxSelector = getContext().Selectors.getSelector(0, &II);
1863   // The constructor returns 'self'.
1864   ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
1865                                                 D->getLocation(),
1866                                                 D->getLocation(), cxxSelector,
1867                                                 getContext().getObjCIdType(), 0,
1868                                                 DC, true, false, true, false,
1869                                                 ObjCMethodDecl::Required);
1870   D->addInstanceMethod(CTORMethod);
1871   CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
1872 
1873 
1874 }
1875 
1876 /// EmitNamespace - Emit all declarations in a namespace.
1877 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
1878   for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
1879        I != E; ++I)
1880     EmitTopLevelDecl(*I);
1881 }
1882 
1883 // EmitLinkageSpec - Emit all declarations in a linkage spec.
1884 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
1885   if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
1886       LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
1887     ErrorUnsupported(LSD, "linkage spec");
1888     return;
1889   }
1890 
1891   for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
1892        I != E; ++I)
1893     EmitTopLevelDecl(*I);
1894 }
1895 
1896 /// EmitTopLevelDecl - Emit code for a single top level declaration.
1897 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
1898   // If an error has occurred, stop code generation, but continue
1899   // parsing and semantic analysis (to ensure all warnings and errors
1900   // are emitted).
1901   if (Diags.hasErrorOccurred())
1902     return;
1903 
1904   // Ignore dependent declarations.
1905   if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
1906     return;
1907 
1908   switch (D->getKind()) {
1909   case Decl::CXXConversion:
1910   case Decl::CXXMethod:
1911   case Decl::Function:
1912     // Skip function templates
1913     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
1914       return;
1915 
1916     EmitGlobal(cast<FunctionDecl>(D));
1917     break;
1918 
1919   case Decl::Var:
1920     EmitGlobal(cast<VarDecl>(D));
1921     break;
1922 
1923   // C++ Decls
1924   case Decl::Namespace:
1925     EmitNamespace(cast<NamespaceDecl>(D));
1926     break;
1927     // No code generation needed.
1928   case Decl::UsingShadow:
1929   case Decl::Using:
1930   case Decl::UsingDirective:
1931   case Decl::ClassTemplate:
1932   case Decl::FunctionTemplate:
1933   case Decl::NamespaceAlias:
1934     break;
1935   case Decl::CXXConstructor:
1936     // Skip function templates
1937     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
1938       return;
1939 
1940     EmitCXXConstructors(cast<CXXConstructorDecl>(D));
1941     break;
1942   case Decl::CXXDestructor:
1943     EmitCXXDestructors(cast<CXXDestructorDecl>(D));
1944     break;
1945 
1946   case Decl::StaticAssert:
1947     // Nothing to do.
1948     break;
1949 
1950   // Objective-C Decls
1951 
1952   // Forward declarations, no (immediate) code generation.
1953   case Decl::ObjCClass:
1954   case Decl::ObjCForwardProtocol:
1955   case Decl::ObjCInterface:
1956     break;
1957 
1958     case Decl::ObjCCategory: {
1959       ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D);
1960       if (CD->IsClassExtension() && CD->hasSynthBitfield())
1961         Context.ResetObjCLayout(CD->getClassInterface());
1962       break;
1963     }
1964 
1965 
1966   case Decl::ObjCProtocol:
1967     Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
1968     break;
1969 
1970   case Decl::ObjCCategoryImpl:
1971     // Categories have properties but don't support synthesize so we
1972     // can ignore them here.
1973     Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
1974     break;
1975 
1976   case Decl::ObjCImplementation: {
1977     ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
1978     if (Features.ObjCNonFragileABI2 && OMD->hasSynthBitfield())
1979       Context.ResetObjCLayout(OMD->getClassInterface());
1980     EmitObjCPropertyImplementations(OMD);
1981     EmitObjCIvarInitializations(OMD);
1982     Runtime->GenerateClass(OMD);
1983     break;
1984   }
1985   case Decl::ObjCMethod: {
1986     ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
1987     // If this is not a prototype, emit the body.
1988     if (OMD->getBody())
1989       CodeGenFunction(*this).GenerateObjCMethod(OMD);
1990     break;
1991   }
1992   case Decl::ObjCCompatibleAlias:
1993     // compatibility-alias is a directive and has no code gen.
1994     break;
1995 
1996   case Decl::LinkageSpec:
1997     EmitLinkageSpec(cast<LinkageSpecDecl>(D));
1998     break;
1999 
2000   case Decl::FileScopeAsm: {
2001     FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
2002     llvm::StringRef AsmString = AD->getAsmString()->getString();
2003 
2004     const std::string &S = getModule().getModuleInlineAsm();
2005     if (S.empty())
2006       getModule().setModuleInlineAsm(AsmString);
2007     else
2008       getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
2009     break;
2010   }
2011 
2012   default:
2013     // Make sure we handled everything we should, every other kind is a
2014     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
2015     // function. Need to recode Decl::Kind to do that easily.
2016     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2017   }
2018 }
2019 
2020 /// Turns the given pointer into a constant.
2021 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2022                                           const void *Ptr) {
2023   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
2024   const llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
2025   return llvm::ConstantInt::get(i64, PtrInt);
2026 }
2027 
2028 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2029                                    llvm::NamedMDNode *&GlobalMetadata,
2030                                    GlobalDecl D,
2031                                    llvm::GlobalValue *Addr) {
2032   if (!GlobalMetadata)
2033     GlobalMetadata =
2034       CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2035 
2036   // TODO: should we report variant information for ctors/dtors?
2037   llvm::Value *Ops[] = {
2038     Addr,
2039     GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2040   };
2041   GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops, 2));
2042 }
2043 
2044 /// Emits metadata nodes associating all the global values in the
2045 /// current module with the Decls they came from.  This is useful for
2046 /// projects using IR gen as a subroutine.
2047 ///
2048 /// Since there's currently no way to associate an MDNode directly
2049 /// with an llvm::GlobalValue, we create a global named metadata
2050 /// with the name 'clang.global.decl.ptrs'.
2051 void CodeGenModule::EmitDeclMetadata() {
2052   llvm::NamedMDNode *GlobalMetadata = 0;
2053 
2054   // StaticLocalDeclMap
2055   for (llvm::DenseMap<GlobalDecl,llvm::StringRef>::iterator
2056          I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2057        I != E; ++I) {
2058     llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2059     EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2060   }
2061 }
2062 
2063 /// Emits metadata nodes for all the local variables in the current
2064 /// function.
2065 void CodeGenFunction::EmitDeclMetadata() {
2066   if (LocalDeclMap.empty()) return;
2067 
2068   llvm::LLVMContext &Context = getLLVMContext();
2069 
2070   // Find the unique metadata ID for this name.
2071   unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2072 
2073   llvm::NamedMDNode *GlobalMetadata = 0;
2074 
2075   for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2076          I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2077     const Decl *D = I->first;
2078     llvm::Value *Addr = I->second;
2079 
2080     if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2081       llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
2082       Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, &DAddr, 1));
2083     } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2084       GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2085       EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2086     }
2087   }
2088 }
2089 
2090 ///@name Custom Runtime Function Interfaces
2091 ///@{
2092 //
2093 // FIXME: These can be eliminated once we can have clients just get the required
2094 // AST nodes from the builtin tables.
2095 
2096 llvm::Constant *CodeGenModule::getBlockObjectDispose() {
2097   if (BlockObjectDispose)
2098     return BlockObjectDispose;
2099 
2100   // If we saw an explicit decl, use that.
2101   if (BlockObjectDisposeDecl) {
2102     return BlockObjectDispose = GetAddrOfFunction(
2103       BlockObjectDisposeDecl,
2104       getTypes().GetFunctionType(BlockObjectDisposeDecl));
2105   }
2106 
2107   // Otherwise construct the function by hand.
2108   const llvm::FunctionType *FTy;
2109   std::vector<const llvm::Type*> ArgTys;
2110   const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
2111   ArgTys.push_back(PtrToInt8Ty);
2112   ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
2113   FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
2114   return BlockObjectDispose =
2115     CreateRuntimeFunction(FTy, "_Block_object_dispose");
2116 }
2117 
2118 llvm::Constant *CodeGenModule::getBlockObjectAssign() {
2119   if (BlockObjectAssign)
2120     return BlockObjectAssign;
2121 
2122   // If we saw an explicit decl, use that.
2123   if (BlockObjectAssignDecl) {
2124     return BlockObjectAssign = GetAddrOfFunction(
2125       BlockObjectAssignDecl,
2126       getTypes().GetFunctionType(BlockObjectAssignDecl));
2127   }
2128 
2129   // Otherwise construct the function by hand.
2130   const llvm::FunctionType *FTy;
2131   std::vector<const llvm::Type*> ArgTys;
2132   const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
2133   ArgTys.push_back(PtrToInt8Ty);
2134   ArgTys.push_back(PtrToInt8Ty);
2135   ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
2136   FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
2137   return BlockObjectAssign =
2138     CreateRuntimeFunction(FTy, "_Block_object_assign");
2139 }
2140 
2141 llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() {
2142   if (NSConcreteGlobalBlock)
2143     return NSConcreteGlobalBlock;
2144 
2145   // If we saw an explicit decl, use that.
2146   if (NSConcreteGlobalBlockDecl) {
2147     return NSConcreteGlobalBlock = GetAddrOfGlobalVar(
2148       NSConcreteGlobalBlockDecl,
2149       getTypes().ConvertType(NSConcreteGlobalBlockDecl->getType()));
2150   }
2151 
2152   // Otherwise construct the variable by hand.
2153   return NSConcreteGlobalBlock = CreateRuntimeVariable(
2154     PtrToInt8Ty, "_NSConcreteGlobalBlock");
2155 }
2156 
2157 llvm::Constant *CodeGenModule::getNSConcreteStackBlock() {
2158   if (NSConcreteStackBlock)
2159     return NSConcreteStackBlock;
2160 
2161   // If we saw an explicit decl, use that.
2162   if (NSConcreteStackBlockDecl) {
2163     return NSConcreteStackBlock = GetAddrOfGlobalVar(
2164       NSConcreteStackBlockDecl,
2165       getTypes().ConvertType(NSConcreteStackBlockDecl->getType()));
2166   }
2167 
2168   // Otherwise construct the variable by hand.
2169   return NSConcreteStackBlock = CreateRuntimeVariable(
2170     PtrToInt8Ty, "_NSConcreteStackBlock");
2171 }
2172 
2173 ///@}
2174