diff options
Diffstat (limited to 'lib/CodeGen/CodeGenModule.cpp')
| -rw-r--r-- | lib/CodeGen/CodeGenModule.cpp | 1561 |
1 files changed, 870 insertions, 691 deletions
diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp index 792fbfce3349..48823befcc07 100644 --- a/lib/CodeGen/CodeGenModule.cpp +++ b/lib/CodeGen/CodeGenModule.cpp @@ -18,7 +18,9 @@ #include "CGDebugInfo.h" #include "CGObjCRuntime.h" #include "CGOpenCLRuntime.h" +#include "CGOpenMPRuntime.h" #include "CodeGenFunction.h" +#include "CodeGenPGO.h" #include "CodeGenTBAA.h" #include "TargetInfo.h" #include "clang/AST/ASTContext.h" @@ -40,30 +42,31 @@ #include "clang/Sema/SemaDiagnostic.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/Triple.h" +#include "llvm/IR/CallSite.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" -#include "llvm/Support/CallSite.h" +#include "llvm/ProfileData/InstrProfReader.h" #include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ErrorHandling.h" -#include "llvm/Target/Mangler.h" using namespace clang; using namespace CodeGen; static const char AnnotationSection[] = "llvm.metadata"; -static CGCXXABI &createCXXABI(CodeGenModule &CGM) { +static CGCXXABI *createCXXABI(CodeGenModule &CGM) { switch (CGM.getTarget().getCXXABI().getKind()) { case TargetCXXABI::GenericAArch64: case TargetCXXABI::GenericARM: case TargetCXXABI::iOS: + case TargetCXXABI::iOS64: case TargetCXXABI::GenericItanium: - return *CreateItaniumCXXABI(CGM); + return CreateItaniumCXXABI(CGM); case TargetCXXABI::Microsoft: - return *CreateMicrosoftCXXABI(CGM); + return CreateMicrosoftCXXABI(CGM); } llvm_unreachable("invalid C++ ABI kind"); @@ -74,18 +77,18 @@ CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, DiagnosticsEngine &diags) : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M), Diags(diags), TheDataLayout(TD), Target(C.getTargetInfo()), - ABI(createCXXABI(*this)), VMContext(M.getContext()), TBAA(0), - TheTargetCodeGenInfo(0), Types(*this), VTables(*this), ObjCRuntime(0), - OpenCLRuntime(0), CUDARuntime(0), DebugInfo(0), ARCData(0), - NoObjCARCExceptionsMetadata(0), RRData(0), CFConstantStringClassRef(0), - ConstantStringClassRef(0), NSConstantStringType(0), - NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), BlockObjectAssign(0), - BlockObjectDispose(0), BlockDescriptorType(0), GenericBlockLiteralType(0), - LifetimeStartFn(0), LifetimeEndFn(0), - SanitizerBlacklist( - llvm::SpecialCaseList::createOrDie(CGO.SanitizerBlacklistFile)), - SanOpts(SanitizerBlacklist->isIn(M) ? SanitizerOptions::Disabled - : LangOpts.Sanitize) { + ABI(createCXXABI(*this)), VMContext(M.getContext()), TBAA(nullptr), + TheTargetCodeGenInfo(nullptr), Types(*this), VTables(*this), + ObjCRuntime(nullptr), OpenCLRuntime(nullptr), OpenMPRuntime(nullptr), + CUDARuntime(nullptr), DebugInfo(nullptr), ARCData(nullptr), + NoObjCARCExceptionsMetadata(nullptr), RRData(nullptr), PGOReader(nullptr), + CFConstantStringClassRef(nullptr), ConstantStringClassRef(nullptr), + NSConstantStringType(nullptr), NSConcreteGlobalBlock(nullptr), + NSConcreteStackBlock(nullptr), BlockObjectAssign(nullptr), + BlockObjectDispose(nullptr), BlockDescriptorType(nullptr), + GenericBlockLiteralType(nullptr), LifetimeStartFn(nullptr), + LifetimeEndFn(nullptr), SanitizerBL(llvm::SpecialCaseList::createOrDie( + CGO.SanitizerBlacklistFile)) { // Initialize the type cache. llvm::LLVMContext &LLVMContext = M.getContext(); @@ -110,14 +113,16 @@ CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, createObjCRuntime(); if (LangOpts.OpenCL) createOpenCLRuntime(); + if (LangOpts.OpenMP) + createOpenMPRuntime(); if (LangOpts.CUDA) createCUDARuntime(); // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0. - if (SanOpts.Thread || + if (LangOpts.Sanitize.Thread || (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)) TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(), - ABI.getMangleContext()); + getCXXABI().getMangleContext()); // If debug info or coverage generation is enabled, create the CGDebugInfo // object. @@ -131,14 +136,23 @@ CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO, if (C.getLangOpts().ObjCAutoRefCount) ARCData = new ARCEntrypoints(); RRData = new RREntrypoints(); + + if (!CodeGenOpts.InstrProfileInput.empty()) { + if (std::error_code EC = llvm::IndexedInstrProfReader::create( + CodeGenOpts.InstrProfileInput, PGOReader)) { + unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, + "Could not read profile: %0"); + getDiags().Report(DiagID) << EC.message(); + } + } } CodeGenModule::~CodeGenModule() { delete ObjCRuntime; delete OpenCLRuntime; + delete OpenMPRuntime; delete CUDARuntime; delete TheTargetCodeGenInfo; - delete &ABI; delete TBAA; delete DebugInfo; delete ARCData; @@ -168,6 +182,10 @@ void CodeGenModule::createOpenCLRuntime() { OpenCLRuntime = new CGOpenCLRuntime(*this); } +void CodeGenModule::createOpenMPRuntime() { + OpenMPRuntime = new CGOpenMPRuntime(*this); +} + void CodeGenModule::createCUDARuntime() { CUDARuntime = CreateNVCUDARuntime(*this); } @@ -181,13 +199,17 @@ void CodeGenModule::applyReplacements() { llvm::GlobalValue *Entry = GetGlobalValue(MangledName); if (!Entry) continue; - llvm::Function *OldF = cast<llvm::Function>(Entry); - llvm::Function *NewF = dyn_cast<llvm::Function>(Replacement); + auto *OldF = cast<llvm::Function>(Entry); + auto *NewF = dyn_cast<llvm::Function>(Replacement); if (!NewF) { - llvm::ConstantExpr *CE = cast<llvm::ConstantExpr>(Replacement); - assert(CE->getOpcode() == llvm::Instruction::BitCast || - CE->getOpcode() == llvm::Instruction::GetElementPtr); - NewF = dyn_cast<llvm::Function>(CE->getOperand(0)); + if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) { + NewF = dyn_cast<llvm::Function>(Alias->getAliasee()); + } else { + auto *CE = cast<llvm::ConstantExpr>(Replacement); + assert(CE->getOpcode() == llvm::Instruction::BitCast || + CE->getOpcode() == llvm::Instruction::GetElementPtr); + NewF = dyn_cast<llvm::Function>(CE->getOperand(0)); + } } // Replace old with new, but keep the old order. @@ -200,23 +222,75 @@ void CodeGenModule::applyReplacements() { } } +// This is only used in aliases that we created and we know they have a +// linear structure. +static const llvm::GlobalObject *getAliasedGlobal(const llvm::GlobalAlias &GA) { + llvm::SmallPtrSet<const llvm::GlobalAlias*, 4> Visited; + const llvm::Constant *C = &GA; + for (;;) { + C = C->stripPointerCasts(); + if (auto *GO = dyn_cast<llvm::GlobalObject>(C)) + return GO; + // stripPointerCasts will not walk over weak aliases. + auto *GA2 = dyn_cast<llvm::GlobalAlias>(C); + if (!GA2) + return nullptr; + if (!Visited.insert(GA2)) + return nullptr; + C = GA2->getAliasee(); + } +} + void CodeGenModule::checkAliases() { + // Check if the constructed aliases are well formed. It is really unfortunate + // that we have to do this in CodeGen, but we only construct mangled names + // and aliases during codegen. bool Error = false; + DiagnosticsEngine &Diags = getDiags(); for (std::vector<GlobalDecl>::iterator I = Aliases.begin(), E = Aliases.end(); I != E; ++I) { const GlobalDecl &GD = *I; - const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); + const auto *D = cast<ValueDecl>(GD.getDecl()); const AliasAttr *AA = D->getAttr<AliasAttr>(); StringRef MangledName = getMangledName(GD); llvm::GlobalValue *Entry = GetGlobalValue(MangledName); - llvm::GlobalAlias *Alias = cast<llvm::GlobalAlias>(Entry); - llvm::GlobalValue *GV = Alias->getAliasedGlobal(); - if (GV->isDeclaration()) { + auto *Alias = cast<llvm::GlobalAlias>(Entry); + const llvm::GlobalValue *GV = getAliasedGlobal(*Alias); + if (!GV) { Error = true; - getDiags().Report(AA->getLocation(), diag::err_alias_to_undefined); - } else if (!Alias->resolveAliasedGlobal(/*stopOnWeak*/ false)) { + Diags.Report(AA->getLocation(), diag::err_cyclic_alias); + } else if (GV->isDeclaration()) { Error = true; - getDiags().Report(AA->getLocation(), diag::err_cyclic_alias); + Diags.Report(AA->getLocation(), diag::err_alias_to_undefined); + } + + llvm::Constant *Aliasee = Alias->getAliasee(); + llvm::GlobalValue *AliaseeGV; + if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee)) + AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0)); + else + AliaseeGV = cast<llvm::GlobalValue>(Aliasee); + + if (const SectionAttr *SA = D->getAttr<SectionAttr>()) { + StringRef AliasSection = SA->getName(); + if (AliasSection != AliaseeGV->getSection()) + Diags.Report(SA->getLocation(), diag::warn_alias_with_section) + << AliasSection; + } + + // We have to handle alias to weak aliases in here. LLVM itself disallows + // this since the object semantics would not match the IL one. For + // compatibility with gcc we implement it by just pointing the alias + // to its aliasee's aliasee. We also warn, since the user is probably + // expecting the link to be weak. + if (auto GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) { + if (GA->mayBeOverridden()) { + Diags.Report(AA->getLocation(), diag::warn_alias_to_weak_alias) + << GV->getName() << GA->getName(); + Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast( + GA->getAliasee(), Alias->getType()); + Alias->setAliasee(Aliasee); + } } } if (!Error) @@ -227,12 +301,29 @@ void CodeGenModule::checkAliases() { const GlobalDecl &GD = *I; StringRef MangledName = getMangledName(GD); llvm::GlobalValue *Entry = GetGlobalValue(MangledName); - llvm::GlobalAlias *Alias = cast<llvm::GlobalAlias>(Entry); + auto *Alias = cast<llvm::GlobalAlias>(Entry); Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType())); Alias->eraseFromParent(); } } +void CodeGenModule::clear() { + DeferredDeclsToEmit.clear(); +} + +void InstrProfStats::reportDiagnostics(DiagnosticsEngine &Diags, + StringRef MainFile) { + if (!hasDiagnostics()) + return; + if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) { + if (MainFile.empty()) + MainFile = "<stdin>"; + Diags.Report(diag::warn_profile_data_unprofiled) << MainFile; + } else + Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Missing + << Mismatched; +} + void CodeGenModule::Release() { EmitDeferred(); applyReplacements(); @@ -243,11 +334,16 @@ void CodeGenModule::Release() { if (ObjCRuntime) if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction()) AddGlobalCtor(ObjCInitFunction); + if (getCodeGenOpts().ProfileInstrGenerate) + if (llvm::Function *PGOInit = CodeGenPGO::emitInitialization(*this)) + AddGlobalCtor(PGOInit, 0); + if (PGOReader && PGOStats.hasDiagnostics()) + PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName); EmitCtorList(GlobalCtors, "llvm.global_ctors"); EmitCtorList(GlobalDtors, "llvm.global_dtors"); EmitGlobalAnnotations(); EmitStaticExternCAliases(); - EmitLLVMUsed(); + emitLLVMUsed(); if (CodeGenOpts.Autolink && (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) { @@ -259,14 +355,29 @@ void CodeGenModule::Release() { getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version", CodeGenOpts.DwarfVersion); if (DebugInfo) - // We support a single version in the linked module: error out when - // modules do not have the same version. We are going to implement dropping - // debug info when the version number is not up-to-date. Once that is - // done, the bitcode linker is not going to see modules with different - // version numbers. - getModule().addModuleFlag(llvm::Module::Error, "Debug Info Version", + // We support a single version in the linked module. The LLVM + // parser will drop debug info with a different version number + // (and warn about it, too). + getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version", llvm::DEBUG_METADATA_VERSION); + // We need to record the widths of enums and wchar_t, so that we can generate + // the correct build attributes in the ARM backend. + llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch(); + if ( Arch == llvm::Triple::arm + || Arch == llvm::Triple::armeb + || Arch == llvm::Triple::thumb + || Arch == llvm::Triple::thumbeb) { + // Width of wchar_t in bytes + uint64_t WCharWidth = + Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity(); + getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth); + + // The minimum width of an enum in bytes + uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4; + getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth); + } + SimplifyPersonality(); if (getCodeGenOpts().EmitDeclMetadata) @@ -279,6 +390,8 @@ void CodeGenModule::Release() { DebugInfo->finalize(); EmitVersionIdentMetadata(); + + EmitTargetMetadata(); } void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { @@ -288,25 +401,25 @@ void CodeGenModule::UpdateCompletedType(const TagDecl *TD) { llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) { if (!TBAA) - return 0; + return nullptr; return TBAA->getTBAAInfo(QTy); } llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() { if (!TBAA) - return 0; + return nullptr; return TBAA->getTBAAInfoForVTablePtr(); } llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) { if (!TBAA) - return 0; + return nullptr; return TBAA->getTBAAStructInfo(QTy); } llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) { if (!TBAA) - return 0; + return nullptr; return TBAA->getTBAAStructTypeInfo(QTy); } @@ -314,7 +427,7 @@ llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy, llvm::MDNode *AccessN, uint64_t O) { if (!TBAA) - return 0; + return nullptr; return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O); } @@ -332,9 +445,9 @@ void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst, Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo); } -void CodeGenModule::Error(SourceLocation loc, StringRef error) { - unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error); - getDiags().Report(Context.getFullLoc(loc), diagID); +void CodeGenModule::Error(SourceLocation loc, StringRef message) { + unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0"); + getDiags().Report(Context.getFullLoc(loc), diagID) << message; } /// ErrorUnsupported - Print out an error that codegen doesn't support the @@ -405,130 +518,61 @@ void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV, TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel()); // Override the TLS model if it is explicitly specified. - if (D.hasAttr<TLSModelAttr>()) { - const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>(); + if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) { TLM = GetLLVMTLSModel(Attr->getModel()); } GV->setThreadLocalMode(TLM); } -/// Set the symbol visibility of type information (vtable and RTTI) -/// associated with the given type. -void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV, - const CXXRecordDecl *RD, - TypeVisibilityKind TVK) const { - setGlobalVisibility(GV, RD); - - if (!CodeGenOpts.HiddenWeakVTables) - return; - - // We never want to drop the visibility for RTTI names. - if (TVK == TVK_ForRTTIName) - return; - - // We want to drop the visibility to hidden for weak type symbols. - // This isn't possible if there might be unresolved references - // elsewhere that rely on this symbol being visible. - - // This should be kept roughly in sync with setThunkVisibility - // in CGVTables.cpp. - - // Preconditions. - if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage || - GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility) - return; - - // Don't override an explicit visibility attribute. - if (RD->getExplicitVisibility(NamedDecl::VisibilityForType)) - return; - - switch (RD->getTemplateSpecializationKind()) { - // We have to disable the optimization if this is an EI definition - // because there might be EI declarations in other shared objects. - case TSK_ExplicitInstantiationDefinition: - case TSK_ExplicitInstantiationDeclaration: - return; - - // Every use of a non-template class's type information has to emit it. - case TSK_Undeclared: - break; - - // In theory, implicit instantiations can ignore the possibility of - // an explicit instantiation declaration because there necessarily - // must be an EI definition somewhere with default visibility. In - // practice, it's possible to have an explicit instantiation for - // an arbitrary template class, and linkers aren't necessarily able - // to deal with mixed-visibility symbols. - case TSK_ExplicitSpecialization: - case TSK_ImplicitInstantiation: - return; - } - - // If there's a key function, there may be translation units - // that don't have the key function's definition. But ignore - // this if we're emitting RTTI under -fno-rtti. - if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) { - // FIXME: what should we do if we "lose" the key function during - // the emission of the file? - if (Context.getCurrentKeyFunction(RD)) - return; - } - - // Otherwise, drop the visibility to hidden. - GV->setVisibility(llvm::GlobalValue::HiddenVisibility); - GV->setUnnamedAddr(true); -} - StringRef CodeGenModule::getMangledName(GlobalDecl GD) { - const NamedDecl *ND = cast<NamedDecl>(GD.getDecl()); - - StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()]; - if (!Str.empty()) - return Str; + StringRef &FoundStr = MangledDeclNames[GD.getCanonicalDecl()]; + if (!FoundStr.empty()) + return FoundStr; - if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { + const auto *ND = cast<NamedDecl>(GD.getDecl()); + SmallString<256> Buffer; + StringRef Str; + if (getCXXABI().getMangleContext().shouldMangleDeclName(ND)) { + llvm::raw_svector_ostream Out(Buffer); + if (const auto *D = dyn_cast<CXXConstructorDecl>(ND)) + getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); + else if (const auto *D = dyn_cast<CXXDestructorDecl>(ND)) + getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); + else + getCXXABI().getMangleContext().mangleName(ND, Out); + Str = Out.str(); + } else { IdentifierInfo *II = ND->getIdentifier(); assert(II && "Attempt to mangle unnamed decl."); - Str = II->getName(); - return Str; } - - SmallString<256> Buffer; - llvm::raw_svector_ostream Out(Buffer); - if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) - getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out); - else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) - getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out); - else - getCXXABI().getMangleContext().mangleName(ND, Out); - // Allocate space for the mangled name. - Out.flush(); - size_t Length = Buffer.size(); - char *Name = MangledNamesAllocator.Allocate<char>(Length); - std::copy(Buffer.begin(), Buffer.end(), Name); - - Str = StringRef(Name, Length); - - return Str; + auto &Mangled = Manglings.GetOrCreateValue(Str); + Mangled.second = GD; + return FoundStr = Mangled.first(); } -void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer, - const BlockDecl *BD) { +StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD, + const BlockDecl *BD) { MangleContext &MangleCtx = getCXXABI().getMangleContext(); const Decl *D = GD.getDecl(); - llvm::raw_svector_ostream Out(Buffer.getBuffer()); - if (D == 0) + + SmallString<256> Buffer; + llvm::raw_svector_ostream Out(Buffer); + if (!D) MangleCtx.mangleGlobalBlock(BD, dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out); - else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) + else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D)) MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out); - else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) + else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out); else MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out); + + auto &Mangled = Manglings.GetOrCreateValue(Out.str()); + Mangled.second = BD; + return Mangled.first(); } llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { @@ -537,16 +581,17 @@ llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) { /// AddGlobalCtor - Add a function to the list that will be called before /// main() runs. -void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { +void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority, + llvm::Constant *AssociatedData) { // FIXME: Type coercion of void()* types. - GlobalCtors.push_back(std::make_pair(Ctor, Priority)); + GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData)); } /// AddGlobalDtor - Add a function to the list that will be called /// when the module is unloaded. -void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { +void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) { // FIXME: Type coercion of void()* types. - GlobalDtors.push_back(std::make_pair(Dtor, Priority)); + GlobalDtors.push_back(Structor(Priority, Dtor, nullptr)); } void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { @@ -554,16 +599,19 @@ void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false); llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); - // Get the type of a ctor entry, { i32, void ()* }. - llvm::StructType *CtorStructTy = - llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL); + // Get the type of a ctor entry, { i32, void ()*, i8* }. + llvm::StructType *CtorStructTy = llvm::StructType::get( + Int32Ty, llvm::PointerType::getUnqual(CtorFTy), VoidPtrTy, NULL); // Construct the constructor and destructor arrays. SmallVector<llvm::Constant*, 8> Ctors; for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { llvm::Constant *S[] = { - llvm::ConstantInt::get(Int32Ty, I->second, false), - llvm::ConstantExpr::getBitCast(I->first, CtorPFTy) + llvm::ConstantInt::get(Int32Ty, I->Priority, false), + llvm::ConstantExpr::getBitCast(I->Initializer, CtorPFTy), + (I->AssociatedData + ? llvm::ConstantExpr::getBitCast(I->AssociatedData, VoidPtrTy) + : llvm::Constant::getNullValue(VoidPtrTy)) }; Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); } @@ -579,67 +627,25 @@ void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { llvm::GlobalValue::LinkageTypes CodeGenModule::getFunctionLinkage(GlobalDecl GD) { - const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); - - if (isa<CXXDestructorDecl>(D) && - getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), - GD.getDtorType())) - return llvm::Function::LinkOnceODRLinkage; + const auto *D = cast<FunctionDecl>(GD.getDecl()); GVALinkage Linkage = getContext().GetGVALinkageForFunction(D); - if (Linkage == GVA_Internal) - return llvm::Function::InternalLinkage; - - if (D->hasAttr<DLLExportAttr>()) - return llvm::Function::DLLExportLinkage; - - if (D->hasAttr<WeakAttr>()) - return llvm::Function::WeakAnyLinkage; - - // In C99 mode, 'inline' functions are guaranteed to have a strong - // definition somewhere else, so we can use available_externally linkage. - if (Linkage == GVA_C99Inline) - return llvm::Function::AvailableExternallyLinkage; - - // Note that Apple's kernel linker doesn't support symbol - // coalescing, so we need to avoid linkonce and weak linkages there. - // Normally, this means we just map to internal, but for explicit - // instantiations we'll map to external. + if (isa<CXXDestructorDecl>(D) && + getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), + GD.getDtorType())) { + // Destructor variants in the Microsoft C++ ABI are always internal or + // linkonce_odr thunks emitted on an as-needed basis. + return Linkage == GVA_Internal ? llvm::GlobalValue::InternalLinkage + : llvm::GlobalValue::LinkOnceODRLinkage; + } - // In C++, the compiler has to emit a definition in every translation unit - // that references the function. We should use linkonce_odr because - // a) if all references in this translation unit are optimized away, we - // don't need to codegen it. b) if the function persists, it needs to be - // merged with other definitions. c) C++ has the ODR, so we know the - // definition is dependable. - if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) - return !Context.getLangOpts().AppleKext - ? llvm::Function::LinkOnceODRLinkage - : llvm::Function::InternalLinkage; - - // An explicit instantiation of a template has weak linkage, since - // explicit instantiations can occur in multiple translation units - // and must all be equivalent. However, we are not allowed to - // throw away these explicit instantiations. - if (Linkage == GVA_ExplicitTemplateInstantiation) - return !Context.getLangOpts().AppleKext - ? llvm::Function::WeakODRLinkage - : llvm::Function::ExternalLinkage; - - // Otherwise, we have strong external linkage. - assert(Linkage == GVA_StrongExternal); - return llvm::Function::ExternalLinkage; + return getLLVMLinkageForDeclarator(D, Linkage, /*isConstantVariable=*/false); } - -/// SetFunctionDefinitionAttributes - Set attributes for a global. -/// -/// FIXME: This is currently only done for aliases and functions, but not for -/// variables (these details are set in EmitGlobalVarDefinition for variables). -void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, - llvm::GlobalValue *GV) { - SetCommonAttributes(D, GV); +void CodeGenModule::setFunctionDefinitionAttributes(const FunctionDecl *D, + llvm::Function *F) { + setNonAliasAttributes(D, F); } void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, @@ -686,10 +692,15 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, // Naked implies noinline: we should not be inlining such functions. B.addAttribute(llvm::Attribute::Naked); B.addAttribute(llvm::Attribute::NoInline); + } else if (D->hasAttr<OptimizeNoneAttr>()) { + // OptimizeNone implies noinline; we should not be inlining such functions. + B.addAttribute(llvm::Attribute::OptimizeNone); + B.addAttribute(llvm::Attribute::NoInline); + } else if (D->hasAttr<NoDuplicateAttr>()) { + B.addAttribute(llvm::Attribute::NoDuplicate); } else if (D->hasAttr<NoInlineAttr>()) { B.addAttribute(llvm::Attribute::NoInline); - } else if ((D->hasAttr<AlwaysInlineAttr>() || - D->hasAttr<ForceInlineAttr>()) && + } else if (D->hasAttr<AlwaysInlineAttr>() && !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex, llvm::Attribute::NoInline)) { // (noinline wins over always_inline, and we can't specify both in IR) @@ -704,23 +715,30 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, if (D->hasAttr<MinSizeAttr>()) B.addAttribute(llvm::Attribute::MinSize); + if (D->hasAttr<OptimizeNoneAttr>()) { + // OptimizeNone wins over OptimizeForSize and MinSize. + B.removeAttribute(llvm::Attribute::OptimizeForSize); + B.removeAttribute(llvm::Attribute::MinSize); + } + if (LangOpts.getStackProtector() == LangOptions::SSPOn) B.addAttribute(llvm::Attribute::StackProtect); + else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) + B.addAttribute(llvm::Attribute::StackProtectStrong); else if (LangOpts.getStackProtector() == LangOptions::SSPReq) B.addAttribute(llvm::Attribute::StackProtectReq); // Add sanitizer attributes if function is not blacklisted. - if (!SanitizerBlacklist->isIn(*F)) { + if (!SanitizerBL.isIn(*F)) { // When AddressSanitizer is enabled, set SanitizeAddress attribute // unless __attribute__((no_sanitize_address)) is used. - if (SanOpts.Address && !D->hasAttr<NoSanitizeAddressAttr>()) + if (LangOpts.Sanitize.Address && !D->hasAttr<NoSanitizeAddressAttr>()) B.addAttribute(llvm::Attribute::SanitizeAddress); // Same for ThreadSanitizer and __attribute__((no_sanitize_thread)) - if (SanOpts.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) { + if (LangOpts.Sanitize.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) B.addAttribute(llvm::Attribute::SanitizeThread); - } // Same for MemorySanitizer and __attribute__((no_sanitize_memory)) - if (SanOpts.Memory && !D->hasAttr<NoSanitizeMemoryAttr>()) + if (LangOpts.Sanitize.Memory && !D->hasAttr<NoSanitizeMemoryAttr>()) B.addAttribute(llvm::Attribute::SanitizeMemory); } @@ -730,7 +748,7 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D)) F->setUnnamedAddr(true); - else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) + else if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) if (MD->isVirtual()) F->setUnnamedAddr(true); @@ -745,20 +763,23 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, void CodeGenModule::SetCommonAttributes(const Decl *D, llvm::GlobalValue *GV) { - if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) + if (const auto *ND = dyn_cast<NamedDecl>(D)) setGlobalVisibility(GV, ND); else GV->setVisibility(llvm::GlobalValue::DefaultVisibility); if (D->hasAttr<UsedAttr>()) - AddUsedGlobal(GV); + addUsedGlobal(GV); +} + +void CodeGenModule::setNonAliasAttributes(const Decl *D, + llvm::GlobalObject *GO) { + SetCommonAttributes(D, GO); if (const SectionAttr *SA = D->getAttr<SectionAttr>()) - GV->setSection(SA->getName()); + GO->setSection(SA->getName()); - // Alias cannot have attributes. Filter them here. - if (!isa<llvm::GlobalAlias>(GV)) - getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this); + getTargetCodeGenInfo().SetTargetAttributes(D, GO, *this); } void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, @@ -769,7 +790,32 @@ void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, F->setLinkage(llvm::Function::InternalLinkage); - SetCommonAttributes(D, F); + setNonAliasAttributes(D, F); +} + +static void setLinkageAndVisibilityForGV(llvm::GlobalValue *GV, + const NamedDecl *ND) { + // Set linkage and visibility in case we never see a definition. + LinkageInfo LV = ND->getLinkageAndVisibility(); + if (LV.getLinkage() != ExternalLinkage) { + // Don't set internal linkage on declarations. + } else { + if (ND->hasAttr<DLLImportAttr>()) { + GV->setLinkage(llvm::GlobalValue::ExternalLinkage); + GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); + } else if (ND->hasAttr<DLLExportAttr>()) { + GV->setLinkage(llvm::GlobalValue::ExternalLinkage); + GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); + } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) { + // "extern_weak" is overloaded in LLVM; we probably should have + // separate linkage types for this. + GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); + } + + // Set visibility on a declaration only if it's explicit. + if (LV.isVisibilityExplicit()) + GV->setVisibility(CodeGenModule::GetLLVMVisibility(LV.getVisibility())); + } } void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, @@ -783,12 +829,17 @@ void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, return; } - const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); + const auto *FD = cast<FunctionDecl>(GD.getDecl()); if (!IsIncompleteFunction) SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F); - if (getCXXABI().HasThisReturn(GD)) { + // Add the Returned attribute for "this", except for iOS 5 and earlier + // where substantial code, including the libstdc++ dylib, was compiled with + // GCC and does not actually return "this". + if (getCXXABI().HasThisReturn(GD) && + !(getTarget().getTriple().isiOS() && + getTarget().getTriple().isOSVersionLT(6))) { assert(!F->arg_empty() && F->arg_begin()->getType() ->canLosslesslyBitCastTo(F->getReturnType()) && @@ -799,19 +850,12 @@ void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, // Only a few attributes are set on declarations; these may later be // overridden by a definition. - if (FD->hasAttr<DLLImportAttr>()) { - F->setLinkage(llvm::Function::DLLImportLinkage); - } else if (FD->hasAttr<WeakAttr>() || - FD->isWeakImported()) { - // "extern_weak" is overloaded in LLVM; we probably should have - // separate linkage types for this. - F->setLinkage(llvm::Function::ExternalWeakLinkage); - } else { - F->setLinkage(llvm::Function::ExternalLinkage); + setLinkageAndVisibilityForGV(F, FD); - LinkageInfo LV = FD->getLinkageAndVisibility(); - if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) { - F->setVisibility(GetLLVMVisibility(LV.getVisibility())); + if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) { + if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) { + // Don't dllexport/import destructor thunks. + F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass); } } @@ -825,39 +869,49 @@ void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Attribute::NoBuiltin); } -void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { +void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) { assert(!GV->isDeclaration() && "Only globals with definition can force usage."); LLVMUsed.push_back(GV); } -void CodeGenModule::EmitLLVMUsed() { +void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) { + assert(!GV->isDeclaration() && + "Only globals with definition can force usage."); + LLVMCompilerUsed.push_back(GV); +} + +static void emitUsed(CodeGenModule &CGM, StringRef Name, + std::vector<llvm::WeakVH> &List) { // Don't create llvm.used if there is no need. - if (LLVMUsed.empty()) + if (List.empty()) return; - // Convert LLVMUsed to what ConstantArray needs. + // Convert List to what ConstantArray needs. SmallVector<llvm::Constant*, 8> UsedArray; - UsedArray.resize(LLVMUsed.size()); - for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { + UsedArray.resize(List.size()); + for (unsigned i = 0, e = List.size(); i != e; ++i) { UsedArray[i] = - llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), - Int8PtrTy); + llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*List[i]), + CGM.Int8PtrTy); } if (UsedArray.empty()) return; - llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size()); + llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size()); - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), ATy, false, - llvm::GlobalValue::AppendingLinkage, - llvm::ConstantArray::get(ATy, UsedArray), - "llvm.used"); + auto *GV = new llvm::GlobalVariable( + CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage, + llvm::ConstantArray::get(ATy, UsedArray), Name); GV->setSection("llvm.metadata"); } +void CodeGenModule::emitLLVMUsed() { + emitUsed(*this, "llvm.used", LLVMUsed); + emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed); +} + void CodeGenModule::AppendLinkerOptions(StringRef Opts) { llvm::Value *MDOpts = llvm::MDString::get(getLLVMContext(), Opts); LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); @@ -1002,31 +1056,23 @@ void CodeGenModule::EmitDeferred() { // Stop if we're out of both deferred v-tables and deferred declarations. if (DeferredDeclsToEmit.empty()) break; - GlobalDecl D = DeferredDeclsToEmit.back(); + DeferredGlobal &G = DeferredDeclsToEmit.back(); + GlobalDecl D = G.GD; + llvm::GlobalValue *GV = G.GV; DeferredDeclsToEmit.pop_back(); + assert(GV == GetGlobalValue(getMangledName(D))); // Check to see if we've already emitted this. This is necessary // for a couple of reasons: first, decls can end up in the // deferred-decls queue multiple times, and second, decls can end // up with definitions in unusual ways (e.g. by an extern inline // function acquiring a strong function redefinition). Just // ignore these cases. - // - // TODO: That said, looking this up multiple times is very wasteful. - StringRef Name = getMangledName(D); - llvm::GlobalValue *CGRef = GetGlobalValue(Name); - assert(CGRef && "Deferred decl wasn't referenced?"); - - if (!CGRef->isDeclaration()) - continue; - - // GlobalAlias::isDeclaration() defers to the aliasee, but for our - // purposes an alias counts as a definition. - if (isa<llvm::GlobalAlias>(CGRef)) + if(!GV->isDeclaration()) continue; // Otherwise, emit the definition and move on to the next one. - EmitGlobalDefinition(D); + EmitGlobalDefinition(D, GV); } } @@ -1037,9 +1083,9 @@ void CodeGenModule::EmitGlobalAnnotations() { // Create a new global variable for the ConstantStruct in the Module. llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get( Annotations[0]->getType(), Annotations.size()), Annotations); - llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), - Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array, - "llvm.global.annotations"); + auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false, + llvm::GlobalValue::AppendingLinkage, + Array, "llvm.global.annotations"); gv->setSection(AnnotationSection); } @@ -1050,8 +1096,9 @@ llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) { // Not found yet, create a new global. llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str); - llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(), - true, llvm::GlobalValue::PrivateLinkage, s, ".str"); + auto *gv = + new llvm::GlobalVariable(getModule(), s->getType(), true, + llvm::GlobalValue::PrivateLinkage, s, ".str"); gv->setSection(AnnotationSection); gv->setUnnamedAddr(true); AStr = gv; @@ -1096,10 +1143,8 @@ void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV) { assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); // Get the struct elements for these annotations. - for (specific_attr_iterator<AnnotateAttr> - ai = D->specific_attr_begin<AnnotateAttr>(), - ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) - Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation())); + for (const auto *I : D->specific_attrs<AnnotateAttr>()) + Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation())); } bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { @@ -1125,7 +1170,7 @@ llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor( llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType()); assert(Init && "failed to initialize as constant"); - llvm::GlobalVariable *GV = new llvm::GlobalVariable( + auto *GV = new llvm::GlobalVariable( getModule(), Init->getType(), /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name); return GV; @@ -1151,9 +1196,10 @@ llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { /*ForVTable=*/false); else Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), - llvm::PointerType::getUnqual(DeclTy), 0); + llvm::PointerType::getUnqual(DeclTy), + nullptr); - llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee); + auto *F = cast<llvm::GlobalValue>(Aliasee); F->setLinkage(llvm::Function::ExternalWeakLinkage); WeakRefReferences.insert(F); @@ -1161,7 +1207,7 @@ llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { } void CodeGenModule::EmitGlobal(GlobalDecl GD) { - const ValueDecl *Global = cast<ValueDecl>(GD.getDecl()); + const auto *Global = cast<ValueDecl>(GD.getDecl()); // Weak references don't produce any output by themselves. if (Global->hasAttr<WeakRefAttr>()) @@ -1190,25 +1236,28 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) { } // Ignore declarations, they will be emitted on their first use. - if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { + if (const auto *FD = dyn_cast<FunctionDecl>(Global)) { // Forward declarations are emitted lazily on first use. if (!FD->doesThisDeclarationHaveABody()) { if (!FD->doesDeclarationForceExternallyVisibleDefinition()) return; - const FunctionDecl *InlineDefinition = 0; - FD->getBody(InlineDefinition); - StringRef MangledName = getMangledName(GD); - DeferredDecls.erase(MangledName); - EmitGlobalDefinition(InlineDefinition); + + // Compute the function info and LLVM type. + const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); + llvm::Type *Ty = getTypes().GetFunctionType(FI); + + GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false, + /*DontDefer=*/false); return; } } else { - const VarDecl *VD = cast<VarDecl>(Global); + const auto *VD = cast<VarDecl>(Global); assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); - if (VD->isThisDeclarationADefinition() != VarDecl::Definition) + if (VD->isThisDeclarationADefinition() != VarDecl::Definition && + !Context.isMSStaticDataMemberInlineDefinition(VD)) return; } @@ -1225,14 +1274,14 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) { if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) && cast<VarDecl>(Global)->hasInit()) { DelayedCXXInitPosition[Global] = CXXGlobalInits.size(); - CXXGlobalInits.push_back(0); + CXXGlobalInits.push_back(nullptr); } // If the value has already been used, add it directly to the // DeferredDeclsToEmit list. StringRef MangledName = getMangledName(GD); - if (GetGlobalValue(MangledName)) - DeferredDeclsToEmit.push_back(GD); + if (llvm::GlobalValue *GV = GetGlobalValue(MangledName)) + addDeferredDeclToEmit(GV, GD); else { // Otherwise, remember that we saw a deferred decl with this name. The // first use of the mangled name will cause it to move into @@ -1300,9 +1349,8 @@ bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) { if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage) return true; - const FunctionDecl *F = cast<FunctionDecl>(GD.getDecl()); - if (CodeGenOpts.OptimizationLevel == 0 && - !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>()) + const auto *F = cast<FunctionDecl>(GD.getDecl()); + if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>()) return false; // PR9614. Avoid cases where the source code is lying to us. An available // externally function should have an equivalent function somewhere else, @@ -1323,14 +1371,13 @@ void CodeGenModule::CompleteDIClassType(const CXXMethodDecl* D) { if (CGDebugInfo *DI = getModuleDebugInfo()) if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { - const PointerType *ThisPtr = - cast<PointerType>(D->getThisType(getContext())); + const auto *ThisPtr = cast<PointerType>(D->getThisType(getContext())); DI->getOrCreateRecordType(ThisPtr->getPointeeType(), D->getLocation()); } } -void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { - const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); +void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) { + const auto *D = cast<ValueDecl>(GD.getDecl()); PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(), Context.getSourceManager(), @@ -1342,16 +1389,16 @@ void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { if (!shouldEmitFunction(GD)) return; - if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { + if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) { CompleteDIClassType(Method); // Make sure to emit the definition(s) before we emit the thunks. // This is necessary for the generation of certain thunks. - if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method)) + if (const auto *CD = dyn_cast<CXXConstructorDecl>(Method)) EmitCXXConstructor(CD, GD.getCtorType()); - else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method)) + else if (const auto *DD = dyn_cast<CXXDestructorDecl>(Method)) EmitCXXDestructor(DD, GD.getDtorType()); else - EmitGlobalFunctionDefinition(GD); + EmitGlobalFunctionDefinition(GD, GV); if (Method->isVirtual()) getVTables().EmitThunks(GD); @@ -1359,10 +1406,10 @@ void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { return; } - return EmitGlobalFunctionDefinition(GD); + return EmitGlobalFunctionDefinition(GD, GV); } - - if (const VarDecl *VD = dyn_cast<VarDecl>(D)) + + if (const auto *VD = dyn_cast<VarDecl>(D)) return EmitGlobalVarDefinition(VD); llvm_unreachable("Invalid argument to EmitGlobalDefinition()"); @@ -1379,6 +1426,7 @@ llvm::Constant * CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable, + bool DontDefer, llvm::AttributeSet ExtraAttrs) { const Decl *D = GD.getDecl(); @@ -1398,14 +1446,6 @@ CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo()); } - // All MSVC dtors other than the base dtor are linkonce_odr and delegate to - // each other bottoming out with the base dtor. Therefore we emit non-base - // dtors on usage, even if there is no dtor definition in the TU. - if (D && isa<CXXDestructorDecl>(D) && - getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), - GD.getDtorType())) - DeferredDeclsToEmit.push_back(GD); - // This function doesn't have a complete type (for example, the return // type is an incomplete struct). Use a fake type instead, and make // sure not to try to set attributes. @@ -1433,50 +1473,64 @@ CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, B)); } - // This is the first use or definition of a mangled name. If there is a - // deferred decl with this name, remember that we need to emit it at the end - // of the file. - llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); - if (DDI != DeferredDecls.end()) { - // Move the potentially referenced deferred decl to the DeferredDeclsToEmit - // list, and remove it from DeferredDecls (since we don't need it anymore). - DeferredDeclsToEmit.push_back(DDI->second); - DeferredDecls.erase(DDI); - - // Otherwise, if this is a sized deallocation function, emit a weak definition - // for it at the end of the translation unit. - } else if (D && cast<FunctionDecl>(D) - ->getCorrespondingUnsizedGlobalDeallocationFunction()) { - DeferredDeclsToEmit.push_back(GD); - - // Otherwise, there are cases we have to worry about where we're - // using a declaration for which we must emit a definition but where - // we might not find a top-level definition: - // - member functions defined inline in their classes - // - friend functions defined inline in some class - // - special member functions with implicit definitions - // If we ever change our AST traversal to walk into class methods, - // this will be unnecessary. - // - // We also don't emit a definition for a function if it's going to be an entry - // in a vtable, unless it's already marked as used. - } else if (getLangOpts().CPlusPlus && D) { - // Look for a declaration that's lexically in a record. - const FunctionDecl *FD = cast<FunctionDecl>(D); - FD = FD->getMostRecentDecl(); - do { - if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { - if (FD->isImplicit() && !ForVTable) { - assert(FD->isUsed() && "Sema didn't mark implicit function as used!"); - DeferredDeclsToEmit.push_back(GD.getWithDecl(FD)); - break; - } else if (FD->doesThisDeclarationHaveABody()) { - DeferredDeclsToEmit.push_back(GD.getWithDecl(FD)); - break; + if (!DontDefer) { + // All MSVC dtors other than the base dtor are linkonce_odr and delegate to + // each other bottoming out with the base dtor. Therefore we emit non-base + // dtors on usage, even if there is no dtor definition in the TU. + if (D && isa<CXXDestructorDecl>(D) && + getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D), + GD.getDtorType())) + addDeferredDeclToEmit(F, GD); + + // This is the first use or definition of a mangled name. If there is a + // deferred decl with this name, remember that we need to emit it at the end + // of the file. + auto DDI = DeferredDecls.find(MangledName); + if (DDI != DeferredDecls.end()) { + // Move the potentially referenced deferred decl to the + // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we + // don't need it anymore). + addDeferredDeclToEmit(F, DDI->second); + DeferredDecls.erase(DDI); + + // Otherwise, if this is a sized deallocation function, emit a weak + // definition + // for it at the end of the translation unit. + } else if (D && cast<FunctionDecl>(D) + ->getCorrespondingUnsizedGlobalDeallocationFunction()) { + addDeferredDeclToEmit(F, GD); + + // Otherwise, there are cases we have to worry about where we're + // using a declaration for which we must emit a definition but where + // we might not find a top-level definition: + // - member functions defined inline in their classes + // - friend functions defined inline in some class + // - special member functions with implicit definitions + // If we ever change our AST traversal to walk into class methods, + // this will be unnecessary. + // + // We also don't emit a definition for a function if it's going to be an + // entry + // in a vtable, unless it's already marked as used. + } else if (getLangOpts().CPlusPlus && D) { + // Look for a declaration that's lexically in a record. + const auto *FD = cast<FunctionDecl>(D); + FD = FD->getMostRecentDecl(); + do { + if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) { + if (FD->isImplicit() && !ForVTable) { + assert(FD->isUsed() && + "Sema didn't mark implicit function as used!"); + addDeferredDeclToEmit(F, GD.getWithDecl(FD)); + break; + } else if (FD->doesThisDeclarationHaveABody()) { + addDeferredDeclToEmit(F, GD.getWithDecl(FD)); + break; + } } - } - FD = FD->getPreviousDecl(); - } while (FD); + FD = FD->getPreviousDecl(); + } while (FD); + } } // Make sure the result is of the requested type. @@ -1494,13 +1548,14 @@ CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName, /// create it (this occurs when we see a definition of the function). llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty, - bool ForVTable) { + bool ForVTable, + bool DontDefer) { // If there was no specific requested type, just convert it now. if (!Ty) Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType()); StringRef MangledName = getMangledName(GD); - return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable); + return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer); } /// CreateRuntimeFunction - Create a new runtime function with the specified @@ -1509,10 +1564,10 @@ llvm::Constant * CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name, llvm::AttributeSet ExtraAttrs) { - llvm::Constant *C - = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, - ExtraAttrs); - if (llvm::Function *F = dyn_cast<llvm::Function>(C)) + llvm::Constant *C = + GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false, + /*DontDefer=*/false, ExtraAttrs); + if (auto *F = dyn_cast<llvm::Function>(C)) if (F->empty()) F->setCallingConv(getRuntimeCC()); return C; @@ -1548,8 +1603,7 @@ bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) { llvm::Constant * CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::PointerType *Ty, - const VarDecl *D, - bool UnnamedAddr) { + const VarDecl *D) { // Lookup the entry, lazily creating it if necessary. llvm::GlobalValue *Entry = GetGlobalValue(MangledName); if (Entry) { @@ -1558,9 +1612,6 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, Entry->setLinkage(llvm::Function::ExternalLinkage); } - if (UnnamedAddr) - Entry->setUnnamedAddr(true); - if (Entry->getType() == Ty) return Entry; @@ -1571,44 +1622,30 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, return llvm::ConstantExpr::getBitCast(Entry, Ty); } + unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); + auto *GV = new llvm::GlobalVariable( + getModule(), Ty->getElementType(), false, + llvm::GlobalValue::ExternalLinkage, nullptr, MangledName, nullptr, + llvm::GlobalVariable::NotThreadLocal, AddrSpace); + // This is the first use or definition of a mangled name. If there is a // deferred decl with this name, remember that we need to emit it at the end // of the file. - llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName); + auto DDI = DeferredDecls.find(MangledName); if (DDI != DeferredDecls.end()) { // Move the potentially referenced deferred decl to the DeferredDeclsToEmit // list, and remove it from DeferredDecls (since we don't need it anymore). - DeferredDeclsToEmit.push_back(DDI->second); + addDeferredDeclToEmit(GV, DDI->second); DeferredDecls.erase(DDI); } - unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace()); - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, - llvm::GlobalValue::ExternalLinkage, - 0, MangledName, 0, - llvm::GlobalVariable::NotThreadLocal, AddrSpace); - // Handle things which are present even on external declarations. if (D) { // FIXME: This code is overly simple and should be merged with other global // handling. GV->setConstant(isTypeConstant(D->getType(), false)); - // Set linkage and visibility in case we never see a definition. - LinkageInfo LV = D->getLinkageAndVisibility(); - if (LV.getLinkage() != ExternalLinkage) { - // Don't set internal linkage on declarations. - } else { - if (D->hasAttr<DLLImportAttr>()) - GV->setLinkage(llvm::GlobalValue::DLLImportLinkage); - else if (D->hasAttr<WeakAttr>() || D->isWeakImported()) - GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); - - // Set visibility on a declaration only if it's explicit. - if (LV.isVisibilityExplicit()) - GV->setVisibility(GetLLVMVisibility(LV.getVisibility())); - } + setLinkageAndVisibilityForGV(GV, D); if (D->getTLSKind()) { if (D->getTLSKind() == VarDecl::TLS_Dynamic) @@ -1618,10 +1655,16 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, // If required by the ABI, treat declarations of static data members with // inline initializers as definitions. - if (getCXXABI().isInlineInitializedStaticDataMemberLinkOnce() && - D->isStaticDataMember() && D->hasInit() && - !D->isThisDeclarationADefinition()) + if (getContext().isMSStaticDataMemberInlineDefinition(D)) { EmitGlobalVarDefinition(D); + } + + // Handle XCore specific ABI requirements. + if (getTarget().getTriple().getArch() == llvm::Triple::xcore && + D->getLanguageLinkage() == CLanguageLinkage && + D->getType().isConstant(Context) && + isExternallyVisible(D->getLinkageAndVisibility().getLinkage())) + GV->setSection(".cp.rodata"); } if (AddrSpace != Ty->getAddressSpace()) @@ -1636,9 +1679,8 @@ CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage) { llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name); - llvm::GlobalVariable *OldGV = 0; + llvm::GlobalVariable *OldGV = nullptr; - if (GV) { // Check if the variable has the right type. if (GV->getType()->getElementType() == Ty) @@ -1652,8 +1694,8 @@ CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name, // Create a new variable. GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true, - Linkage, 0, Name); - + Linkage, nullptr, Name); + if (OldGV) { // Replace occurrences of the old variable if needed. GV->takeName(OldGV); @@ -1678,7 +1720,7 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty) { assert(D->hasGlobalStorage() && "Not a global variable"); QualType ASTTy = D->getType(); - if (Ty == 0) + if (!Ty) Ty = getTypes().ConvertTypeForMem(ASTTy); llvm::PointerType *PTy = @@ -1693,8 +1735,7 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, llvm::Constant * CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty, StringRef Name) { - return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0, - true); + return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), nullptr); } void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { @@ -1764,11 +1805,11 @@ void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D, // If we have multiple internal linkage entities with the same name // in extern "C" regions, none of them gets that name. if (!R.second) - R.first->second = 0; + R.first->second = nullptr; } void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { - llvm::Constant *Init = 0; + llvm::Constant *Init = nullptr; QualType ASTTy = D->getType(); CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); bool NeedsGlobalCtor = false; @@ -1818,7 +1859,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); // Strip off a bitcast if we got one back. - if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { + if (auto *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { assert(CE->getOpcode() == llvm::Instruction::BitCast || CE->getOpcode() == llvm::Instruction::AddrSpaceCast || // All zero index gep. @@ -1827,7 +1868,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { } // Entry is now either a Function or GlobalVariable. - llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); + auto *GV = dyn_cast<llvm::GlobalVariable>(Entry); // We have a definition after a declaration with the wrong type. // We must make a new GlobalVariable* and update everything that used OldGV @@ -1838,7 +1879,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { // "extern int x[];") and then a definition of a different type (e.g. // "int x[10];"). This also happens when an initializer has a different type // from the type of the global (this happens with unions). - if (GV == 0 || + if (!GV || GV->getType()->getElementType() != InitType || GV->getType()->getAddressSpace() != GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) { @@ -1872,38 +1913,35 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); // Set the llvm linkage type as appropriate. - llvm::GlobalValue::LinkageTypes Linkage = - GetLLVMLinkageVarDefinition(D, GV->isConstant()); - GV->setLinkage(Linkage); + llvm::GlobalValue::LinkageTypes Linkage = + getLLVMLinkageVarDefinition(D, GV->isConstant()); + + // On Darwin, the backing variable for a C++11 thread_local variable always + // has internal linkage; all accesses should just be calls to the + // Itanium-specified entry point, which has the normal linkage of the + // variable. + if (const auto *VD = dyn_cast<VarDecl>(D)) + if (!VD->isStaticLocal() && VD->getTLSKind() == VarDecl::TLS_Dynamic && + Context.getTargetInfo().getTriple().isMacOSX()) + Linkage = llvm::GlobalValue::InternalLinkage; - // If required by the ABI, give definitions of static data members with inline - // initializers linkonce_odr linkage. - if (getCXXABI().isInlineInitializedStaticDataMemberLinkOnce() && - D->isStaticDataMember() && InitExpr && - !InitDecl->isThisDeclarationADefinition()) - GV->setLinkage(llvm::GlobalVariable::LinkOnceODRLinkage); + GV->setLinkage(Linkage); + if (D->hasAttr<DLLImportAttr>()) + GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass); + else if (D->hasAttr<DLLExportAttr>()) + GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass); if (Linkage == llvm::GlobalVariable::CommonLinkage) // common vars aren't constant even if declared const. GV->setConstant(false); - SetCommonAttributes(D, GV); + setNonAliasAttributes(D, GV); // Emit the initializer function if necessary. if (NeedsGlobalCtor || NeedsGlobalDtor) EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor); - // If we are compiling with ASan, add metadata indicating dynamically - // initialized globals. - if (SanOpts.Address && NeedsGlobalCtor) { - llvm::Module &M = getModule(); - - llvm::NamedMDNode *DynamicInitializers = - M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals"); - llvm::Value *GlobalToAdd[] = { GV }; - llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd); - DynamicInitializers->addOperand(ThisGlobal); - } + reportGlobalToASan(GV, *D, NeedsGlobalCtor); // Emit global variable debug information. if (CGDebugInfo *DI = getModuleDebugInfo()) @@ -1911,47 +1949,164 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { DI->EmitGlobalVariable(GV, D); } -llvm::GlobalValue::LinkageTypes -CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, bool isConstant) { - GVALinkage Linkage = getContext().GetGVALinkageForVariable(D); +void CodeGenModule::reportGlobalToASan(llvm::GlobalVariable *GV, + SourceLocation Loc, StringRef Name, + bool IsDynInit, bool IsBlacklisted) { + if (!LangOpts.Sanitize.Address) + return; + IsDynInit &= !SanitizerBL.isIn(*GV, "init"); + IsBlacklisted |= SanitizerBL.isIn(*GV); + + llvm::GlobalVariable *LocDescr = nullptr; + llvm::GlobalVariable *GlobalName = nullptr; + if (!IsBlacklisted) { + // Don't generate source location and global name if it is blacklisted - + // it won't be instrumented anyway. + PresumedLoc PLoc = Context.getSourceManager().getPresumedLoc(Loc); + if (PLoc.isValid()) { + llvm::Constant *LocData[] = { + GetAddrOfConstantCString(PLoc.getFilename()), + llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), + PLoc.getLine()), + llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), + PLoc.getColumn()), + }; + auto LocStruct = llvm::ConstantStruct::getAnon(LocData); + LocDescr = new llvm::GlobalVariable(TheModule, LocStruct->getType(), true, + llvm::GlobalValue::PrivateLinkage, + LocStruct, ".asan_loc_descr"); + LocDescr->setUnnamedAddr(true); + // Add LocDescr to llvm.compiler.used, so that it won't be removed by + // the optimizer before the ASan instrumentation pass. + addCompilerUsedGlobal(LocDescr); + } + if (!Name.empty()) { + GlobalName = GetAddrOfConstantCString(Name); + // GlobalName shouldn't be removed by the optimizer. + addCompilerUsedGlobal(GlobalName); + } + } + + llvm::Value *GlobalMetadata[] = { + GV, LocDescr, GlobalName, + llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsDynInit), + llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsBlacklisted)}; + + llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalMetadata); + llvm::NamedMDNode *AsanGlobals = + TheModule.getOrInsertNamedMetadata("llvm.asan.globals"); + AsanGlobals->addOperand(ThisGlobal); +} + +void CodeGenModule::reportGlobalToASan(llvm::GlobalVariable *GV, + const VarDecl &D, bool IsDynInit) { + if (!LangOpts.Sanitize.Address) + return; + std::string QualName; + llvm::raw_string_ostream OS(QualName); + D.printQualifiedName(OS); + reportGlobalToASan(GV, D.getLocation(), OS.str(), IsDynInit); +} + +void CodeGenModule::disableSanitizerForGlobal(llvm::GlobalVariable *GV) { + // For now, just make sure the global is not modified by the ASan + // instrumentation. + if (LangOpts.Sanitize.Address) + reportGlobalToASan(GV, SourceLocation(), "", false, true); +} + +static bool isVarDeclStrongDefinition(const VarDecl *D, bool NoCommon) { + // Don't give variables common linkage if -fno-common was specified unless it + // was overridden by a NoCommon attribute. + if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>()) + return true; + + // C11 6.9.2/2: + // A declaration of an identifier for an object that has file scope without + // an initializer, and without a storage-class specifier or with the + // storage-class specifier static, constitutes a tentative definition. + if (D->getInit() || D->hasExternalStorage()) + return true; + + // A variable cannot be both common and exist in a section. + if (D->hasAttr<SectionAttr>()) + return true; + + // Thread local vars aren't considered common linkage. + if (D->getTLSKind()) + return true; + + // Tentative definitions marked with WeakImportAttr are true definitions. + if (D->hasAttr<WeakImportAttr>()) + return true; + + return false; +} + +llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageForDeclarator( + const DeclaratorDecl *D, GVALinkage Linkage, bool IsConstantVariable) { if (Linkage == GVA_Internal) return llvm::Function::InternalLinkage; - else if (D->hasAttr<DLLImportAttr>()) - return llvm::Function::DLLImportLinkage; - else if (D->hasAttr<DLLExportAttr>()) - return llvm::Function::DLLExportLinkage; - else if (D->hasAttr<SelectAnyAttr>()) { - // selectany symbols are externally visible, so use weak instead of - // linkonce. MSVC optimizes away references to const selectany globals, so - // all definitions should be the same and ODR linkage should be used. - // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx - return llvm::GlobalVariable::WeakODRLinkage; - } else if (D->hasAttr<WeakAttr>()) { - if (isConstant) + + if (D->hasAttr<WeakAttr>()) { + if (IsConstantVariable) return llvm::GlobalVariable::WeakODRLinkage; else return llvm::GlobalVariable::WeakAnyLinkage; - } else if (Linkage == GVA_TemplateInstantiation || - Linkage == GVA_ExplicitTemplateInstantiation) - return llvm::GlobalVariable::WeakODRLinkage; - else if (!getLangOpts().CPlusPlus && - ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) || - D->getAttr<CommonAttr>()) && - !D->hasExternalStorage() && !D->getInit() && - !D->getAttr<SectionAttr>() && !D->getTLSKind() && - !D->getAttr<WeakImportAttr>()) { - // Thread local vars aren't considered common linkage. + } + + // We are guaranteed to have a strong definition somewhere else, + // so we can use available_externally linkage. + if (Linkage == GVA_AvailableExternally) + return llvm::Function::AvailableExternallyLinkage; + + // Note that Apple's kernel linker doesn't support symbol + // coalescing, so we need to avoid linkonce and weak linkages there. + // Normally, this means we just map to internal, but for explicit + // instantiations we'll map to external. + + // In C++, the compiler has to emit a definition in every translation unit + // that references the function. We should use linkonce_odr because + // a) if all references in this translation unit are optimized away, we + // don't need to codegen it. b) if the function persists, it needs to be + // merged with other definitions. c) C++ has the ODR, so we know the + // definition is dependable. + if (Linkage == GVA_DiscardableODR) + return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage + : llvm::Function::InternalLinkage; + + // An explicit instantiation of a template has weak linkage, since + // explicit instantiations can occur in multiple translation units + // and must all be equivalent. However, we are not allowed to + // throw away these explicit instantiations. + if (Linkage == GVA_StrongODR) + return !Context.getLangOpts().AppleKext ? llvm::Function::WeakODRLinkage + : llvm::Function::ExternalLinkage; + + // C++ doesn't have tentative definitions and thus cannot have common + // linkage. + if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) && + !isVarDeclStrongDefinition(cast<VarDecl>(D), CodeGenOpts.NoCommon)) return llvm::GlobalVariable::CommonLinkage; - } else if (D->getTLSKind() == VarDecl::TLS_Dynamic && - getTarget().getTriple().isMacOSX()) - // On Darwin, the backing variable for a C++11 thread_local variable always - // has internal linkage; all accesses should just be calls to the - // Itanium-specified entry point, which has the normal linkage of the - // variable. - return llvm::GlobalValue::InternalLinkage; + + // selectany symbols are externally visible, so use weak instead of + // linkonce. MSVC optimizes away references to const selectany globals, so + // all definitions should be the same and ODR linkage should be used. + // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx + if (D->hasAttr<SelectAnyAttr>()) + return llvm::GlobalVariable::WeakODRLinkage; + + // Otherwise, we have strong external linkage. + assert(Linkage == GVA_StrongExternal); return llvm::GlobalVariable::ExternalLinkage; } +llvm::GlobalValue::LinkageTypes CodeGenModule::getLLVMLinkageVarDefinition( + const VarDecl *VD, bool IsConstant) { + GVALinkage Linkage = getContext().GetGVALinkageForVariable(VD); + return getLLVMLinkageForDeclarator(VD, Linkage, IsConstant); +} + /// Replace the uses of a function that was declared with a non-proto type. /// We want to silently drop extra arguments from call sites static void replaceUsesOfNonProtoConstant(llvm::Constant *old, @@ -1965,11 +2120,11 @@ static void replaceUsesOfNonProtoConstant(llvm::Constant *old, for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end(); ui != ue; ) { llvm::Value::use_iterator use = ui++; // Increment before the use is erased. - llvm::User *user = *use; + llvm::User *user = use->getUser(); // Recognize and replace uses of bitcasts. Most calls to // unprototyped functions will use bitcasts. - if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) { + if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) { if (bitcast->getOpcode() == llvm::Instruction::BitCast) replaceUsesOfNonProtoConstant(bitcast, newFn); continue; @@ -1978,7 +2133,7 @@ static void replaceUsesOfNonProtoConstant(llvm::Constant *old, // Recognize calls to the function. llvm::CallSite callSite(user); if (!callSite) continue; - if (!callSite.isCallee(use)) continue; + if (!callSite.isCallee(&*use)) continue; // If the return types don't match exactly, then we can't // transform this call unless it's dead. @@ -2033,8 +2188,7 @@ static void replaceUsesOfNonProtoConstant(llvm::Constant *old, newCall = llvm::CallInst::Create(newFn, newArgs, "", callSite.getInstruction()); } else { - llvm::InvokeInst *oldInvoke = - cast<llvm::InvokeInst>(callSite.getInstruction()); + auto *oldInvoke = cast<llvm::InvokeInst>(callSite.getInstruction()); newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(), oldInvoke->getUnwindDest(), @@ -2087,33 +2241,36 @@ void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { EmitTopLevelDecl(VD); } -void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { - const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); +void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD, + llvm::GlobalValue *GV) { + const auto *D = cast<FunctionDecl>(GD.getDecl()); // Compute the function info and LLVM type. const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD); llvm::FunctionType *Ty = getTypes().GetFunctionType(FI); // Get or create the prototype for the function. - llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); - - // Strip off a bitcast if we got one back. - if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { - assert(CE->getOpcode() == llvm::Instruction::BitCast); - Entry = CE->getOperand(0); + if (!GV) { + llvm::Constant *C = + GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer*/ true); + + // Strip off a bitcast if we got one back. + if (auto *CE = dyn_cast<llvm::ConstantExpr>(C)) { + assert(CE->getOpcode() == llvm::Instruction::BitCast); + GV = cast<llvm::GlobalValue>(CE->getOperand(0)); + } else { + GV = cast<llvm::GlobalValue>(C); + } } - if (!cast<llvm::GlobalValue>(Entry)->isDeclaration()) { + if (!GV->isDeclaration()) { getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name); return; } - if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { - llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); - + if (GV->getType()->getElementType() != Ty) { // If the types mismatch then we have to rewrite the definition. - assert(OldFn->isDeclaration() && - "Shouldn't replace non-declaration"); + assert(GV->isDeclaration() && "Shouldn't replace non-declaration"); // F is the Function* for the one with the wrong type, we must make a new // Function* and update everything that used F (a declaration) with the new @@ -2123,8 +2280,8 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { // (e.g. "int f()") and then a definition of a different type // (e.g. "int f(int x)"). Move the old function aside so that it // doesn't interfere with GetAddrOfFunction. - OldFn->setName(StringRef()); - llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); + GV->setName(StringRef()); + auto *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); // This might be an implementation of a function without a // prototype, in which case, try to do special replacement of @@ -2133,39 +2290,39 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { // so as to make a direct call, which makes the inliner happier // and suppresses a number of optimizer warnings (!) about // dropping arguments. - if (!OldFn->use_empty()) { - ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); - OldFn->removeDeadConstantUsers(); + if (!GV->use_empty()) { + ReplaceUsesOfNonProtoTypeWithRealFunction(GV, NewFn); + GV->removeDeadConstantUsers(); } // Replace uses of F with the Function we will endow with a body. - if (!Entry->use_empty()) { + if (!GV->use_empty()) { llvm::Constant *NewPtrForOldDecl = - llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); - Entry->replaceAllUsesWith(NewPtrForOldDecl); + llvm::ConstantExpr::getBitCast(NewFn, GV->getType()); + GV->replaceAllUsesWith(NewPtrForOldDecl); } // Ok, delete the old function now, which is dead. - OldFn->eraseFromParent(); + GV->eraseFromParent(); - Entry = NewFn; + GV = NewFn; } // We need to set linkage and visibility on the function before // generating code for it because various parts of IR generation // want to propagate this information down (e.g. to local static // declarations). - llvm::Function *Fn = cast<llvm::Function>(Entry); + auto *Fn = cast<llvm::Function>(GV); setFunctionLinkage(GD, Fn); - // FIXME: this is redundant with part of SetFunctionDefinitionAttributes + // FIXME: this is redundant with part of setFunctionDefinitionAttributes setGlobalVisibility(Fn, D); MaybeHandleStaticInExternC(D, Fn); CodeGenFunction(*this).GenerateCode(D, Fn, FI); - SetFunctionDefinitionAttributes(D, Fn); + setFunctionDefinitionAttributes(D, Fn); SetLLVMFunctionAttributesForDefinition(D, Fn); if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) @@ -2177,7 +2334,7 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { } void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { - const ValueDecl *D = cast<ValueDecl>(GD.getDecl()); + const auto *D = cast<ValueDecl>(GD.getDecl()); const AliasAttr *AA = D->getAttr<AliasAttr>(); assert(AA && "Not an alias?"); @@ -2201,15 +2358,20 @@ void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { /*ForVTable=*/false); else Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), - llvm::PointerType::getUnqual(DeclTy), 0); + llvm::PointerType::getUnqual(DeclTy), + nullptr); // Create the new alias itself, but don't set a name yet. - llvm::GlobalValue *GA = - new llvm::GlobalAlias(Aliasee->getType(), - llvm::Function::ExternalLinkage, - "", Aliasee, &getModule()); + auto *GA = llvm::GlobalAlias::create( + cast<llvm::PointerType>(Aliasee->getType())->getElementType(), 0, + llvm::Function::ExternalLinkage, "", Aliasee, &getModule()); if (Entry) { + if (GA->getAliasee() == Entry) { + Diags.Report(AA->getLocation(), diag::err_cyclic_alias); + return; + } + assert(Entry->isDeclaration()); // If there is a declaration in the module, then we had an extern followed @@ -2232,12 +2394,12 @@ void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) { // specialization of the attributes which may be set on a global // variable/function. if (D->hasAttr<DLLExportAttr>()) { - if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { + if (const auto *FD = dyn_cast<FunctionDecl>(D)) { // The dllexport attribute is ignored for undefined symbols. if (FD->hasBody()) - GA->setLinkage(llvm::Function::DLLExportLinkage); + GA->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); } else { - GA->setLinkage(llvm::Function::DLLExportLinkage); + GA->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); } } else if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() || @@ -2330,8 +2492,7 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { QualType CFTy = getContext().getCFConstantStringType(); - llvm::StructType *STy = - cast<llvm::StructType>(getTypes().ConvertType(CFTy)); + auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy)); llvm::Constant *Fields[4]; @@ -2344,7 +2505,7 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { llvm::ConstantInt::get(Ty, 0x07C8); // String pointer. - llvm::Constant *C = 0; + llvm::Constant *C = nullptr; if (isUTF16) { ArrayRef<uint16_t> Arr = llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>( @@ -2355,30 +2516,25 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey()); } - llvm::GlobalValue::LinkageTypes Linkage; - if (isUTF16) - // FIXME: why do utf strings get "_" labels instead of "L" labels? - Linkage = llvm::GlobalValue::InternalLinkage; - else - // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error - // when using private linkage. It is not clear if this is a bug in ld - // or a reasonable new restriction. - Linkage = llvm::GlobalValue::LinkerPrivateLinkage; - // Note: -fwritable-strings doesn't make the backing store strings of // CFStrings writable. (See <rdar://problem/10657500>) - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, - Linkage, C, ".str"); + auto *GV = + new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true, + llvm::GlobalValue::PrivateLinkage, C, ".str"); GV->setUnnamedAddr(true); // Don't enforce the target's minimum global alignment, since the only use // of the string is via this class initializer. + // FIXME: We set the section explicitly to avoid a bug in ld64 224.1. Without + // it LLVM can merge the string with a non unnamed_addr one during LTO. Doing + // that changes the section it ends in, which surprises ld64. if (isUTF16) { CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy); GV->setAlignment(Align.getQuantity()); + GV->setSection("__TEXT,__ustring"); } else { CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy); GV->setAlignment(Align.getQuantity()); + GV->setSection("__TEXT,__cstring,cstring_literals"); } // String. @@ -2397,23 +2553,12 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { GV = new llvm::GlobalVariable(getModule(), C->getType(), true, llvm::GlobalVariable::PrivateLinkage, C, "_unnamed_cfstring_"); - if (const char *Sect = getTarget().getCFStringSection()) - GV->setSection(Sect); + GV->setSection("__DATA,__cfstring"); Entry.setValue(GV); return GV; } -static RecordDecl * -CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, - DeclContext *DC, IdentifierInfo *Id) { - SourceLocation Loc; - if (Ctx.getLangOpts().CPlusPlus) - return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); - else - return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); -} - llvm::Constant * CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { unsigned StringLength = 0; @@ -2456,9 +2601,7 @@ CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { if (!NSConstantStringType) { // Construct the type for a constant NSString. - RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, - Context.getTranslationUnitDecl(), - &Context.Idents.get("__builtin_NSString")); + RecordDecl *D = Context.buildImplicitRecord("__builtin_NSString"); D->startDefinition(); QualType FieldTypes[3]; @@ -2474,9 +2617,9 @@ CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { for (unsigned i = 0; i < 3; ++i) { FieldDecl *Field = FieldDecl::Create(Context, D, SourceLocation(), - SourceLocation(), 0, - FieldTypes[i], /*TInfo=*/0, - /*BitWidth=*/0, + SourceLocation(), nullptr, + FieldTypes[i], /*TInfo=*/nullptr, + /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit); Field->setAccess(AS_public); @@ -2501,10 +2644,9 @@ CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { bool isConstant; Linkage = llvm::GlobalValue::PrivateLinkage; isConstant = !LangOpts.WritableStrings; - - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C, - ".str"); + + auto *GV = new llvm::GlobalVariable(getModule(), C->getType(), isConstant, + Linkage, C, ".str"); GV->setUnnamedAddr(true); // Don't enforce the target's minimum global alignment, since the only use // of the string is via this class initializer. @@ -2521,12 +2663,13 @@ CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { GV = new llvm::GlobalVariable(getModule(), C->getType(), true, llvm::GlobalVariable::PrivateLinkage, C, "_unnamed_nsstring_"); + const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip"; + const char *NSStringNonFragileABISection = + "__DATA,__objc_stringobj,regular,no_dead_strip"; // FIXME. Fix section. - if (const char *Sect = - LangOpts.ObjCRuntime.isNonFragile() - ? getTarget().getNSStringNonFragileABISection() - : getTarget().getNSStringSection()) - GV->setSection(Sect); + GV->setSection(LangOpts.ObjCRuntime.isNonFragile() + ? NSStringNonFragileABISection + : NSStringSection); Entry.setValue(GV); return GV; @@ -2534,9 +2677,7 @@ CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) { QualType CodeGenModule::getObjCFastEnumerationStateType() { if (ObjCFastEnumerationStateType.isNull()) { - RecordDecl *D = CreateRecordDecl(Context, TTK_Struct, - Context.getTranslationUnitDecl(), - &Context.Idents.get("__objcFastEnumerationState")); + RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState"); D->startDefinition(); QualType FieldTypes[] = { @@ -2551,9 +2692,9 @@ QualType CodeGenModule::getObjCFastEnumerationStateType() { FieldDecl *Field = FieldDecl::Create(Context, D, SourceLocation(), - SourceLocation(), 0, - FieldTypes[i], /*TInfo=*/0, - /*BitWidth=*/0, + SourceLocation(), nullptr, + FieldTypes[i], /*TInfo=*/nullptr, + /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit); Field->setAccess(AS_public); @@ -2581,9 +2722,8 @@ CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { Str.resize(CAT->getSize().getZExtValue()); return llvm::ConstantDataArray::getString(VMContext, Str, false); } - - llvm::ArrayType *AType = - cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); + + auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType())); llvm::Type *ElemTy = AType->getElementType(); unsigned NumElements = AType->getNumElements(); @@ -2608,36 +2748,73 @@ CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) { return llvm::ConstantDataArray::get(VMContext, Elements); } +static llvm::GlobalVariable * +GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, + CodeGenModule &CGM, StringRef GlobalName, + unsigned Alignment) { + // OpenCL v1.2 s6.5.3: a string literal is in the constant address space. + unsigned AddrSpace = 0; + if (CGM.getLangOpts().OpenCL) + AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant); + + // Create a global variable for this string + auto *GV = new llvm::GlobalVariable( + CGM.getModule(), C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, + GlobalName, nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace); + GV->setAlignment(Alignment); + GV->setUnnamedAddr(true); + return GV; +} + /// GetAddrOfConstantStringFromLiteral - Return a pointer to a /// constant array for the given string literal. -llvm::Constant * +llvm::GlobalVariable * CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { - CharUnits Align = getContext().getAlignOfGlobalVarInChars(S->getType()); - if (S->isAscii() || S->isUTF8()) { - SmallString<64> Str(S->getString()); - - // Resize the string to the right size, which is indicated by its type. - const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType()); - Str.resize(CAT->getSize().getZExtValue()); - return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity()); - } + auto Alignment = + getContext().getAlignOfGlobalVarInChars(S->getType()).getQuantity(); - // FIXME: the following does not memoize wide strings. llvm::Constant *C = GetConstantArrayFromStringLiteral(S); - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(),C->getType(), - !LangOpts.WritableStrings, - llvm::GlobalValue::PrivateLinkage, - C,".str"); + llvm::GlobalVariable **Entry = nullptr; + if (!LangOpts.WritableStrings) { + Entry = &ConstantStringMap[C]; + if (auto GV = *Entry) { + if (Alignment > GV->getAlignment()) + GV->setAlignment(Alignment); + return GV; + } + } - GV->setAlignment(Align.getQuantity()); - GV->setUnnamedAddr(true); + SmallString<256> MangledNameBuffer; + StringRef GlobalVariableName; + llvm::GlobalValue::LinkageTypes LT; + + // Mangle the string literal if the ABI allows for it. However, we cannot + // do this if we are compiling with ASan or -fwritable-strings because they + // rely on strings having normal linkage. + if (!LangOpts.WritableStrings && !LangOpts.Sanitize.Address && + getCXXABI().getMangleContext().shouldMangleStringLiteral(S)) { + llvm::raw_svector_ostream Out(MangledNameBuffer); + getCXXABI().getMangleContext().mangleStringLiteral(S, Out); + Out.flush(); + + LT = llvm::GlobalValue::LinkOnceODRLinkage; + GlobalVariableName = MangledNameBuffer; + } else { + LT = llvm::GlobalValue::PrivateLinkage; + GlobalVariableName = ".str"; + } + + auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment); + if (Entry) + *Entry = GV; + + reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>"); return GV; } /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant /// array for the given ObjCEncodeExpr node. -llvm::Constant * +llvm::GlobalVariable * CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { std::string Str; getContext().getObjCEncodingForType(E->getEncodedType(), Str); @@ -2645,87 +2822,48 @@ CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { return GetAddrOfConstantCString(Str); } - -/// GenerateWritableString -- Creates storage for a string literal. -static llvm::GlobalVariable *GenerateStringLiteral(StringRef str, - bool constant, - CodeGenModule &CGM, - const char *GlobalName, - unsigned Alignment) { - // Create Constant for this string literal. Don't add a '\0'. - llvm::Constant *C = - llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false); - - // OpenCL v1.1 s6.5.3: a string literal is in the constant address space. - unsigned AddrSpace = 0; - if (CGM.getLangOpts().OpenCL) - AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant); - - // Create a global variable for this string - llvm::GlobalVariable *GV = new llvm::GlobalVariable( - CGM.getModule(), C->getType(), constant, - llvm::GlobalValue::PrivateLinkage, C, GlobalName, 0, - llvm::GlobalVariable::NotThreadLocal, AddrSpace); - GV->setAlignment(Alignment); - GV->setUnnamedAddr(true); - return GV; -} - -/// GetAddrOfConstantString - Returns a pointer to a character array -/// containing the literal. This contents are exactly that of the -/// given string, i.e. it will not be null terminated automatically; -/// see GetAddrOfConstantCString. Note that whether the result is -/// actually a pointer to an LLVM constant depends on -/// Feature.WriteableStrings. -/// +/// GetAddrOfConstantCString - Returns a pointer to a character array containing +/// the literal and a terminating '\0' character. /// The result has pointer to array type. -llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str, - const char *GlobalName, - unsigned Alignment) { - // Get the default prefix if a name wasn't specified. - if (!GlobalName) - GlobalName = ".str"; +llvm::GlobalVariable *CodeGenModule::GetAddrOfConstantCString( + const std::string &Str, const char *GlobalName, unsigned Alignment) { + StringRef StrWithNull(Str.c_str(), Str.size() + 1); + if (Alignment == 0) { + Alignment = getContext() + .getAlignOfGlobalVarInChars(getContext().CharTy) + .getQuantity(); + } - if (Alignment == 0) - Alignment = getContext().getAlignOfGlobalVarInChars(getContext().CharTy) - .getQuantity(); + llvm::Constant *C = + llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false); // Don't share any string literals if strings aren't constant. - if (LangOpts.WritableStrings) - return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment); - - llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = - ConstantStringMap.GetOrCreateValue(Str); - - if (llvm::GlobalVariable *GV = Entry.getValue()) { - if (Alignment > GV->getAlignment()) { - GV->setAlignment(Alignment); + llvm::GlobalVariable **Entry = nullptr; + if (!LangOpts.WritableStrings) { + Entry = &ConstantStringMap[C]; + if (auto GV = *Entry) { + if (Alignment > GV->getAlignment()) + GV->setAlignment(Alignment); + return GV; } - return GV; } + // Get the default prefix if a name wasn't specified. + if (!GlobalName) + GlobalName = ".str"; // Create a global variable for this. - llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName, - Alignment); - Entry.setValue(GV); + auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this, + GlobalName, Alignment); + if (Entry) + *Entry = GV; return GV; } -/// GetAddrOfConstantCString - Returns a pointer to a character -/// array containing the literal and a terminating '\0' -/// character. The result has pointer to array type. -llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str, - const char *GlobalName, - unsigned Alignment) { - StringRef StrWithNull(Str.c_str(), Str.size() + 1); - return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment); -} - llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( const MaterializeTemporaryExpr *E, const Expr *Init) { assert((E->getStorageDuration() == SD_Static || E->getStorageDuration() == SD_Thread) && "not a global temporary"); - const VarDecl *VD = cast<VarDecl>(E->getExtendingDecl()); + const auto *VD = cast<VarDecl>(E->getExtendingDecl()); // If we're not materializing a subobject of the temporary, keep the // cv-qualifiers from the type of the MaterializeTemporaryExpr. @@ -2742,10 +2880,11 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( // we also need to make the temporaries externally-visible). SmallString<256> Name; llvm::raw_svector_ostream Out(Name); - getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out); + getCXXABI().getMangleContext().mangleReferenceTemporary( + VD, E->getManglingNumber(), Out); Out.flush(); - APValue *Value = 0; + APValue *Value = nullptr; if (E->getStorageDuration() == SD_Static) { // We might have a cached constant initializer for this temporary. Note // that this might have a different value from the value computed by @@ -2753,7 +2892,7 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( // modifies the temporary. Value = getContext().getMaterializedTemporaryValue(E, false); if (Value && Value->isUninit()) - Value = 0; + Value = nullptr; } // Try evaluating it now, it might have a constant initializer. @@ -2762,12 +2901,12 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( !EvalResult.hasSideEffects()) Value = &EvalResult.Val; - llvm::Constant *InitialValue = 0; + llvm::Constant *InitialValue = nullptr; bool Constant = false; llvm::Type *Type; if (Value) { // The temporary has a constant initializer, use it. - InitialValue = EmitConstantValue(*Value, MaterializedType, 0); + InitialValue = EmitConstantValue(*Value, MaterializedType, nullptr); Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value); Type = InitialValue->getType(); } else { @@ -2777,10 +2916,19 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( } // Create a global variable for this lifetime-extended temporary. - llvm::GlobalVariable *GV = - new llvm::GlobalVariable(getModule(), Type, Constant, - llvm::GlobalValue::PrivateLinkage, - InitialValue, Name.c_str()); + llvm::GlobalValue::LinkageTypes Linkage = + getLLVMLinkageVarDefinition(VD, Constant); + // There is no need for this temporary to have global linkage if the global + // variable has external linkage. + if (Linkage == llvm::GlobalVariable::ExternalLinkage) + Linkage = llvm::GlobalVariable::PrivateLinkage; + unsigned AddrSpace = GetGlobalVarAddressSpace( + VD, getContext().getTargetAddressSpace(MaterializedType)); + auto *GV = new llvm::GlobalVariable( + getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(), + /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, + AddrSpace); + setGlobalVisibility(GV, VD); GV->setAlignment( getContext().getTypeAlignInChars(MaterializedType).getQuantity()); if (VD->getTLSKind()) @@ -2793,10 +2941,7 @@ llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary( /// properties for an implementation. void CodeGenModule::EmitObjCPropertyImplementations(const ObjCImplementationDecl *D) { - for (ObjCImplementationDecl::propimpl_iterator - i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { - ObjCPropertyImplDecl *PID = *i; - + for (const auto *PID : D->property_impls()) { // Dynamic is just for type-checking. if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { ObjCPropertyDecl *PD = PID->getPropertyDecl(); @@ -2836,7 +2981,7 @@ void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { Selector cxxSelector = getContext().Selectors.getSelector(0, &II); ObjCMethodDecl *DTORMethod = ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(), - cxxSelector, getContext().VoidTy, 0, D, + cxxSelector, getContext().VoidTy, nullptr, D, /*isInstance=*/true, /*isVariadic=*/false, /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, /*isDefined=*/false, ObjCMethodDecl::Required); @@ -2857,8 +3002,8 @@ void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { D->getLocation(), D->getLocation(), cxxSelector, - getContext().getObjCIdType(), 0, - D, /*isInstance=*/true, + getContext().getObjCIdType(), + nullptr, D, /*isInstance=*/true, /*isVariadic=*/false, /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true, @@ -2871,13 +3016,12 @@ void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) { /// EmitNamespace - Emit all declarations in a namespace. void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { - for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); - I != E; ++I) { - if (const VarDecl *VD = dyn_cast<VarDecl>(*I)) + for (auto *I : ND->decls()) { + if (const auto *VD = dyn_cast<VarDecl>(I)) if (VD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization && VD->getTemplateSpecializationKind() != TSK_Undeclared) continue; - EmitTopLevelDecl(*I); + EmitTopLevelDecl(I); } } @@ -2889,17 +3033,14 @@ void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { return; } - for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); - I != E; ++I) { + for (auto *I : LSD->decls()) { // Meta-data for ObjC class includes references to implemented methods. // Generate class's method definitions first. - if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) { - for (ObjCContainerDecl::method_iterator M = OID->meth_begin(), - MEnd = OID->meth_end(); - M != MEnd; ++M) - EmitTopLevelDecl(*M); + if (auto *OID = dyn_cast<ObjCImplDecl>(I)) { + for (auto *M : OID->methods()) + EmitTopLevelDecl(M); } - EmitTopLevelDecl(*I); + EmitTopLevelDecl(I); } } @@ -2940,7 +3081,6 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; // No code generation needed. case Decl::UsingShadow: - case Decl::Using: case Decl::ClassTemplate: case Decl::VarTemplate: case Decl::VarTemplatePartialSpecialization: @@ -2949,6 +3089,10 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { case Decl::Block: case Decl::Empty: break; + case Decl::Using: // using X; [C++] + if (CGDebugInfo *DI = getModuleDebugInfo()) + DI->EmitUsingDecl(cast<UsingDecl>(*D)); + return; case Decl::NamespaceAlias: if (CGDebugInfo *DI = getModuleDebugInfo()) DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D)); @@ -2983,7 +3127,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; case Decl::ObjCProtocol: { - ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D); + auto *Proto = cast<ObjCProtocolDecl>(D); if (Proto->isThisDeclarationADefinition()) ObjCRuntime->GenerateProtocol(Proto); break; @@ -2996,7 +3140,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; case Decl::ObjCImplementation: { - ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); + auto *OMD = cast<ObjCImplementationDecl>(D); EmitObjCPropertyImplementations(OMD); EmitObjCIvarInitializations(OMD); ObjCRuntime->GenerateClass(OMD); @@ -3008,7 +3152,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; } case Decl::ObjCMethod: { - ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); + auto *OMD = cast<ObjCMethodDecl>(D); // If this is not a prototype, emit the body. if (OMD->getBody()) CodeGenFunction(*this).GenerateObjCMethod(OMD); @@ -3023,7 +3167,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { break; case Decl::FileScopeAsm: { - FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); + auto *AD = cast<FileScopeAsmDecl>(D); StringRef AsmString = AD->getAsmString()->getString(); const std::string &S = getModule().getModuleInlineAsm(); @@ -3037,7 +3181,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { } case Decl::Import: { - ImportDecl *Import = cast<ImportDecl>(D); + auto *Import = cast<ImportDecl>(D); // Ignore import declarations that come from imported modules. if (clang::Module *Owner = Import->getOwningModule()) { @@ -3048,7 +3192,14 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) { ImportedModules.insert(Import->getImportedModule()); break; - } + } + + case Decl::ClassTemplateSpecialization: { + const auto *Spec = cast<ClassTemplateSpecializationDecl>(D); + if (DebugInfo && + Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition) + DebugInfo->completeTemplateDefinition(*Spec); + } default: // Make sure we handled everything we should, every other kind is a @@ -3094,11 +3245,19 @@ void CodeGenModule::EmitStaticExternCAliases() { IdentifierInfo *Name = I->first; llvm::GlobalValue *Val = I->second; if (Val && !getModule().getNamedValue(Name->getName())) - AddUsedGlobal(new llvm::GlobalAlias(Val->getType(), Val->getLinkage(), - Name->getName(), Val, &getModule())); + addUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val)); } } +bool CodeGenModule::lookupRepresentativeDecl(StringRef MangledName, + GlobalDecl &Result) const { + auto Res = Manglings.find(MangledName); + if (Res == Manglings.end()) + return false; + Result = Res->getValue(); + return true; +} + /// Emits metadata nodes associating all the global values in the /// current module with the Decls they came from. This is useful for /// projects using IR gen as a subroutine. @@ -3107,14 +3266,12 @@ void CodeGenModule::EmitStaticExternCAliases() { /// with an llvm::GlobalValue, we create a global named metadata /// with the name 'clang.global.decl.ptrs'. void CodeGenModule::EmitDeclMetadata() { - llvm::NamedMDNode *GlobalMetadata = 0; + llvm::NamedMDNode *GlobalMetadata = nullptr; // StaticLocalDeclMap - for (llvm::DenseMap<GlobalDecl,StringRef>::iterator - I = MangledDeclNames.begin(), E = MangledDeclNames.end(); - I != E; ++I) { - llvm::GlobalValue *Addr = getModule().getNamedValue(I->second); - EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr); + for (auto &I : MangledDeclNames) { + llvm::GlobalValue *Addr = getModule().getNamedValue(I.second); + EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr); } } @@ -3128,17 +3285,15 @@ void CodeGenFunction::EmitDeclMetadata() { // Find the unique metadata ID for this name. unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr"); - llvm::NamedMDNode *GlobalMetadata = 0; - - for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator - I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) { - const Decl *D = I->first; - llvm::Value *Addr = I->second; + llvm::NamedMDNode *GlobalMetadata = nullptr; - if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { + for (auto &I : LocalDeclMap) { + const Decl *D = I.first; + llvm::Value *Addr = I.second; + if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) { llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D); Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr)); - } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) { + } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) { GlobalDecl GD = GlobalDecl(cast<VarDecl>(D)); EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV); } @@ -3157,6 +3312,14 @@ void CodeGenModule::EmitVersionIdentMetadata() { IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode)); } +void CodeGenModule::EmitTargetMetadata() { + for (auto &I : MangledDeclNames) { + const Decl *D = I.first.getDecl()->getMostRecentDecl(); + llvm::GlobalValue *GV = GetGlobalValue(I.second); + getTargetCodeGenInfo().emitTargetMD(D, GV, *this); + } +} + void CodeGenModule::EmitCoverageFile() { if (!getCodeGenOpts().CoverageFile.empty()) { if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) { @@ -3200,3 +3363,19 @@ llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid, return llvm::ConstantStruct::getAnon(Fields); } + +llvm::Constant *CodeGenModule::GetAddrOfRTTIDescriptor(QualType Ty, + bool ForEH) { + // Return a bogus pointer if RTTI is disabled, unless it's for EH. + // FIXME: should we even be calling this method if RTTI is disabled + // and it's not for EH? + if (!ForEH && !getLangOpts().RTTI) + return llvm::Constant::getNullValue(Int8PtrTy); + + if (ForEH && Ty->isObjCObjectPointerType() && + LangOpts.ObjCRuntime.isGNUFamily()) + return ObjCRuntime->GetEHType(Ty); + + return getCXXABI().getAddrOfRTTIDescriptor(Ty); +} + |