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 "CGCUDARuntime.h"
  16 #include "CGCXXABI.h"
  17 #include "CGCall.h"
  18 #include "CGDebugInfo.h"
  19 #include "CGObjCRuntime.h"
  20 #include "CGOpenCLRuntime.h"
  21 #include "CodeGenFunction.h"
  22 #include "CodeGenTBAA.h"
  23 #include "TargetInfo.h"
  24 #include "clang/AST/ASTContext.h"
  25 #include "clang/AST/CharUnits.h"
  26 #include "clang/AST/DeclCXX.h"
  27 #include "clang/AST/DeclObjC.h"
  28 #include "clang/AST/DeclTemplate.h"
  29 #include "clang/AST/Mangle.h"
  30 #include "clang/AST/RecordLayout.h"
  31 #include "clang/AST/RecursiveASTVisitor.h"
  32 #include "clang/Basic/Builtins.h"
  33 #include "clang/Basic/CharInfo.h"
  34 #include "clang/Basic/Diagnostic.h"
  35 #include "clang/Basic/Module.h"
  36 #include "clang/Basic/SourceManager.h"
  37 #include "clang/Basic/TargetInfo.h"
  38 #include "clang/Basic/TargetOptions.h"
  39 #include "clang/Frontend/CodeGenOptions.h"
  40 #include "llvm/ADT/APSInt.h"
  41 #include "llvm/ADT/Triple.h"
  42 #include "llvm/IR/CallingConv.h"
  43 #include "llvm/IR/DataLayout.h"
  44 #include "llvm/IR/Intrinsics.h"
  45 #include "llvm/IR/LLVMContext.h"
  46 #include "llvm/IR/Module.h"
  47 #include "llvm/Support/CallSite.h"
  48 #include "llvm/Support/ConvertUTF.h"
  49 #include "llvm/Support/ErrorHandling.h"
  50 #include "llvm/Target/Mangler.h"
  51
  52 using namespace clang;
  53 using namespace CodeGen;
  54
  55 static const char AnnotationSection[] = "llvm.metadata";
  56
  57 static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
  58   switch (CGM.getContext().getTargetInfo().getCXXABI().getKind()) {
  59   case TargetCXXABI::GenericAArch64:
  60   case TargetCXXABI::GenericARM:
  61   case TargetCXXABI::iOS:
  62   case TargetCXXABI::GenericItanium:
  63     return *CreateItaniumCXXABI(CGM);
  64   case TargetCXXABI::Microsoft:
  65     return *CreateMicrosoftCXXABI(CGM);
  66   }
  67
  68   llvm_unreachable("invalid C++ ABI kind");
  69 }
  70
  71
  72 CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
  73                              const TargetOptions &TO, llvm::Module &M,
  74                              const llvm::DataLayout &TD,
  75                              DiagnosticsEngine &diags)
  76   : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TargetOpts(TO),
  77     TheModule(M), TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags),
  78     ABI(createCXXABI(*this)),
  79     Types(*this),
  80     TBAA(0),
  81     VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0),
  82     DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0),
  83     RRData(0), CFConstantStringClassRef(0),
  84     ConstantStringClassRef(0), NSConstantStringType(0),
  85     VMContext(M.getContext()),
  86     NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
  87     BlockObjectAssign(0), BlockObjectDispose(0),
  88     BlockDescriptorType(0), GenericBlockLiteralType(0),
  89     LifetimeStartFn(0), LifetimeEndFn(0),
  90     SanitizerBlacklist(CGO.SanitizerBlacklistFile),
  91     SanOpts(SanitizerBlacklist.isIn(M) ?
  92             SanitizerOptions::Disabled : LangOpts.Sanitize) {
  93
  94   // Initialize the type cache.
  95   llvm::LLVMContext &LLVMContext = M.getContext();
  96   VoidTy = llvm::Type::getVoidTy(LLVMContext);
  97   Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
  98   Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
  99   Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
 100   Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
 101   FloatTy = llvm::Type::getFloatTy(LLVMContext);
 102   DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
 103   PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
 104   PointerAlignInBytes =
 105   C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
 106   IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
 107   IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
 108   Int8PtrTy = Int8Ty->getPointerTo(0);
 109   Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
 110
 111   RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
 112
 113   if (LangOpts.ObjC1)
 114     createObjCRuntime();
 115   if (LangOpts.OpenCL)
 116     createOpenCLRuntime();
 117   if (LangOpts.CUDA)
 118     createCUDARuntime();
 119
 120   // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
 121   if (SanOpts.Thread ||
 122       (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
 123     TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
 124                            ABI.getMangleContext());
 125
 126   // If debug info or coverage generation is enabled, create the CGDebugInfo
 127   // object.
 128   if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
 129       CodeGenOpts.EmitGcovArcs ||
 130       CodeGenOpts.EmitGcovNotes)
 131     DebugInfo = new CGDebugInfo(*this);
 132
 133   Block.GlobalUniqueCount = 0;
 134
 135   if (C.getLangOpts().ObjCAutoRefCount)
 136     ARCData = new ARCEntrypoints();
 137   RRData = new RREntrypoints();
 138 }
 139
 140 CodeGenModule::~CodeGenModule() {
 141   delete ObjCRuntime;
 142   delete OpenCLRuntime;
 143   delete CUDARuntime;
 144   delete TheTargetCodeGenInfo;
 145   delete &ABI;
 146   delete TBAA;
 147   delete DebugInfo;
 148   delete ARCData;
 149   delete RRData;
 150 }
 151
 152 void CodeGenModule::createObjCRuntime() {
 153   // This is just isGNUFamily(), but we want to force implementors of
 154   // new ABIs to decide how best to do this.
 155   switch (LangOpts.ObjCRuntime.getKind()) {
 156   case ObjCRuntime::GNUstep:
 157   case ObjCRuntime::GCC:
 158   case ObjCRuntime::ObjFW:
 159     ObjCRuntime = CreateGNUObjCRuntime(*this);
 160     return;
 161
 162   case ObjCRuntime::FragileMacOSX:
 163   case ObjCRuntime::MacOSX:
 164   case ObjCRuntime::iOS:
 165     ObjCRuntime = CreateMacObjCRuntime(*this);
 166     return;
 167   }
 168   llvm_unreachable("bad runtime kind");
 169 }
 170
 171 void CodeGenModule::createOpenCLRuntime() {
 172   OpenCLRuntime = new CGOpenCLRuntime(*this);
 173 }
 174
 175 void CodeGenModule::createCUDARuntime() {
 176   CUDARuntime = CreateNVCUDARuntime(*this);
 177 }
 178
 179 void CodeGenModule::Release() {
 180   EmitDeferred();
 181   EmitCXXGlobalInitFunc();
 182   EmitCXXGlobalDtorFunc();
 183   if (ObjCRuntime)
 184     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
 185       AddGlobalCtor(ObjCInitFunction);
 186   EmitCtorList(GlobalCtors, "llvm.global_ctors");
 187   EmitCtorList(GlobalDtors, "llvm.global_dtors");
 188   EmitGlobalAnnotations();
 189   EmitLLVMUsed();
 190
 191   if (CodeGenOpts.ModulesAutolink) {
 192     EmitModuleLinkOptions();
 193   }
 194
 195   SimplifyPersonality();
 196
 197   if (getCodeGenOpts().EmitDeclMetadata)
 198     EmitDeclMetadata();
 199
 200   if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
 201     EmitCoverageFile();
 202
 203   if (DebugInfo)
 204     DebugInfo->finalize();
 205 }
 206
 207 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
 208   // Make sure that this type is translated.
 209   Types.UpdateCompletedType(TD);
 210 }
 211
 212 llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
 213   if (!TBAA)
 214     return 0;
 215   return TBAA->getTBAAInfo(QTy);
 216 }
 217
 218 llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
 219   if (!TBAA)
 220     return 0;
 221   return TBAA->getTBAAInfoForVTablePtr();
 222 }
 223
 224 llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
 225   if (!TBAA)
 226     return 0;
 227   return TBAA->getTBAAStructInfo(QTy);
 228 }
 229
 230 llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) {
 231   if (!TBAA)
 232     return 0;
 233   return TBAA->getTBAAStructTypeInfo(QTy);
 234 }
 235
 236 llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy,
 237                                                   llvm::MDNode *AccessN,
 238                                                   uint64_t O) {
 239   if (!TBAA)
 240     return 0;
 241   return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O);
 242 }
 243
 244 void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
 245                                         llvm::MDNode *TBAAInfo) {
 246   Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
 247 }
 248
 249 bool CodeGenModule::isTargetDarwin() const {
 250   return getContext().getTargetInfo().getTriple().isOSDarwin();
 251 }
 252
 253 void CodeGenModule::Error(SourceLocation loc, StringRef error) {
 254   unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
 255   getDiags().Report(Context.getFullLoc(loc), diagID);
 256 }
 257
 258 /// ErrorUnsupported - Print out an error that codegen doesn't support the
 259 /// specified stmt yet.
 260 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
 261                                      bool OmitOnError) {
 262   if (OmitOnError && getDiags().hasErrorOccurred())
 263     return;
 264   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
 265                                                "cannot compile this %0 yet");
 266   std::string Msg = Type;
 267   getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
 268     << Msg << S->getSourceRange();
 269 }
 270
 271 /// ErrorUnsupported - Print out an error that codegen doesn't support the
 272 /// specified decl yet.
 273 void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
 274                                      bool OmitOnError) {
 275   if (OmitOnError && getDiags().hasErrorOccurred())
 276     return;
 277   unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
 278                                                "cannot compile this %0 yet");
 279   std::string Msg = Type;
 280   getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
 281 }
 282
 283 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
 284   return llvm::ConstantInt::get(SizeTy, size.getQuantity());
 285 }
 286
 287 void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
 288                                         const NamedDecl *D) const {
 289   // Internal definitions always have default visibility.
 290   if (GV->hasLocalLinkage()) {
 291     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
 292     return;
 293   }
 294
 295   // Set visibility for definitions.
 296   LinkageInfo LV = D->getLinkageAndVisibility();
 297   if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
 298     GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
 299 }
 300
 301 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
 302   return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
 303       .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
 304       .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
 305       .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
 306       .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
 307 }
 308
 309 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
 310     CodeGenOptions::TLSModel M) {
 311   switch (M) {
 312   case CodeGenOptions::GeneralDynamicTLSModel:
 313     return llvm::GlobalVariable::GeneralDynamicTLSModel;
 314   case CodeGenOptions::LocalDynamicTLSModel:
 315     return llvm::GlobalVariable::LocalDynamicTLSModel;
 316   case CodeGenOptions::InitialExecTLSModel:
 317     return llvm::GlobalVariable::InitialExecTLSModel;
 318   case CodeGenOptions::LocalExecTLSModel:
 319     return llvm::GlobalVariable::LocalExecTLSModel;
 320   }
 321   llvm_unreachable("Invalid TLS model!");
 322 }
 323
 324 void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
 325                                const VarDecl &D) const {
 326   assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!");
 327
 328   llvm::GlobalVariable::ThreadLocalMode TLM;
 329   TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
 330
 331   // Override the TLS model if it is explicitly specified.
 332   if (D.hasAttr<TLSModelAttr>()) {
 333     const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
 334     TLM = GetLLVMTLSModel(Attr->getModel());
 335   }
 336
 337   GV->setThreadLocalMode(TLM);
 338 }
 339
 340 /// Set the symbol visibility of type information (vtable and RTTI)
 341 /// associated with the given type.
 342 void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
 343                                       const CXXRecordDecl *RD,
 344                                       TypeVisibilityKind TVK) const {
 345   setGlobalVisibility(GV, RD);
 346
 347   if (!CodeGenOpts.HiddenWeakVTables)
 348     return;
 349
 350   // We never want to drop the visibility for RTTI names.
 351   if (TVK == TVK_ForRTTIName)
 352     return;
 353
 354   // We want to drop the visibility to hidden for weak type symbols.
 355   // This isn't possible if there might be unresolved references
 356   // elsewhere that rely on this symbol being visible.
 357
 358   // This should be kept roughly in sync with setThunkVisibility
 359   // in CGVTables.cpp.
 360
 361   // Preconditions.
 362   if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
 363       GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
 364     return;
 365
 366   // Don't override an explicit visibility attribute.
 367   if (RD->getExplicitVisibility(NamedDecl::VisibilityForType))
 368     return;
 369
 370   switch (RD->getTemplateSpecializationKind()) {
 371   // We have to disable the optimization if this is an EI definition
 372   // because there might be EI declarations in other shared objects.
 373   case TSK_ExplicitInstantiationDefinition:
 374   case TSK_ExplicitInstantiationDeclaration:
 375     return;
 376
 377   // Every use of a non-template class's type information has to emit it.
 378   case TSK_Undeclared:
 379     break;
 380
 381   // In theory, implicit instantiations can ignore the possibility of
 382   // an explicit instantiation declaration because there necessarily
 383   // must be an EI definition somewhere with default visibility.  In
 384   // practice, it's possible to have an explicit instantiation for
 385   // an arbitrary template class, and linkers aren't necessarily able
 386   // to deal with mixed-visibility symbols.
 387   case TSK_ExplicitSpecialization:
 388   case TSK_ImplicitInstantiation:
 389     return;
 390   }
 391
 392   // If there's a key function, there may be translation units
 393   // that don't have the key function's definition.  But ignore
 394   // this if we're emitting RTTI under -fno-rtti.
 395   if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
 396     // FIXME: what should we do if we "lose" the key function during
 397     // the emission of the file?
 398     if (Context.getCurrentKeyFunction(RD))
 399       return;
 400   }
 401
 402   // Otherwise, drop the visibility to hidden.
 403   GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
 404   GV->setUnnamedAddr(true);
 405 }
 406
 407 StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
 408   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
 409
 410   StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
 411   if (!Str.empty())
 412     return Str;
 413
 414   if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
 415     IdentifierInfo *II = ND->getIdentifier();
 416     assert(II && "Attempt to mangle unnamed decl.");
 417
 418     Str = II->getName();
 419     return Str;
 420   }
 421
 422   SmallString<256> Buffer;
 423   llvm::raw_svector_ostream Out(Buffer);
 424   if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
 425     getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
 426   else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
 427     getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
 428   else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
 429     getCXXABI().getMangleContext().mangleBlock(BD, Out,
 430       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
 431   else
 432     getCXXABI().getMangleContext().mangleName(ND, Out);
 433
 434   // Allocate space for the mangled name.
 435   Out.flush();
 436   size_t Length = Buffer.size();
 437   char *Name = MangledNamesAllocator.Allocate<char>(Length);
 438   std::copy(Buffer.begin(), Buffer.end(), Name);
 439
 440   Str = StringRef(Name, Length);
 441
 442   return Str;
 443 }
 444
 445 void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
 446                                         const BlockDecl *BD) {
 447   MangleContext &MangleCtx = getCXXABI().getMangleContext();
 448   const Decl *D = GD.getDecl();
 449   llvm::raw_svector_ostream Out(Buffer.getBuffer());
 450   if (D == 0)
 451     MangleCtx.mangleGlobalBlock(BD,
 452       dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
 453   else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
 454     MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
 455   else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
 456     MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
 457   else
 458     MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
 459 }
 460
 461 llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
 462   return getModule().getNamedValue(Name);
 463 }
 464
 465 /// AddGlobalCtor - Add a function to the list that will be called before
 466 /// main() runs.
 467 void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
 468   // FIXME: Type coercion of void()* types.
 469   GlobalCtors.push_back(std::make_pair(Ctor, Priority));
 470 }
 471
 472 /// AddGlobalDtor - Add a function to the list that will be called
 473 /// when the module is unloaded.
 474 void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
 475   // FIXME: Type coercion of void()* types.
 476   GlobalDtors.push_back(std::make_pair(Dtor, Priority));
 477 }
 478
 479 void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
 480   // Ctor function type is void()*.
 481   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
 482   llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
 483
 484   // Get the type of a ctor entry, { i32, void ()* }.
 485   llvm::StructType *CtorStructTy =
 486     llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
 487
 488   // Construct the constructor and destructor arrays.
 489   SmallVector<llvm::Constant*, 8> Ctors;
 490   for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
 491     llvm::Constant *S[] = {
 492       llvm::ConstantInt::get(Int32Ty, I->second, false),
 493       llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
 494     };
 495     Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
 496   }
 497
 498   if (!Ctors.empty()) {
 499     llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
 500     new llvm::GlobalVariable(TheModule, AT, false,
 501                              llvm::GlobalValue::AppendingLinkage,
 502                              llvm::ConstantArray::get(AT, Ctors),
 503                              GlobalName);
 504   }
 505 }
 506
 507 llvm::GlobalValue::LinkageTypes
 508 CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
 509   GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
 510
 511   if (Linkage == GVA_Internal)
 512     return llvm::Function::InternalLinkage;
 513
 514   if (D->hasAttr<DLLExportAttr>())
 515     return llvm::Function::DLLExportLinkage;
 516
 517   if (D->hasAttr<WeakAttr>())
 518     return llvm::Function::WeakAnyLinkage;
 519
 520   // In C99 mode, 'inline' functions are guaranteed to have a strong
 521   // definition somewhere else, so we can use available_externally linkage.
 522   if (Linkage == GVA_C99Inline)
 523     return llvm::Function::AvailableExternallyLinkage;
 524
 525   // Note that Apple's kernel linker doesn't support symbol
 526   // coalescing, so we need to avoid linkonce and weak linkages there.
 527   // Normally, this means we just map to internal, but for explicit
 528   // instantiations we'll map to external.
 529
 530   // In C++, the compiler has to emit a definition in every translation unit
 531   // that references the function.  We should use linkonce_odr because
 532   // a) if all references in this translation unit are optimized away, we
 533   // don't need to codegen it.  b) if the function persists, it needs to be
 534   // merged with other definitions. c) C++ has the ODR, so we know the
 535   // definition is dependable.
 536   if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
 537     return !Context.getLangOpts().AppleKext
 538              ? llvm::Function::LinkOnceODRLinkage
 539              : llvm::Function::InternalLinkage;
 540
 541   // An explicit instantiation of a template has weak linkage, since
 542   // explicit instantiations can occur in multiple translation units
 543   // and must all be equivalent. However, we are not allowed to
 544   // throw away these explicit instantiations.
 545   if (Linkage == GVA_ExplicitTemplateInstantiation)
 546     return !Context.getLangOpts().AppleKext
 547              ? llvm::Function::WeakODRLinkage
 548              : llvm::Function::ExternalLinkage;
 549
 550   // Otherwise, we have strong external linkage.
 551   assert(Linkage == GVA_StrongExternal);
 552   return llvm::Function::ExternalLinkage;
 553 }
 554
 555
 556 /// SetFunctionDefinitionAttributes - Set attributes for a global.
 557 ///
 558 /// FIXME: This is currently only done for aliases and functions, but not for
 559 /// variables (these details are set in EmitGlobalVarDefinition for variables).
 560 void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
 561                                                     llvm::GlobalValue *GV) {
 562   SetCommonAttributes(D, GV);
 563 }
 564
 565 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
 566                                               const CGFunctionInfo &Info,
 567                                               llvm::Function *F) {
 568   unsigned CallingConv;
 569   AttributeListType AttributeList;
 570   ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
 571   F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
 572   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
 573 }
 574
 575 /// Determines whether the language options require us to model
 576 /// unwind exceptions.  We treat -fexceptions as mandating this
 577 /// except under the fragile ObjC ABI with only ObjC exceptions
 578 /// enabled.  This means, for example, that C with -fexceptions
 579 /// enables this.
 580 static bool hasUnwindExceptions(const LangOptions &LangOpts) {
 581   // If exceptions are completely disabled, obviously this is false.
 582   if (!LangOpts.Exceptions) return false;
 583
 584   // If C++ exceptions are enabled, this is true.
 585   if (LangOpts.CXXExceptions) return true;
 586
 587   // If ObjC exceptions are enabled, this depends on the ABI.
 588   if (LangOpts.ObjCExceptions) {
 589     return LangOpts.ObjCRuntime.hasUnwindExceptions();
 590   }
 591
 592   return true;
 593 }
 594
 595 void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
 596                                                            llvm::Function *F) {
 597   if (CodeGenOpts.UnwindTables)
 598     F->setHasUWTable();
 599
 600   if (!hasUnwindExceptions(LangOpts))
 601     F->addFnAttr(llvm::Attribute::NoUnwind);
 602
 603   if (D->hasAttr<NakedAttr>()) {
 604     // Naked implies noinline: we should not be inlining such functions.
 605     F->addFnAttr(llvm::Attribute::Naked);
 606     F->addFnAttr(llvm::Attribute::NoInline);
 607   }
 608
 609   if (D->hasAttr<NoInlineAttr>())
 610     F->addFnAttr(llvm::Attribute::NoInline);
 611
 612   // (noinline wins over always_inline, and we can't specify both in IR)
 613   if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) &&
 614       !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
 615                                        llvm::Attribute::NoInline))
 616     F->addFnAttr(llvm::Attribute::AlwaysInline);
 617
 618   // FIXME: Communicate hot and cold attributes to LLVM more directly.
 619   if (D->hasAttr<ColdAttr>())
 620     F->addFnAttr(llvm::Attribute::OptimizeForSize);
 621
 622   if (D->hasAttr<MinSizeAttr>())
 623     F->addFnAttr(llvm::Attribute::MinSize);
 624
 625   if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
 626     F->setUnnamedAddr(true);
 627
 628   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
 629     if (MD->isVirtual())
 630       F->setUnnamedAddr(true);
 631
 632   if (LangOpts.getStackProtector() == LangOptions::SSPOn)
 633     F->addFnAttr(llvm::Attribute::StackProtect);
 634   else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
 635     F->addFnAttr(llvm::Attribute::StackProtectReq);
 636
 637   // Add sanitizer attributes if function is not blacklisted.
 638   if (!SanitizerBlacklist.isIn(*F)) {
 639     // When AddressSanitizer is enabled, set SanitizeAddress attribute
 640     // unless __attribute__((no_sanitize_address)) is used.
 641     if (SanOpts.Address && !D->hasAttr<NoSanitizeAddressAttr>())
 642       F->addFnAttr(llvm::Attribute::SanitizeAddress);
 643     // Same for ThreadSanitizer and __attribute__((no_sanitize_thread))
 644     if (SanOpts.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) {
 645       F->addFnAttr(llvm::Attribute::SanitizeThread);
 646     }
 647     // Same for MemorySanitizer and __attribute__((no_sanitize_memory))
 648     if (SanOpts.Memory && !D->hasAttr<NoSanitizeMemoryAttr>())
 649       F->addFnAttr(llvm::Attribute::SanitizeMemory);
 650   }
 651
 652   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
 653   if (alignment)
 654     F->setAlignment(alignment);
 655
 656   // C++ ABI requires 2-byte alignment for member functions.
 657   if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
 658     F->setAlignment(2);
 659 }
 660
 661 void CodeGenModule::SetCommonAttributes(const Decl *D,
 662                                         llvm::GlobalValue *GV) {
 663   if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
 664     setGlobalVisibility(GV, ND);
 665   else
 666     GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
 667
 668   if (D->hasAttr<UsedAttr>())
 669     AddUsedGlobal(GV);
 670
 671   if (const SectionAttr *SA = D->getAttr<SectionAttr>())
 672     GV->setSection(SA->getName());
 673
 674   // Alias cannot have attributes. Filter them here.
 675   if (!isa<llvm::GlobalAlias>(GV))
 676     getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
 677 }
 678
 679 void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
 680                                                   llvm::Function *F,
 681                                                   const CGFunctionInfo &FI) {
 682   SetLLVMFunctionAttributes(D, FI, F);
 683   SetLLVMFunctionAttributesForDefinition(D, F);
 684
 685   F->setLinkage(llvm::Function::InternalLinkage);
 686
 687   SetCommonAttributes(D, F);
 688 }
 689
 690 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
 691                                           llvm::Function *F,
 692                                           bool IsIncompleteFunction) {
 693   if (unsigned IID = F->getIntrinsicID()) {
 694     // If this is an intrinsic function, set the function's attributes
 695     // to the intrinsic's attributes.
 696     F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
 697                                                     (llvm::Intrinsic::ID)IID));
 698     return;
 699   }
 700
 701   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
 702
 703   if (!IsIncompleteFunction)
 704     SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
 705
 706   // Only a few attributes are set on declarations; these may later be
 707   // overridden by a definition.
 708
 709   if (FD->hasAttr<DLLImportAttr>()) {
 710     F->setLinkage(llvm::Function::DLLImportLinkage);
 711   } else if (FD->hasAttr<WeakAttr>() ||
 712              FD->isWeakImported()) {
 713     // "extern_weak" is overloaded in LLVM; we probably should have
 714     // separate linkage types for this.
 715     F->setLinkage(llvm::Function::ExternalWeakLinkage);
 716   } else {
 717     F->setLinkage(llvm::Function::ExternalLinkage);
 718
 719     LinkageInfo LV = FD->getLinkageAndVisibility();
 720     if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) {
 721       F->setVisibility(GetLLVMVisibility(LV.getVisibility()));
 722     }
 723   }
 724
 725   if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
 726     F->setSection(SA->getName());
 727 }
 728
 729 void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
 730   assert(!GV->isDeclaration() &&
 731          "Only globals with definition can force usage.");
 732   LLVMUsed.push_back(GV);
 733 }
 734
 735 void CodeGenModule::EmitLLVMUsed() {
 736   // Don't create llvm.used if there is no need.
 737   if (LLVMUsed.empty())
 738     return;
 739
 740   // Convert LLVMUsed to what ConstantArray needs.
 741   SmallVector<llvm::Constant*, 8> UsedArray;
 742   UsedArray.resize(LLVMUsed.size());
 743   for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
 744     UsedArray[i] =
 745      llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
 746                                     Int8PtrTy);
 747   }
 748
 749   if (UsedArray.empty())
 750     return;
 751   llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
 752
 753   llvm::GlobalVariable *GV =
 754     new llvm::GlobalVariable(getModule(), ATy, false,
 755                              llvm::GlobalValue::AppendingLinkage,
 756                              llvm::ConstantArray::get(ATy, UsedArray),
 757                              "llvm.used");
 758
 759   GV->setSection("llvm.metadata");
 760 }
 761
 762 /// \brief Add link options implied by the given module, including modules
 763 /// it depends on, using a postorder walk.
 764 static void addLinkOptionsPostorder(llvm::LLVMContext &Context,
 765                                     Module *Mod,
 766                                     SmallVectorImpl<llvm::Value *> &Metadata,
 767                                     llvm::SmallPtrSet<Module *, 16> &Visited) {
 768   // Import this module's parent.
 769   if (Mod->Parent && Visited.insert(Mod->Parent)) {
 770     addLinkOptionsPostorder(Context, Mod->Parent, Metadata, Visited);
 771   }
 772
 773   // Import this module's dependencies.
 774   for (unsigned I = Mod->Imports.size(); I > 0; --I) {
 775     if (Visited.insert(Mod->Imports[I-1]))
 776       addLinkOptionsPostorder(Context, Mod->Imports[I-1], Metadata, Visited);
 777   }
 778
 779   // Add linker options to link against the libraries/frameworks
 780   // described by this module.
 781   for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
 782     // FIXME: -lfoo is Unix-centric and -framework Foo is Darwin-centric.
 783     // We need to know more about the linker to know how to encode these
 784     // options propertly.
 785
 786     // Link against a framework.
 787     if (Mod->LinkLibraries[I-1].IsFramework) {
 788       llvm::Value *Args[2] = {
 789         llvm::MDString::get(Context, "-framework"),
 790         llvm::MDString::get(Context, Mod->LinkLibraries[I-1].Library)
 791       };
 792
 793       Metadata.push_back(llvm::MDNode::get(Context, Args));
 794       continue;
 795     }
 796
 797     // Link against a library.
 798     llvm::Value *OptString
 799     = llvm::MDString::get(Context,
 800                           "-l" + Mod->LinkLibraries[I-1].Library);
 801     Metadata.push_back(llvm::MDNode::get(Context, OptString));
 802   }
 803 }
 804
 805 void CodeGenModule::EmitModuleLinkOptions() {
 806   // Collect the set of all of the modules we want to visit to emit link
 807   // options, which is essentially the imported modules and all of their
 808   // non-explicit child modules.
 809   llvm::SetVector<clang::Module *> LinkModules;
 810   llvm::SmallPtrSet<clang::Module *, 16> Visited;
 811   SmallVector<clang::Module *, 16> Stack;
 812
 813   // Seed the stack with imported modules.
 814   for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(),
 815                                                MEnd = ImportedModules.end();
 816        M != MEnd; ++M) {
 817     if (Visited.insert(*M))
 818       Stack.push_back(*M);
 819   }
 820
 821   // Find all of the modules to import, making a little effort to prune
 822   // non-leaf modules.
 823   while (!Stack.empty()) {
 824     clang::Module *Mod = Stack.back();
 825     Stack.pop_back();
 826
 827     bool AnyChildren = false;
 828
 829     // Visit the submodules of this module.
 830     for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
 831                                         SubEnd = Mod->submodule_end();
 832          Sub != SubEnd; ++Sub) {
 833       // Skip explicit children; they need to be explicitly imported to be
 834       // linked against.
 835       if ((*Sub)->IsExplicit)
 836         continue;
 837
 838       if (Visited.insert(*Sub)) {
 839         Stack.push_back(*Sub);
 840         AnyChildren = true;
 841       }
 842     }
 843
 844     // We didn't find any children, so add this module to the list of
 845     // modules to link against.
 846     if (!AnyChildren) {
 847       LinkModules.insert(Mod);
 848     }
 849   }
 850
 851   // Add link options for all of the imported modules in reverse topological
 852   // order.
 853   SmallVector<llvm::Value *, 16> MetadataArgs;
 854   Visited.clear();
 855   for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(),
 856                                                MEnd = LinkModules.end();
 857        M != MEnd; ++M) {
 858     if (Visited.insert(*M))
 859       addLinkOptionsPostorder(getLLVMContext(), *M, MetadataArgs, Visited);
 860   }
 861   std::reverse(MetadataArgs.begin(), MetadataArgs.end());
 862
 863   // Add the linker options metadata flag.
 864   getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
 865                             llvm::MDNode::get(getLLVMContext(), MetadataArgs));
 866 }
 867
 868 void CodeGenModule::EmitDeferred() {
 869   // Emit code for any potentially referenced deferred decls.  Since a
 870   // previously unused static decl may become used during the generation of code
 871   // for a static function, iterate until no changes are made.
 872
 873   while (true) {
 874     if (!DeferredVTables.empty()) {
 875       EmitDeferredVTables();
 876
 877       // Emitting a v-table doesn't directly cause more v-tables to
 878       // become deferred, although it can cause functions to be
 879       // emitted that then need those v-tables.
 880       assert(DeferredVTables.empty());
 881     }
 882
 883     // Stop if we're out of both deferred v-tables and deferred declarations.
 884     if (DeferredDeclsToEmit.empty()) break;
 885
 886     GlobalDecl D = DeferredDeclsToEmit.back();
 887     DeferredDeclsToEmit.pop_back();
 888
 889     // Check to see if we've already emitted this.  This is necessary
 890     // for a couple of reasons: first, decls can end up in the
 891     // deferred-decls queue multiple times, and second, decls can end
 892     // up with definitions in unusual ways (e.g. by an extern inline
 893     // function acquiring a strong function redefinition).  Just
 894     // ignore these cases.
 895     //
 896     // TODO: That said, looking this up multiple times is very wasteful.
 897     StringRef Name = getMangledName(D);
 898     llvm::GlobalValue *CGRef = GetGlobalValue(Name);
 899     assert(CGRef && "Deferred decl wasn't referenced?");
 900
 901     if (!CGRef->isDeclaration())
 902       continue;
 903
 904     // GlobalAlias::isDeclaration() defers to the aliasee, but for our
 905     // purposes an alias counts as a definition.
 906     if (isa<llvm::GlobalAlias>(CGRef))
 907       continue;
 908
 909     // Otherwise, emit the definition and move on to the next one.
 910     EmitGlobalDefinition(D);
 911   }
 912 }
 913
 914 void CodeGenModule::EmitGlobalAnnotations() {
 915   if (Annotations.empty())
 916     return;
 917
 918   // Create a new global variable for the ConstantStruct in the Module.
 919   llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
 920     Annotations[0]->getType(), Annotations.size()), Annotations);
 921   llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
 922     Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
 923     "llvm.global.annotations");
 924   gv->setSection(AnnotationSection);
 925 }
 926
 927 llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
 928   llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
 929   if (i != AnnotationStrings.end())
 930     return i->second;
 931
 932   // Not found yet, create a new global.
 933   llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
 934   llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
 935     true, llvm::GlobalValue::PrivateLinkage, s, ".str");
 936   gv->setSection(AnnotationSection);
 937   gv->setUnnamedAddr(true);
 938   AnnotationStrings[Str] = gv;
 939   return gv;
 940 }
 941
 942 llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
 943   SourceManager &SM = getContext().getSourceManager();
 944   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
 945   if (PLoc.isValid())
 946     return EmitAnnotationString(PLoc.getFilename());
 947   return EmitAnnotationString(SM.getBufferName(Loc));
 948 }
 949
 950 llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
 951   SourceManager &SM = getContext().getSourceManager();
 952   PresumedLoc PLoc = SM.getPresumedLoc(L);
 953   unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
 954     SM.getExpansionLineNumber(L);
 955   return llvm::ConstantInt::get(Int32Ty, LineNo);
 956 }
 957
 958 llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
 959                                                 const AnnotateAttr *AA,
 960                                                 SourceLocation L) {
 961   // Get the globals for file name, annotation, and the line number.
 962   llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
 963                  *UnitGV = EmitAnnotationUnit(L),
 964                  *LineNoCst = EmitAnnotationLineNo(L);
 965
 966   // Create the ConstantStruct for the global annotation.
 967   llvm::Constant *Fields[4] = {
 968     llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
 969     llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
 970     llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
 971     LineNoCst
 972   };
 973   return llvm::ConstantStruct::getAnon(Fields);
 974 }
 975
 976 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
 977                                          llvm::GlobalValue *GV) {
 978   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
 979   // Get the struct elements for these annotations.
 980   for (specific_attr_iterator<AnnotateAttr>
 981        ai = D->specific_attr_begin<AnnotateAttr>(),
 982        ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
 983     Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
 984 }
 985
 986 bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
 987   // Never defer when EmitAllDecls is specified.
 988   if (LangOpts.EmitAllDecls)
 989     return false;
 990
 991   return !getContext().DeclMustBeEmitted(Global);
 992 }
 993
 994 llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
 995     const CXXUuidofExpr* E) {
 996   // Sema has verified that IIDSource has a __declspec(uuid()), and that its
 997   // well-formed.
 998   StringRef Uuid;
 999   if (E->isTypeOperand())
1000     Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid();
1001   else {
1002     // Special case: __uuidof(0) means an all-zero GUID.
1003     Expr *Op = E->getExprOperand();
1004     if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
1005       Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid();
1006     else
1007       Uuid = "00000000-0000-0000-0000-000000000000";
1008   }
1009   std::string Name = "__uuid_" + Uuid.str();
1010
1011   // Look for an existing global.
1012   if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
1013     return GV;
1014
1015   llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
1016   assert(Init && "failed to initialize as constant");
1017
1018   // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
1019   // first field is declared as "long", which for many targets is 8 bytes.
1020   // Those architectures are not supported. (With the MS abi, long is always 4
1021   // bytes.)
1022   llvm::Type *GuidType = getTypes().ConvertType(E->getType());
1023   if (Init->getType() != GuidType) {
1024     DiagnosticsEngine &Diags = getDiags();
1025     unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1026         "__uuidof codegen is not supported on this architecture");
1027     Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
1028     Init = llvm::UndefValue::get(GuidType);
1029   }
1030
1031   llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
1032       /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name);
1033   GV->setUnnamedAddr(true);
1034   return GV;
1035 }
1036
1037 llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
1038   const AliasAttr *AA = VD->getAttr<AliasAttr>();
1039   assert(AA && "No alias?");
1040
1041   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
1042
1043   // See if there is already something with the target's name in the module.
1044   llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
1045   if (Entry) {
1046     unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1047     return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1048   }
1049
1050   llvm::Constant *Aliasee;
1051   if (isa<llvm::FunctionType>(DeclTy))
1052     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1053                                       GlobalDecl(cast<FunctionDecl>(VD)),
1054                                       /*ForVTable=*/false);
1055   else
1056     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
1057                                     llvm::PointerType::getUnqual(DeclTy), 0);
1058
1059   llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
1060   F->setLinkage(llvm::Function::ExternalWeakLinkage);
1061   WeakRefReferences.insert(F);
1062
1063   return Aliasee;
1064 }
1065
1066 void CodeGenModule::EmitGlobal(GlobalDecl GD) {
1067   const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
1068
1069   // Weak references don't produce any output by themselves.
1070   if (Global->hasAttr<WeakRefAttr>())
1071     return;
1072
1073   // If this is an alias definition (which otherwise looks like a declaration)
1074   // emit it now.
1075   if (Global->hasAttr<AliasAttr>())
1076     return EmitAliasDefinition(GD);
1077
1078   // If this is CUDA, be selective about which declarations we emit.
1079   if (LangOpts.CUDA) {
1080     if (CodeGenOpts.CUDAIsDevice) {
1081       if (!Global->hasAttr<CUDADeviceAttr>() &&
1082           !Global->hasAttr<CUDAGlobalAttr>() &&
1083           !Global->hasAttr<CUDAConstantAttr>() &&
1084           !Global->hasAttr<CUDASharedAttr>())
1085         return;
1086     } else {
1087       if (!Global->hasAttr<CUDAHostAttr>() && (
1088             Global->hasAttr<CUDADeviceAttr>() ||
1089             Global->hasAttr<CUDAConstantAttr>() ||
1090             Global->hasAttr<CUDASharedAttr>()))
1091         return;
1092     }
1093   }
1094
1095   // Ignore declarations, they will be emitted on their first use.
1096   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
1097     // Forward declarations are emitted lazily on first use.
1098     if (!FD->doesThisDeclarationHaveABody()) {
1099       if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1100         return;
1101
1102       const FunctionDecl *InlineDefinition = 0;
1103       FD->getBody(InlineDefinition);
1104
1105       StringRef MangledName = getMangledName(GD);
1106       DeferredDecls.erase(MangledName);
1107       EmitGlobalDefinition(InlineDefinition);
1108       return;
1109     }
1110   } else {
1111     const VarDecl *VD = cast<VarDecl>(Global);
1112     assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1113
1114     if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
1115       return;
1116   }
1117
1118   // Defer code generation when possible if this is a static definition, inline
1119   // function etc.  These we only want to emit if they are used.
1120   if (!MayDeferGeneration(Global)) {
1121     // Emit the definition if it can't be deferred.
1122     EmitGlobalDefinition(GD);
1123     return;
1124   }
1125
1126   // If we're deferring emission of a C++ variable with an
1127   // initializer, remember the order in which it appeared in the file.
1128   if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
1129       cast<VarDecl>(Global)->hasInit()) {
1130     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1131     CXXGlobalInits.push_back(0);
1132   }
1133
1134   // If the value has already been used, add it directly to the
1135   // DeferredDeclsToEmit list.
1136   StringRef MangledName = getMangledName(GD);
1137   if (GetGlobalValue(MangledName))
1138     DeferredDeclsToEmit.push_back(GD);
1139   else {
1140     // Otherwise, remember that we saw a deferred decl with this name.  The
1141     // first use of the mangled name will cause it to move into
1142     // DeferredDeclsToEmit.
1143     DeferredDecls[MangledName] = GD;
1144   }
1145 }
1146
1147 namespace {
1148   struct FunctionIsDirectlyRecursive :
1149     public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1150     const StringRef Name;
1151     const Builtin::Context &BI;
1152     bool Result;
1153     FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1154       Name(N), BI(C), Result(false) {
1155     }
1156     typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1157
1158     bool TraverseCallExpr(CallExpr *E) {
1159       const FunctionDecl *FD = E->getDirectCallee();
1160       if (!FD)
1161         return true;
1162       AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1163       if (Attr && Name == Attr->getLabel()) {
1164         Result = true;
1165         return false;
1166       }
1167       unsigned BuiltinID = FD->getBuiltinID();
1168       if (!BuiltinID)
1169         return true;
1170       StringRef BuiltinName = BI.GetName(BuiltinID);
1171       if (BuiltinName.startswith("__builtin_") &&
1172           Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
1173         Result = true;
1174         return false;
1175       }
1176       return true;
1177     }
1178   };
1179 }
1180
1181 // isTriviallyRecursive - Check if this function calls another
1182 // decl that, because of the asm attribute or the other decl being a builtin,
1183 // ends up pointing to itself.
1184 bool
1185 CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1186   StringRef Name;
1187   if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
1188     // asm labels are a special kind of mangling we have to support.
1189     AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1190     if (!Attr)
1191       return false;
1192     Name = Attr->getLabel();
1193   } else {
1194     Name = FD->getName();
1195   }
1196
1197   FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1198   Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
1199   return Walker.Result;
1200 }
1201
1202 bool
1203 CodeGenModule::shouldEmitFunction(const FunctionDecl *F) {
1204   if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage)
1205     return true;
1206   if (CodeGenOpts.OptimizationLevel == 0 &&
1207       !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
1208     return false;
1209   // PR9614. Avoid cases where the source code is lying to us. An available
1210   // externally function should have an equivalent function somewhere else,
1211   // but a function that calls itself is clearly not equivalent to the real
1212   // implementation.
1213   // This happens in glibc's btowc and in some configure checks.
1214   return !isTriviallyRecursive(F);
1215 }
1216
1217 void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
1218   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
1219
1220   PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
1221                                  Context.getSourceManager(),
1222                                  "Generating code for declaration");
1223
1224   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1225     // At -O0, don't generate IR for functions with available_externally
1226     // linkage.
1227     if (!shouldEmitFunction(Function))
1228       return;
1229
1230     if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1231       // Make sure to emit the definition(s) before we emit the thunks.
1232       // This is necessary for the generation of certain thunks.
1233       if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1234         EmitCXXConstructor(CD, GD.getCtorType());
1235       else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1236         EmitCXXDestructor(DD, GD.getDtorType());
1237       else
1238         EmitGlobalFunctionDefinition(GD);
1239
1240       if (Method->isVirtual())
1241         getVTables().EmitThunks(GD);
1242
1243       return;
1244     }
1245
1246     return EmitGlobalFunctionDefinition(GD);
1247   }
1248
1249   if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1250     return EmitGlobalVarDefinition(VD);
1251
1252   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
1253 }
1254
1255 /// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1256 /// module, create and return an llvm Function with the specified type. If there
1257 /// is something in the module with the specified name, return it potentially
1258 /// bitcasted to the right type.
1259 ///
1260 /// If D is non-null, it specifies a decl that correspond to this.  This is used
1261 /// to set the attributes on the function when it is first created.
1262 llvm::Constant *
1263 CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
1264                                        llvm::Type *Ty,
1265                                        GlobalDecl D, bool ForVTable,
1266                                        llvm::AttributeSet ExtraAttrs) {
1267   // Lookup the entry, lazily creating it if necessary.
1268   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1269   if (Entry) {
1270     if (WeakRefReferences.erase(Entry)) {
1271       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
1272       if (FD && !FD->hasAttr<WeakAttr>())
1273         Entry->setLinkage(llvm::Function::ExternalLinkage);
1274     }
1275
1276     if (Entry->getType()->getElementType() == Ty)
1277       return Entry;
1278
1279     // Make sure the result is of the correct type.
1280     return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
1281   }
1282
1283   // This function doesn't have a complete type (for example, the return
1284   // type is an incomplete struct). Use a fake type instead, and make
1285   // sure not to try to set attributes.
1286   bool IsIncompleteFunction = false;
1287
1288   llvm::FunctionType *FTy;
1289   if (isa<llvm::FunctionType>(Ty)) {
1290     FTy = cast<llvm::FunctionType>(Ty);
1291   } else {
1292     FTy = llvm::FunctionType::get(VoidTy, false);
1293     IsIncompleteFunction = true;
1294   }
1295
1296   llvm::Function *F = llvm::Function::Create(FTy,
1297                                              llvm::Function::ExternalLinkage,
1298                                              MangledName, &getModule());
1299   assert(F->getName() == MangledName && "name was uniqued!");
1300   if (D.getDecl())
1301     SetFunctionAttributes(D, F, IsIncompleteFunction);
1302   if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) {
1303     llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex);
1304     F->addAttributes(llvm::AttributeSet::FunctionIndex,
1305                      llvm::AttributeSet::get(VMContext,
1306                                              llvm::AttributeSet::FunctionIndex,
1307                                              B));
1308   }
1309
1310   // This is the first use or definition of a mangled name.  If there is a
1311   // deferred decl with this name, remember that we need to emit it at the end
1312   // of the file.
1313   llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
1314   if (DDI != DeferredDecls.end()) {
1315     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1316     // list, and remove it from DeferredDecls (since we don't need it anymore).
1317     DeferredDeclsToEmit.push_back(DDI->second);
1318     DeferredDecls.erase(DDI);
1319
1320   // Otherwise, there are cases we have to worry about where we're
1321   // using a declaration for which we must emit a definition but where
1322   // we might not find a top-level definition:
1323   //   - member functions defined inline in their classes
1324   //   - friend functions defined inline in some class
1325   //   - special member functions with implicit definitions
1326   // If we ever change our AST traversal to walk into class methods,
1327   // this will be unnecessary.
1328   //
1329   // We also don't emit a definition for a function if it's going to be an entry
1330   // in a vtable, unless it's already marked as used.
1331   } else if (getLangOpts().CPlusPlus && D.getDecl()) {
1332     // Look for a declaration that's lexically in a record.
1333     const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
1334     FD = FD->getMostRecentDecl();
1335     do {
1336       if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
1337         if (FD->isImplicit() && !ForVTable) {
1338           assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
1339           DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
1340           break;
1341         } else if (FD->doesThisDeclarationHaveABody()) {
1342           DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
1343           break;
1344         }
1345       }
1346       FD = FD->getPreviousDecl();
1347     } while (FD);
1348   }
1349
1350   // Make sure the result is of the requested type.
1351   if (!IsIncompleteFunction) {
1352     assert(F->getType()->getElementType() == Ty);
1353     return F;
1354   }
1355
1356   llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
1357   return llvm::ConstantExpr::getBitCast(F, PTy);
1358 }
1359
1360 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
1361 /// non-null, then this function will use the specified type if it has to
1362 /// create it (this occurs when we see a definition of the function).
1363 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
1364                                                  llvm::Type *Ty,
1365                                                  bool ForVTable) {
1366   // If there was no specific requested type, just convert it now.
1367   if (!Ty)
1368     Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
1369
1370   StringRef MangledName = getMangledName(GD);
1371   return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
1372 }
1373
1374 /// CreateRuntimeFunction - Create a new runtime function with the specified
1375 /// type and name.
1376 llvm::Constant *
1377 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
1378                                      StringRef Name,
1379                                      llvm::AttributeSet ExtraAttrs) {
1380   llvm::Constant *C
1381     = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1382                               ExtraAttrs);
1383   if (llvm::Function *F = dyn_cast<llvm::Function>(C))
1384     if (F->empty())
1385       F->setCallingConv(getRuntimeCC());
1386   return C;
1387 }
1388
1389 /// isTypeConstant - Determine whether an object of this type can be emitted
1390 /// as a constant.
1391 ///
1392 /// If ExcludeCtor is true, the duration when the object's constructor runs
1393 /// will not be considered. The caller will need to verify that the object is
1394 /// not written to during its construction.
1395 bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1396   if (!Ty.isConstant(Context) && !Ty->isReferenceType())
1397     return false;
1398
1399   if (Context.getLangOpts().CPlusPlus) {
1400     if (const CXXRecordDecl *Record
1401           = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1402       return ExcludeCtor && !Record->hasMutableFields() &&
1403              Record->hasTrivialDestructor();
1404   }
1405
1406   return true;
1407 }
1408
1409 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1410 /// create and return an llvm GlobalVariable with the specified type.  If there
1411 /// is something in the module with the specified name, return it potentially
1412 /// bitcasted to the right type.
1413 ///
1414 /// If D is non-null, it specifies a decl that correspond to this.  This is used
1415 /// to set the attributes on the global when it is first created.
1416 llvm::Constant *
1417 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
1418                                      llvm::PointerType *Ty,
1419                                      const VarDecl *D,
1420                                      bool UnnamedAddr) {
1421   // Lookup the entry, lazily creating it if necessary.
1422   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1423   if (Entry) {
1424     if (WeakRefReferences.erase(Entry)) {
1425       if (D && !D->hasAttr<WeakAttr>())
1426         Entry->setLinkage(llvm::Function::ExternalLinkage);
1427     }
1428
1429     if (UnnamedAddr)
1430       Entry->setUnnamedAddr(true);
1431
1432     if (Entry->getType() == Ty)
1433       return Entry;
1434
1435     // Make sure the result is of the correct type.
1436     return llvm::ConstantExpr::getBitCast(Entry, Ty);
1437   }
1438
1439   // This is the first use or definition of a mangled name.  If there is a
1440   // deferred decl with this name, remember that we need to emit it at the end
1441   // of the file.
1442   llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
1443   if (DDI != DeferredDecls.end()) {
1444     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1445     // list, and remove it from DeferredDecls (since we don't need it anymore).
1446     DeferredDeclsToEmit.push_back(DDI->second);
1447     DeferredDecls.erase(DDI);
1448   }
1449
1450   unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
1451   llvm::GlobalVariable *GV =
1452     new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
1453                              llvm::GlobalValue::ExternalLinkage,
1454                              0, MangledName, 0,
1455                              llvm::GlobalVariable::NotThreadLocal, AddrSpace);
1456
1457   // Handle things which are present even on external declarations.
1458   if (D) {
1459     // FIXME: This code is overly simple and should be merged with other global
1460     // handling.
1461     GV->setConstant(isTypeConstant(D->getType(), false));
1462
1463     // Set linkage and visibility in case we never see a definition.
1464     LinkageInfo LV = D->getLinkageAndVisibility();
1465     if (LV.getLinkage() != ExternalLinkage) {
1466       // Don't set internal linkage on declarations.
1467     } else {
1468       if (D->hasAttr<DLLImportAttr>())
1469         GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
1470       else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
1471         GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
1472
1473       // Set visibility on a declaration only if it's explicit.
1474       if (LV.isVisibilityExplicit())
1475         GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
1476     }
1477
1478     if (D->isThreadSpecified())
1479       setTLSMode(GV, *D);
1480   }
1481
1482   if (AddrSpace != Ty->getAddressSpace())
1483     return llvm::ConstantExpr::getBitCast(GV, Ty);
1484   else
1485     return GV;
1486 }
1487
1488
1489 llvm::GlobalVariable *
1490 CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
1491                                       llvm::Type *Ty,
1492                                       llvm::GlobalValue::LinkageTypes Linkage) {
1493   llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1494   llvm::GlobalVariable *OldGV = 0;
1495
1496
1497   if (GV) {
1498     // Check if the variable has the right type.
1499     if (GV->getType()->getElementType() == Ty)
1500       return GV;
1501
1502     // Because C++ name mangling, the only way we can end up with an already
1503     // existing global with the same name is if it has been declared extern "C".
1504     assert(GV->isDeclaration() && "Declaration has wrong type!");
1505     OldGV = GV;
1506   }
1507
1508   // Create a new variable.
1509   GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1510                                 Linkage, 0, Name);
1511
1512   if (OldGV) {
1513     // Replace occurrences of the old variable if needed.
1514     GV->takeName(OldGV);
1515
1516     if (!OldGV->use_empty()) {
1517       llvm::Constant *NewPtrForOldDecl =
1518       llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1519       OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1520     }
1521
1522     OldGV->eraseFromParent();
1523   }
1524
1525   return GV;
1526 }
1527
1528 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1529 /// given global variable.  If Ty is non-null and if the global doesn't exist,
1530 /// then it will be created with the specified type instead of whatever the
1531 /// normal requested type would be.
1532 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
1533                                                   llvm::Type *Ty) {
1534   assert(D->hasGlobalStorage() && "Not a global variable");
1535   QualType ASTTy = D->getType();
1536   if (Ty == 0)
1537     Ty = getTypes().ConvertTypeForMem(ASTTy);
1538
1539   llvm::PointerType *PTy =
1540     llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
1541
1542   StringRef MangledName = getMangledName(D);
1543   return GetOrCreateLLVMGlobal(MangledName, PTy, D);
1544 }
1545
1546 /// CreateRuntimeVariable - Create a new runtime global variable with the
1547 /// specified type and name.
1548 llvm::Constant *
1549 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
1550                                      StringRef Name) {
1551   return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
1552                                true);
1553 }
1554
1555 void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1556   assert(!D->getInit() && "Cannot emit definite definitions here!");
1557
1558   if (MayDeferGeneration(D)) {
1559     // If we have not seen a reference to this variable yet, place it
1560     // into the deferred declarations table to be emitted if needed
1561     // later.
1562     StringRef MangledName = getMangledName(D);
1563     if (!GetGlobalValue(MangledName)) {
1564       DeferredDecls[MangledName] = D;
1565       return;
1566     }
1567   }
1568
1569   // The tentative definition is the only definition.
1570   EmitGlobalVarDefinition(D);
1571 }
1572
1573 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
1574     return Context.toCharUnitsFromBits(
1575       TheDataLayout.getTypeStoreSizeInBits(Ty));
1576 }
1577
1578 llvm::Constant *
1579 CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
1580                                                        const Expr *rawInit) {
1581   ArrayRef<ExprWithCleanups::CleanupObject> cleanups;
1582   if (const ExprWithCleanups *withCleanups =
1583           dyn_cast<ExprWithCleanups>(rawInit)) {
1584     cleanups = withCleanups->getObjects();
1585     rawInit = withCleanups->getSubExpr();
1586   }
1587
1588   const InitListExpr *init = dyn_cast<InitListExpr>(rawInit);
1589   if (!init || !init->initializesStdInitializerList() ||
1590       init->getNumInits() == 0)
1591     return 0;
1592
1593   ASTContext &ctx = getContext();
1594   unsigned numInits = init->getNumInits();
1595   // FIXME: This check is here because we would otherwise silently miscompile
1596   // nested global std::initializer_lists. Better would be to have a real
1597   // implementation.
1598   for (unsigned i = 0; i < numInits; ++i) {
1599     const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i));
1600     if (inner && inner->initializesStdInitializerList()) {
1601       ErrorUnsupported(inner, "nested global std::initializer_list");
1602       return 0;
1603     }
1604   }
1605
1606   // Synthesize a fake VarDecl for the array and initialize that.
1607   QualType elementType = init->getInit(0)->getType();
1608   llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits);
1609   QualType arrayType = ctx.getConstantArrayType(elementType, numElements,
1610                                                 ArrayType::Normal, 0);
1611
1612   IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist");
1613   TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo(
1614                                               arrayType, D->getLocation());
1615   VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>(
1616                                                           D->getDeclContext()),
1617                                           D->getLocStart(), D->getLocation(),
1618                                           name, arrayType, sourceInfo,
1619                                           SC_Static);
1620
1621   // Now clone the InitListExpr to initialize the array instead.
1622   // Incredible hack: we want to use the existing InitListExpr here, so we need
1623   // to tell it that it no longer initializes a std::initializer_list.
1624   ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(),
1625                         init->getNumInits());
1626   Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits,
1627                                            init->getRBraceLoc());
1628   arrayInit->setType(arrayType);
1629
1630   if (!cleanups.empty())
1631     arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups);
1632
1633   backingArray->setInit(arrayInit);
1634
1635   // Emit the definition of the array.
1636   EmitGlobalVarDefinition(backingArray);
1637
1638   // Inspect the initializer list to validate it and determine its type.
1639   // FIXME: doing this every time is probably inefficient; caching would be nice
1640   RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl();
1641   RecordDecl::field_iterator field = record->field_begin();
1642   if (field == record->field_end()) {
1643     ErrorUnsupported(D, "weird std::initializer_list");
1644     return 0;
1645   }
1646   QualType elementPtr = ctx.getPointerType(elementType.withConst());
1647   // Start pointer.
1648   if (!ctx.hasSameType(field->getType(), elementPtr)) {
1649     ErrorUnsupported(D, "weird std::initializer_list");
1650     return 0;
1651   }
1652   ++field;
1653   if (field == record->field_end()) {
1654     ErrorUnsupported(D, "weird std::initializer_list");
1655     return 0;
1656   }
1657   bool isStartEnd = false;
1658   if (ctx.hasSameType(field->getType(), elementPtr)) {
1659     // End pointer.
1660     isStartEnd = true;
1661   } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) {
1662     ErrorUnsupported(D, "weird std::initializer_list");
1663     return 0;
1664   }
1665
1666   // Now build an APValue representing the std::initializer_list.
1667   APValue initListValue(APValue::UninitStruct(), 0, 2);
1668   APValue &startField = initListValue.getStructField(0);
1669   APValue::LValuePathEntry startOffsetPathEntry;
1670   startOffsetPathEntry.ArrayIndex = 0;
1671   startField = APValue(APValue::LValueBase(backingArray),
1672                        CharUnits::fromQuantity(0),
1673                        llvm::makeArrayRef(startOffsetPathEntry),
1674                        /*IsOnePastTheEnd=*/false, 0);
1675
1676   if (isStartEnd) {
1677     APValue &endField = initListValue.getStructField(1);
1678     APValue::LValuePathEntry endOffsetPathEntry;
1679     endOffsetPathEntry.ArrayIndex = numInits;
1680     endField = APValue(APValue::LValueBase(backingArray),
1681                        ctx.getTypeSizeInChars(elementType) * numInits,
1682                        llvm::makeArrayRef(endOffsetPathEntry),
1683                        /*IsOnePastTheEnd=*/true, 0);
1684   } else {
1685     APValue &sizeField = initListValue.getStructField(1);
1686     sizeField = APValue(llvm::APSInt(numElements));
1687   }
1688
1689   // Emit the constant for the initializer_list.
1690   llvm::Constant *llvmInit =
1691       EmitConstantValueForMemory(initListValue, D->getType());
1692   assert(llvmInit && "failed to initialize as constant");
1693   return llvmInit;
1694 }
1695
1696 unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1697                                                  unsigned AddrSpace) {
1698   if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1699     if (D->hasAttr<CUDAConstantAttr>())
1700       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1701     else if (D->hasAttr<CUDASharedAttr>())
1702       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1703     else
1704       AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1705   }
1706
1707   return AddrSpace;
1708 }
1709
1710 void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
1711   llvm::Constant *Init = 0;
1712   QualType ASTTy = D->getType();
1713   CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1714   bool NeedsGlobalCtor = false;
1715   bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
1716
1717   const VarDecl *InitDecl;
1718   const Expr *InitExpr = D->getAnyInitializer(InitDecl);
1719
1720   if (!InitExpr) {
1721     // This is a tentative definition; tentative definitions are
1722     // implicitly initialized with { 0 }.
1723     //
1724     // Note that tentative definitions are only emitted at the end of
1725     // a translation unit, so they should never have incomplete
1726     // type. In addition, EmitTentativeDefinition makes sure that we
1727     // never attempt to emit a tentative definition if a real one
1728     // exists. A use may still exists, however, so we still may need
1729     // to do a RAUW.
1730     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
1731     Init = EmitNullConstant(D->getType());
1732   } else {
1733     // If this is a std::initializer_list, emit the special initializer.
1734     Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr);
1735     // An empty init list will perform zero-initialization, which happens
1736     // to be exactly what we want.
1737     // FIXME: It does so in a global constructor, which is *not* what we
1738     // want.
1739
1740     if (!Init) {
1741       initializedGlobalDecl = GlobalDecl(D);
1742       Init = EmitConstantInit(*InitDecl);
1743     }
1744     if (!Init) {
1745       QualType T = InitExpr->getType();
1746       if (D->getType()->isReferenceType())
1747         T = D->getType();
1748
1749       if (getLangOpts().CPlusPlus) {
1750         Init = EmitNullConstant(T);
1751         NeedsGlobalCtor = true;
1752       } else {
1753         ErrorUnsupported(D, "static initializer");
1754         Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1755       }
1756     } else {
1757       // We don't need an initializer, so remove the entry for the delayed
1758       // initializer position (just in case this entry was delayed) if we
1759       // also don't need to register a destructor.
1760       if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
1761         DelayedCXXInitPosition.erase(D);
1762     }
1763   }
1764
1765   llvm::Type* InitType = Init->getType();
1766   llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
1767
1768   // Strip off a bitcast if we got one back.
1769   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1770     assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1771            // all zero index gep.
1772            CE->getOpcode() == llvm::Instruction::GetElementPtr);
1773     Entry = CE->getOperand(0);
1774   }
1775
1776   // Entry is now either a Function or GlobalVariable.
1777   llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
1778
1779   // We have a definition after a declaration with the wrong type.
1780   // We must make a new GlobalVariable* and update everything that used OldGV
1781   // (a declaration or tentative definition) with the new GlobalVariable*
1782   // (which will be a definition).
1783   //
1784   // This happens if there is a prototype for a global (e.g.
1785   // "extern int x[];") and then a definition of a different type (e.g.
1786   // "int x[10];"). This also happens when an initializer has a different type
1787   // from the type of the global (this happens with unions).
1788   if (GV == 0 ||
1789       GV->getType()->getElementType() != InitType ||
1790       GV->getType()->getAddressSpace() !=
1791        GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
1792
1793     // Move the old entry aside so that we'll create a new one.
1794     Entry->setName(StringRef());
1795
1796     // Make a new global with the correct type, this is now guaranteed to work.
1797     GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
1798
1799     // Replace all uses of the old global with the new global
1800     llvm::Constant *NewPtrForOldDecl =
1801         llvm::ConstantExpr::getBitCast(GV, Entry->getType());
1802     Entry->replaceAllUsesWith(NewPtrForOldDecl);
1803
1804     // Erase the old global, since it is no longer used.
1805     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
1806   }
1807
1808   if (D->hasAttr<AnnotateAttr>())
1809     AddGlobalAnnotations(D, GV);
1810
1811   GV->setInitializer(Init);
1812
1813   // If it is safe to mark the global 'constant', do so now.
1814   GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1815                   isTypeConstant(D->getType(), true));
1816
1817   GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
1818
1819   // Set the llvm linkage type as appropriate.
1820   llvm::GlobalValue::LinkageTypes Linkage =
1821     GetLLVMLinkageVarDefinition(D, GV);
1822   GV->setLinkage(Linkage);
1823   if (Linkage == llvm::GlobalVariable::CommonLinkage)
1824     // common vars aren't constant even if declared const.
1825     GV->setConstant(false);
1826
1827   SetCommonAttributes(D, GV);
1828
1829   // Emit the initializer function if necessary.
1830   if (NeedsGlobalCtor || NeedsGlobalDtor)
1831     EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
1832
1833   // If we are compiling with ASan, add metadata indicating dynamically
1834   // initialized globals.
1835   if (SanOpts.Address && NeedsGlobalCtor) {
1836     llvm::Module &M = getModule();
1837
1838     llvm::NamedMDNode *DynamicInitializers =
1839         M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals");
1840     llvm::Value *GlobalToAdd[] = { GV };
1841     llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd);
1842     DynamicInitializers->addOperand(ThisGlobal);
1843   }
1844
1845   // Emit global variable debug information.
1846   if (CGDebugInfo *DI = getModuleDebugInfo())
1847     if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
1848       DI->EmitGlobalVariable(GV, D);
1849 }
1850
1851 llvm::GlobalValue::LinkageTypes
1852 CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1853                                            llvm::GlobalVariable *GV) {
1854   GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1855   if (Linkage == GVA_Internal)
1856     return llvm::Function::InternalLinkage;
1857   else if (D->hasAttr<DLLImportAttr>())
1858     return llvm::Function::DLLImportLinkage;
1859   else if (D->hasAttr<DLLExportAttr>())
1860     return llvm::Function::DLLExportLinkage;
1861   else if (D->hasAttr<WeakAttr>()) {
1862     if (GV->isConstant())
1863       return llvm::GlobalVariable::WeakODRLinkage;
1864     else
1865       return llvm::GlobalVariable::WeakAnyLinkage;
1866   } else if (Linkage == GVA_TemplateInstantiation ||
1867              Linkage == GVA_ExplicitTemplateInstantiation)
1868     return llvm::GlobalVariable::WeakODRLinkage;
1869   else if (!getLangOpts().CPlusPlus &&
1870            ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1871              D->getAttr<CommonAttr>()) &&
1872            !D->hasExternalStorage() && !D->getInit() &&
1873            !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1874            !D->getAttr<WeakImportAttr>()) {
1875     // Thread local vars aren't considered common linkage.
1876     return llvm::GlobalVariable::CommonLinkage;
1877   }
1878   return llvm::GlobalVariable::ExternalLinkage;
1879 }
1880
1881 /// Replace the uses of a function that was declared with a non-proto type.
1882 /// We want to silently drop extra arguments from call sites
1883 static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
1884                                           llvm::Function *newFn) {
1885   // Fast path.
1886   if (old->use_empty()) return;
1887
1888   llvm::Type *newRetTy = newFn->getReturnType();
1889   SmallVector<llvm::Value*, 4> newArgs;
1890
1891   for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
1892          ui != ue; ) {
1893     llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
1894     llvm::User *user = *use;
1895
1896     // Recognize and replace uses of bitcasts.  Most calls to
1897     // unprototyped functions will use bitcasts.
1898     if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
1899       if (bitcast->getOpcode() == llvm::Instruction::BitCast)
1900         replaceUsesOfNonProtoConstant(bitcast, newFn);
1901       continue;
1902     }
1903
1904     // Recognize calls to the function.
1905     llvm::CallSite callSite(user);
1906     if (!callSite) continue;
1907     if (!callSite.isCallee(use)) continue;
1908
1909     // If the return types don't match exactly, then we can't
1910     // transform this call unless it's dead.
1911     if (callSite->getType() != newRetTy && !callSite->use_empty())
1912       continue;
1913
1914     // Get the call site's attribute list.
1915     SmallVector<llvm::AttributeSet, 8> newAttrs;
1916     llvm::AttributeSet oldAttrs = callSite.getAttributes();
1917
1918     // Collect any return attributes from the call.
1919     if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex))
1920       newAttrs.push_back(
1921         llvm::AttributeSet::get(newFn->getContext(),
1922                                 oldAttrs.getRetAttributes()));
1923
1924     // If the function was passed too few arguments, don't transform.
1925     unsigned newNumArgs = newFn->arg_size();
1926     if (callSite.arg_size() < newNumArgs) continue;
1927
1928     // If extra arguments were passed, we silently drop them.
1929     // If any of the types mismatch, we don't transform.
1930     unsigned argNo = 0;
1931     bool dontTransform = false;
1932     for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
1933            ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
1934       if (callSite.getArgument(argNo)->getType() != ai->getType()) {
1935         dontTransform = true;
1936         break;
1937       }
1938
1939       // Add any parameter attributes.
1940       if (oldAttrs.hasAttributes(argNo + 1))
1941         newAttrs.
1942           push_back(llvm::
1943                     AttributeSet::get(newFn->getContext(),
1944                                       oldAttrs.getParamAttributes(argNo + 1)));
1945     }
1946     if (dontTransform)
1947       continue;
1948
1949     if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex))
1950       newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(),
1951                                                  oldAttrs.getFnAttributes()));
1952
1953     // Okay, we can transform this.  Create the new call instruction and copy
1954     // over the required information.
1955     newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
1956
1957     llvm::CallSite newCall;
1958     if (callSite.isCall()) {
1959       newCall = llvm::CallInst::Create(newFn, newArgs, "",
1960                                        callSite.getInstruction());
1961     } else {
1962       llvm::InvokeInst *oldInvoke =
1963         cast<llvm::InvokeInst>(callSite.getInstruction());
1964       newCall = llvm::InvokeInst::Create(newFn,
1965                                          oldInvoke->getNormalDest(),
1966                                          oldInvoke->getUnwindDest(),
1967                                          newArgs, "",
1968                                          callSite.getInstruction());
1969     }
1970     newArgs.clear(); // for the next iteration
1971
1972     if (!newCall->getType()->isVoidTy())
1973       newCall->takeName(callSite.getInstruction());
1974     newCall.setAttributes(
1975                      llvm::AttributeSet::get(newFn->getContext(), newAttrs));
1976     newCall.setCallingConv(callSite.getCallingConv());
1977
1978     // Finally, remove the old call, replacing any uses with the new one.
1979     if (!callSite->use_empty())
1980       callSite->replaceAllUsesWith(newCall.getInstruction());
1981
1982     // Copy debug location attached to CI.
1983     if (!callSite->getDebugLoc().isUnknown())
1984       newCall->setDebugLoc(callSite->getDebugLoc());
1985     callSite->eraseFromParent();
1986   }
1987 }
1988
1989 /// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1990 /// implement a function with no prototype, e.g. "int foo() {}".  If there are
1991 /// existing call uses of the old function in the module, this adjusts them to
1992 /// call the new function directly.
1993 ///
1994 /// This is not just a cleanup: the always_inline pass requires direct calls to
1995 /// functions to be able to inline them.  If there is a bitcast in the way, it
1996 /// won't inline them.  Instcombine normally deletes these calls, but it isn't
1997 /// run at -O0.
1998 static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1999                                                       llvm::Function *NewFn) {
2000   // If we're redefining a global as a function, don't transform it.
2001   if (!isa<llvm::Function>(Old)) return;
2002
2003   replaceUsesOfNonProtoConstant(Old, NewFn);
2004 }
2005
2006 void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
2007   TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
2008   // If we have a definition, this might be a deferred decl. If the
2009   // instantiation is explicit, make sure we emit it at the end.
2010   if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
2011     GetAddrOfGlobalVar(VD);
2012
2013   EmitTopLevelDecl(VD);
2014 }
2015
2016 void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
2017   const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
2018
2019   // Compute the function info and LLVM type.
2020   const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2021   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
2022
2023   // Get or create the prototype for the function.
2024   llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
2025
2026   // Strip off a bitcast if we got one back.
2027   if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2028     assert(CE->getOpcode() == llvm::Instruction::BitCast);
2029     Entry = CE->getOperand(0);
2030   }
2031
2032
2033   if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
2034     llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
2035
2036     // If the types mismatch then we have to rewrite the definition.
2037     assert(OldFn->isDeclaration() &&
2038            "Shouldn't replace non-declaration");
2039
2040     // F is the Function* for the one with the wrong type, we must make a new
2041     // Function* and update everything that used F (a declaration) with the new
2042     // Function* (which will be a definition).
2043     //
2044     // This happens if there is a prototype for a function
2045     // (e.g. "int f()") and then a definition of a different type
2046     // (e.g. "int f(int x)").  Move the old function aside so that it
2047     // doesn't interfere with GetAddrOfFunction.
2048     OldFn->setName(StringRef());
2049     llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
2050
2051     // This might be an implementation of a function without a
2052     // prototype, in which case, try to do special replacement of
2053     // calls which match the new prototype.  The really key thing here
2054     // is that we also potentially drop arguments from the call site
2055     // so as to make a direct call, which makes the inliner happier
2056     // and suppresses a number of optimizer warnings (!) about
2057     // dropping arguments.
2058     if (!OldFn->use_empty()) {
2059       ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
2060       OldFn->removeDeadConstantUsers();
2061     }
2062
2063     // Replace uses of F with the Function we will endow with a body.
2064     if (!Entry->use_empty()) {
2065       llvm::Constant *NewPtrForOldDecl =
2066         llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
2067       Entry->replaceAllUsesWith(NewPtrForOldDecl);
2068     }
2069
2070     // Ok, delete the old function now, which is dead.
2071     OldFn->eraseFromParent();
2072
2073     Entry = NewFn;
2074   }
2075
2076   // We need to set linkage and visibility on the function before
2077   // generating code for it because various parts of IR generation
2078   // want to propagate this information down (e.g. to local static
2079   // declarations).
2080   llvm::Function *Fn = cast<llvm::Function>(Entry);
2081   setFunctionLinkage(D, Fn);
2082
2083   // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
2084   setGlobalVisibility(Fn, D);
2085
2086   CodeGenFunction(*this).GenerateCode(D, Fn, FI);
2087
2088   SetFunctionDefinitionAttributes(D, Fn);
2089   SetLLVMFunctionAttributesForDefinition(D, Fn);
2090
2091   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
2092     AddGlobalCtor(Fn, CA->getPriority());
2093   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
2094     AddGlobalDtor(Fn, DA->getPriority());
2095   if (D->hasAttr<AnnotateAttr>())
2096     AddGlobalAnnotations(D, Fn);
2097 }
2098
2099 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2100   const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
2101   const AliasAttr *AA = D->getAttr<AliasAttr>();
2102   assert(AA && "Not an alias?");
2103
2104   StringRef MangledName = getMangledName(GD);
2105
2106   // If there is a definition in the module, then it wins over the alias.
2107   // This is dubious, but allow it to be safe.  Just ignore the alias.
2108   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2109   if (Entry && !Entry->isDeclaration())
2110     return;
2111
2112   llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
2113
2114   // Create a reference to the named value.  This ensures that it is emitted
2115   // if a deferred decl.
2116   llvm::Constant *Aliasee;
2117   if (isa<llvm::FunctionType>(DeclTy))
2118     Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
2119                                       /*ForVTable=*/false);
2120   else
2121     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
2122                                     llvm::PointerType::getUnqual(DeclTy), 0);
2123
2124   // Create the new alias itself, but don't set a name yet.
2125   llvm::GlobalValue *GA =
2126     new llvm::GlobalAlias(Aliasee->getType(),
2127                           llvm::Function::ExternalLinkage,
2128                           "", Aliasee, &getModule());
2129
2130   if (Entry) {
2131     assert(Entry->isDeclaration());
2132
2133     // If there is a declaration in the module, then we had an extern followed
2134     // by the alias, as in:
2135     //   extern int test6();
2136     //   ...
2137     //   int test6() __attribute__((alias("test7")));
2138     //
2139     // Remove it and replace uses of it with the alias.
2140     GA->takeName(Entry);
2141
2142     Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
2143                                                           Entry->getType()));
2144     Entry->eraseFromParent();
2145   } else {
2146     GA->setName(MangledName);
2147   }
2148
2149   // Set attributes which are particular to an alias; this is a
2150   // specialization of the attributes which may be set on a global
2151   // variable/function.
2152   if (D->hasAttr<DLLExportAttr>()) {
2153     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2154       // The dllexport attribute is ignored for undefined symbols.
2155       if (FD->hasBody())
2156         GA->setLinkage(llvm::Function::DLLExportLinkage);
2157     } else {
2158       GA->setLinkage(llvm::Function::DLLExportLinkage);
2159     }
2160   } else if (D->hasAttr<WeakAttr>() ||
2161              D->hasAttr<WeakRefAttr>() ||
2162              D->isWeakImported()) {
2163     GA->setLinkage(llvm::Function::WeakAnyLinkage);
2164   }
2165
2166   SetCommonAttributes(D, GA);
2167 }
2168
2169 llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
2170                                             ArrayRef<llvm::Type*> Tys) {
2171   return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
2172                                          Tys);
2173 }
2174
2175 static llvm::StringMapEntry<llvm::Constant*> &
2176 GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2177                          const StringLiteral *Literal,
2178                          bool TargetIsLSB,
2179                          bool &IsUTF16,
2180                          unsigned &StringLength) {
2181   StringRef String = Literal->getString();
2182   unsigned NumBytes = String.size();
2183
2184   // Check for simple case.
2185   if (!Literal->containsNonAsciiOrNull()) {
2186     StringLength = NumBytes;
2187     return Map.GetOrCreateValue(String);
2188   }
2189
2190   // Otherwise, convert the UTF8 literals into a string of shorts.
2191   IsUTF16 = true;
2192
2193   SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
2194   const UTF8 *FromPtr = (const UTF8 *)String.data();
2195   UTF16 *ToPtr = &ToBuf[0];
2196
2197   (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2198                            &ToPtr, ToPtr + NumBytes,
2199                            strictConversion);
2200
2201   // ConvertUTF8toUTF16 returns the length in ToPtr.
2202   StringLength = ToPtr - &ToBuf[0];
2203
2204   // Add an explicit null.
2205   *ToPtr = 0;
2206   return Map.
2207     GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2208                                (StringLength + 1) * 2));
2209 }
2210
2211 static llvm::StringMapEntry<llvm::Constant*> &
2212 GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2213                        const StringLiteral *Literal,
2214                        unsigned &StringLength) {
2215   StringRef String = Literal->getString();
2216   StringLength = String.size();
2217   return Map.GetOrCreateValue(String);
2218 }
2219
2220 llvm::Constant *
2221 CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2222   unsigned StringLength = 0;
2223   bool isUTF16 = false;
2224   llvm::StringMapEntry<llvm::Constant*> &Entry =
2225     GetConstantCFStringEntry(CFConstantStringMap, Literal,
2226                              getDataLayout().isLittleEndian(),
2227                              isUTF16, StringLength);
2228
2229   if (llvm::Constant *C = Entry.getValue())
2230     return C;
2231
2232   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2233   llvm::Constant *Zeros[] = { Zero, Zero };
2234
2235   // If we don't already have it, get __CFConstantStringClassReference.
2236   if (!CFConstantStringClassRef) {
2237     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2238     Ty = llvm::ArrayType::get(Ty, 0);
2239     llvm::Constant *GV = CreateRuntimeVariable(Ty,
2240                                            "__CFConstantStringClassReference");
2241     // Decay array -> ptr
2242     CFConstantStringClassRef =
2243       llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2244   }
2245
2246   QualType CFTy = getContext().getCFConstantStringType();
2247
2248   llvm::StructType *STy =
2249     cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2250
2251   llvm::Constant *Fields[4];
2252
2253   // Class pointer.
2254   Fields[0] = CFConstantStringClassRef;
2255
2256   // Flags.
2257   llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2258   Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
2259     llvm::ConstantInt::get(Ty, 0x07C8);
2260
2261   // String pointer.
2262   llvm::Constant *C = 0;
2263   if (isUTF16) {
2264     ArrayRef<uint16_t> Arr =
2265       llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>(
2266                                      const_cast<char *>(Entry.getKey().data())),
2267                                    Entry.getKey().size() / 2);
2268     C = llvm::ConstantDataArray::get(VMContext, Arr);
2269   } else {
2270     C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2271   }
2272
2273   llvm::GlobalValue::LinkageTypes Linkage;
2274   if (isUTF16)
2275     // FIXME: why do utf strings get "_" labels instead of "L" labels?
2276     Linkage = llvm::GlobalValue::InternalLinkage;
2277   else
2278     // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2279     // when using private linkage. It is not clear if this is a bug in ld
2280     // or a reasonable new restriction.
2281     Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
2282
2283   // Note: -fwritable-strings doesn't make the backing store strings of
2284   // CFStrings writable. (See <rdar://problem/10657500>)
2285   llvm::GlobalVariable *GV =
2286     new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2287                              Linkage, C, ".str");
2288   GV->setUnnamedAddr(true);
2289   if (isUTF16) {
2290     CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2291     GV->setAlignment(Align.getQuantity());
2292   } else {
2293     CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2294     GV->setAlignment(Align.getQuantity());
2295   }
2296
2297   // String.
2298   Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2299
2300   if (isUTF16)
2301     // Cast the UTF16 string to the correct type.
2302     Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2303
2304   // String length.
2305   Ty = getTypes().ConvertType(getContext().LongTy);
2306   Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
2307
2308   // The struct.
2309   C = llvm::ConstantStruct::get(STy, Fields);
2310   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2311                                 llvm::GlobalVariable::PrivateLinkage, C,
2312                                 "_unnamed_cfstring_");
2313   if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
2314     GV->setSection(Sect);
2315   Entry.setValue(GV);
2316
2317   return GV;
2318 }
2319
2320 static RecordDecl *
2321 CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2322                  DeclContext *DC, IdentifierInfo *Id) {
2323   SourceLocation Loc;
2324   if (Ctx.getLangOpts().CPlusPlus)
2325     return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2326   else
2327     return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2328 }
2329
2330 llvm::Constant *
2331 CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
2332   unsigned StringLength = 0;
2333   llvm::StringMapEntry<llvm::Constant*> &Entry =
2334     GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
2335
2336   if (llvm::Constant *C = Entry.getValue())
2337     return C;
2338
2339   llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
2340   llvm::Constant *Zeros[] = { Zero, Zero };
2341
2342   // If we don't already have it, get _NSConstantStringClassReference.
2343   if (!ConstantStringClassRef) {
2344     std::string StringClass(getLangOpts().ObjCConstantStringClass);
2345     llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
2346     llvm::Constant *GV;
2347     if (LangOpts.ObjCRuntime.isNonFragile()) {
2348       std::string str =
2349         StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2350                             : "OBJC_CLASS_$_" + StringClass;
2351       GV = getObjCRuntime().GetClassGlobal(str);
2352       // Make sure the result is of the correct type.
2353       llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
2354       ConstantStringClassRef =
2355         llvm::ConstantExpr::getBitCast(GV, PTy);
2356     } else {
2357       std::string str =
2358         StringClass.empty() ? "_NSConstantStringClassReference"
2359                             : "_" + StringClass + "ClassReference";
2360       llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
2361       GV = CreateRuntimeVariable(PTy, str);
2362       // Decay array -> ptr
2363       ConstantStringClassRef =
2364         llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2365     }
2366   }
2367
2368   if (!NSConstantStringType) {
2369     // Construct the type for a constant NSString.
2370     RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2371                                      Context.getTranslationUnitDecl(),
2372                                    &Context.Idents.get("__builtin_NSString"));
2373     D->startDefinition();
2374
2375     QualType FieldTypes[3];
2376
2377     // const int *isa;
2378     FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2379     // const char *str;
2380     FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2381     // unsigned int length;
2382     FieldTypes[2] = Context.UnsignedIntTy;
2383
2384     // Create fields
2385     for (unsigned i = 0; i < 3; ++i) {
2386       FieldDecl *Field = FieldDecl::Create(Context, D,
2387                                            SourceLocation(),
2388                                            SourceLocation(), 0,
2389                                            FieldTypes[i], /*TInfo=*/0,
2390                                            /*BitWidth=*/0,
2391                                            /*Mutable=*/false,
2392                                            ICIS_NoInit);
2393       Field->setAccess(AS_public);
2394       D->addDecl(Field);
2395     }
2396
2397     D->completeDefinition();
2398     QualType NSTy = Context.getTagDeclType(D);
2399     NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2400   }
2401
2402   llvm::Constant *Fields[3];
2403
2404   // Class pointer.
2405   Fields[0] = ConstantStringClassRef;
2406
2407   // String pointer.
2408   llvm::Constant *C =
2409     llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2410
2411   llvm::GlobalValue::LinkageTypes Linkage;
2412   bool isConstant;
2413   Linkage = llvm::GlobalValue::PrivateLinkage;
2414   isConstant = !LangOpts.WritableStrings;
2415
2416   llvm::GlobalVariable *GV =
2417   new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2418                            ".str");
2419   GV->setUnnamedAddr(true);
2420   CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2421   GV->setAlignment(Align.getQuantity());
2422   Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2423
2424   // String length.
2425   llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
2426   Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2427
2428   // The struct.
2429   C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
2430   GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2431                                 llvm::GlobalVariable::PrivateLinkage, C,
2432                                 "_unnamed_nsstring_");
2433   // FIXME. Fix section.
2434   if (const char *Sect =
2435         LangOpts.ObjCRuntime.isNonFragile()
2436           ? getContext().getTargetInfo().getNSStringNonFragileABISection()
2437           : getContext().getTargetInfo().getNSStringSection())
2438     GV->setSection(Sect);
2439   Entry.setValue(GV);
2440
2441   return GV;
2442 }
2443
2444 QualType CodeGenModule::getObjCFastEnumerationStateType() {
2445   if (ObjCFastEnumerationStateType.isNull()) {
2446     RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2447                                      Context.getTranslationUnitDecl(),
2448                       &Context.Idents.get("__objcFastEnumerationState"));
2449     D->startDefinition();
2450
2451     QualType FieldTypes[] = {
2452       Context.UnsignedLongTy,
2453       Context.getPointerType(Context.getObjCIdType()),
2454       Context.getPointerType(Context.UnsignedLongTy),
2455       Context.getConstantArrayType(Context.UnsignedLongTy,
2456                            llvm::APInt(32, 5), ArrayType::Normal, 0)
2457     };
2458
2459     for (size_t i = 0; i < 4; ++i) {
2460       FieldDecl *Field = FieldDecl::Create(Context,
2461                                            D,
2462                                            SourceLocation(),
2463                                            SourceLocation(), 0,
2464                                            FieldTypes[i], /*TInfo=*/0,
2465                                            /*BitWidth=*/0,
2466                                            /*Mutable=*/false,
2467                                            ICIS_NoInit);
2468       Field->setAccess(AS_public);
2469       D->addDecl(Field);
2470     }
2471
2472     D->completeDefinition();
2473     ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2474   }
2475
2476   return ObjCFastEnumerationStateType;
2477 }
2478
2479 llvm::Constant *
2480 CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2481   assert(!E->getType()->isPointerType() && "Strings are always arrays");
2482
2483   // Don't emit it as the address of the string, emit the string data itself
2484   // as an inline array.
2485   if (E->getCharByteWidth() == 1) {
2486     SmallString<64> Str(E->getString());
2487
2488     // Resize the string to the right size, which is indicated by its type.
2489     const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2490     Str.resize(CAT->getSize().getZExtValue());
2491     return llvm::ConstantDataArray::getString(VMContext, Str, false);
2492   }
2493
2494   llvm::ArrayType *AType =
2495     cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2496   llvm::Type *ElemTy = AType->getElementType();
2497   unsigned NumElements = AType->getNumElements();
2498
2499   // Wide strings have either 2-byte or 4-byte elements.
2500   if (ElemTy->getPrimitiveSizeInBits() == 16) {
2501     SmallVector<uint16_t, 32> Elements;
2502     Elements.reserve(NumElements);
2503
2504     for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2505       Elements.push_back(E->getCodeUnit(i));
2506     Elements.resize(NumElements);
2507     return llvm::ConstantDataArray::get(VMContext, Elements);
2508   }
2509
2510   assert(ElemTy->getPrimitiveSizeInBits() == 32);
2511   SmallVector<uint32_t, 32> Elements;
2512   Elements.reserve(NumElements);
2513
2514   for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2515     Elements.push_back(E->getCodeUnit(i));
2516   Elements.resize(NumElements);
2517   return llvm::ConstantDataArray::get(VMContext, Elements);
2518 }
2519
2520 /// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2521 /// constant array for the given string literal.
2522 llvm::Constant *
2523 CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
2524   CharUnits Align = getContext().getTypeAlignInChars(S->getType());
2525   if (S->isAscii() || S->isUTF8()) {
2526     SmallString<64> Str(S->getString());
2527
2528     // Resize the string to the right size, which is indicated by its type.
2529     const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2530     Str.resize(CAT->getSize().getZExtValue());
2531     return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
2532   }
2533
2534   // FIXME: the following does not memoize wide strings.
2535   llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2536   llvm::GlobalVariable *GV =
2537     new llvm::GlobalVariable(getModule(),C->getType(),
2538                              !LangOpts.WritableStrings,
2539                              llvm::GlobalValue::PrivateLinkage,
2540                              C,".str");
2541
2542   GV->setAlignment(Align.getQuantity());
2543   GV->setUnnamedAddr(true);
2544   return GV;
2545 }
2546
2547 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2548 /// array for the given ObjCEncodeExpr node.
2549 llvm::Constant *
2550 CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2551   std::string Str;
2552   getContext().getObjCEncodingForType(E->getEncodedType(), Str);
2553
2554   return GetAddrOfConstantCString(Str);
2555 }
2556
2557
2558 /// GenerateWritableString -- Creates storage for a string literal.
2559 static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
2560                                              bool constant,
2561                                              CodeGenModule &CGM,
2562                                              const char *GlobalName,
2563                                              unsigned Alignment) {
2564   // Create Constant for this string literal. Don't add a '\0'.
2565   llvm::Constant *C =
2566       llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
2567
2568   // Create a global variable for this string
2569   llvm::GlobalVariable *GV =
2570     new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2571                              llvm::GlobalValue::PrivateLinkage,
2572                              C, GlobalName);
2573   GV->setAlignment(Alignment);
2574   GV->setUnnamedAddr(true);
2575   return GV;
2576 }
2577
2578 /// GetAddrOfConstantString - Returns a pointer to a character array
2579 /// containing the literal. This contents are exactly that of the
2580 /// given string, i.e. it will not be null terminated automatically;
2581 /// see GetAddrOfConstantCString. Note that whether the result is
2582 /// actually a pointer to an LLVM constant depends on
2583 /// Feature.WriteableStrings.
2584 ///
2585 /// The result has pointer to array type.
2586 llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
2587                                                        const char *GlobalName,
2588                                                        unsigned Alignment) {
2589   // Get the default prefix if a name wasn't specified.
2590   if (!GlobalName)
2591     GlobalName = ".str";
2592
2593   // Don't share any string literals if strings aren't constant.
2594   if (LangOpts.WritableStrings)
2595     return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
2596
2597   llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2598     ConstantStringMap.GetOrCreateValue(Str);
2599
2600   if (llvm::GlobalVariable *GV = Entry.getValue()) {
2601     if (Alignment > GV->getAlignment()) {
2602       GV->setAlignment(Alignment);
2603     }
2604     return GV;
2605   }
2606
2607   // Create a global variable for this.
2608   llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2609                                                    Alignment);
2610   Entry.setValue(GV);
2611   return GV;
2612 }
2613
2614 /// GetAddrOfConstantCString - Returns a pointer to a character
2615 /// array containing the literal and a terminating '\0'
2616 /// character. The result has pointer to array type.
2617 llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
2618                                                         const char *GlobalName,
2619                                                         unsigned Alignment) {
2620   StringRef StrWithNull(Str.c_str(), Str.size() + 1);
2621   return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
2622 }
2623
2624 /// EmitObjCPropertyImplementations - Emit information for synthesized
2625 /// properties for an implementation.
2626 void CodeGenModule::EmitObjCPropertyImplementations(const
2627                                                     ObjCImplementationDecl *D) {
2628   for (ObjCImplementationDecl::propimpl_iterator
2629          i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
2630     ObjCPropertyImplDecl *PID = *i;
2631
2632     // Dynamic is just for type-checking.
2633     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2634       ObjCPropertyDecl *PD = PID->getPropertyDecl();
2635
2636       // Determine which methods need to be implemented, some may have
2637       // been overridden. Note that ::isPropertyAccessor is not the method
2638       // we want, that just indicates if the decl came from a
2639       // property. What we want to know is if the method is defined in
2640       // this implementation.
2641       if (!D->getInstanceMethod(PD->getGetterName()))
2642         CodeGenFunction(*this).GenerateObjCGetter(
2643                                  const_cast<ObjCImplementationDecl *>(D), PID);
2644       if (!PD->isReadOnly() &&
2645           !D->getInstanceMethod(PD->getSetterName()))
2646         CodeGenFunction(*this).GenerateObjCSetter(
2647                                  const_cast<ObjCImplementationDecl *>(D), PID);
2648     }
2649   }
2650 }
2651
2652 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
2653   const ObjCInterfaceDecl *iface = impl->getClassInterface();
2654   for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
2655        ivar; ivar = ivar->getNextIvar())
2656     if (ivar->getType().isDestructedType())
2657       return true;
2658
2659   return false;
2660 }
2661
2662 /// EmitObjCIvarInitializations - Emit information for ivar initialization
2663 /// for an implementation.
2664 void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
2665   // We might need a .cxx_destruct even if we don't have any ivar initializers.
2666   if (needsDestructMethod(D)) {
2667     IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2668     Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2669     ObjCMethodDecl *DTORMethod =
2670       ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
2671                              cxxSelector, getContext().VoidTy, 0, D,
2672                              /*isInstance=*/true, /*isVariadic=*/false,
2673                           /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
2674                              /*isDefined=*/false, ObjCMethodDecl::Required);
2675     D->addInstanceMethod(DTORMethod);
2676     CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
2677     D->setHasDestructors(true);
2678   }
2679
2680   // If the implementation doesn't have any ivar initializers, we don't need
2681   // a .cxx_construct.
2682   if (D->getNumIvarInitializers() == 0)
2683     return;
2684
2685   IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2686   Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2687   // The constructor returns 'self'.
2688   ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2689                                                 D->getLocation(),
2690                                                 D->getLocation(),
2691                                                 cxxSelector,
2692                                                 getContext().getObjCIdType(), 0,
2693                                                 D, /*isInstance=*/true,
2694                                                 /*isVariadic=*/false,
2695                                                 /*isPropertyAccessor=*/true,
2696                                                 /*isImplicitlyDeclared=*/true,
2697                                                 /*isDefined=*/false,
2698                                                 ObjCMethodDecl::Required);
2699   D->addInstanceMethod(CTORMethod);
2700   CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
2701   D->setHasNonZeroConstructors(true);
2702 }
2703
2704 /// EmitNamespace - Emit all declarations in a namespace.
2705 void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
2706   for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
2707        I != E; ++I)
2708     EmitTopLevelDecl(*I);
2709 }
2710
2711 // EmitLinkageSpec - Emit all declarations in a linkage spec.
2712 void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
2713   if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2714       LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
2715     ErrorUnsupported(LSD, "linkage spec");
2716     return;
2717   }
2718
2719   for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
2720        I != E; ++I) {
2721     // Meta-data for ObjC class includes references to implemented methods.
2722     // Generate class's method definitions first.
2723     if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) {
2724       for (ObjCContainerDecl::method_iterator M = OID->meth_begin(),
2725            MEnd = OID->meth_end();
2726            M != MEnd; ++M)
2727         EmitTopLevelDecl(*M);
2728     }
2729     EmitTopLevelDecl(*I);
2730   }
2731 }
2732
2733 /// EmitTopLevelDecl - Emit code for a single top level declaration.
2734 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2735   // If an error has occurred, stop code generation, but continue
2736   // parsing and semantic analysis (to ensure all warnings and errors
2737   // are emitted).
2738   if (Diags.hasErrorOccurred())
2739     return;
2740
2741   // Ignore dependent declarations.
2742   if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2743     return;
2744
2745   switch (D->getKind()) {
2746   case Decl::CXXConversion:
2747   case Decl::CXXMethod:
2748   case Decl::Function:
2749     // Skip function templates
2750     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2751         cast<FunctionDecl>(D)->isLateTemplateParsed())
2752       return;
2753
2754     EmitGlobal(cast<FunctionDecl>(D));
2755     break;
2756
2757   case Decl::Var:
2758     EmitGlobal(cast<VarDecl>(D));
2759     break;
2760
2761   // Indirect fields from global anonymous structs and unions can be
2762   // ignored; only the actual variable requires IR gen support.
2763   case Decl::IndirectField:
2764     break;
2765
2766   // C++ Decls
2767   case Decl::Namespace:
2768     EmitNamespace(cast<NamespaceDecl>(D));
2769     break;
2770     // No code generation needed.
2771   case Decl::UsingShadow:
2772   case Decl::Using:
2773   case Decl::UsingDirective:
2774   case Decl::ClassTemplate:
2775   case Decl::FunctionTemplate:
2776   case Decl::TypeAliasTemplate:
2777   case Decl::NamespaceAlias:
2778   case Decl::Block:
2779   case Decl::Empty:
2780     break;
2781   case Decl::CXXConstructor:
2782     // Skip function templates
2783     if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2784         cast<FunctionDecl>(D)->isLateTemplateParsed())
2785       return;
2786
2787     EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2788     break;
2789   case Decl::CXXDestructor:
2790     if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2791       return;
2792     EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2793     break;
2794
2795   case Decl::StaticAssert:
2796     // Nothing to do.
2797     break;
2798
2799   // Objective-C Decls
2800
2801   // Forward declarations, no (immediate) code generation.
2802   case Decl::ObjCInterface:
2803   case Decl::ObjCCategory:
2804     break;
2805
2806   case Decl::ObjCProtocol: {
2807     ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2808     if (Proto->isThisDeclarationADefinition())
2809       ObjCRuntime->GenerateProtocol(Proto);
2810     break;
2811   }
2812
2813   case Decl::ObjCCategoryImpl:
2814     // Categories have properties but don't support synthesize so we
2815     // can ignore them here.
2816     ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
2817     break;
2818
2819   case Decl::ObjCImplementation: {
2820     ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2821     EmitObjCPropertyImplementations(OMD);
2822     EmitObjCIvarInitializations(OMD);
2823     ObjCRuntime->GenerateClass(OMD);
2824     // Emit global variable debug information.
2825     if (CGDebugInfo *DI = getModuleDebugInfo())
2826       if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2827         DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
2828             OMD->getClassInterface()), OMD->getLocation());
2829     break;
2830   }
2831   case Decl::ObjCMethod: {
2832     ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2833     // If this is not a prototype, emit the body.
2834     if (OMD->getBody())
2835       CodeGenFunction(*this).GenerateObjCMethod(OMD);
2836     break;
2837   }
2838   case Decl::ObjCCompatibleAlias:
2839     ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
2840     break;
2841
2842   case Decl::LinkageSpec:
2843     EmitLinkageSpec(cast<LinkageSpecDecl>(D));
2844     break;
2845
2846   case Decl::FileScopeAsm: {
2847     FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
2848     StringRef AsmString = AD->getAsmString()->getString();
2849
2850     const std::string &S = getModule().getModuleInlineAsm();
2851     if (S.empty())
2852       getModule().setModuleInlineAsm(AsmString);
2853     else if (S.end()[-1] == '\n')
2854       getModule().setModuleInlineAsm(S + AsmString.str());
2855     else
2856       getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
2857     break;
2858   }
2859
2860   case Decl::Import: {
2861     ImportDecl *Import = cast<ImportDecl>(D);
2862
2863     // Ignore import declarations that come from imported modules.
2864     if (clang::Module *Owner = Import->getOwningModule()) {
2865       if (getLangOpts().CurrentModule.empty() ||
2866           Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
2867         break;
2868     }
2869
2870     ImportedModules.insert(Import->getImportedModule());
2871     break;
2872  }
2873
2874   default:
2875     // Make sure we handled everything we should, every other kind is a
2876     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
2877     // function. Need to recode Decl::Kind to do that easily.
2878     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2879   }
2880 }
2881
2882 /// Turns the given pointer into a constant.
2883 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2884                                           const void *Ptr) {
2885   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
2886   llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
2887   return llvm::ConstantInt::get(i64, PtrInt);
2888 }
2889
2890 static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2891                                    llvm::NamedMDNode *&GlobalMetadata,
2892                                    GlobalDecl D,
2893                                    llvm::GlobalValue *Addr) {
2894   if (!GlobalMetadata)
2895     GlobalMetadata =
2896       CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2897
2898   // TODO: should we report variant information for ctors/dtors?
2899   llvm::Value *Ops[] = {
2900     Addr,
2901     GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2902   };
2903   GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
2904 }
2905
2906 /// Emits metadata nodes associating all the global values in the
2907 /// current module with the Decls they came from.  This is useful for
2908 /// projects using IR gen as a subroutine.
2909 ///
2910 /// Since there's currently no way to associate an MDNode directly
2911 /// with an llvm::GlobalValue, we create a global named metadata
2912 /// with the name 'clang.global.decl.ptrs'.
2913 void CodeGenModule::EmitDeclMetadata() {
2914   llvm::NamedMDNode *GlobalMetadata = 0;
2915
2916   // StaticLocalDeclMap
2917   for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
2918          I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2919        I != E; ++I) {
2920     llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2921     EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2922   }
2923 }
2924
2925 /// Emits metadata nodes for all the local variables in the current
2926 /// function.
2927 void CodeGenFunction::EmitDeclMetadata() {
2928   if (LocalDeclMap.empty()) return;
2929
2930   llvm::LLVMContext &Context = getLLVMContext();
2931
2932   // Find the unique metadata ID for this name.
2933   unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2934
2935   llvm::NamedMDNode *GlobalMetadata = 0;
2936
2937   for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2938          I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2939     const Decl *D = I->first;
2940     llvm::Value *Addr = I->second;
2941
2942     if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2943       llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
2944       Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
2945     } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2946       GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2947       EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2948     }
2949   }
2950 }
2951
2952 void CodeGenModule::EmitCoverageFile() {
2953   if (!getCodeGenOpts().CoverageFile.empty()) {
2954     if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2955       llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2956       llvm::LLVMContext &Ctx = TheModule.getContext();
2957       llvm::MDString *CoverageFile =
2958           llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
2959       for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2960         llvm::MDNode *CU = CUNode->getOperand(i);
2961         llvm::Value *node[] = { CoverageFile, CU };
2962         llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2963         GCov->addOperand(N);
2964       }
2965     }
2966   }
2967 }
2968
2969 llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
2970                                                      QualType GuidType) {
2971   // Sema has checked that all uuid strings are of the form
2972   // "12345678-1234-1234-1234-1234567890ab".
2973   assert(Uuid.size() == 36);
2974   const char *Uuidstr = Uuid.data();
2975   for (int i = 0; i < 36; ++i) {
2976     if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
2977     else                                         assert(isHexDigit(Uuidstr[i]));
2978   }
2979
2980   llvm::APInt Field0(32, StringRef(Uuidstr     , 8), 16);
2981   llvm::APInt Field1(16, StringRef(Uuidstr +  9, 4), 16);
2982   llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
2983   static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
2984
2985   APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
2986   InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
2987   InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
2988   InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
2989   APValue& Arr = InitStruct.getStructField(3);
2990   Arr = APValue(APValue::UninitArray(), 8, 8);
2991   for (int t = 0; t < 8; ++t)
2992     Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
2993           llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
2994
2995   return EmitConstantValue(InitStruct, GuidType);
2996 }