xref: /llvm-project/clang/lib/CodeGen/CodeGenModule.cpp (revision d4324148d70f064842c74fedf3cda2234eda915e)
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 "CGCall.h"
18 #include "CGObjCRuntime.h"
19 #include "Mangle.h"
20 #include "TargetInfo.h"
21 #include "clang/CodeGen/CodeGenOptions.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/CharUnits.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/DeclCXX.h"
26 #include "clang/AST/RecordLayout.h"
27 #include "clang/Basic/Builtins.h"
28 #include "clang/Basic/Diagnostic.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/TargetInfo.h"
31 #include "clang/Basic/ConvertUTF.h"
32 #include "llvm/CallingConv.h"
33 #include "llvm/Module.h"
34 #include "llvm/Intrinsics.h"
35 #include "llvm/LLVMContext.h"
36 #include "llvm/Target/TargetData.h"
37 #include "llvm/Support/ErrorHandling.h"
38 using namespace clang;
39 using namespace CodeGen;
40 
41 
42 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
43                              llvm::Module &M, const llvm::TargetData &TD,
44                              Diagnostic &diags)
45   : BlockModule(C, M, TD, Types, *this), Context(C),
46     Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M),
47     TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags),
48     Types(C, M, TD, getTargetCodeGenInfo().getABIInfo()),
49     MangleCtx(C), VtableInfo(*this), Runtime(0),
50     MemCpyFn(0), MemMoveFn(0), MemSetFn(0), CFConstantStringClassRef(0),
51     VMContext(M.getContext()) {
52 
53   if (!Features.ObjC1)
54     Runtime = 0;
55   else if (!Features.NeXTRuntime)
56     Runtime = CreateGNUObjCRuntime(*this);
57   else if (Features.ObjCNonFragileABI)
58     Runtime = CreateMacNonFragileABIObjCRuntime(*this);
59   else
60     Runtime = CreateMacObjCRuntime(*this);
61 
62   // If debug info generation is enabled, create the CGDebugInfo object.
63   DebugInfo = CodeGenOpts.DebugInfo ? new CGDebugInfo(*this) : 0;
64 }
65 
66 CodeGenModule::~CodeGenModule() {
67   delete Runtime;
68   delete DebugInfo;
69 }
70 
71 void CodeGenModule::createObjCRuntime() {
72   if (!Features.NeXTRuntime)
73     Runtime = CreateGNUObjCRuntime(*this);
74   else if (Features.ObjCNonFragileABI)
75     Runtime = CreateMacNonFragileABIObjCRuntime(*this);
76   else
77     Runtime = CreateMacObjCRuntime(*this);
78 }
79 
80 void CodeGenModule::Release() {
81   EmitDeferred();
82   EmitCXXGlobalInitFunc();
83   if (Runtime)
84     if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
85       AddGlobalCtor(ObjCInitFunction);
86   EmitCtorList(GlobalCtors, "llvm.global_ctors");
87   EmitCtorList(GlobalDtors, "llvm.global_dtors");
88   EmitAnnotations();
89   EmitLLVMUsed();
90 }
91 
92 /// ErrorUnsupported - Print out an error that codegen doesn't support the
93 /// specified stmt yet.
94 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
95                                      bool OmitOnError) {
96   if (OmitOnError && getDiags().hasErrorOccurred())
97     return;
98   unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
99                                                "cannot compile this %0 yet");
100   std::string Msg = Type;
101   getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
102     << Msg << S->getSourceRange();
103 }
104 
105 /// ErrorUnsupported - Print out an error that codegen doesn't support the
106 /// specified decl yet.
107 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
108                                      bool OmitOnError) {
109   if (OmitOnError && getDiags().hasErrorOccurred())
110     return;
111   unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
112                                                "cannot compile this %0 yet");
113   std::string Msg = Type;
114   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
115 }
116 
117 LangOptions::VisibilityMode
118 CodeGenModule::getDeclVisibilityMode(const Decl *D) const {
119   if (const VarDecl *VD = dyn_cast<VarDecl>(D))
120     if (VD->getStorageClass() == VarDecl::PrivateExtern)
121       return LangOptions::Hidden;
122 
123   if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) {
124     switch (attr->getVisibility()) {
125     default: assert(0 && "Unknown visibility!");
126     case VisibilityAttr::DefaultVisibility:
127       return LangOptions::Default;
128     case VisibilityAttr::HiddenVisibility:
129       return LangOptions::Hidden;
130     case VisibilityAttr::ProtectedVisibility:
131       return LangOptions::Protected;
132     }
133   }
134 
135   // This decl should have the same visibility as its parent.
136   if (const DeclContext *DC = D->getDeclContext())
137     return getDeclVisibilityMode(cast<Decl>(DC));
138 
139   return getLangOptions().getVisibilityMode();
140 }
141 
142 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
143                                         const Decl *D) const {
144   // Internal definitions always have default visibility.
145   if (GV->hasLocalLinkage()) {
146     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
147     return;
148   }
149 
150   switch (getDeclVisibilityMode(D)) {
151   default: assert(0 && "Unknown visibility!");
152   case LangOptions::Default:
153     return GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
154   case LangOptions::Hidden:
155     return GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
156   case LangOptions::Protected:
157     return GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
158   }
159 }
160 
161 const char *CodeGenModule::getMangledName(const GlobalDecl &GD) {
162   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
163 
164   if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
165     return getMangledCXXCtorName(D, GD.getCtorType());
166   if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
167     return getMangledCXXDtorName(D, GD.getDtorType());
168 
169   return getMangledName(ND);
170 }
171 
172 /// \brief Retrieves the mangled name for the given declaration.
173 ///
174 /// If the given declaration requires a mangled name, returns an
175 /// const char* containing the mangled name.  Otherwise, returns
176 /// the unmangled name.
177 ///
178 const char *CodeGenModule::getMangledName(const NamedDecl *ND) {
179   if (!getMangleContext().shouldMangleDeclName(ND)) {
180     assert(ND->getIdentifier() && "Attempt to mangle unnamed decl.");
181     return ND->getNameAsCString();
182   }
183 
184   llvm::SmallString<256> Name;
185   getMangleContext().mangleName(ND, Name);
186   Name += '\0';
187   return UniqueMangledName(Name.begin(), Name.end());
188 }
189 
190 const char *CodeGenModule::UniqueMangledName(const char *NameStart,
191                                              const char *NameEnd) {
192   assert(*(NameEnd - 1) == '\0' && "Mangled name must be null terminated!");
193 
194   return MangledNames.GetOrCreateValue(NameStart, NameEnd).getKeyData();
195 }
196 
197 /// AddGlobalCtor - Add a function to the list that will be called before
198 /// main() runs.
199 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
200   // FIXME: Type coercion of void()* types.
201   GlobalCtors.push_back(std::make_pair(Ctor, Priority));
202 }
203 
204 /// AddGlobalDtor - Add a function to the list that will be called
205 /// when the module is unloaded.
206 void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
207   // FIXME: Type coercion of void()* types.
208   GlobalDtors.push_back(std::make_pair(Dtor, Priority));
209 }
210 
211 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
212   // Ctor function type is void()*.
213   llvm::FunctionType* CtorFTy =
214     llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
215                             std::vector<const llvm::Type*>(),
216                             false);
217   llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
218 
219   // Get the type of a ctor entry, { i32, void ()* }.
220   llvm::StructType* CtorStructTy =
221     llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext),
222                           llvm::PointerType::getUnqual(CtorFTy), NULL);
223 
224   // Construct the constructor and destructor arrays.
225   std::vector<llvm::Constant*> Ctors;
226   for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
227     std::vector<llvm::Constant*> S;
228     S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
229                 I->second, false));
230     S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
231     Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
232   }
233 
234   if (!Ctors.empty()) {
235     llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
236     new llvm::GlobalVariable(TheModule, AT, false,
237                              llvm::GlobalValue::AppendingLinkage,
238                              llvm::ConstantArray::get(AT, Ctors),
239                              GlobalName);
240   }
241 }
242 
243 void CodeGenModule::EmitAnnotations() {
244   if (Annotations.empty())
245     return;
246 
247   // Create a new global variable for the ConstantStruct in the Module.
248   llvm::Constant *Array =
249   llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
250                                                 Annotations.size()),
251                            Annotations);
252   llvm::GlobalValue *gv =
253   new llvm::GlobalVariable(TheModule, Array->getType(), false,
254                            llvm::GlobalValue::AppendingLinkage, Array,
255                            "llvm.global.annotations");
256   gv->setSection("llvm.metadata");
257 }
258 
259 static CodeGenModule::GVALinkage
260 GetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD,
261                       const LangOptions &Features) {
262   CodeGenModule::GVALinkage External = CodeGenModule::GVA_StrongExternal;
263 
264   Linkage L = FD->getLinkage();
265   if (L == ExternalLinkage && Context.getLangOptions().CPlusPlus &&
266       FD->getType()->getLinkage() == UniqueExternalLinkage)
267     L = UniqueExternalLinkage;
268 
269   switch (L) {
270   case NoLinkage:
271   case InternalLinkage:
272   case UniqueExternalLinkage:
273     return CodeGenModule::GVA_Internal;
274 
275   case ExternalLinkage:
276     switch (FD->getTemplateSpecializationKind()) {
277     case TSK_Undeclared:
278     case TSK_ExplicitSpecialization:
279       External = CodeGenModule::GVA_StrongExternal;
280       break;
281 
282     case TSK_ExplicitInstantiationDefinition:
283       // FIXME: explicit instantiation definitions should use weak linkage
284       return CodeGenModule::GVA_StrongExternal;
285 
286     case TSK_ExplicitInstantiationDeclaration:
287     case TSK_ImplicitInstantiation:
288       External = CodeGenModule::GVA_TemplateInstantiation;
289       break;
290     }
291   }
292 
293   if (!FD->isInlined())
294     return External;
295 
296   if (!Features.CPlusPlus || FD->hasAttr<GNUInlineAttr>()) {
297     // GNU or C99 inline semantics. Determine whether this symbol should be
298     // externally visible.
299     if (FD->isInlineDefinitionExternallyVisible())
300       return External;
301 
302     // C99 inline semantics, where the symbol is not externally visible.
303     return CodeGenModule::GVA_C99Inline;
304   }
305 
306   // C++0x [temp.explicit]p9:
307   //   [ Note: The intent is that an inline function that is the subject of
308   //   an explicit instantiation declaration will still be implicitly
309   //   instantiated when used so that the body can be considered for
310   //   inlining, but that no out-of-line copy of the inline function would be
311   //   generated in the translation unit. -- end note ]
312   if (FD->getTemplateSpecializationKind()
313                                        == TSK_ExplicitInstantiationDeclaration)
314     return CodeGenModule::GVA_C99Inline;
315 
316   return CodeGenModule::GVA_CXXInline;
317 }
318 
319 llvm::GlobalValue::LinkageTypes
320 CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
321   GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features);
322 
323   if (Linkage == GVA_Internal) {
324     return llvm::Function::InternalLinkage;
325   } else if (D->hasAttr<DLLExportAttr>()) {
326     return llvm::Function::DLLExportLinkage;
327   } else if (D->hasAttr<WeakAttr>()) {
328     return llvm::Function::WeakAnyLinkage;
329   } else if (Linkage == GVA_C99Inline) {
330     // In C99 mode, 'inline' functions are guaranteed to have a strong
331     // definition somewhere else, so we can use available_externally linkage.
332     return llvm::Function::AvailableExternallyLinkage;
333   } else if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) {
334     // In C++, the compiler has to emit a definition in every translation unit
335     // that references the function.  We should use linkonce_odr because
336     // a) if all references in this translation unit are optimized away, we
337     // don't need to codegen it.  b) if the function persists, it needs to be
338     // merged with other definitions. c) C++ has the ODR, so we know the
339     // definition is dependable.
340     return llvm::Function::LinkOnceODRLinkage;
341   } else {
342     assert(Linkage == GVA_StrongExternal);
343     // Otherwise, we have strong external linkage.
344     return llvm::Function::ExternalLinkage;
345   }
346 }
347 
348 
349 /// SetFunctionDefinitionAttributes - Set attributes for a global.
350 ///
351 /// FIXME: This is currently only done for aliases and functions, but not for
352 /// variables (these details are set in EmitGlobalVarDefinition for variables).
353 void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
354                                                     llvm::GlobalValue *GV) {
355   GV->setLinkage(getFunctionLinkage(D));
356   SetCommonAttributes(D, GV);
357 }
358 
359 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
360                                               const CGFunctionInfo &Info,
361                                               llvm::Function *F) {
362   unsigned CallingConv;
363   AttributeListType AttributeList;
364   ConstructAttributeList(Info, D, AttributeList, CallingConv);
365   F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
366                                           AttributeList.size()));
367   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
368 }
369 
370 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
371                                                            llvm::Function *F) {
372   if (!Features.Exceptions && !Features.ObjCNonFragileABI)
373     F->addFnAttr(llvm::Attribute::NoUnwind);
374 
375   if (D->hasAttr<AlwaysInlineAttr>())
376     F->addFnAttr(llvm::Attribute::AlwaysInline);
377 
378   if (D->hasAttr<NoInlineAttr>())
379     F->addFnAttr(llvm::Attribute::NoInline);
380 
381   if (Features.getStackProtectorMode() == LangOptions::SSPOn)
382     F->addFnAttr(llvm::Attribute::StackProtect);
383   else if (Features.getStackProtectorMode() == LangOptions::SSPReq)
384     F->addFnAttr(llvm::Attribute::StackProtectReq);
385 
386   if (const AlignedAttr *AA = D->getAttr<AlignedAttr>()) {
387     unsigned width = Context.Target.getCharWidth();
388     F->setAlignment(AA->getAlignment() / width);
389     while ((AA = AA->getNext<AlignedAttr>()))
390       F->setAlignment(std::max(F->getAlignment(), AA->getAlignment() / width));
391   }
392   // C++ ABI requires 2-byte alignment for member functions.
393   if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
394     F->setAlignment(2);
395 }
396 
397 void CodeGenModule::SetCommonAttributes(const Decl *D,
398                                         llvm::GlobalValue *GV) {
399   setGlobalVisibility(GV, D);
400 
401   if (D->hasAttr<UsedAttr>())
402     AddUsedGlobal(GV);
403 
404   if (const SectionAttr *SA = D->getAttr<SectionAttr>())
405     GV->setSection(SA->getName());
406 
407   getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
408 }
409 
410 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
411                                                   llvm::Function *F,
412                                                   const CGFunctionInfo &FI) {
413   SetLLVMFunctionAttributes(D, FI, F);
414   SetLLVMFunctionAttributesForDefinition(D, F);
415 
416   F->setLinkage(llvm::Function::InternalLinkage);
417 
418   SetCommonAttributes(D, F);
419 }
420 
421 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
422                                           llvm::Function *F,
423                                           bool IsIncompleteFunction) {
424   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
425 
426   if (!IsIncompleteFunction)
427     SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F);
428 
429   // Only a few attributes are set on declarations; these may later be
430   // overridden by a definition.
431 
432   if (FD->hasAttr<DLLImportAttr>()) {
433     F->setLinkage(llvm::Function::DLLImportLinkage);
434   } else if (FD->hasAttr<WeakAttr>() ||
435              FD->hasAttr<WeakImportAttr>()) {
436     // "extern_weak" is overloaded in LLVM; we probably should have
437     // separate linkage types for this.
438     F->setLinkage(llvm::Function::ExternalWeakLinkage);
439   } else {
440     F->setLinkage(llvm::Function::ExternalLinkage);
441   }
442 
443   if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
444     F->setSection(SA->getName());
445 }
446 
447 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
448   assert(!GV->isDeclaration() &&
449          "Only globals with definition can force usage.");
450   LLVMUsed.push_back(GV);
451 }
452 
453 void CodeGenModule::EmitLLVMUsed() {
454   // Don't create llvm.used if there is no need.
455   if (LLVMUsed.empty())
456     return;
457 
458   const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
459 
460   // Convert LLVMUsed to what ConstantArray needs.
461   std::vector<llvm::Constant*> UsedArray;
462   UsedArray.resize(LLVMUsed.size());
463   for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
464     UsedArray[i] =
465      llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
466                                       i8PTy);
467   }
468 
469   if (UsedArray.empty())
470     return;
471   llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size());
472 
473   llvm::GlobalVariable *GV =
474     new llvm::GlobalVariable(getModule(), ATy, false,
475                              llvm::GlobalValue::AppendingLinkage,
476                              llvm::ConstantArray::get(ATy, UsedArray),
477                              "llvm.used");
478 
479   GV->setSection("llvm.metadata");
480 }
481 
482 void CodeGenModule::EmitDeferred() {
483   // Emit code for any potentially referenced deferred decls.  Since a
484   // previously unused static decl may become used during the generation of code
485   // for a static function, iterate until no  changes are made.
486   while (!DeferredDeclsToEmit.empty()) {
487     GlobalDecl D = DeferredDeclsToEmit.back();
488     DeferredDeclsToEmit.pop_back();
489 
490     // The mangled name for the decl must have been emitted in GlobalDeclMap.
491     // Look it up to see if it was defined with a stronger definition (e.g. an
492     // extern inline function with a strong function redefinition).  If so,
493     // just ignore the deferred decl.
494     llvm::GlobalValue *CGRef = GlobalDeclMap[getMangledName(D)];
495     assert(CGRef && "Deferred decl wasn't referenced?");
496 
497     if (!CGRef->isDeclaration())
498       continue;
499 
500     // Otherwise, emit the definition and move on to the next one.
501     EmitGlobalDefinition(D);
502   }
503 }
504 
505 /// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
506 /// annotation information for a given GlobalValue.  The annotation struct is
507 /// {i8 *, i8 *, i8 *, i32}.  The first field is a constant expression, the
508 /// GlobalValue being annotated.  The second field is the constant string
509 /// created from the AnnotateAttr's annotation.  The third field is a constant
510 /// string containing the name of the translation unit.  The fourth field is
511 /// the line number in the file of the annotated value declaration.
512 ///
513 /// FIXME: this does not unique the annotation string constants, as llvm-gcc
514 ///        appears to.
515 ///
516 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
517                                                 const AnnotateAttr *AA,
518                                                 unsigned LineNo) {
519   llvm::Module *M = &getModule();
520 
521   // get [N x i8] constants for the annotation string, and the filename string
522   // which are the 2nd and 3rd elements of the global annotation structure.
523   const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext);
524   llvm::Constant *anno = llvm::ConstantArray::get(VMContext,
525                                                   AA->getAnnotation(), true);
526   llvm::Constant *unit = llvm::ConstantArray::get(VMContext,
527                                                   M->getModuleIdentifier(),
528                                                   true);
529 
530   // Get the two global values corresponding to the ConstantArrays we just
531   // created to hold the bytes of the strings.
532   llvm::GlobalValue *annoGV =
533     new llvm::GlobalVariable(*M, anno->getType(), false,
534                              llvm::GlobalValue::PrivateLinkage, anno,
535                              GV->getName());
536   // translation unit name string, emitted into the llvm.metadata section.
537   llvm::GlobalValue *unitGV =
538     new llvm::GlobalVariable(*M, unit->getType(), false,
539                              llvm::GlobalValue::PrivateLinkage, unit,
540                              ".str");
541 
542   // Create the ConstantStruct for the global annotation.
543   llvm::Constant *Fields[4] = {
544     llvm::ConstantExpr::getBitCast(GV, SBP),
545     llvm::ConstantExpr::getBitCast(annoGV, SBP),
546     llvm::ConstantExpr::getBitCast(unitGV, SBP),
547     llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo)
548   };
549   return llvm::ConstantStruct::get(VMContext, Fields, 4, false);
550 }
551 
552 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
553   // Never defer when EmitAllDecls is specified or the decl has
554   // attribute used.
555   if (Features.EmitAllDecls || Global->hasAttr<UsedAttr>())
556     return false;
557 
558   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
559     // Constructors and destructors should never be deferred.
560     if (FD->hasAttr<ConstructorAttr>() ||
561         FD->hasAttr<DestructorAttr>())
562       return false;
563 
564     // The key function for a class must never be deferred.
565     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Global)) {
566       const CXXRecordDecl *RD = MD->getParent();
567       if (MD->isOutOfLine() && RD->isDynamicClass()) {
568         const CXXMethodDecl *KeyFunction = getContext().getKeyFunction(RD);
569         if (KeyFunction &&
570             KeyFunction->getCanonicalDecl() == MD->getCanonicalDecl())
571           return false;
572       }
573     }
574 
575     GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features);
576 
577     // static, static inline, always_inline, and extern inline functions can
578     // always be deferred.  Normal inline functions can be deferred in C99/C++.
579     if (Linkage == GVA_Internal || Linkage == GVA_C99Inline ||
580         Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
581       return true;
582     return false;
583   }
584 
585   const VarDecl *VD = cast<VarDecl>(Global);
586   assert(VD->isFileVarDecl() && "Invalid decl");
587 
588   // We never want to defer structs that have non-trivial constructors or
589   // destructors.
590 
591   // FIXME: Handle references.
592   if (const RecordType *RT = VD->getType()->getAs<RecordType>()) {
593     if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
594       if (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor())
595         return false;
596     }
597   }
598 
599   // Static data may be deferred, but out-of-line static data members
600   // cannot be.
601   Linkage L = VD->getLinkage();
602   if (L == ExternalLinkage && getContext().getLangOptions().CPlusPlus &&
603       VD->getType()->getLinkage() == UniqueExternalLinkage)
604     L = UniqueExternalLinkage;
605 
606   switch (L) {
607   case NoLinkage:
608   case InternalLinkage:
609   case UniqueExternalLinkage:
610     // Initializer has side effects?
611     if (VD->getInit() && VD->getInit()->HasSideEffects(Context))
612       return false;
613     return !(VD->isStaticDataMember() && VD->isOutOfLine());
614 
615   case ExternalLinkage:
616     break;
617   }
618 
619   return false;
620 }
621 
622 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
623   const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
624 
625   // If this is an alias definition (which otherwise looks like a declaration)
626   // emit it now.
627   if (Global->hasAttr<AliasAttr>())
628     return EmitAliasDefinition(Global);
629 
630   // Ignore declarations, they will be emitted on their first use.
631   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
632     // Forward declarations are emitted lazily on first use.
633     if (!FD->isThisDeclarationADefinition())
634       return;
635   } else {
636     const VarDecl *VD = cast<VarDecl>(Global);
637     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
638 
639     if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
640       return;
641   }
642 
643   // Defer code generation when possible if this is a static definition, inline
644   // function etc.  These we only want to emit if they are used.
645   if (MayDeferGeneration(Global)) {
646     // If the value has already been used, add it directly to the
647     // DeferredDeclsToEmit list.
648     const char *MangledName = getMangledName(GD);
649     if (GlobalDeclMap.count(MangledName))
650       DeferredDeclsToEmit.push_back(GD);
651     else {
652       // Otherwise, remember that we saw a deferred decl with this name.  The
653       // first use of the mangled name will cause it to move into
654       // DeferredDeclsToEmit.
655       DeferredDecls[MangledName] = GD;
656     }
657     return;
658   }
659 
660   // Otherwise emit the definition.
661   EmitGlobalDefinition(GD);
662 }
663 
664 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
665   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
666 
667   PrettyStackTraceDecl CrashInfo((ValueDecl *)D, D->getLocation(),
668                                  Context.getSourceManager(),
669                                  "Generating code for declaration");
670 
671   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
672     getVtableInfo().MaybeEmitVtable(GD);
673     if (MD->isVirtual() && MD->isOutOfLine() &&
674         (!isa<CXXDestructorDecl>(D) || GD.getDtorType() != Dtor_Base)) {
675       if (isa<CXXDestructorDecl>(D)) {
676         GlobalDecl CanonGD(cast<CXXDestructorDecl>(D->getCanonicalDecl()),
677                            GD.getDtorType());
678         BuildThunksForVirtual(CanonGD);
679       } else {
680         BuildThunksForVirtual(MD->getCanonicalDecl());
681       }
682     }
683   }
684 
685   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
686     EmitCXXConstructor(CD, GD.getCtorType());
687   else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
688     EmitCXXDestructor(DD, GD.getDtorType());
689   else if (isa<FunctionDecl>(D))
690     EmitGlobalFunctionDefinition(GD);
691   else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
692     EmitGlobalVarDefinition(VD);
693   else {
694     assert(0 && "Invalid argument to EmitGlobalDefinition()");
695   }
696 }
697 
698 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
699 /// module, create and return an llvm Function with the specified type. If there
700 /// is something in the module with the specified name, return it potentially
701 /// bitcasted to the right type.
702 ///
703 /// If D is non-null, it specifies a decl that correspond to this.  This is used
704 /// to set the attributes on the function when it is first created.
705 llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(const char *MangledName,
706                                                        const llvm::Type *Ty,
707                                                        GlobalDecl D) {
708   // Lookup the entry, lazily creating it if necessary.
709   llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
710   if (Entry) {
711     if (Entry->getType()->getElementType() == Ty)
712       return Entry;
713 
714     // Make sure the result is of the correct type.
715     const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
716     return llvm::ConstantExpr::getBitCast(Entry, PTy);
717   }
718 
719   // This function doesn't have a complete type (for example, the return
720   // type is an incomplete struct). Use a fake type instead, and make
721   // sure not to try to set attributes.
722   bool IsIncompleteFunction = false;
723   if (!isa<llvm::FunctionType>(Ty)) {
724     Ty = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
725                                  std::vector<const llvm::Type*>(), false);
726     IsIncompleteFunction = true;
727   }
728   llvm::Function *F = llvm::Function::Create(cast<llvm::FunctionType>(Ty),
729                                              llvm::Function::ExternalLinkage,
730                                              "", &getModule());
731   F->setName(MangledName);
732   if (D.getDecl())
733     SetFunctionAttributes(D, F, IsIncompleteFunction);
734   Entry = F;
735 
736   // This is the first use or definition of a mangled name.  If there is a
737   // deferred decl with this name, remember that we need to emit it at the end
738   // of the file.
739   llvm::DenseMap<const char*, GlobalDecl>::iterator DDI =
740     DeferredDecls.find(MangledName);
741   if (DDI != DeferredDecls.end()) {
742     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
743     // list, and remove it from DeferredDecls (since we don't need it anymore).
744     DeferredDeclsToEmit.push_back(DDI->second);
745     DeferredDecls.erase(DDI);
746   } else if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl())) {
747     // If this the first reference to a C++ inline function in a class, queue up
748     // the deferred function body for emission.  These are not seen as
749     // top-level declarations.
750     if (FD->isThisDeclarationADefinition() && MayDeferGeneration(FD))
751       DeferredDeclsToEmit.push_back(D);
752     // A called constructor which has no definition or declaration need be
753     // synthesized.
754     else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
755       if (CD->isImplicit())
756         DeferredDeclsToEmit.push_back(D);
757     } else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD)) {
758       if (DD->isImplicit())
759         DeferredDeclsToEmit.push_back(D);
760     } else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
761       if (MD->isCopyAssignment() && MD->isImplicit())
762         DeferredDeclsToEmit.push_back(D);
763     }
764   }
765 
766   return F;
767 }
768 
769 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
770 /// non-null, then this function will use the specified type if it has to
771 /// create it (this occurs when we see a definition of the function).
772 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
773                                                  const llvm::Type *Ty) {
774   // If there was no specific requested type, just convert it now.
775   if (!Ty)
776     Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
777   return GetOrCreateLLVMFunction(getMangledName(GD), Ty, GD);
778 }
779 
780 /// CreateRuntimeFunction - Create a new runtime function with the specified
781 /// type and name.
782 llvm::Constant *
783 CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
784                                      const char *Name) {
785   // Convert Name to be a uniqued string from the IdentifierInfo table.
786   Name = getContext().Idents.get(Name).getNameStart();
787   return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl());
788 }
789 
790 static bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D) {
791   if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType())
792     return false;
793   if (Context.getLangOptions().CPlusPlus &&
794       Context.getBaseElementType(D->getType())->getAs<RecordType>()) {
795     // FIXME: We should do something fancier here!
796     return false;
797   }
798   return true;
799 }
800 
801 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
802 /// create and return an llvm GlobalVariable with the specified type.  If there
803 /// is something in the module with the specified name, return it potentially
804 /// bitcasted to the right type.
805 ///
806 /// If D is non-null, it specifies a decl that correspond to this.  This is used
807 /// to set the attributes on the global when it is first created.
808 llvm::Constant *CodeGenModule::GetOrCreateLLVMGlobal(const char *MangledName,
809                                                      const llvm::PointerType*Ty,
810                                                      const VarDecl *D) {
811   // Lookup the entry, lazily creating it if necessary.
812   llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
813   if (Entry) {
814     if (Entry->getType() == Ty)
815       return Entry;
816 
817     // Make sure the result is of the correct type.
818     return llvm::ConstantExpr::getBitCast(Entry, Ty);
819   }
820 
821   // This is the first use or definition of a mangled name.  If there is a
822   // deferred decl with this name, remember that we need to emit it at the end
823   // of the file.
824   llvm::DenseMap<const char*, GlobalDecl>::iterator DDI =
825     DeferredDecls.find(MangledName);
826   if (DDI != DeferredDecls.end()) {
827     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
828     // list, and remove it from DeferredDecls (since we don't need it anymore).
829     DeferredDeclsToEmit.push_back(DDI->second);
830     DeferredDecls.erase(DDI);
831   }
832 
833   llvm::GlobalVariable *GV =
834     new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
835                              llvm::GlobalValue::ExternalLinkage,
836                              0, "", 0,
837                              false, Ty->getAddressSpace());
838   GV->setName(MangledName);
839 
840   // Handle things which are present even on external declarations.
841   if (D) {
842     // FIXME: This code is overly simple and should be merged with other global
843     // handling.
844     GV->setConstant(DeclIsConstantGlobal(Context, D));
845 
846     // FIXME: Merge with other attribute handling code.
847     if (D->getStorageClass() == VarDecl::PrivateExtern)
848       GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
849 
850     if (D->hasAttr<WeakAttr>() ||
851         D->hasAttr<WeakImportAttr>())
852       GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
853 
854     GV->setThreadLocal(D->isThreadSpecified());
855   }
856 
857   return Entry = GV;
858 }
859 
860 
861 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
862 /// given global variable.  If Ty is non-null and if the global doesn't exist,
863 /// then it will be greated with the specified type instead of whatever the
864 /// normal requested type would be.
865 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
866                                                   const llvm::Type *Ty) {
867   assert(D->hasGlobalStorage() && "Not a global variable");
868   QualType ASTTy = D->getType();
869   if (Ty == 0)
870     Ty = getTypes().ConvertTypeForMem(ASTTy);
871 
872   const llvm::PointerType *PTy =
873     llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
874   return GetOrCreateLLVMGlobal(getMangledName(D), PTy, D);
875 }
876 
877 /// CreateRuntimeVariable - Create a new runtime global variable with the
878 /// specified type and name.
879 llvm::Constant *
880 CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty,
881                                      const char *Name) {
882   // Convert Name to be a uniqued string from the IdentifierInfo table.
883   Name = getContext().Idents.get(Name).getNameStart();
884   return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0);
885 }
886 
887 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
888   assert(!D->getInit() && "Cannot emit definite definitions here!");
889 
890   if (MayDeferGeneration(D)) {
891     // If we have not seen a reference to this variable yet, place it
892     // into the deferred declarations table to be emitted if needed
893     // later.
894     const char *MangledName = getMangledName(D);
895     if (GlobalDeclMap.count(MangledName) == 0) {
896       DeferredDecls[MangledName] = D;
897       return;
898     }
899   }
900 
901   // The tentative definition is the only definition.
902   EmitGlobalVarDefinition(D);
903 }
904 
905 llvm::GlobalVariable::LinkageTypes
906 CodeGenModule::getVtableLinkage(const CXXRecordDecl *RD) {
907   if (RD->isInAnonymousNamespace() || !RD->hasLinkage())
908     return llvm::GlobalVariable::InternalLinkage;
909 
910   if (const CXXMethodDecl *KeyFunction
911                                     = RD->getASTContext().getKeyFunction(RD)) {
912     // If this class has a key function, use that to determine the linkage of
913     // the vtable.
914     const FunctionDecl *Def = 0;
915     if (KeyFunction->getBody(Def))
916       KeyFunction = cast<CXXMethodDecl>(Def);
917 
918     switch (KeyFunction->getTemplateSpecializationKind()) {
919       case TSK_Undeclared:
920       case TSK_ExplicitSpecialization:
921         if (KeyFunction->isInlined())
922           return llvm::GlobalVariable::WeakODRLinkage;
923 
924         return llvm::GlobalVariable::ExternalLinkage;
925 
926       case TSK_ImplicitInstantiation:
927       case TSK_ExplicitInstantiationDefinition:
928         return llvm::GlobalVariable::WeakODRLinkage;
929 
930       case TSK_ExplicitInstantiationDeclaration:
931         // FIXME: Use available_externally linkage. However, this currently
932         // breaks LLVM's build due to undefined symbols.
933         //      return llvm::GlobalVariable::AvailableExternallyLinkage;
934         return llvm::GlobalVariable::WeakODRLinkage;
935     }
936   }
937 
938   switch (RD->getTemplateSpecializationKind()) {
939   case TSK_Undeclared:
940   case TSK_ExplicitSpecialization:
941   case TSK_ImplicitInstantiation:
942   case TSK_ExplicitInstantiationDefinition:
943     return llvm::GlobalVariable::WeakODRLinkage;
944 
945   case TSK_ExplicitInstantiationDeclaration:
946     // FIXME: Use available_externally linkage. However, this currently
947     // breaks LLVM's build due to undefined symbols.
948     //   return llvm::GlobalVariable::AvailableExternallyLinkage;
949     return llvm::GlobalVariable::WeakODRLinkage;
950   }
951 
952   // Silence GCC warning.
953   return llvm::GlobalVariable::WeakODRLinkage;
954 }
955 
956 static CodeGenModule::GVALinkage
957 GetLinkageForVariable(ASTContext &Context, const VarDecl *VD) {
958   // If this is a static data member, compute the kind of template
959   // specialization. Otherwise, this variable is not part of a
960   // template.
961   TemplateSpecializationKind TSK = TSK_Undeclared;
962   if (VD->isStaticDataMember())
963     TSK = VD->getTemplateSpecializationKind();
964 
965   Linkage L = VD->getLinkage();
966   if (L == ExternalLinkage && Context.getLangOptions().CPlusPlus &&
967       VD->getType()->getLinkage() == UniqueExternalLinkage)
968     L = UniqueExternalLinkage;
969 
970   switch (L) {
971   case NoLinkage:
972   case InternalLinkage:
973   case UniqueExternalLinkage:
974     return CodeGenModule::GVA_Internal;
975 
976   case ExternalLinkage:
977     switch (TSK) {
978     case TSK_Undeclared:
979     case TSK_ExplicitSpecialization:
980 
981       // FIXME: ExplicitInstantiationDefinition should be weak!
982     case TSK_ExplicitInstantiationDefinition:
983       return CodeGenModule::GVA_StrongExternal;
984 
985     case TSK_ExplicitInstantiationDeclaration:
986       llvm_unreachable("Variable should not be instantiated");
987       // Fall through to treat this like any other instantiation.
988 
989     case TSK_ImplicitInstantiation:
990       return CodeGenModule::GVA_TemplateInstantiation;
991     }
992   }
993 
994   return CodeGenModule::GVA_StrongExternal;
995 }
996 
997 CharUnits CodeGenModule::GetTargetTypeStoreSize(const llvm::Type *Ty) const {
998     return CharUnits::fromQuantity(
999       TheTargetData.getTypeStoreSizeInBits(Ty) / Context.getCharWidth());
1000 }
1001 
1002 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1003   llvm::Constant *Init = 0;
1004   QualType ASTTy = D->getType();
1005   bool NonConstInit = false;
1006 
1007   const Expr *InitExpr = D->getAnyInitializer();
1008 
1009   if (!InitExpr) {
1010     // This is a tentative definition; tentative definitions are
1011     // implicitly initialized with { 0 }.
1012     //
1013     // Note that tentative definitions are only emitted at the end of
1014     // a translation unit, so they should never have incomplete
1015     // type. In addition, EmitTentativeDefinition makes sure that we
1016     // never attempt to emit a tentative definition if a real one
1017     // exists. A use may still exists, however, so we still may need
1018     // to do a RAUW.
1019     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
1020     Init = EmitNullConstant(D->getType());
1021   } else {
1022     Init = EmitConstantExpr(InitExpr, D->getType());
1023 
1024     if (!Init) {
1025       QualType T = InitExpr->getType();
1026       if (getLangOptions().CPlusPlus) {
1027         EmitCXXGlobalVarDeclInitFunc(D);
1028         Init = EmitNullConstant(T);
1029         NonConstInit = true;
1030       } else {
1031         ErrorUnsupported(D, "static initializer");
1032         Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1033       }
1034     }
1035   }
1036 
1037   const llvm::Type* InitType = Init->getType();
1038   llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
1039 
1040   // Strip off a bitcast if we got one back.
1041   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1042     assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1043            // all zero index gep.
1044            CE->getOpcode() == llvm::Instruction::GetElementPtr);
1045     Entry = CE->getOperand(0);
1046   }
1047 
1048   // Entry is now either a Function or GlobalVariable.
1049   llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
1050 
1051   // We have a definition after a declaration with the wrong type.
1052   // We must make a new GlobalVariable* and update everything that used OldGV
1053   // (a declaration or tentative definition) with the new GlobalVariable*
1054   // (which will be a definition).
1055   //
1056   // This happens if there is a prototype for a global (e.g.
1057   // "extern int x[];") and then a definition of a different type (e.g.
1058   // "int x[10];"). This also happens when an initializer has a different type
1059   // from the type of the global (this happens with unions).
1060   if (GV == 0 ||
1061       GV->getType()->getElementType() != InitType ||
1062       GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) {
1063 
1064     // Remove the old entry from GlobalDeclMap so that we'll create a new one.
1065     GlobalDeclMap.erase(getMangledName(D));
1066 
1067     // Make a new global with the correct type, this is now guaranteed to work.
1068     GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
1069     GV->takeName(cast<llvm::GlobalValue>(Entry));
1070 
1071     // Replace all uses of the old global with the new global
1072     llvm::Constant *NewPtrForOldDecl =
1073         llvm::ConstantExpr::getBitCast(GV, Entry->getType());
1074     Entry->replaceAllUsesWith(NewPtrForOldDecl);
1075 
1076     // Erase the old global, since it is no longer used.
1077     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
1078   }
1079 
1080   if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
1081     SourceManager &SM = Context.getSourceManager();
1082     AddAnnotation(EmitAnnotateAttr(GV, AA,
1083                               SM.getInstantiationLineNumber(D->getLocation())));
1084   }
1085 
1086   GV->setInitializer(Init);
1087 
1088   // If it is safe to mark the global 'constant', do so now.
1089   GV->setConstant(false);
1090   if (!NonConstInit && DeclIsConstantGlobal(Context, D))
1091     GV->setConstant(true);
1092 
1093   GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
1094 
1095   // Set the llvm linkage type as appropriate.
1096   GVALinkage Linkage = GetLinkageForVariable(getContext(), D);
1097   if (Linkage == GVA_Internal)
1098     GV->setLinkage(llvm::Function::InternalLinkage);
1099   else if (D->hasAttr<DLLImportAttr>())
1100     GV->setLinkage(llvm::Function::DLLImportLinkage);
1101   else if (D->hasAttr<DLLExportAttr>())
1102     GV->setLinkage(llvm::Function::DLLExportLinkage);
1103   else if (D->hasAttr<WeakAttr>()) {
1104     if (GV->isConstant())
1105       GV->setLinkage(llvm::GlobalVariable::WeakODRLinkage);
1106     else
1107       GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
1108   } else if (Linkage == GVA_TemplateInstantiation)
1109     GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
1110   else if (!getLangOptions().CPlusPlus && !CodeGenOpts.NoCommon &&
1111            !D->hasExternalStorage() && !D->getInit() &&
1112            !D->getAttr<SectionAttr>()) {
1113     GV->setLinkage(llvm::GlobalVariable::CommonLinkage);
1114     // common vars aren't constant even if declared const.
1115     GV->setConstant(false);
1116   } else
1117     GV->setLinkage(llvm::GlobalVariable::ExternalLinkage);
1118 
1119   SetCommonAttributes(D, GV);
1120 
1121   // Emit global variable debug information.
1122   if (CGDebugInfo *DI = getDebugInfo()) {
1123     DI->setLocation(D->getLocation());
1124     DI->EmitGlobalVariable(GV, D);
1125   }
1126 }
1127 
1128 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1129 /// implement a function with no prototype, e.g. "int foo() {}".  If there are
1130 /// existing call uses of the old function in the module, this adjusts them to
1131 /// call the new function directly.
1132 ///
1133 /// This is not just a cleanup: the always_inline pass requires direct calls to
1134 /// functions to be able to inline them.  If there is a bitcast in the way, it
1135 /// won't inline them.  Instcombine normally deletes these calls, but it isn't
1136 /// run at -O0.
1137 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1138                                                       llvm::Function *NewFn) {
1139   // If we're redefining a global as a function, don't transform it.
1140   llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1141   if (OldFn == 0) return;
1142 
1143   const llvm::Type *NewRetTy = NewFn->getReturnType();
1144   llvm::SmallVector<llvm::Value*, 4> ArgList;
1145 
1146   for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
1147        UI != E; ) {
1148     // TODO: Do invokes ever occur in C code?  If so, we should handle them too.
1149     unsigned OpNo = UI.getOperandNo();
1150     llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*UI++);
1151     if (!CI || OpNo != 0) continue;
1152 
1153     // If the return types don't match exactly, and if the call isn't dead, then
1154     // we can't transform this call.
1155     if (CI->getType() != NewRetTy && !CI->use_empty())
1156       continue;
1157 
1158     // If the function was passed too few arguments, don't transform.  If extra
1159     // arguments were passed, we silently drop them.  If any of the types
1160     // mismatch, we don't transform.
1161     unsigned ArgNo = 0;
1162     bool DontTransform = false;
1163     for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1164          E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
1165       if (CI->getNumOperands()-1 == ArgNo ||
1166           CI->getOperand(ArgNo+1)->getType() != AI->getType()) {
1167         DontTransform = true;
1168         break;
1169       }
1170     }
1171     if (DontTransform)
1172       continue;
1173 
1174     // Okay, we can transform this.  Create the new call instruction and copy
1175     // over the required information.
1176     ArgList.append(CI->op_begin()+1, CI->op_begin()+1+ArgNo);
1177     llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(),
1178                                                      ArgList.end(), "", CI);
1179     ArgList.clear();
1180     if (!NewCall->getType()->isVoidTy())
1181       NewCall->takeName(CI);
1182     NewCall->setAttributes(CI->getAttributes());
1183     NewCall->setCallingConv(CI->getCallingConv());
1184 
1185     // Finally, remove the old call, replacing any uses with the new one.
1186     if (!CI->use_empty())
1187       CI->replaceAllUsesWith(NewCall);
1188 
1189     // Copy any custom metadata attached with CI.
1190     if (llvm::MDNode *DbgNode = CI->getMetadata("dbg"))
1191       NewCall->setMetadata("dbg", DbgNode);
1192     CI->eraseFromParent();
1193   }
1194 }
1195 
1196 
1197 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
1198   const llvm::FunctionType *Ty;
1199   const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
1200 
1201   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
1202     bool isVariadic = D->getType()->getAs<FunctionProtoType>()->isVariadic();
1203 
1204     Ty = getTypes().GetFunctionType(getTypes().getFunctionInfo(MD), isVariadic);
1205   } else {
1206     Ty = cast<llvm::FunctionType>(getTypes().ConvertType(D->getType()));
1207 
1208     // As a special case, make sure that definitions of K&R function
1209     // "type foo()" aren't declared as varargs (which forces the backend
1210     // to do unnecessary work).
1211     if (D->getType()->isFunctionNoProtoType()) {
1212       assert(Ty->isVarArg() && "Didn't lower type as expected");
1213       // Due to stret, the lowered function could have arguments.
1214       // Just create the same type as was lowered by ConvertType
1215       // but strip off the varargs bit.
1216       std::vector<const llvm::Type*> Args(Ty->param_begin(), Ty->param_end());
1217       Ty = llvm::FunctionType::get(Ty->getReturnType(), Args, false);
1218     }
1219   }
1220 
1221   // Get or create the prototype for the function.
1222   llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
1223 
1224   // Strip off a bitcast if we got one back.
1225   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1226     assert(CE->getOpcode() == llvm::Instruction::BitCast);
1227     Entry = CE->getOperand(0);
1228   }
1229 
1230 
1231   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
1232     llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
1233 
1234     // If the types mismatch then we have to rewrite the definition.
1235     assert(OldFn->isDeclaration() &&
1236            "Shouldn't replace non-declaration");
1237 
1238     // F is the Function* for the one with the wrong type, we must make a new
1239     // Function* and update everything that used F (a declaration) with the new
1240     // Function* (which will be a definition).
1241     //
1242     // This happens if there is a prototype for a function
1243     // (e.g. "int f()") and then a definition of a different type
1244     // (e.g. "int f(int x)").  Start by making a new function of the
1245     // correct type, RAUW, then steal the name.
1246     GlobalDeclMap.erase(getMangledName(D));
1247     llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
1248     NewFn->takeName(OldFn);
1249 
1250     // If this is an implementation of a function without a prototype, try to
1251     // replace any existing uses of the function (which may be calls) with uses
1252     // of the new function
1253     if (D->getType()->isFunctionNoProtoType()) {
1254       ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
1255       OldFn->removeDeadConstantUsers();
1256     }
1257 
1258     // Replace uses of F with the Function we will endow with a body.
1259     if (!Entry->use_empty()) {
1260       llvm::Constant *NewPtrForOldDecl =
1261         llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
1262       Entry->replaceAllUsesWith(NewPtrForOldDecl);
1263     }
1264 
1265     // Ok, delete the old function now, which is dead.
1266     OldFn->eraseFromParent();
1267 
1268     Entry = NewFn;
1269   }
1270 
1271   llvm::Function *Fn = cast<llvm::Function>(Entry);
1272 
1273   CodeGenFunction(*this).GenerateCode(D, Fn);
1274 
1275   SetFunctionDefinitionAttributes(D, Fn);
1276   SetLLVMFunctionAttributesForDefinition(D, Fn);
1277 
1278   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
1279     AddGlobalCtor(Fn, CA->getPriority());
1280   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
1281     AddGlobalDtor(Fn, DA->getPriority());
1282 }
1283 
1284 void CodeGenModule::EmitAliasDefinition(const ValueDecl *D) {
1285   const AliasAttr *AA = D->getAttr<AliasAttr>();
1286   assert(AA && "Not an alias?");
1287 
1288   const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
1289 
1290   // Unique the name through the identifier table.
1291   const char *AliaseeName =
1292     getContext().Idents.get(AA->getAliasee()).getNameStart();
1293 
1294   // Create a reference to the named value.  This ensures that it is emitted
1295   // if a deferred decl.
1296   llvm::Constant *Aliasee;
1297   if (isa<llvm::FunctionType>(DeclTy))
1298     Aliasee = GetOrCreateLLVMFunction(AliaseeName, DeclTy, GlobalDecl());
1299   else
1300     Aliasee = GetOrCreateLLVMGlobal(AliaseeName,
1301                                     llvm::PointerType::getUnqual(DeclTy), 0);
1302 
1303   // Create the new alias itself, but don't set a name yet.
1304   llvm::GlobalValue *GA =
1305     new llvm::GlobalAlias(Aliasee->getType(),
1306                           llvm::Function::ExternalLinkage,
1307                           "", Aliasee, &getModule());
1308 
1309   // See if there is already something with the alias' name in the module.
1310   const char *MangledName = getMangledName(D);
1311   llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName];
1312 
1313   if (Entry && !Entry->isDeclaration()) {
1314     // If there is a definition in the module, then it wins over the alias.
1315     // This is dubious, but allow it to be safe.  Just ignore the alias.
1316     GA->eraseFromParent();
1317     return;
1318   }
1319 
1320   if (Entry) {
1321     // If there is a declaration in the module, then we had an extern followed
1322     // by the alias, as in:
1323     //   extern int test6();
1324     //   ...
1325     //   int test6() __attribute__((alias("test7")));
1326     //
1327     // Remove it and replace uses of it with the alias.
1328 
1329     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
1330                                                           Entry->getType()));
1331     Entry->eraseFromParent();
1332   }
1333 
1334   // Now we know that there is no conflict, set the name.
1335   Entry = GA;
1336   GA->setName(MangledName);
1337 
1338   // Set attributes which are particular to an alias; this is a
1339   // specialization of the attributes which may be set on a global
1340   // variable/function.
1341   if (D->hasAttr<DLLExportAttr>()) {
1342     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1343       // The dllexport attribute is ignored for undefined symbols.
1344       if (FD->getBody())
1345         GA->setLinkage(llvm::Function::DLLExportLinkage);
1346     } else {
1347       GA->setLinkage(llvm::Function::DLLExportLinkage);
1348     }
1349   } else if (D->hasAttr<WeakAttr>() ||
1350              D->hasAttr<WeakImportAttr>()) {
1351     GA->setLinkage(llvm::Function::WeakAnyLinkage);
1352   }
1353 
1354   SetCommonAttributes(D, GA);
1355 }
1356 
1357 /// getBuiltinLibFunction - Given a builtin id for a function like
1358 /// "__builtin_fabsf", return a Function* for "fabsf".
1359 llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
1360                                                   unsigned BuiltinID) {
1361   assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
1362           Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
1363          "isn't a lib fn");
1364 
1365   // Get the name, skip over the __builtin_ prefix (if necessary).
1366   const char *Name = Context.BuiltinInfo.GetName(BuiltinID);
1367   if (Context.BuiltinInfo.isLibFunction(BuiltinID))
1368     Name += 10;
1369 
1370   const llvm::FunctionType *Ty =
1371     cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
1372 
1373   // Unique the name through the identifier table.
1374   Name = getContext().Idents.get(Name).getNameStart();
1375   return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD));
1376 }
1377 
1378 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
1379                                             unsigned NumTys) {
1380   return llvm::Intrinsic::getDeclaration(&getModule(),
1381                                          (llvm::Intrinsic::ID)IID, Tys, NumTys);
1382 }
1383 
1384 llvm::Function *CodeGenModule::getMemCpyFn() {
1385   if (MemCpyFn) return MemCpyFn;
1386   const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext);
1387   return MemCpyFn = getIntrinsic(llvm::Intrinsic::memcpy, &IntPtr, 1);
1388 }
1389 
1390 llvm::Function *CodeGenModule::getMemMoveFn() {
1391   if (MemMoveFn) return MemMoveFn;
1392   const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext);
1393   return MemMoveFn = getIntrinsic(llvm::Intrinsic::memmove, &IntPtr, 1);
1394 }
1395 
1396 llvm::Function *CodeGenModule::getMemSetFn() {
1397   if (MemSetFn) return MemSetFn;
1398   const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext);
1399   return MemSetFn = getIntrinsic(llvm::Intrinsic::memset, &IntPtr, 1);
1400 }
1401 
1402 static llvm::StringMapEntry<llvm::Constant*> &
1403 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
1404                          const StringLiteral *Literal,
1405                          bool TargetIsLSB,
1406                          bool &IsUTF16,
1407                          unsigned &StringLength) {
1408   unsigned NumBytes = Literal->getByteLength();
1409 
1410   // Check for simple case.
1411   if (!Literal->containsNonAsciiOrNull()) {
1412     StringLength = NumBytes;
1413     return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(),
1414                                                 StringLength));
1415   }
1416 
1417   // Otherwise, convert the UTF8 literals into a byte string.
1418   llvm::SmallVector<UTF16, 128> ToBuf(NumBytes);
1419   const UTF8 *FromPtr = (UTF8 *)Literal->getStrData();
1420   UTF16 *ToPtr = &ToBuf[0];
1421 
1422   ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
1423                                                &ToPtr, ToPtr + NumBytes,
1424                                                strictConversion);
1425 
1426   // Check for conversion failure.
1427   if (Result != conversionOK) {
1428     // FIXME: Have Sema::CheckObjCString() validate the UTF-8 string and remove
1429     // this duplicate code.
1430     assert(Result == sourceIllegal && "UTF-8 to UTF-16 conversion failed");
1431     StringLength = NumBytes;
1432     return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(),
1433                                                 StringLength));
1434   }
1435 
1436   // ConvertUTF8toUTF16 returns the length in ToPtr.
1437   StringLength = ToPtr - &ToBuf[0];
1438 
1439   // Render the UTF-16 string into a byte array and convert to the target byte
1440   // order.
1441   //
1442   // FIXME: This isn't something we should need to do here.
1443   llvm::SmallString<128> AsBytes;
1444   AsBytes.reserve(StringLength * 2);
1445   for (unsigned i = 0; i != StringLength; ++i) {
1446     unsigned short Val = ToBuf[i];
1447     if (TargetIsLSB) {
1448       AsBytes.push_back(Val & 0xFF);
1449       AsBytes.push_back(Val >> 8);
1450     } else {
1451       AsBytes.push_back(Val >> 8);
1452       AsBytes.push_back(Val & 0xFF);
1453     }
1454   }
1455   // Append one extra null character, the second is automatically added by our
1456   // caller.
1457   AsBytes.push_back(0);
1458 
1459   IsUTF16 = true;
1460   return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size()));
1461 }
1462 
1463 llvm::Constant *
1464 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
1465   unsigned StringLength = 0;
1466   bool isUTF16 = false;
1467   llvm::StringMapEntry<llvm::Constant*> &Entry =
1468     GetConstantCFStringEntry(CFConstantStringMap, Literal,
1469                              getTargetData().isLittleEndian(),
1470                              isUTF16, StringLength);
1471 
1472   if (llvm::Constant *C = Entry.getValue())
1473     return C;
1474 
1475   llvm::Constant *Zero =
1476       llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
1477   llvm::Constant *Zeros[] = { Zero, Zero };
1478 
1479   // If we don't already have it, get __CFConstantStringClassReference.
1480   if (!CFConstantStringClassRef) {
1481     const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
1482     Ty = llvm::ArrayType::get(Ty, 0);
1483     llvm::Constant *GV = CreateRuntimeVariable(Ty,
1484                                            "__CFConstantStringClassReference");
1485     // Decay array -> ptr
1486     CFConstantStringClassRef =
1487       llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1488   }
1489 
1490   QualType CFTy = getContext().getCFConstantStringType();
1491 
1492   const llvm::StructType *STy =
1493     cast<llvm::StructType>(getTypes().ConvertType(CFTy));
1494 
1495   std::vector<llvm::Constant*> Fields(4);
1496 
1497   // Class pointer.
1498   Fields[0] = CFConstantStringClassRef;
1499 
1500   // Flags.
1501   const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
1502   Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
1503     llvm::ConstantInt::get(Ty, 0x07C8);
1504 
1505   // String pointer.
1506   llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1507 
1508   llvm::GlobalValue::LinkageTypes Linkage;
1509   bool isConstant;
1510   if (isUTF16) {
1511     // FIXME: why do utf strings get "_" labels instead of "L" labels?
1512     Linkage = llvm::GlobalValue::InternalLinkage;
1513     // Note: -fwritable-strings doesn't make unicode CFStrings writable, but
1514     // does make plain ascii ones writable.
1515     isConstant = true;
1516   } else {
1517     Linkage = llvm::GlobalValue::PrivateLinkage;
1518     isConstant = !Features.WritableStrings;
1519   }
1520 
1521   llvm::GlobalVariable *GV =
1522     new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1523                              ".str");
1524   if (isUTF16) {
1525     CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1526     GV->setAlignment(Align.getQuantity());
1527   }
1528   Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1529 
1530   // String length.
1531   Ty = getTypes().ConvertType(getContext().LongTy);
1532   Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
1533 
1534   // The struct.
1535   C = llvm::ConstantStruct::get(STy, Fields);
1536   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1537                                 llvm::GlobalVariable::PrivateLinkage, C,
1538                                 "_unnamed_cfstring_");
1539   if (const char *Sect = getContext().Target.getCFStringSection())
1540     GV->setSection(Sect);
1541   Entry.setValue(GV);
1542 
1543   return GV;
1544 }
1545 
1546 /// GetStringForStringLiteral - Return the appropriate bytes for a
1547 /// string literal, properly padded to match the literal type.
1548 std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
1549   const char *StrData = E->getStrData();
1550   unsigned Len = E->getByteLength();
1551 
1552   const ConstantArrayType *CAT =
1553     getContext().getAsConstantArrayType(E->getType());
1554   assert(CAT && "String isn't pointer or array!");
1555 
1556   // Resize the string to the right size.
1557   std::string Str(StrData, StrData+Len);
1558   uint64_t RealLen = CAT->getSize().getZExtValue();
1559 
1560   if (E->isWide())
1561     RealLen *= getContext().Target.getWCharWidth()/8;
1562 
1563   Str.resize(RealLen, '\0');
1564 
1565   return Str;
1566 }
1567 
1568 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
1569 /// constant array for the given string literal.
1570 llvm::Constant *
1571 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
1572   // FIXME: This can be more efficient.
1573   // FIXME: We shouldn't need to bitcast the constant in the wide string case.
1574   llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S));
1575   if (S->isWide()) {
1576     llvm::Type *DestTy =
1577         llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType()));
1578     C = llvm::ConstantExpr::getBitCast(C, DestTy);
1579   }
1580   return C;
1581 }
1582 
1583 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
1584 /// array for the given ObjCEncodeExpr node.
1585 llvm::Constant *
1586 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
1587   std::string Str;
1588   getContext().getObjCEncodingForType(E->getEncodedType(), Str);
1589 
1590   return GetAddrOfConstantCString(Str);
1591 }
1592 
1593 
1594 /// GenerateWritableString -- Creates storage for a string literal.
1595 static llvm::Constant *GenerateStringLiteral(const std::string &str,
1596                                              bool constant,
1597                                              CodeGenModule &CGM,
1598                                              const char *GlobalName) {
1599   // Create Constant for this string literal. Don't add a '\0'.
1600   llvm::Constant *C =
1601       llvm::ConstantArray::get(CGM.getLLVMContext(), str, false);
1602 
1603   // Create a global variable for this string
1604   return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
1605                                   llvm::GlobalValue::PrivateLinkage,
1606                                   C, GlobalName);
1607 }
1608 
1609 /// GetAddrOfConstantString - Returns a pointer to a character array
1610 /// containing the literal. This contents are exactly that of the
1611 /// given string, i.e. it will not be null terminated automatically;
1612 /// see GetAddrOfConstantCString. Note that whether the result is
1613 /// actually a pointer to an LLVM constant depends on
1614 /// Feature.WriteableStrings.
1615 ///
1616 /// The result has pointer to array type.
1617 llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str,
1618                                                        const char *GlobalName) {
1619   bool IsConstant = !Features.WritableStrings;
1620 
1621   // Get the default prefix if a name wasn't specified.
1622   if (!GlobalName)
1623     GlobalName = ".str";
1624 
1625   // Don't share any string literals if strings aren't constant.
1626   if (!IsConstant)
1627     return GenerateStringLiteral(str, false, *this, GlobalName);
1628 
1629   llvm::StringMapEntry<llvm::Constant *> &Entry =
1630     ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
1631 
1632   if (Entry.getValue())
1633     return Entry.getValue();
1634 
1635   // Create a global variable for this.
1636   llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName);
1637   Entry.setValue(C);
1638   return C;
1639 }
1640 
1641 /// GetAddrOfConstantCString - Returns a pointer to a character
1642 /// array containing the literal and a terminating '\-'
1643 /// character. The result has pointer to array type.
1644 llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str,
1645                                                         const char *GlobalName){
1646   return GetAddrOfConstantString(str + '\0', GlobalName);
1647 }
1648 
1649 /// EmitObjCPropertyImplementations - Emit information for synthesized
1650 /// properties for an implementation.
1651 void CodeGenModule::EmitObjCPropertyImplementations(const
1652                                                     ObjCImplementationDecl *D) {
1653   for (ObjCImplementationDecl::propimpl_iterator
1654          i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
1655     ObjCPropertyImplDecl *PID = *i;
1656 
1657     // Dynamic is just for type-checking.
1658     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
1659       ObjCPropertyDecl *PD = PID->getPropertyDecl();
1660 
1661       // Determine which methods need to be implemented, some may have
1662       // been overridden. Note that ::isSynthesized is not the method
1663       // we want, that just indicates if the decl came from a
1664       // property. What we want to know is if the method is defined in
1665       // this implementation.
1666       if (!D->getInstanceMethod(PD->getGetterName()))
1667         CodeGenFunction(*this).GenerateObjCGetter(
1668                                  const_cast<ObjCImplementationDecl *>(D), PID);
1669       if (!PD->isReadOnly() &&
1670           !D->getInstanceMethod(PD->getSetterName()))
1671         CodeGenFunction(*this).GenerateObjCSetter(
1672                                  const_cast<ObjCImplementationDecl *>(D), PID);
1673     }
1674   }
1675 }
1676 
1677 /// EmitNamespace - Emit all declarations in a namespace.
1678 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
1679   for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
1680        I != E; ++I)
1681     EmitTopLevelDecl(*I);
1682 }
1683 
1684 // EmitLinkageSpec - Emit all declarations in a linkage spec.
1685 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
1686   if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
1687       LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
1688     ErrorUnsupported(LSD, "linkage spec");
1689     return;
1690   }
1691 
1692   for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
1693        I != E; ++I)
1694     EmitTopLevelDecl(*I);
1695 }
1696 
1697 /// EmitTopLevelDecl - Emit code for a single top level declaration.
1698 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
1699   // If an error has occurred, stop code generation, but continue
1700   // parsing and semantic analysis (to ensure all warnings and errors
1701   // are emitted).
1702   if (Diags.hasErrorOccurred())
1703     return;
1704 
1705   // Ignore dependent declarations.
1706   if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
1707     return;
1708 
1709   switch (D->getKind()) {
1710   case Decl::CXXConversion:
1711   case Decl::CXXMethod:
1712   case Decl::Function:
1713     // Skip function templates
1714     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
1715       return;
1716 
1717     EmitGlobal(cast<FunctionDecl>(D));
1718     break;
1719 
1720   case Decl::Var:
1721     EmitGlobal(cast<VarDecl>(D));
1722     break;
1723 
1724   // C++ Decls
1725   case Decl::Namespace:
1726     EmitNamespace(cast<NamespaceDecl>(D));
1727     break;
1728     // No code generation needed.
1729   case Decl::UsingShadow:
1730   case Decl::Using:
1731   case Decl::UsingDirective:
1732   case Decl::ClassTemplate:
1733   case Decl::FunctionTemplate:
1734   case Decl::NamespaceAlias:
1735     break;
1736   case Decl::CXXConstructor:
1737     // Skip function templates
1738     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
1739       return;
1740 
1741     EmitCXXConstructors(cast<CXXConstructorDecl>(D));
1742     break;
1743   case Decl::CXXDestructor:
1744     EmitCXXDestructors(cast<CXXDestructorDecl>(D));
1745     break;
1746 
1747   case Decl::StaticAssert:
1748     // Nothing to do.
1749     break;
1750 
1751   // Objective-C Decls
1752 
1753   // Forward declarations, no (immediate) code generation.
1754   case Decl::ObjCClass:
1755   case Decl::ObjCForwardProtocol:
1756   case Decl::ObjCCategory:
1757   case Decl::ObjCInterface:
1758     break;
1759 
1760   case Decl::ObjCProtocol:
1761     Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
1762     break;
1763 
1764   case Decl::ObjCCategoryImpl:
1765     // Categories have properties but don't support synthesize so we
1766     // can ignore them here.
1767     Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
1768     break;
1769 
1770   case Decl::ObjCImplementation: {
1771     ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
1772     EmitObjCPropertyImplementations(OMD);
1773     Runtime->GenerateClass(OMD);
1774     break;
1775   }
1776   case Decl::ObjCMethod: {
1777     ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
1778     // If this is not a prototype, emit the body.
1779     if (OMD->getBody())
1780       CodeGenFunction(*this).GenerateObjCMethod(OMD);
1781     break;
1782   }
1783   case Decl::ObjCCompatibleAlias:
1784     // compatibility-alias is a directive and has no code gen.
1785     break;
1786 
1787   case Decl::LinkageSpec:
1788     EmitLinkageSpec(cast<LinkageSpecDecl>(D));
1789     break;
1790 
1791   case Decl::FileScopeAsm: {
1792     FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
1793     llvm::StringRef AsmString = AD->getAsmString()->getString();
1794 
1795     const std::string &S = getModule().getModuleInlineAsm();
1796     if (S.empty())
1797       getModule().setModuleInlineAsm(AsmString);
1798     else
1799       getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
1800     break;
1801   }
1802 
1803   default:
1804     // Make sure we handled everything we should, every other kind is a
1805     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
1806     // function. Need to recode Decl::Kind to do that easily.
1807     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
1808   }
1809 }
1810