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