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