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