From 5dcb77e9fbcd5546b9c749329d02da18c1f672f5 Mon Sep 17 00:00:00 2001 From: Peter Collingbourne Date: Tue, 14 Jun 2016 21:01:22 +0000 Subject: [PATCH] IR: Introduce local_unnamed_addr attribute. If a local_unnamed_addr attribute is attached to a global, the address is known to be insignificant within the module. It is distinct from the existing unnamed_addr attribute in that it only describes a local property of the module rather than a global property of the symbol. This attribute is intended to be used by the code generator and LTO to allow the linker to decide whether the global needs to be in the symbol table. It is possible to exclude a global from the symbol table if three things are true: - This attribute is present on every instance of the global (which means that the normal rule that the global must have a unique address can be broken without being observable by the program by performing comparisons against the global's address) - The global has linkonce_odr linkage (which means that each linkage unit must have its own copy of the global if it requires one, and the copy in each linkage unit must be the same) - It is a constant or a function (which means that the program cannot observe that the unique-address rule has been broken by writing to the global) Although this attribute could in principle be computed from the module contents, LTO clients (i.e. linkers) will normally need to be able to compute this property as part of symbol resolution, and it would be inefficient to materialize every module just to compute it. See: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20160509/356401.html http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20160516/356738.html for earlier discussion. Part of the fix for PR27553. Differential Revision: http://reviews.llvm.org/D20348 llvm-svn: 272709 --- docs/BitCodeFormat.rst | 18 +- docs/LangRef.rst | 36 ++-- include/llvm/IR/GlobalValue.h | 42 ++++- lib/Analysis/InstructionSimplify.cpp | 2 +- lib/AsmParser/LLLexer.cpp | 1 + lib/AsmParser/LLParser.cpp | 35 ++-- lib/AsmParser/LLParser.h | 9 +- lib/AsmParser/LLToken.h | 1 + lib/Bitcode/Reader/BitcodeReader.cpp | 20 ++- lib/Bitcode/Writer/BitcodeWriter.cpp | 21 ++- lib/CodeGen/Analysis.cpp | 20 +-- lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 2 +- lib/CodeGen/TargetLoweringObjectFileImpl.cpp | 2 +- lib/ExecutionEngine/Orc/IndirectionUtils.cpp | 2 +- lib/IR/AsmWriter.cpp | 26 ++- lib/IR/Core.cpp | 6 +- lib/IR/Globals.cpp | 2 +- lib/IR/IRBuilder.cpp | 2 +- lib/IR/Verifier.cpp | 2 +- lib/Linker/IRMover.cpp | 2 +- lib/Linker/LinkModules.cpp | 7 +- lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp | 2 +- lib/Target/TargetLoweringObjectFile.cpp | 2 +- lib/Transforms/IPO/ConstantMerge.cpp | 8 +- lib/Transforms/IPO/GlobalOpt.cpp | 19 ++- lib/Transforms/IPO/MergeFunctions.cpp | 2 +- .../Instrumentation/AddressSanitizer.cpp | 4 +- .../Instrumentation/EfficiencySanitizer.cpp | 2 +- .../Instrumentation/GCOVProfiling.cpp | 12 +- .../Instrumentation/InstrProfiling.cpp | 4 +- lib/Transforms/Scalar/LoopIdiomRecognize.cpp | 2 +- lib/Transforms/Utils/FunctionImportUtils.cpp | 2 +- lib/Transforms/Utils/GlobalStatus.cpp | 2 +- lib/Transforms/Utils/SimplifyCFG.cpp | 2 +- test/Assembler/local-unnamed-addr.ll | 13 ++ test/Bitcode/compatibility.ll | 16 +- .../CodeGen/PowerPC/weak_def_can_be_hidden.ll | 8 +- test/CodeGen/X86/weak_def_can_be_hidden.ll | 8 +- test/Feature/OperandBundles/pr26510.ll | 2 +- test/LTO/X86/cfi_endproc.ll | 4 +- test/LTO/X86/linkonce_odr_func.ll | 59 +++---- test/Other/constant-fold-gep.ll | 156 +++++++++--------- .../GlobalOpt/2010-10-19-WeakOdr.ll | 2 +- .../GlobalOpt/alias-used-address-space.ll | 2 +- test/Transforms/GlobalOpt/alias-used.ll | 4 +- test/Transforms/GlobalOpt/assume.ll | 2 +- .../GlobalOpt/constantfold-initializers.ll | 12 +- .../GlobalOpt/ctor-list-opt-inbounds.ll | 4 +- .../GlobalOpt/invariant.group.barrier.ll | 4 +- test/Transforms/GlobalOpt/invoke.ll | 2 +- test/Transforms/GlobalOpt/pr21191.ll | 4 +- test/Transforms/GlobalOpt/unnamed-addr.ll | 2 +- test/tools/gold/X86/coff.ll | 4 +- test/tools/gold/X86/emit-llvm.ll | 28 +++- tools/gold/gold-plugin.cpp | 41 ++--- 55 files changed, 403 insertions(+), 295 deletions(-) create mode 100644 test/Assembler/local-unnamed-addr.ll diff --git a/docs/BitCodeFormat.rst b/docs/BitCodeFormat.rst index ac051c49bc8..f9989936a1f 100644 --- a/docs/BitCodeFormat.rst +++ b/docs/BitCodeFormat.rst @@ -731,8 +731,14 @@ global variable. The operand fields are: * ``initialexec``: code 3 * ``localexec``: code 4 -* *unnamed_addr*: If present and non-zero, indicates that the variable has - ``unnamed_addr`` +.. _bcunnamedaddr: + +* *unnamed_addr*: If present, an encoding of the ``unnamed_addr`` attribute of this + variable: + + * not ``unnamed_addr``: code 0 + * ``unnamed_addr``: code 1 + * ``local_unnamed_addr``: code 2 .. _bcdllstorageclass: @@ -791,8 +797,8 @@ function. The operand fields are: * *gc*: If present and nonzero, the 1-based garbage collector index in the table of `MODULE_CODE_GCNAME`_ entries. -* *unnamed_addr*: If present and non-zero, indicates that the function has - ``unnamed_addr`` +* *unnamed_addr*: If present, an encoding of the + :ref:`unnamed_addr` attribute of this function * *prologuedata*: If non-zero, the value index of the prologue data for this function, plus 1. @@ -830,8 +836,8 @@ fields are * *threadlocal*: If present, an encoding of the :ref:`thread local property` of the alias -* *unnamed_addr*: If present and non-zero, indicates that the alias has - ``unnamed_addr`` +* *unnamed_addr*: If present, an encoding of the + :ref:`unnamed_addr` attribute of this alias MODULE_CODE_PURGEVALS Record ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/docs/LangRef.rst b/docs/LangRef.rst index 1645371787e..086df648da4 100644 --- a/docs/LangRef.rst +++ b/docs/LangRef.rst @@ -589,6 +589,9 @@ initializer. Note that a constant with significant address *can* be merged with a ``unnamed_addr`` constant, the result being a constant whose address is significant. +If the ``local_unnamed_addr`` attribute is given, the address is known to +not be significant within the module. + A global variable may be declared to reside in a target-specific numbered address space. For targets that support them, address spaces may affect how optimizations are performed and/or what target @@ -628,7 +631,8 @@ Variables and aliases can have a Syntax:: @ = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] - [unnamed_addr] [AddrSpace] [ExternallyInitialized] + [(unnamed_addr|local_unnamed_addr)] [AddrSpace] + [ExternallyInitialized] [] [, section "name"] [, comdat [($name)]] [, align ] (, !name !N)* @@ -675,14 +679,14 @@ an optional list of attached :ref:`metadata `, an opening curly brace, a list of basic blocks, and a closing curly brace. LLVM function declarations consist of the "``declare``" keyword, an -optional :ref:`linkage type `, an optional :ref:`visibility -style `, an optional :ref:`DLL storage class `, -an optional :ref:`calling convention `, -an optional ``unnamed_addr`` attribute, a return type, an optional -:ref:`parameter attribute ` for the return type, a function -name, a possibly empty list of arguments, an optional alignment, an optional -:ref:`garbage collector name `, an optional :ref:`prefix `, -and an optional :ref:`prologue `. +optional :ref:`linkage type `, an optional :ref:`visibility style +`, an optional :ref:`DLL storage class `, an +optional :ref:`calling convention `, an optional ``unnamed_addr`` +or ``local_unnamed_addr`` attribute, a return type, an optional :ref:`parameter +attribute ` for the return type, a function name, a possibly +empty list of arguments, an optional alignment, an optional :ref:`garbage +collector name `, an optional :ref:`prefix `, and an optional +:ref:`prologue `. A function definition contains a list of basic blocks, forming the CFG (Control Flow Graph) for the function. Each basic block may optionally start with a label @@ -713,14 +717,17 @@ alignment. All alignments must be a power of 2. If the ``unnamed_addr`` attribute is given, the address is known to not be significant and two identical functions can be merged. +If the ``local_unnamed_addr`` attribute is given, the address is known to +not be significant within the module. + Syntax:: define [linkage] [visibility] [DLLStorageClass] [cconv] [ret attrs] @ ([argument list]) - [unnamed_addr] [fn Attrs] [section "name"] [comdat [($name)]] - [align N] [gc] [prefix Constant] [prologue Constant] - [personality Constant] (!name !N)* { ... } + [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"] + [comdat [($name)]] [align N] [gc] [prefix Constant] + [prologue Constant] [personality Constant] (!name !N)* { ... } The argument list is a comma separated sequence of arguments where each argument is of the following form: @@ -747,7 +754,7 @@ Aliases may have an optional :ref:`linkage type `, an optional Syntax:: - @ = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] [unnamed_addr] alias , * @ + @ = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias , * @ The linkage must be one of ``private``, ``internal``, ``linkonce``, ``weak``, ``linkonce_odr``, ``weak_odr``, ``external``. Note that some system linkers @@ -757,6 +764,9 @@ Aliases that are not ``unnamed_addr`` are guaranteed to have the same address as the aliasee expression. ``unnamed_addr`` ones are only guaranteed to point to the same content. +If the ``local_unnamed_addr`` attribute is given, the address is known to +not be significant within the module. + Since aliases are only a second name, some restrictions apply, of which some can only be checked when producing an object file: diff --git a/include/llvm/IR/GlobalValue.h b/include/llvm/IR/GlobalValue.h index c6a4b3fdb91..09682f7aa34 100644 --- a/include/llvm/IR/GlobalValue.h +++ b/include/llvm/IR/GlobalValue.h @@ -70,8 +70,9 @@ protected: LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace) : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps), ValueType(Ty), Linkage(Linkage), Visibility(DefaultVisibility), - UnnamedAddr(0), DllStorageClass(DefaultStorageClass), - ThreadLocal(NotThreadLocal), IntID((Intrinsic::ID)0U), Parent(nullptr) { + UnnamedAddrVal(unsigned(UnnamedAddr::None)), + DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal), + IntID((Intrinsic::ID)0U), Parent(nullptr) { setName(Name); } @@ -80,7 +81,7 @@ protected: // them. unsigned Linkage : 4; // The linkage of this global unsigned Visibility : 2; // The visibility style of this global - unsigned UnnamedAddr : 1; // This value's address is not significant + unsigned UnnamedAddrVal : 2; // This value's address is not significant unsigned DllStorageClass : 2; // DLL storage class unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is @@ -89,7 +90,7 @@ protected: private: // Give subclasses access to what otherwise would be wasted padding. - // (19 + 3 + 2 + 1 + 2 + 5) == 32. + // (19 + 4 + 2 + 2 + 2 + 3) == 32. unsigned SubClassData : GlobalValueSubClassDataBits; friend class Constant; @@ -153,8 +154,37 @@ public: unsigned getAlignment() const; - bool hasUnnamedAddr() const { return UnnamedAddr; } - void setUnnamedAddr(bool Val) { UnnamedAddr = Val; } + enum class UnnamedAddr { + None, + Local, + Global, + }; + + bool hasGlobalUnnamedAddr() const { + return getUnnamedAddr() == UnnamedAddr::Global; + } + + /// Returns true if this value's address is not significant in this module. + /// This attribute is intended to be used only by the code generator and LTO + /// to allow the linker to decide whether the global needs to be in the symbol + /// table. It should probably not be used in optimizations, as the value may + /// have uses outside the module; use hasGlobalUnnamedAddr() instead. + bool hasAtLeastLocalUnnamedAddr() const { + return getUnnamedAddr() != UnnamedAddr::None; + } + + UnnamedAddr getUnnamedAddr() const { + return UnnamedAddr(UnnamedAddrVal); + } + void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); } + + static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) { + if (A == UnnamedAddr::None || B == UnnamedAddr::None) + return UnnamedAddr::None; + if (A == UnnamedAddr::Local || B == UnnamedAddr::Local) + return UnnamedAddr::Local; + return UnnamedAddr::Global; + } bool hasComdat() const { return getComdat() != nullptr; } Comdat *getComdat(); diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index 43dcaec1373..a9fed16f8aa 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/lib/Analysis/InstructionSimplify.cpp @@ -2086,7 +2086,7 @@ computePointerICmp(const DataLayout &DL, const TargetLibraryInfo *TLI, return AI->getParent() && AI->getFunction() && AI->isStaticAlloca(); if (const GlobalValue *GV = dyn_cast(V)) return (GV->hasLocalLinkage() || GV->hasHiddenVisibility() || - GV->hasProtectedVisibility() || GV->hasUnnamedAddr()) && + GV->hasProtectedVisibility() || GV->hasGlobalUnnamedAddr()) && !GV->isThreadLocal(); if (const Argument *A = dyn_cast(V)) return A->hasByValAttr(); diff --git a/lib/AsmParser/LLLexer.cpp b/lib/AsmParser/LLLexer.cpp index 1ba698ebd61..a3d1346e7d2 100644 --- a/lib/AsmParser/LLLexer.cpp +++ b/lib/AsmParser/LLLexer.cpp @@ -513,6 +513,7 @@ lltok::Kind LLLexer::LexIdentifier() { KEYWORD(hidden); KEYWORD(protected); KEYWORD(unnamed_addr); + KEYWORD(local_unnamed_addr); KEYWORD(externally_initialized); KEYWORD(extern_weak); KEYWORD(external); diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index cc7b98fa56d..2725386f8da 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -429,6 +429,17 @@ bool LLParser::ParseGlobalType(bool &IsConstant) { return false; } +bool LLParser::ParseOptionalUnnamedAddr( + GlobalVariable::UnnamedAddr &UnnamedAddr) { + if (EatIfPresent(lltok::kw_unnamed_addr)) + UnnamedAddr = GlobalValue::UnnamedAddr::Global; + else if (EatIfPresent(lltok::kw_local_unnamed_addr)) + UnnamedAddr = GlobalValue::UnnamedAddr::Local; + else + UnnamedAddr = GlobalValue::UnnamedAddr::None; + return false; +} + /// ParseUnnamedGlobal: /// OptionalVisibility (ALIAS | IFUNC) ... /// OptionalLinkage OptionalVisibility OptionalDLLStorageClass @@ -455,9 +466,9 @@ bool LLParser::ParseUnnamedGlobal() { bool HasLinkage; unsigned Linkage, Visibility, DLLStorageClass; GlobalVariable::ThreadLocalMode TLM; - bool UnnamedAddr; + GlobalVariable::UnnamedAddr UnnamedAddr; if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) || - ParseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr)) + ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr)) return true; if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc) @@ -481,10 +492,10 @@ bool LLParser::ParseNamedGlobal() { bool HasLinkage; unsigned Linkage, Visibility, DLLStorageClass; GlobalVariable::ThreadLocalMode TLM; - bool UnnamedAddr; + GlobalVariable::UnnamedAddr UnnamedAddr; if (ParseToken(lltok::equal, "expected '=' in global variable") || ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) || - ParseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr)) + ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr)) return true; if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc) @@ -659,11 +670,10 @@ static bool isValidVisibilityForLinkage(unsigned V, unsigned L) { /// /// Everything through OptionalUnnamedAddr has already been parsed. /// -bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc, - unsigned L, unsigned Visibility, - unsigned DLLStorageClass, - GlobalVariable::ThreadLocalMode TLM, - bool UnnamedAddr) { +bool LLParser::parseIndirectSymbol( + const std::string &Name, LocTy NameLoc, unsigned L, unsigned Visibility, + unsigned DLLStorageClass, GlobalVariable::ThreadLocalMode TLM, + GlobalVariable::UnnamedAddr UnnamedAddr) { bool IsAlias; if (Lex.getKind() == lltok::kw_alias) IsAlias = true; @@ -799,7 +809,7 @@ bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage, bool HasLinkage, unsigned Visibility, unsigned DLLStorageClass, GlobalVariable::ThreadLocalMode TLM, - bool UnnamedAddr) { + GlobalVariable::UnnamedAddr UnnamedAddr) { if (!isValidVisibilityForLinkage(Visibility, Linkage)) return Error(NameLoc, "symbol with local linkage must have default visibility"); @@ -4580,7 +4590,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { std::string Section; unsigned Alignment; std::string GC; - bool UnnamedAddr; + GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None; LocTy UnnamedAddrLoc; Constant *Prefix = nullptr; Constant *Prologue = nullptr; @@ -4588,8 +4598,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { Comdat *C; if (ParseArgumentList(ArgList, isVarArg) || - ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr, - &UnnamedAddrLoc) || + ParseOptionalUnnamedAddr(UnnamedAddr) || ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false, BuiltinLoc) || (EatIfPresent(lltok::kw_section) && diff --git a/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h index 7c32f2c7fac..479ff96bc8a 100644 --- a/lib/AsmParser/LLParser.h +++ b/lib/AsmParser/LLParser.h @@ -226,9 +226,7 @@ namespace llvm { bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM); bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM); - bool parseOptionalUnnamedAddr(bool &UnnamedAddr) { - return ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr); - } + bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr); bool ParseOptionalAddrSpace(unsigned &AddrSpace); bool ParseOptionalParamAttrs(AttrBuilder &B); bool ParseOptionalReturnAttrs(AttrBuilder &B); @@ -275,12 +273,13 @@ namespace llvm { bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage, bool HasLinkage, unsigned Visibility, unsigned DLLStorageClass, - GlobalVariable::ThreadLocalMode TLM, bool UnnamedAddr); + GlobalVariable::ThreadLocalMode TLM, + GlobalVariable::UnnamedAddr UnnamedAddr); bool parseIndirectSymbol(const std::string &Name, LocTy Loc, unsigned Linkage, unsigned Visibility, unsigned DLLStorageClass, GlobalVariable::ThreadLocalMode TLM, - bool UnnamedAddr); + GlobalVariable::UnnamedAddr UnnamedAddr); bool parseComdat(); bool ParseStandaloneMetadata(); bool ParseNamedMetadata(); diff --git a/lib/AsmParser/LLToken.h b/lib/AsmParser/LLToken.h index 85881d6f11b..be3697aefdd 100644 --- a/lib/AsmParser/LLToken.h +++ b/lib/AsmParser/LLToken.h @@ -60,6 +60,7 @@ enum Kind { kw_hidden, kw_protected, kw_unnamed_addr, + kw_local_unnamed_addr, kw_externally_initialized, kw_extern_weak, kw_external, diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 3bba0250af5..ac72f69c76e 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -773,6 +773,15 @@ static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) { } } +static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) { + switch (Val) { + default: // Map unknown to UnnamedAddr::None. + case 0: return GlobalVariable::UnnamedAddr::None; + case 1: return GlobalVariable::UnnamedAddr::Global; + case 2: return GlobalVariable::UnnamedAddr::Local; + } +} + static int getDecodedCastOpcode(unsigned Val) { switch (Val) { default: return -1; @@ -3791,9 +3800,9 @@ std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, if (Record.size() > 7) TLM = getDecodedThreadLocalMode(Record[7]); - bool UnnamedAddr = false; + GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None; if (Record.size() > 8) - UnnamedAddr = Record[8]; + UnnamedAddr = getDecodedUnnamedAddrType(Record[8]); bool ExternallyInitialized = false; if (Record.size() > 9) @@ -3828,6 +3837,7 @@ std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, } else if (hasImplicitComdat(RawLinkage)) { NewGV->setComdat(reinterpret_cast(1)); } + break; } case bitc::MODULE_CODE_GLOBALVAR_ATTACHMENT: { @@ -3885,9 +3895,9 @@ std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, return error("Invalid ID"); Func->setGC(GCTable[Record[8] - 1]); } - bool UnnamedAddr = false; + GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None; if (Record.size() > 9) - UnnamedAddr = Record[9]; + UnnamedAddr = getDecodedUnnamedAddrType(Record[9]); Func->setUnnamedAddr(UnnamedAddr); if (Record.size() > 10 && Record[10] != 0) FunctionPrologues.push_back(std::make_pair(Func, Record[10]-1)); @@ -3974,7 +3984,7 @@ std::error_code BitcodeReader::parseModule(uint64_t ResumeBit, if (OpNum != Record.size()) NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++])); if (OpNum != Record.size()) - NewGA->setUnnamedAddr(Record[OpNum++]); + NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++])); ValueList.push_back(NewGA); IndirectSymbolInits.push_back(std::make_pair(NewGA, Val)); break; diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index 06a4ef1892d..4699e7dac77 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -996,6 +996,15 @@ static unsigned getEncodedComdatSelectionKind(const Comdat &C) { llvm_unreachable("Invalid selection kind"); } +static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) { + switch (GV.getUnnamedAddr()) { + case GlobalValue::UnnamedAddr::None: return 0; + case GlobalValue::UnnamedAddr::Local: return 2; + case GlobalValue::UnnamedAddr::Global: return 1; + } + llvm_unreachable("Invalid unnamed_addr"); +} + void ModuleBitcodeWriter::writeComdats() { SmallVector Vals; for (const Comdat *C : VE.getComdats()) { @@ -1157,12 +1166,13 @@ void ModuleBitcodeWriter::writeModuleInfo() { Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0); if (GV.isThreadLocal() || GV.getVisibility() != GlobalValue::DefaultVisibility || - GV.hasUnnamedAddr() || GV.isExternallyInitialized() || + GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None || + GV.isExternallyInitialized() || GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass || GV.hasComdat()) { Vals.push_back(getEncodedVisibility(GV)); Vals.push_back(getEncodedThreadLocalMode(GV)); - Vals.push_back(GV.hasUnnamedAddr()); + Vals.push_back(getEncodedUnnamedAddr(GV)); Vals.push_back(GV.isExternallyInitialized()); Vals.push_back(getEncodedDLLStorageClass(GV)); Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0); @@ -1188,7 +1198,7 @@ void ModuleBitcodeWriter::writeModuleInfo() { Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0); Vals.push_back(getEncodedVisibility(F)); Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0); - Vals.push_back(F.hasUnnamedAddr()); + Vals.push_back(getEncodedUnnamedAddr(F)); Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1) : 0); Vals.push_back(getEncodedDLLStorageClass(F)); @@ -1205,7 +1215,8 @@ void ModuleBitcodeWriter::writeModuleInfo() { // Emit the alias information. for (const GlobalAlias &A : M.aliases()) { - // ALIAS: [alias type, aliasee val#, linkage, visibility] + // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass, + // threadlocal, unnamed_addr] Vals.push_back(VE.getTypeID(A.getValueType())); Vals.push_back(A.getType()->getAddressSpace()); Vals.push_back(VE.getValueID(A.getAliasee())); @@ -1213,7 +1224,7 @@ void ModuleBitcodeWriter::writeModuleInfo() { Vals.push_back(getEncodedVisibility(A)); Vals.push_back(getEncodedDLLStorageClass(A)); Vals.push_back(getEncodedThreadLocalMode(A)); - Vals.push_back(A.hasUnnamedAddr()); + Vals.push_back(getEncodedUnnamedAddr(A)); unsigned AbbrevToUse = 0; Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse); Vals.clear(); diff --git a/lib/CodeGen/Analysis.cpp b/lib/CodeGen/Analysis.cpp index ef405484e84..73bd3d29eae 100644 --- a/lib/CodeGen/Analysis.cpp +++ b/lib/CodeGen/Analysis.cpp @@ -623,7 +623,9 @@ bool llvm::canBeOmittedFromSymbolTable(const GlobalValue *GV) { if (!GV->hasLinkOnceODRLinkage()) return false; - if (GV->hasUnnamedAddr()) + // We assume that anyone who sets global unnamed_addr on a non-constant knows + // what they're doing. + if (GV->hasGlobalUnnamedAddr()) return true; // If it is a non constant variable, it needs to be uniqued across shared @@ -633,21 +635,7 @@ bool llvm::canBeOmittedFromSymbolTable(const GlobalValue *GV) { return false; } - // An alias can point to a variable. We could try to resolve the alias to - // decide, but for now just don't hide them. - if (isa(GV)) - return false; - - // If we don't see every use, we have to be conservative and assume the value - // address is significant. - if (GV->getParent()->getMaterializer()) - return false; - - GlobalStatus GS; - if (GlobalStatus::analyzeGlobal(GV, GS)) - return false; - - return !GS.IsCompared; + return GV->hasAtLeastLocalUnnamedAddr(); } // FIXME: make this a proper option diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index d39881d9ce3..02640f55fa2 100644 --- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -1001,7 +1001,7 @@ static bool isGOTEquivalentCandidate(const GlobalVariable *GV, // Global GOT equivalents are unnamed private globals with a constant // pointer initializer to another global symbol. They must point to a // GlobalVariable or Function, i.e., as GlobalValue. - if (!GV->hasUnnamedAddr() || !GV->hasInitializer() || !GV->isConstant() || + if (!GV->hasGlobalUnnamedAddr() || !GV->hasInitializer() || !GV->isConstant() || !GV->isDiscardableIfUnused() || !dyn_cast(GV->getOperand(0))) return false; diff --git a/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/lib/CodeGen/TargetLoweringObjectFileImpl.cpp index f7ba62ff231..6d5dd5fa4d5 100644 --- a/lib/CodeGen/TargetLoweringObjectFileImpl.cpp +++ b/lib/CodeGen/TargetLoweringObjectFileImpl.cpp @@ -429,7 +429,7 @@ const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference( const TargetMachine &TM) const { // We may only use a PLT-relative relocation to refer to unnamed_addr // functions. - if (!LHS->hasUnnamedAddr() || !LHS->getValueType()->isFunctionTy()) + if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy()) return nullptr; // Basic sanity checks. diff --git a/lib/ExecutionEngine/Orc/IndirectionUtils.cpp b/lib/ExecutionEngine/Orc/IndirectionUtils.cpp index c7b97865ab7..6f7c29feef0 100644 --- a/lib/ExecutionEngine/Orc/IndirectionUtils.cpp +++ b/lib/ExecutionEngine/Orc/IndirectionUtils.cpp @@ -144,7 +144,7 @@ static void raiseVisibilityOnValue(GlobalValue &V, GlobalRenamer &R) { V.setLinkage(GlobalValue::ExternalLinkage); V.setVisibility(GlobalValue::HiddenVisibility); } - V.setUnnamedAddr(false); + V.setUnnamedAddr(GlobalValue::UnnamedAddr::None); assert(!R.needsRenaming(V) && "Invalid global name."); } diff --git a/lib/IR/AsmWriter.cpp b/lib/IR/AsmWriter.cpp index 24b92b8eb3c..0d488c27aa8 100644 --- a/lib/IR/AsmWriter.cpp +++ b/lib/IR/AsmWriter.cpp @@ -2426,6 +2426,17 @@ static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, } } +static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA) { + switch (UA) { + case GlobalVariable::UnnamedAddr::None: + return ""; + case GlobalVariable::UnnamedAddr::Local: + return "local_unnamed_addr"; + case GlobalVariable::UnnamedAddr::Global: + return "unnamed_addr"; + } +} + static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO) { const Comdat *C = GO.getComdat(); @@ -2458,8 +2469,9 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) { PrintVisibility(GV->getVisibility(), Out); PrintDLLStorageClass(GV->getDLLStorageClass(), Out); PrintThreadLocalModel(GV->getThreadLocalMode(), Out); - if (GV->hasUnnamedAddr()) - Out << "unnamed_addr "; + StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr()); + if (!UA.empty()) + Out << UA << ' '; if (unsigned AddressSpace = GV->getType()->getAddressSpace()) Out << "addrspace(" << AddressSpace << ") "; @@ -2499,8 +2511,9 @@ void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) { PrintVisibility(GIS->getVisibility(), Out); PrintDLLStorageClass(GIS->getDLLStorageClass(), Out); PrintThreadLocalModel(GIS->getThreadLocalMode(), Out); - if (GIS->hasUnnamedAddr()) - Out << "unnamed_addr "; + StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr()); + if (!UA.empty()) + Out << UA << ' '; if (isa(GIS)) Out << "alias "; @@ -2656,8 +2669,9 @@ void AssemblyWriter::printFunction(const Function *F) { Out << "..."; // Output varargs portion of signature! } Out << ')'; - if (F->hasUnnamedAddr()) - Out << " unnamed_addr"; + StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr()); + if (!UA.empty()) + Out << ' ' << UA; if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes()); if (F->hasSection()) { diff --git a/lib/IR/Core.cpp b/lib/IR/Core.cpp index 380fca8c10f..b044781302c 100644 --- a/lib/IR/Core.cpp +++ b/lib/IR/Core.cpp @@ -1560,11 +1560,13 @@ void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) { } LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) { - return unwrap(Global)->hasUnnamedAddr(); + return unwrap(Global)->hasGlobalUnnamedAddr(); } void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) { - unwrap(Global)->setUnnamedAddr(HasUnnamedAddr); + unwrap(Global)->setUnnamedAddr( + HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global + : GlobalValue::UnnamedAddr::None); } /*--.. Operations on global variables, load and store instructions .........--*/ diff --git a/lib/IR/Globals.cpp b/lib/IR/Globals.cpp index d151b9c5dc2..c5e1b9b9fa0 100644 --- a/lib/IR/Globals.cpp +++ b/lib/IR/Globals.cpp @@ -51,7 +51,7 @@ Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) { /// create a GlobalValue) from the GlobalValue Src to this one. void GlobalValue::copyAttributesFrom(const GlobalValue *Src) { setVisibility(Src->getVisibility()); - setUnnamedAddr(Src->hasUnnamedAddr()); + setUnnamedAddr(Src->getUnnamedAddr()); setDLLStorageClass(Src->getDLLStorageClass()); } diff --git a/lib/IR/IRBuilder.cpp b/lib/IR/IRBuilder.cpp index bc75de2693b..480e5e5d426 100644 --- a/lib/IR/IRBuilder.cpp +++ b/lib/IR/IRBuilder.cpp @@ -34,7 +34,7 @@ GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str, StrConstant, Name, nullptr, GlobalVariable::NotThreadLocal, AddressSpace); - GV->setUnnamedAddr(true); + GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); return GV; } diff --git a/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp index 79c9f4d3a13..0395f5b36fe 100644 --- a/lib/IR/Verifier.cpp +++ b/lib/IR/Verifier.cpp @@ -1535,7 +1535,7 @@ void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, if (Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::JumpTable)) { const GlobalValue *GV = cast(V); - Assert(GV->hasUnnamedAddr(), + Assert(GV->hasGlobalUnnamedAddr(), "Attribute 'jumptable' requires 'unnamed_addr'", V); } diff --git a/lib/Linker/IRMover.cpp b/lib/Linker/IRMover.cpp index d2c6d78abe2..14b0a43030d 100644 --- a/lib/Linker/IRMover.cpp +++ b/lib/Linker/IRMover.cpp @@ -791,7 +791,7 @@ IRLinker::linkAppendingVarProto(GlobalVariable *DstGV, return stringErr( "Appending variables with different visibility need to be linked!"); - if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr()) + if (DstGV->hasGlobalUnnamedAddr() != SrcGV->hasGlobalUnnamedAddr()) return stringErr( "Appending variables with different unnamed_addr need to be linked!"); diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index ff36f90b53f..fae9c95ebe8 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -377,9 +377,10 @@ bool ModuleLinker::linkIfNeeded(GlobalValue &GV) { DGV->setVisibility(Visibility); GV.setVisibility(Visibility); - bool HasUnnamedAddr = GV.hasUnnamedAddr() && DGV->hasUnnamedAddr(); - DGV->setUnnamedAddr(HasUnnamedAddr); - GV.setUnnamedAddr(HasUnnamedAddr); + GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::getMinUnnamedAddr( + DGV->getUnnamedAddr(), GV.getUnnamedAddr()); + DGV->setUnnamedAddr(UnnamedAddr); + GV.setUnnamedAddr(UnnamedAddr); } // Don't want to append to global_ctors list, for example, when we diff --git a/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp b/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp index 5222bed0d25..17b45fa65f1 100644 --- a/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp +++ b/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp @@ -694,7 +694,7 @@ void AMDGPUPromoteAlloca::handleAlloca(AllocaInst &I) { nullptr, GlobalVariable::NotThreadLocal, AMDGPUAS::LOCAL_ADDRESS); - GV->setUnnamedAddr(true); + GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); GV->setAlignment(I.getAlignment()); Value *TCntY, *TCntZ; diff --git a/lib/Target/TargetLoweringObjectFile.cpp b/lib/Target/TargetLoweringObjectFile.cpp index b2b69025851..fd4936e1904 100644 --- a/lib/Target/TargetLoweringObjectFile.cpp +++ b/lib/Target/TargetLoweringObjectFile.cpp @@ -174,7 +174,7 @@ SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV, // If the global is required to have a unique address, it can't be put // into a mergable section: just drop it into the general read-only // section instead. - if (!GVar->hasUnnamedAddr()) + if (!GVar->hasGlobalUnnamedAddr()) return SectionKind::getReadOnly(); // If initializer is a null-terminated string, put it in a "cstring" diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index 11f40e86460..65b042534f3 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -57,7 +57,7 @@ static bool IsBetterCanonical(const GlobalVariable &A, if (A.hasLocalLinkage() && !B.hasLocalLinkage()) return false; - return A.hasUnnamedAddr(); + return A.hasGlobalUnnamedAddr(); } static unsigned getAlignment(GlobalVariable *GV) { @@ -152,11 +152,11 @@ static bool mergeConstants(Module &M) { if (!Slot || Slot == GV) continue; - if (!Slot->hasUnnamedAddr() && !GV->hasUnnamedAddr()) + if (!Slot->hasGlobalUnnamedAddr() && !GV->hasGlobalUnnamedAddr()) continue; - if (!GV->hasUnnamedAddr()) - Slot->setUnnamedAddr(false); + if (!GV->hasGlobalUnnamedAddr()) + Slot->setUnnamedAddr(GlobalValue::UnnamedAddr::None); // Make all uses of the duplicate constant use the canonical version. Replacements.push_back(std::make_pair(GV, Slot)); diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index e66ed8359ff..ded55dbb443 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -1942,8 +1942,7 @@ static bool processInternalGlobal( static bool processGlobal(GlobalValue &GV, TargetLibraryInfo *TLI, function_ref LookupDomTree) { - // Do more involved optimizations if the global is internal. - if (!GV.hasLocalLinkage()) + if (GV.getName().startswith("llvm.")) return false; GlobalStatus GS; @@ -1952,12 +1951,20 @@ processGlobal(GlobalValue &GV, TargetLibraryInfo *TLI, return false; bool Changed = false; - if (!GS.IsCompared && !GV.hasUnnamedAddr()) { - GV.setUnnamedAddr(true); - NumUnnamed++; - Changed = true; + if (!GS.IsCompared && !GV.hasGlobalUnnamedAddr()) { + auto NewUnnamedAddr = GV.hasLocalLinkage() ? GlobalValue::UnnamedAddr::Global + : GlobalValue::UnnamedAddr::Local; + if (NewUnnamedAddr != GV.getUnnamedAddr()) { + GV.setUnnamedAddr(NewUnnamedAddr); + NumUnnamed++; + Changed = true; + } } + // Do more involved optimizations if the global is internal. + if (!GV.hasLocalLinkage()) + return Changed; + auto *GVar = dyn_cast(&GV); if (!GVar) return Changed; diff --git a/lib/Transforms/IPO/MergeFunctions.cpp b/lib/Transforms/IPO/MergeFunctions.cpp index 27caa07c165..adf0d3f680b 100644 --- a/lib/Transforms/IPO/MergeFunctions.cpp +++ b/lib/Transforms/IPO/MergeFunctions.cpp @@ -1637,7 +1637,7 @@ void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) { // Replace G with an alias to F if possible, or else a thunk to F. Deletes G. void MergeFunctions::writeThunkOrAlias(Function *F, Function *G) { - if (HasGlobalAliases && G->hasUnnamedAddr()) { + if (HasGlobalAliases && G->hasGlobalUnnamedAddr()) { if (G->hasExternalLinkage() || G->hasLocalLinkage() || G->hasWeakLinkage()) { writeAlias(F, G); diff --git a/lib/Transforms/Instrumentation/AddressSanitizer.cpp b/lib/Transforms/Instrumentation/AddressSanitizer.cpp index 08f148139a2..16a55527c20 100644 --- a/lib/Transforms/Instrumentation/AddressSanitizer.cpp +++ b/lib/Transforms/Instrumentation/AddressSanitizer.cpp @@ -832,7 +832,7 @@ static GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str, GlobalVariable *GV = new GlobalVariable(M, StrConst->getType(), true, GlobalValue::PrivateLinkage, StrConst, kAsanGenPrefix); - if (AllowMerging) GV->setUnnamedAddr(true); + if (AllowMerging) GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); GV->setAlignment(1); // Strings may not be merged w/o setting align 1. return GV; } @@ -849,7 +849,7 @@ static GlobalVariable *createPrivateGlobalForSourceLoc(Module &M, auto GV = new GlobalVariable(M, LocStruct->getType(), true, GlobalValue::PrivateLinkage, LocStruct, kAsanGenPrefix); - GV->setUnnamedAddr(true); + GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); return GV; } diff --git a/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp b/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp index 40a9fce7b0b..eafab784e57 100644 --- a/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp +++ b/lib/Transforms/Instrumentation/EfficiencySanitizer.cpp @@ -137,7 +137,7 @@ static GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str, new GlobalVariable(M, StrConst->getType(), true, GlobalValue::PrivateLinkage, StrConst, ""); if (AllowMerging) - GV->setUnnamedAddr(true); + GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); GV->setAlignment(1); // Strings may not be merged w/o setting align 1. return GV; } diff --git a/lib/Transforms/Instrumentation/GCOVProfiling.cpp b/lib/Transforms/Instrumentation/GCOVProfiling.cpp index 9b19833cb75..6b2df2a1d9d 100644 --- a/lib/Transforms/Instrumentation/GCOVProfiling.cpp +++ b/lib/Transforms/Instrumentation/GCOVProfiling.cpp @@ -691,7 +691,7 @@ bool GCOVProfiler::emitProfileArcs() { FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false); Function *F = Function::Create(FTy, GlobalValue::InternalLinkage, "__llvm_gcov_init", M); - F->setUnnamedAddr(true); + F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); F->setLinkage(GlobalValue::InternalLinkage); F->addFnAttr(Attribute::NoInline); if (Options.NoRedZone) @@ -766,7 +766,7 @@ GlobalVariable *GCOVProfiler::buildEdgeLookupTable( ConstantArray::get(EdgeTableTy, makeArrayRef(&EdgeTable[0],TableSize)), "__llvm_gcda_edge_table"); - EdgeTableGV->setUnnamedAddr(true); + EdgeTableGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); return EdgeTableGV; } @@ -840,7 +840,7 @@ GlobalVariable *GCOVProfiler::getEdgeStateValue() { ConstantInt::get(Type::getInt32Ty(*Ctx), 0xffffffff), "__llvm_gcov_global_state_pred"); - GV->setUnnamedAddr(true); + GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); } return GV; } @@ -852,7 +852,7 @@ Function *GCOVProfiler::insertCounterWriteout( if (!WriteoutF) WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage, "__llvm_gcov_writeout", M); - WriteoutF->setUnnamedAddr(true); + WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); WriteoutF->addFnAttr(Attribute::NoInline); if (Options.NoRedZone) WriteoutF->addFnAttr(Attribute::NoRedZone); @@ -912,7 +912,7 @@ Function *GCOVProfiler::insertCounterWriteout( void GCOVProfiler::insertIndirectCounterIncrement() { Function *Fn = cast(GCOVProfiler::getIncrementIndirectCounterFunc()); - Fn->setUnnamedAddr(true); + Fn->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); Fn->setLinkage(GlobalValue::InternalLinkage); Fn->addFnAttr(Attribute::NoInline); if (Options.NoRedZone) @@ -969,7 +969,7 @@ insertFlush(ArrayRef > CountersBySP) { "__llvm_gcov_flush", M); else FlushF->setLinkage(GlobalValue::InternalLinkage); - FlushF->setUnnamedAddr(true); + FlushF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); FlushF->addFnAttr(Attribute::NoInline); if (Options.NoRedZone) FlushF->addFnAttr(Attribute::NoRedZone); diff --git a/lib/Transforms/Instrumentation/InstrProfiling.cpp b/lib/Transforms/Instrumentation/InstrProfiling.cpp index 7bb3bdc1137..a3fc16c9a9f 100644 --- a/lib/Transforms/Instrumentation/InstrProfiling.cpp +++ b/lib/Transforms/Instrumentation/InstrProfiling.cpp @@ -506,7 +506,7 @@ void InstrProfiling::emitRegistration() { auto *RegisterFTy = FunctionType::get(VoidTy, false); auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage, getInstrProfRegFuncsName(), M); - RegisterF->setUnnamedAddr(true); + RegisterF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); if (Options.NoRedZone) RegisterF->addFnAttr(Attribute::NoRedZone); auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false); @@ -606,7 +606,7 @@ void InstrProfiling::emitInitialization() { auto *F = Function::Create(FunctionType::get(VoidTy, false), GlobalValue::InternalLinkage, getInstrProfInitFuncName(), M); - F->setUnnamedAddr(true); + F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); F->addFnAttr(Attribute::NoInline); if (Options.NoRedZone) F->addFnAttr(Attribute::NoRedZone); diff --git a/lib/Transforms/Scalar/LoopIdiomRecognize.cpp b/lib/Transforms/Scalar/LoopIdiomRecognize.cpp index d99d4b6e596..f923673484f 100644 --- a/lib/Transforms/Scalar/LoopIdiomRecognize.cpp +++ b/lib/Transforms/Scalar/LoopIdiomRecognize.cpp @@ -777,7 +777,7 @@ bool LoopIdiomRecognize::processLoopStridedStore( GlobalVariable *GV = new GlobalVariable(*M, PatternValue->getType(), true, GlobalValue::PrivateLinkage, PatternValue, ".memset_pattern"); - GV->setUnnamedAddr(true); // Ok to merge these. + GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); // Ok to merge these. GV->setAlignment(16); Value *PatternPtr = ConstantExpr::getBitCast(GV, Int8PtrTy); NewCall = Builder.CreateCall(MSP, {BasePtr, PatternPtr, NumBytes}); diff --git a/lib/Transforms/Utils/FunctionImportUtils.cpp b/lib/Transforms/Utils/FunctionImportUtils.cpp index 92e7fbc7e69..fcb25baf321 100644 --- a/lib/Transforms/Utils/FunctionImportUtils.cpp +++ b/lib/Transforms/Utils/FunctionImportUtils.cpp @@ -64,7 +64,7 @@ bool FunctionImportGlobalProcessing::doPromoteLocalToGlobal( // of the module and recorded in the summary index for use when importing // from that module. auto *GVar = dyn_cast(SGV); - if (GVar && GVar->isConstant() && GVar->hasUnnamedAddr()) + if (GVar && GVar->isConstant() && GVar->hasGlobalUnnamedAddr()) return false; if (GVar && GVar->hasSection()) diff --git a/lib/Transforms/Utils/GlobalStatus.cpp b/lib/Transforms/Utils/GlobalStatus.cpp index 8be42aed972..266be41fbea 100644 --- a/lib/Transforms/Utils/GlobalStatus.cpp +++ b/lib/Transforms/Utils/GlobalStatus.cpp @@ -105,7 +105,7 @@ static bool analyzeGlobalAux(const Value *V, GlobalStatus &GS, } } - if (StoredVal == GV->getInitializer()) { + if (GV->hasInitializer() && StoredVal == GV->getInitializer()) { if (GS.StoredType < GlobalStatus::InitializerStored) GS.StoredType = GlobalStatus::InitializerStored; } else if (isa(StoredVal) && diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index ec2c1af97ea..8f35f887c0b 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -4540,7 +4540,7 @@ SwitchLookupTable::SwitchLookupTable( Array = new GlobalVariable(M, ArrayTy, /*constant=*/true, GlobalVariable::PrivateLinkage, Initializer, "switch.table"); - Array->setUnnamedAddr(true); + Array->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); Kind = ArrayKind; } diff --git a/test/Assembler/local-unnamed-addr.ll b/test/Assembler/local-unnamed-addr.ll new file mode 100644 index 00000000000..ba278409934 --- /dev/null +++ b/test/Assembler/local-unnamed-addr.ll @@ -0,0 +1,13 @@ +; RUN: llvm-as < %s | llvm-dis | FileCheck %s +; RUN: verify-uselistorder %s + +; CHECK: @c = local_unnamed_addr constant i32 0 +@c = local_unnamed_addr constant i32 0 + +; CHECK: @a = local_unnamed_addr alias i32, i32* @c +@a = local_unnamed_addr alias i32, i32* @c + +; CHECK: define void @f() local_unnamed_addr { +define void @f() local_unnamed_addr { + ret void +} diff --git a/test/Bitcode/compatibility.ll b/test/Bitcode/compatibility.ll index 4f0f29cfc87..827bc6a56ca 100644 --- a/test/Bitcode/compatibility.ll +++ b/test/Bitcode/compatibility.ll @@ -80,7 +80,7 @@ $comdat.samesize = comdat samesize ;; Global Variables ; Format: [@ =] [Linkage] [Visibility] [DLLStorageClass] -; [ThreadLocal] [unnamed_addr] [AddrSpace] [ExternallyInitialized] +; [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] [AddrSpace] [ExternallyInitialized] ; [] ; [, section "name"] [, comdat [($name)]] [, align ] @@ -142,9 +142,11 @@ $comdat.samesize = comdat samesize @g.localexec = thread_local(localexec) global i32 0 ; CHECK: @g.localexec = thread_local(localexec) global i32 0 -; Global Variables -- unnamed_addr +; Global Variables -- unnamed_addr and local_unnamed_addr @g.unnamed_addr = unnamed_addr global i32 0 ; CHECK: @g.unnamed_addr = unnamed_addr global i32 0 +@g.local_unnamed_addr = local_unnamed_addr global i32 0 +; CHECK: @g.local_unnamed_addr = local_unnamed_addr global i32 0 ; Global Variables -- AddrSpace @g.addrspace = addrspace(1) global i32 0 @@ -245,9 +247,11 @@ declare void @g.f1() @a.localexec = thread_local(localexec) alias i32, i32* @g.localexec ; CHECK: @a.localexec = thread_local(localexec) alias i32, i32* @g.localexec -; Aliases -- unnamed_addr +; Aliases -- unnamed_addr and local_unnamed_addr @a.unnamed_addr = unnamed_addr alias i32, i32* @g.unnamed_addr ; CHECK: @a.unnamed_addr = unnamed_addr alias i32, i32* @g.unnamed_addr +@a.local_unnamed_addr = local_unnamed_addr alias i32, i32* @g.local_unnamed_addr +; CHECK: @a.local_unnamed_addr = local_unnamed_addr alias i32, i32* @g.local_unnamed_addr ;; IFunc ; Format @ = [Linkage] [Visibility] ifunc , @@ -278,7 +282,7 @@ entry: ; Format: define [linkage] [visibility] [DLLStorageClass] ; [cconv] [ret attrs] ; @ ([argument list]) -; [unnamed_addr] [fn Attrs] [section "name"] [comdat [($name)]] +; [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"] [comdat [($name)]] ; [align N] [gc] [prefix Constant] [prologue Constant] ; [personality Constant] { ... } @@ -523,9 +527,11 @@ declare void @f.param.dereferenceable(i8* dereferenceable(4)) declare void @f.param.dereferenceable_or_null(i8* dereferenceable_or_null(4)) ; CHECK: declare void @f.param.dereferenceable_or_null(i8* dereferenceable_or_null(4)) -; Functions -- unnamed_addr +; Functions -- unnamed_addr and local_unnamed_addr declare void @f.unnamed_addr() unnamed_addr ; CHECK: declare void @f.unnamed_addr() unnamed_addr +declare void @f.local_unnamed_addr() local_unnamed_addr +; CHECK: declare void @f.local_unnamed_addr() local_unnamed_addr ; Functions -- fn Attrs (Function attributes) declare void @f.alignstack4() alignstack(4) diff --git a/test/CodeGen/PowerPC/weak_def_can_be_hidden.ll b/test/CodeGen/PowerPC/weak_def_can_be_hidden.ll index 0b87613bb4d..3760f1bb165 100644 --- a/test/CodeGen/PowerPC/weak_def_can_be_hidden.ll +++ b/test/CodeGen/PowerPC/weak_def_can_be_hidden.ll @@ -3,7 +3,7 @@ ; RUN: llc -mtriple=powerpc-apple-darwin9 -O0 < %s | FileCheck --check-prefix=CHECK-D89 %s ; RUN: llc -mtriple=powerpc-apple-darwin8 -O0 < %s | FileCheck --check-prefix=CHECK-D89 %s -@v1 = linkonce_odr constant i32 32 +@v1 = linkonce_odr local_unnamed_addr constant i32 32 ; CHECK: .globl _v1 ; CHECK: .weak_def_can_be_hidden _v1 @@ -26,7 +26,7 @@ define i32* @f2() { ret i32* @v2 } -@v3 = linkonce_odr unnamed_addr global i32 32 +@v3 = linkonce_odr unnamed_addr constant i32 32 ; CHECK: .globl _v3 ; CHECK: .weak_def_can_be_hidden _v3 @@ -37,9 +37,9 @@ define i32* @f3() { ret i32* @v3 } -@v4 = linkonce_odr global i32 32 +@v4 = linkonce_odr unnamed_addr global i32 32 ; CHECK: .globl _v4 -; CHECK: .weak_definition _v4 +; CHECK: .weak_def_can_be_hidden _v4 ; CHECK-D89: .globl _v4 ; CHECK-D89: .weak_definition _v4 diff --git a/test/CodeGen/X86/weak_def_can_be_hidden.ll b/test/CodeGen/X86/weak_def_can_be_hidden.ll index 8e6d34c89d8..516bc02cc2f 100644 --- a/test/CodeGen/X86/weak_def_can_be_hidden.ll +++ b/test/CodeGen/X86/weak_def_can_be_hidden.ll @@ -4,7 +4,7 @@ ; RUN: llc -mtriple=i686-apple-darwin9 -O0 < %s | FileCheck --check-prefix=CHECK-D89 %s ; RUN: llc -mtriple=i686-apple-darwin8 -O0 < %s | FileCheck --check-prefix=CHECK-D89 %s -@v1 = linkonce_odr constant i32 32 +@v1 = linkonce_odr local_unnamed_addr constant i32 32 ; CHECK: .globl _v1 ; CHECK: .weak_def_can_be_hidden _v1 @@ -27,7 +27,7 @@ define i32* @f2() { ret i32* @v2 } -@v3 = linkonce_odr unnamed_addr global i32 32 +@v3 = linkonce_odr unnamed_addr constant i32 32 ; CHECK: .globl _v3 ; CHECK: .weak_def_can_be_hidden _v3 @@ -38,9 +38,9 @@ define i32* @f3() { ret i32* @v3 } -@v4 = linkonce_odr global i32 32 +@v4 = linkonce_odr unnamed_addr global i32 32 ; CHECK: .globl _v4 -; CHECK: .weak_definition _v4 +; CHECK: .weak_def_can_be_hidden _v4 ; CHECK-D89: .globl _v4 ; CHECK-D89: .weak_definition _v4 diff --git a/test/Feature/OperandBundles/pr26510.ll b/test/Feature/OperandBundles/pr26510.ll index d1d60b47313..08bd92aa6fa 100644 --- a/test/Feature/OperandBundles/pr26510.ll +++ b/test/Feature/OperandBundles/pr26510.ll @@ -10,7 +10,7 @@ declare void @foo() readnone -; CHECK-LABEL: define i8* @test(i8* %p) { +; CHECK-LABEL: define i8* @test(i8* %p) ; CHECK: %a = alloca i8*, align 8 ; CHECK: store i8* %p, i8** %a, align 8 ; CHECK: call void @foo() [ "abc"(i8** %a) ] diff --git a/test/LTO/X86/cfi_endproc.ll b/test/LTO/X86/cfi_endproc.ll index 57d822b047e..7a9ab2b23b5 100644 --- a/test/LTO/X86/cfi_endproc.ll +++ b/test/LTO/X86/cfi_endproc.ll @@ -33,8 +33,8 @@ define i32* @get_zed1() { ret i32* @zed1 } -; ZED1_AND_ZED2: d zed2 -@zed2 = linkonce_odr unnamed_addr global i32 42 +; ZED1_AND_ZED2: r zed2 +@zed2 = linkonce_odr unnamed_addr constant i32 42 define i32 @useZed2() { %x = load i32, i32* @zed2 diff --git a/test/LTO/X86/linkonce_odr_func.ll b/test/LTO/X86/linkonce_odr_func.ll index 671b30a460c..df81e06e935 100644 --- a/test/LTO/X86/linkonce_odr_func.ll +++ b/test/LTO/X86/linkonce_odr_func.ll @@ -1,61 +1,54 @@ ; RUN: llvm-as < %s >%t1 ; RUN: llvm-lto -o %t2 -dso-symbol=foo1 -dso-symbol=foo2 -dso-symbol=foo3 \ -; RUN: -dso-symbol=foo4 -dso-symbol=v1 -dso-symbol=v2 %t1 -O0 +; RUN: -dso-symbol=v1 -dso-symbol=v2 -dso-symbol=v3 \ +; RUN: -dso-symbol=v4 -dso-symbol=v5 -dso-symbol=v6 %t1 -O0 ; RUN: llvm-nm %t2 | FileCheck %s target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" -; CHECK: t foo1 +; CHECK: W foo1 define linkonce_odr void @foo1() noinline { ret void } -; CHECK: W foo2 -define linkonce_odr void @foo2() noinline { +; CHECK: t foo2 +define linkonce_odr void @foo2() local_unnamed_addr noinline { ret void } ; CHECK: t foo3 -define linkonce_odr void @foo3() noinline { +define linkonce_odr void @foo3() unnamed_addr noinline { ret void } -; CHECK: W foo4 -define linkonce_odr void @foo4() noinline { - ret void -} - -; CHECK: r v1 +; CHECK: V v1 @v1 = linkonce_odr constant i32 32 -define i32 @useV1() { - %x = load i32, i32* @v1 - ret i32 %x -} +; CHECK: r v2 +@v2 = linkonce_odr local_unnamed_addr constant i32 32 -; CHECK: V v2 -@v2 = linkonce_odr global i32 32 +; CHECK: r v3 +@v3 = linkonce_odr unnamed_addr constant i32 32 -define i32 @useV2() { - %x = load i32, i32* @v2 - ret i32 %x -} +; CHECK: V v4 +@v4 = linkonce_odr global i32 32 -declare void @f(void()*) +; CHECK: V v5 +@v5 = linkonce_odr local_unnamed_addr global i32 32 -declare void @p() +; CHECK: d v6 +@v6 = linkonce_odr unnamed_addr global i32 32 -define void @bar() personality void()* @p { -bb0: +define void @use() { call void @foo1() - call void @f(void()* @foo2) - invoke void @foo3() to label %bb1 unwind label %clean -bb1: - invoke void @f(void()* @foo4) to label %bb2 unwind label %clean -bb2: - ret void -clean: - landingpad {i32, i32} cleanup + call void @foo2() + call void @foo3() + %x1 = load i32, i32* @v1 + %x2 = load i32, i32* @v2 + %x3 = load i32, i32* @v3 + %x4 = load i32, i32* @v4 + %x5 = load i32, i32* @v5 + %x6 = load i32, i32* @v6 ret void } diff --git a/test/Other/constant-fold-gep.ll b/test/Other/constant-fold-gep.ll index 6923aadeb44..9d52f800bc2 100644 --- a/test/Other/constant-fold-gep.ll +++ b/test/Other/constant-fold-gep.ll @@ -24,18 +24,18 @@ ; PLAIN: @F1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -2) ; PLAIN: @H8 = global i8* getelementptr (i8, i8* null, i32 -1) ; PLAIN: @H1 = global i1* getelementptr (i1, i1* null, i32 -1) -; OPT: @G8 = global i8* null -; OPT: @G1 = global i1* null -; OPT: @F8 = global i8* inttoptr (i64 -1 to i8*) -; OPT: @F1 = global i1* inttoptr (i64 -1 to i1*) -; OPT: @H8 = global i8* inttoptr (i64 -1 to i8*) -; OPT: @H1 = global i1* inttoptr (i64 -1 to i1*) -; TO: @G8 = global i8* null -; TO: @G1 = global i1* null -; TO: @F8 = global i8* inttoptr (i64 -1 to i8*) -; TO: @F1 = global i1* inttoptr (i64 -1 to i1*) -; TO: @H8 = global i8* inttoptr (i64 -1 to i8*) -; TO: @H1 = global i1* inttoptr (i64 -1 to i1*) +; OPT: @G8 = local_unnamed_addr global i8* null +; OPT: @G1 = local_unnamed_addr global i1* null +; OPT: @F8 = local_unnamed_addr global i8* inttoptr (i64 -1 to i8*) +; OPT: @F1 = local_unnamed_addr global i1* inttoptr (i64 -1 to i1*) +; OPT: @H8 = local_unnamed_addr global i8* inttoptr (i64 -1 to i8*) +; OPT: @H1 = local_unnamed_addr global i1* inttoptr (i64 -1 to i1*) +; TO: @G8 = local_unnamed_addr global i8* null +; TO: @G1 = local_unnamed_addr global i1* null +; TO: @F8 = local_unnamed_addr global i8* inttoptr (i64 -1 to i8*) +; TO: @F1 = local_unnamed_addr global i1* inttoptr (i64 -1 to i1*) +; TO: @H8 = local_unnamed_addr global i8* inttoptr (i64 -1 to i8*) +; TO: @H1 = local_unnamed_addr global i1* inttoptr (i64 -1 to i1*) @G8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1) @G1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -1) @@ -57,24 +57,24 @@ ; PLAIN: @g = constant i64 ptrtoint (double* getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) to i64) ; PLAIN: @h = constant i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64) ; PLAIN: @i = constant i64 ptrtoint (i1** getelementptr ({ i1, i1* }, { i1, i1* }* null, i64 0, i32 1) to i64) -; OPT: @a = constant i64 18480 -; OPT: @b = constant i64 8 -; OPT: @c = constant i64 16 -; OPT: @d = constant i64 88 -; OPT: @e = constant i64 16 -; OPT: @f = constant i64 1 -; OPT: @g = constant i64 8 -; OPT: @h = constant i64 8 -; OPT: @i = constant i64 8 -; TO: @a = constant i64 18480 -; TO: @b = constant i64 8 -; TO: @c = constant i64 16 -; TO: @d = constant i64 88 -; TO: @e = constant i64 16 -; TO: @f = constant i64 1 -; TO: @g = constant i64 8 -; TO: @h = constant i64 8 -; TO: @i = constant i64 8 +; OPT: @a = local_unnamed_addr constant i64 18480 +; OPT: @b = local_unnamed_addr constant i64 8 +; OPT: @c = local_unnamed_addr constant i64 16 +; OPT: @d = local_unnamed_addr constant i64 88 +; OPT: @e = local_unnamed_addr constant i64 16 +; OPT: @f = local_unnamed_addr constant i64 1 +; OPT: @g = local_unnamed_addr constant i64 8 +; OPT: @h = local_unnamed_addr constant i64 8 +; OPT: @i = local_unnamed_addr constant i64 8 +; TO: @a = local_unnamed_addr constant i64 18480 +; TO: @b = local_unnamed_addr constant i64 8 +; TO: @c = local_unnamed_addr constant i64 16 +; TO: @d = local_unnamed_addr constant i64 88 +; TO: @e = local_unnamed_addr constant i64 16 +; TO: @f = local_unnamed_addr constant i64 1 +; TO: @g = local_unnamed_addr constant i64 8 +; TO: @h = local_unnamed_addr constant i64 8 +; TO: @i = local_unnamed_addr constant i64 8 @a = constant i64 mul (i64 3, i64 mul (i64 ptrtoint ({[7 x double], [7 x double]}* getelementptr ({[7 x double], [7 x double]}, {[7 x double], [7 x double]}* null, i64 11) to i64), i64 5)) @b = constant i64 ptrtoint ([13 x double]* getelementptr ({i1, [13 x double]}, {i1, [13 x double]}* null, i64 0, i32 1) to i64) @@ -91,12 +91,12 @@ ; PLAIN: @M = constant i64* getelementptr (i64, i64* null, i32 1) ; PLAIN: @N = constant i64* getelementptr ({ i64, i64 }, { i64, i64 }* null, i32 0, i32 1) ; PLAIN: @O = constant i64* getelementptr ([2 x i64], [2 x i64]* null, i32 0, i32 1) -; OPT: @M = constant i64* inttoptr (i64 8 to i64*) -; OPT: @N = constant i64* inttoptr (i64 8 to i64*) -; OPT: @O = constant i64* inttoptr (i64 8 to i64*) -; TO: @M = constant i64* inttoptr (i64 8 to i64*) -; TO: @N = constant i64* inttoptr (i64 8 to i64*) -; TO: @O = constant i64* inttoptr (i64 8 to i64*) +; OPT: @M = local_unnamed_addr constant i64* inttoptr (i64 8 to i64*) +; OPT: @N = local_unnamed_addr constant i64* inttoptr (i64 8 to i64*) +; OPT: @O = local_unnamed_addr constant i64* inttoptr (i64 8 to i64*) +; TO: @M = local_unnamed_addr constant i64* inttoptr (i64 8 to i64*) +; TO: @N = local_unnamed_addr constant i64* inttoptr (i64 8 to i64*) +; TO: @O = local_unnamed_addr constant i64* inttoptr (i64 8 to i64*) @M = constant i64* getelementptr (i64, i64* null, i32 1) @N = constant i64* getelementptr ({ i64, i64 }, { i64, i64 }* null, i32 0, i32 1) @@ -106,10 +106,10 @@ ; PLAIN: @Y = global [3 x { i32, i32 }]* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 2) ; PLAIN: @Z = global i32* getelementptr inbounds (i32, i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 0), i64 1) -; OPT: @Y = global [3 x { i32, i32 }]* getelementptr ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 2) -; OPT: @Z = global i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 1) -; TO: @Y = global [3 x { i32, i32 }]* getelementptr ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 2) -; TO: @Z = global i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 1) +; OPT: @Y = local_unnamed_addr global [3 x { i32, i32 }]* getelementptr ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 2) +; OPT: @Z = local_unnamed_addr global i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 1) +; TO: @Y = local_unnamed_addr global [3 x { i32, i32 }]* getelementptr ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 2) +; TO: @Z = local_unnamed_addr global i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 1) @ext = external global [3 x { i32, i32 }] @Y = global [3 x { i32, i32 }]* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 1), i64 1) @@ -142,40 +142,40 @@ ; PLAIN: %t = bitcast i1* getelementptr (i1, i1* null, i32 -1) to i1* ; PLAIN: ret i1* %t ; PLAIN: } -; OPT: define i8* @goo8() #0 { +; OPT: define i8* @goo8() local_unnamed_addr #0 { ; OPT: ret i8* null ; OPT: } -; OPT: define i1* @goo1() #0 { +; OPT: define i1* @goo1() local_unnamed_addr #0 { ; OPT: ret i1* null ; OPT: } -; OPT: define i8* @foo8() #0 { +; OPT: define i8* @foo8() local_unnamed_addr #0 { ; OPT: ret i8* inttoptr (i64 -1 to i8*) ; OPT: } -; OPT: define i1* @foo1() #0 { +; OPT: define i1* @foo1() local_unnamed_addr #0 { ; OPT: ret i1* inttoptr (i64 -1 to i1*) ; OPT: } -; OPT: define i8* @hoo8() #0 { +; OPT: define i8* @hoo8() local_unnamed_addr #0 { ; OPT: ret i8* inttoptr (i64 -1 to i8*) ; OPT: } -; OPT: define i1* @hoo1() #0 { +; OPT: define i1* @hoo1() local_unnamed_addr #0 { ; OPT: ret i1* inttoptr (i64 -1 to i1*) ; OPT: } -; TO: define i8* @goo8() #0 { +; TO: define i8* @goo8() local_unnamed_addr #0 { ; TO: ret i8* null ; TO: } -; TO: define i1* @goo1() #0 { +; TO: define i1* @goo1() local_unnamed_addr #0 { ; TO: ret i1* null ; TO: } -; TO: define i8* @foo8() #0 { +; TO: define i8* @foo8() local_unnamed_addr #0 { ; TO: ret i8* inttoptr (i64 -1 to i8*) ; TO: } -; TO: define i1* @foo1() #0 { +; TO: define i1* @foo1() local_unnamed_addr #0 { ; TO: ret i1* inttoptr (i64 -1 to i1*) ; TO: } -; TO: define i8* @hoo8() #0 { +; TO: define i8* @hoo8() local_unnamed_addr #0 { ; TO: ret i8* inttoptr (i64 -1 to i8*) ; TO: } -; TO: define i1* @hoo1() #0 { +; TO: define i1* @hoo1() local_unnamed_addr #0 { ; TO: ret i1* inttoptr (i64 -1 to i1*) ; TO: } ; SCEV: Classifying expressions for: @goo8 @@ -256,58 +256,58 @@ define i1* @hoo1() nounwind { ; PLAIN: %t = bitcast i64 ptrtoint (i1** getelementptr ({ i1, i1* }, { i1, i1* }* null, i64 0, i32 1) to i64) to i64 ; PLAIN: ret i64 %t ; PLAIN: } -; OPT: define i64 @fa() #0 { +; OPT: define i64 @fa() local_unnamed_addr #0 { ; OPT: ret i64 18480 ; OPT: } -; OPT: define i64 @fb() #0 { +; OPT: define i64 @fb() local_unnamed_addr #0 { ; OPT: ret i64 8 ; OPT: } -; OPT: define i64 @fc() #0 { +; OPT: define i64 @fc() local_unnamed_addr #0 { ; OPT: ret i64 16 ; OPT: } -; OPT: define i64 @fd() #0 { +; OPT: define i64 @fd() local_unnamed_addr #0 { ; OPT: ret i64 88 ; OPT: } -; OPT: define i64 @fe() #0 { +; OPT: define i64 @fe() local_unnamed_addr #0 { ; OPT: ret i64 16 ; OPT: } -; OPT: define i64 @ff() #0 { +; OPT: define i64 @ff() local_unnamed_addr #0 { ; OPT: ret i64 1 ; OPT: } -; OPT: define i64 @fg() #0 { +; OPT: define i64 @fg() local_unnamed_addr #0 { ; OPT: ret i64 8 ; OPT: } -; OPT: define i64 @fh() #0 { +; OPT: define i64 @fh() local_unnamed_addr #0 { ; OPT: ret i64 8 ; OPT: } -; OPT: define i64 @fi() #0 { +; OPT: define i64 @fi() local_unnamed_addr #0 { ; OPT: ret i64 8 ; OPT: } -; TO: define i64 @fa() #0 { +; TO: define i64 @fa() local_unnamed_addr #0 { ; TO: ret i64 18480 ; TO: } -; TO: define i64 @fb() #0 { +; TO: define i64 @fb() local_unnamed_addr #0 { ; TO: ret i64 8 ; TO: } -; TO: define i64 @fc() #0 { +; TO: define i64 @fc() local_unnamed_addr #0 { ; TO: ret i64 16 ; TO: } -; TO: define i64 @fd() #0 { +; TO: define i64 @fd() local_unnamed_addr #0 { ; TO: ret i64 88 ; TO: } -; TO: define i64 @fe() #0 { +; TO: define i64 @fe() local_unnamed_addr #0 { ; TO: ret i64 16 ; TO: } -; TO: define i64 @ff() #0 { +; TO: define i64 @ff() local_unnamed_addr #0 { ; TO: ret i64 1 ; TO: } -; TO: define i64 @fg() #0 { +; TO: define i64 @fg() local_unnamed_addr #0 { ; TO: ret i64 8 ; TO: } -; TO: define i64 @fh() #0 { +; TO: define i64 @fh() local_unnamed_addr #0 { ; TO: ret i64 8 ; TO: } -; TO: define i64 @fi() #0 { +; TO: define i64 @fi() local_unnamed_addr #0 { ; TO: ret i64 8 ; TO: } ; SCEV: Classifying expressions for: @fa @@ -387,22 +387,22 @@ define i64 @fi() nounwind { ; PLAIN: %t = bitcast i64* getelementptr ([2 x i64], [2 x i64]* null, i32 0, i32 1) to i64* ; PLAIN: ret i64* %t ; PLAIN: } -; OPT: define i64* @fM() #0 { +; OPT: define i64* @fM() local_unnamed_addr #0 { ; OPT: ret i64* inttoptr (i64 8 to i64*) ; OPT: } -; OPT: define i64* @fN() #0 { +; OPT: define i64* @fN() local_unnamed_addr #0 { ; OPT: ret i64* inttoptr (i64 8 to i64*) ; OPT: } -; OPT: define i64* @fO() #0 { +; OPT: define i64* @fO() local_unnamed_addr #0 { ; OPT: ret i64* inttoptr (i64 8 to i64*) ; OPT: } -; TO: define i64* @fM() #0 { +; TO: define i64* @fM() local_unnamed_addr #0 { ; TO: ret i64* inttoptr (i64 8 to i64*) ; TO: } -; TO: define i64* @fN() #0 { +; TO: define i64* @fN() local_unnamed_addr #0 { ; TO: ret i64* inttoptr (i64 8 to i64*) ; TO: } -; TO: define i64* @fO() #0 { +; TO: define i64* @fO() local_unnamed_addr #0 { ; TO: ret i64* inttoptr (i64 8 to i64*) ; TO: } ; SCEV: Classifying expressions for: @fM @@ -432,10 +432,10 @@ define i64* @fO() nounwind { ; PLAIN: %t = bitcast i32* getelementptr inbounds (i32, i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 0), i64 1) to i32* ; PLAIN: ret i32* %t ; PLAIN: } -; OPT: define i32* @fZ() #0 { +; OPT: define i32* @fZ() local_unnamed_addr #0 { ; OPT: ret i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 1) ; OPT: } -; TO: define i32* @fZ() #0 { +; TO: define i32* @fZ() local_unnamed_addr #0 { ; TO: ret i32* getelementptr inbounds ([3 x { i32, i32 }], [3 x { i32, i32 }]* @ext, i64 0, i64 1, i32 1) ; TO: } ; SCEV: Classifying expressions for: @fZ diff --git a/test/Transforms/GlobalOpt/2010-10-19-WeakOdr.ll b/test/Transforms/GlobalOpt/2010-10-19-WeakOdr.ll index ad5b440a5ab..c88dc1c2d12 100644 --- a/test/Transforms/GlobalOpt/2010-10-19-WeakOdr.ll +++ b/test/Transforms/GlobalOpt/2010-10-19-WeakOdr.ll @@ -2,7 +2,7 @@ ; PR8389: Globals with weak_odr linkage type must not be modified -; CHECK: weak_odr global i32 0 +; CHECK: weak_odr local_unnamed_addr global i32 0 @SomeVar = weak_odr global i32 0 diff --git a/test/Transforms/GlobalOpt/alias-used-address-space.ll b/test/Transforms/GlobalOpt/alias-used-address-space.ll index 367f375ec90..08081b89ac6 100644 --- a/test/Transforms/GlobalOpt/alias-used-address-space.ll +++ b/test/Transforms/GlobalOpt/alias-used-address-space.ll @@ -16,7 +16,7 @@ target datalayout = "p:32:32:32-p1:16:16:16" ; CHECK-DAG: @llvm.compiler.used = appending global [1 x i8*] [i8* addrspacecast (i8 addrspace(1)* @ia to i8*)], section "llvm.metadata" @sameAsUsed = global [1 x i8*] [i8* addrspacecast(i8 addrspace(1)* @ca to i8*)] -; CHECK-DAG: @sameAsUsed = global [1 x i8*] [i8* addrspacecast (i8 addrspace(1)* @c to i8*)] +; CHECK-DAG: @sameAsUsed = local_unnamed_addr global [1 x i8*] [i8* addrspacecast (i8 addrspace(1)* @c to i8*)] @ca = internal alias i8, i8 addrspace(1)* @c ; CHECK: @ca = internal alias i8, i8 addrspace(1)* @c diff --git a/test/Transforms/GlobalOpt/alias-used.ll b/test/Transforms/GlobalOpt/alias-used.ll index bb905871764..91601fb9927 100644 --- a/test/Transforms/GlobalOpt/alias-used.ll +++ b/test/Transforms/GlobalOpt/alias-used.ll @@ -13,10 +13,10 @@ ; CHECK-DAG: @llvm.compiler.used = appending global [2 x i8*] [i8* bitcast (void ()* @fa3 to i8*), i8* @ia], section "llvm.metadata" @sameAsUsed = global [3 x i8*] [i8* bitcast (void ()* @fa to i8*), i8* bitcast (void ()* @f to i8*), i8* @ca] -; CHECK-DAG: @sameAsUsed = global [3 x i8*] [i8* bitcast (void ()* @f to i8*), i8* bitcast (void ()* @f to i8*), i8* @c] +; CHECK-DAG: @sameAsUsed = local_unnamed_addr global [3 x i8*] [i8* bitcast (void ()* @f to i8*), i8* bitcast (void ()* @f to i8*), i8* @c] @other = global i32* bitcast (void ()* @fa to i32*) -; CHECK-DAG: @other = global i32* bitcast (void ()* @f to i32*) +; CHECK-DAG: @other = local_unnamed_addr global i32* bitcast (void ()* @f to i32*) @fa = internal alias void (), void ()* @f ; CHECK: @fa = internal alias void (), void ()* @f diff --git a/test/Transforms/GlobalOpt/assume.ll b/test/Transforms/GlobalOpt/assume.ll index 3f3157a38fb..b15106bc83a 100644 --- a/test/Transforms/GlobalOpt/assume.ll +++ b/test/Transforms/GlobalOpt/assume.ll @@ -1,6 +1,6 @@ ; RUN: opt -S -globalopt < %s | FileCheck %s -; CHECK: @tmp = global i32 42 +; CHECK: @tmp = local_unnamed_addr global i32 42 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }] @tmp = global i32 0 diff --git a/test/Transforms/GlobalOpt/constantfold-initializers.ll b/test/Transforms/GlobalOpt/constantfold-initializers.ll index d0c18812cd9..3c20353d157 100644 --- a/test/Transforms/GlobalOpt/constantfold-initializers.ll +++ b/test/Transforms/GlobalOpt/constantfold-initializers.ll @@ -4,13 +4,13 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3 @.str91250 = global [3 x i8] zeroinitializer -; CHECK: @A = global i1 false +; CHECK: @A = local_unnamed_addr global i1 false @A = global i1 icmp ne (i64 sub nsw (i64 ptrtoint (i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str91250, i64 0, i64 1) to i64), i64 ptrtoint ([3 x i8]* @.str91250 to i64)), i64 1) ; PR11352 @xs = global [2 x i32] zeroinitializer, align 4 -; CHECK: @xs = global [2 x i32] [i32 1, i32 1] +; CHECK: @xs = local_unnamed_addr global [2 x i32] [i32 1, i32 1] ; PR12642 %PR12642.struct = type { i8 } @@ -32,7 +32,7 @@ entry: @f = internal global %closure zeroinitializer, align 4 @m = global i32 0, align 4 ; CHECK-NOT: @f -; CHECK: @m = global i32 13 +; CHECK: @m = local_unnamed_addr global i32 13 define internal i32 @test2_helper(%closure* %this, i32 %b) { entry: @@ -53,7 +53,7 @@ entry: ; PR19955 @dllimportptr = global i32* null, align 4 -; CHECK: @dllimportptr = global i32* null, align 4 +; CHECK: @dllimportptr = local_unnamed_addr global i32* null, align 4 @dllimportvar = external dllimport global i32 define internal void @test3() { entry: @@ -62,7 +62,7 @@ entry: } @dllexportptr = global i32* null, align 4 -; CHECK: @dllexportptr = global i32* @dllexportvar, align 4 +; CHECK: @dllexportptr = local_unnamed_addr global i32* @dllexportvar, align 4 @dllexportvar = dllexport global i32 0, align 4 ; CHECK: @dllexportvar = dllexport global i32 20, align 4 define internal void @test4() { @@ -83,7 +83,7 @@ entry: @test6_v1 = internal global { i32, i32 } { i32 42, i32 0 }, align 8 @test6_v2 = global i32 0, align 4 -; CHECK: @test6_v2 = global i32 42, align 4 +; CHECK: @test6_v2 = local_unnamed_addr global i32 42, align 4 define internal void @test6() { %load = load { i32, i32 }, { i32, i32 }* @test6_v1, align 8 %xv0 = extractvalue { i32, i32 } %load, 0 diff --git a/test/Transforms/GlobalOpt/ctor-list-opt-inbounds.ll b/test/Transforms/GlobalOpt/ctor-list-opt-inbounds.ll index 63dc783ae19..b969345710d 100644 --- a/test/Transforms/GlobalOpt/ctor-list-opt-inbounds.ll +++ b/test/Transforms/GlobalOpt/ctor-list-opt-inbounds.ll @@ -3,8 +3,8 @@ ; Don't get fooled by the inbounds keyword; it doesn't change ; the computed address. -; CHECK: @H = global i32 2 -; CHECK: @I = global i32 2 +; CHECK: @H = local_unnamed_addr global i32 2 +; CHECK: @I = local_unnamed_addr global i32 2 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [ { i32, void ()* } { i32 65535, void ()* @CTOR } ] @addr = external global i32 diff --git a/test/Transforms/GlobalOpt/invariant.group.barrier.ll b/test/Transforms/GlobalOpt/invariant.group.barrier.ll index 54d91d40801..80cd411afdc 100644 --- a/test/Transforms/GlobalOpt/invariant.group.barrier.ll +++ b/test/Transforms/GlobalOpt/invariant.group.barrier.ll @@ -2,8 +2,8 @@ ; This test is hint, what could globalOpt optimize and what it can't ; FIXME: @tmp and @tmp2 can be safely set to 42 -; CHECK: @tmp = global i32 0 -; CHECK: @tmp2 = global i32 0 +; CHECK: @tmp = local_unnamed_addr global i32 0 +; CHECK: @tmp2 = local_unnamed_addr global i32 0 ; CHECK: @tmp3 = global i32 0 @tmp = global i32 0 diff --git a/test/Transforms/GlobalOpt/invoke.ll b/test/Transforms/GlobalOpt/invoke.ll index a0f7890a985..a3019939735 100644 --- a/test/Transforms/GlobalOpt/invoke.ll +++ b/test/Transforms/GlobalOpt/invoke.ll @@ -2,7 +2,7 @@ ; rdar://11022897 ; Globalopt should be able to evaluate an invoke. -; CHECK: @tmp = global i32 1 +; CHECK: @tmp = local_unnamed_addr global i32 1 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }] @tmp = global i32 0 diff --git a/test/Transforms/GlobalOpt/pr21191.ll b/test/Transforms/GlobalOpt/pr21191.ll index 34e15cb3404..9e201b888be 100644 --- a/test/Transforms/GlobalOpt/pr21191.ll +++ b/test/Transforms/GlobalOpt/pr21191.ll @@ -6,12 +6,12 @@ $c = comdat any define linkonce_odr void @foo() comdat($c) { ret void } -; CHECK: define linkonce_odr void @foo() comdat($c) +; CHECK: define linkonce_odr void @foo() local_unnamed_addr comdat($c) define linkonce_odr void @bar() comdat($c) { ret void } -; CHECK: define linkonce_odr void @bar() comdat($c) +; CHECK: define linkonce_odr void @bar() local_unnamed_addr comdat($c) define void @zed() { call void @foo() diff --git a/test/Transforms/GlobalOpt/unnamed-addr.ll b/test/Transforms/GlobalOpt/unnamed-addr.ll index de436c62a34..9f11f1bd92c 100644 --- a/test/Transforms/GlobalOpt/unnamed-addr.ll +++ b/test/Transforms/GlobalOpt/unnamed-addr.ll @@ -10,7 +10,7 @@ ; CHECK: @b = internal global i32 0, align 4 ; CHECK: @c = internal unnamed_addr global i32 0, align 4 ; CHECK: @d = internal unnamed_addr constant [4 x i8] c"foo\00", align 1 -; CHECK: @e = linkonce_odr global i32 0 +; CHECK: @e = linkonce_odr local_unnamed_addr global i32 0 ; CHECK: define internal fastcc void @used_internal() unnamed_addr { define internal void @used_internal() { diff --git a/test/tools/gold/X86/coff.ll b/test/tools/gold/X86/coff.ll index 5d8a1c9da5f..7ab80707ba1 100644 --- a/test/tools/gold/X86/coff.ll +++ b/test/tools/gold/X86/coff.ll @@ -16,7 +16,7 @@ define hidden void @g() { ret void } -; CHECK: define internal void @h() { -define linkonce_odr void @h() { +; CHECK: define internal void @h() local_unnamed_addr { +define linkonce_odr void @h() local_unnamed_addr { ret void } diff --git a/test/tools/gold/X86/emit-llvm.ll b/test/tools/gold/X86/emit-llvm.ll index 4a6d5963cff..0a955088c40 100644 --- a/test/tools/gold/X86/emit-llvm.ll +++ b/test/tools/gold/X86/emit-llvm.ll @@ -25,6 +25,24 @@ target triple = "x86_64-unknown-linux-gnu" +; CHECK-DAG: @g1 = linkonce_odr constant i32 32 +@g1 = linkonce_odr constant i32 32 + +; CHECK-DAG: @g2 = internal local_unnamed_addr constant i32 32 +@g2 = linkonce_odr local_unnamed_addr constant i32 32 + +; CHECK-DAG: @g3 = internal unnamed_addr constant i32 32 +@g3 = linkonce_odr unnamed_addr constant i32 32 + +; CHECK-DAG: @g4 = linkonce_odr global i32 32 +@g4 = linkonce_odr global i32 32 + +; CHECK-DAG: @g5 = linkonce_odr local_unnamed_addr global i32 32 +@g5 = linkonce_odr local_unnamed_addr global i32 32 + +; CHECK-DAG: @g6 = internal unnamed_addr global i32 32 +@g6 = linkonce_odr unnamed_addr global i32 32 + @g7 = extern_weak global i32 ; CHECK-DAG: @g7 = extern_weak global i32 @@ -53,7 +71,7 @@ define void @f3() { ; CHECK-DAG: define internal void @f4() ; OPT2-NOT: @f4 -define linkonce_odr void @f4() { +define linkonce_odr void @f4() local_unnamed_addr { ret void } @@ -62,14 +80,14 @@ define linkonce_odr void @f4() { define linkonce_odr void @f5() { ret void } -@g5 = global void()* @f5 +@g9 = global void()* @f5 ; CHECK-DAG: define internal void @f6() unnamed_addr ; OPT-DAG: define internal void @f6() unnamed_addr define linkonce_odr void @f6() unnamed_addr { ret void } -@g6 = global void()* @f6 +@g10 = global void()* @f6 define i32* @f7() { ret i32* @g7 @@ -89,5 +107,5 @@ define i32* @f8() { ; API: f8 PREVAILING_DEF_IRONLY_EXP ; API: g7 UNDEF ; API: g8 UNDEF -; API: g5 PREVAILING_DEF_IRONLY_EXP -; API: g6 PREVAILING_DEF_IRONLY_EXP +; API: g9 PREVAILING_DEF_IRONLY_EXP +; API: g10 PREVAILING_DEF_IRONLY_EXP diff --git a/tools/gold/gold-plugin.cpp b/tools/gold/gold-plugin.cpp index 595e0695b08..105fef9a2d7 100644 --- a/tools/gold/gold-plugin.cpp +++ b/tools/gold/gold-plugin.cpp @@ -109,7 +109,7 @@ struct ResolutionInfo { uint64_t CommonSize = 0; unsigned CommonAlign = 0; bool IsLinkonceOdr = true; - bool UnnamedAddr = true; + GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::Global; GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; bool CommonInternal = false; bool UseCommon = false; @@ -551,7 +551,8 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, sym.visibility = LDPV_DEFAULT; if (GV) { - Res.UnnamedAddr &= GV->hasUnnamedAddr(); + Res.UnnamedAddr = + GlobalValue::getMinUnnamedAddr(Res.UnnamedAddr, GV->getUnnamedAddr()); Res.IsLinkonceOdr &= GV->hasLinkOnceLinkage(); Res.Visibility = getMinVisibility(Res.Visibility, GV->getVisibility()); switch (GV->getVisibility()) { @@ -690,10 +691,11 @@ getModuleSummaryIndexForFile(claimed_file &F) { return Obj.takeIndex(); } -static std::unique_ptr getModuleForFile( - LLVMContext &Context, claimed_file &F, const void *View, StringRef Name, - raw_fd_ostream *ApiFile, StringSet<> &Internalize, StringSet<> &Maybe, - std::vector &Keep, StringMap &Realign) { +static std::unique_ptr +getModuleForFile(LLVMContext &Context, claimed_file &F, const void *View, + StringRef Name, raw_fd_ostream *ApiFile, + StringSet<> &Internalize, std::vector &Keep, + StringMap &Realign) { MemoryBufferRef BufferRef(StringRef((const char *)View, F.filesize), Name); ErrorOr> ObjOrErr = object::IRObjectFile::create(BufferRef, Context); @@ -827,12 +829,9 @@ static std::unique_ptr getModuleForFile( break; case LDPR_PREVAILING_DEF_IRONLY_EXP: { - // We can only check for address uses after we merge the modules. The - // reason is that this GV might have a copy in another module - // and in that module the address might be significant, but that - // copy will be LDPR_PREEMPTED_IR. - Maybe.insert(GV->getName()); Keep.push_back(GV); + if (canBeOmittedFromSymbolTable(GV)) + Internalize.insert(GV->getName()); break; } } @@ -1149,11 +1148,11 @@ void CodeGen::runAll() { static void linkInModule(LLVMContext &Context, IRMover &L, claimed_file &F, const void *View, StringRef Name, raw_fd_ostream *ApiFile, StringSet<> &Internalize, - StringSet<> &Maybe, bool SetName = false) { + bool SetName = false) { std::vector Keep; StringMap Realign; - std::unique_ptr M = getModuleForFile( - Context, F, View, Name, ApiFile, Internalize, Maybe, Keep, Realign); + std::unique_ptr M = getModuleForFile(Context, F, View, Name, ApiFile, + Internalize, Keep, Realign); if (!M.get()) return; if (!options::triple.empty()) @@ -1204,7 +1203,7 @@ static void thinLTOBackendTask(claimed_file &F, const void *View, IRMover L(*NewModule.get()); StringSet<> Dummy; - linkInModule(Context, L, F, View, Name, ApiFile, Dummy, Dummy, true); + linkInModule(Context, L, F, View, Name, ApiFile, Dummy, true); if (renameModuleForThinLTO(*NewModule, CombinedIndex)) message(LDPL_FATAL, "Failed to rename module for ThinLTO"); @@ -1474,7 +1473,6 @@ static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) { IRMover L(*Combined); StringSet<> Internalize; - StringSet<> Maybe; for (claimed_file &F : Modules) { // RAII object to manage the file opening and releasing interfaces with // gold. @@ -1482,7 +1480,7 @@ static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) { const void *View = getSymbolsAndView(F); if (!View) continue; - linkInModule(Context, L, F, View, F.name, ApiFile, Internalize, Maybe); + linkInModule(Context, L, F, View, F.name, ApiFile, Internalize); } for (const auto &Name : Internalize) { @@ -1491,15 +1489,6 @@ static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) { internalize(*GV); } - for (const auto &Name : Maybe) { - GlobalValue *GV = Combined->getNamedValue(Name.first()); - if (!GV) - continue; - GV->setLinkage(GlobalValue::LinkOnceODRLinkage); - if (canBeOmittedFromSymbolTable(GV)) - internalize(*GV); - } - if (options::TheOutputType == options::OT_DISABLE) return LDPS_OK;