contrib/llvm/tools/clang/lib/CodeGen/CodeGenModule.cpp

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