IR: Introduce can_omit_from_dynsym attribute.

[pcc]

Summary

If this attribute is given and all modules in the linkage unit have this
attribute, this value may be omitted from the dynamic symbol table. This
is set on constant linkonce_odr globals whose addresses are insignificant
within the module. Because such globals must be defined in each linkage unit
that uses them, a valid program would not be able to observe the absence of
the symbol unless its address is significant.

Part of the fix for PR27553.

[mehdi_amini]

Great, I had in my todo list to look how to move this out of the the object emission to the IR level.
Any reason for the name change though? The one you came up with does not sound pretty to me, what was wrong with weak_def_can_be_hidden or xxxx_can_be_hidden?

[pcc]

It's basically the same name as the function it replaces, canBeOmittedFromSymbolTable with a tweak for accuracy. That said I don't feel strongly about the name.

[• rafael]

As for naming, I would probably name it after what it checks, not what
it is currently used for.

How about making the attribute be just "address_not_used_in_module"?
The other properties (like being linkonce_odr) are easy to check
without having to walk all uses.

Should the verifier check if this the property is invalidly set?

Cheers,
Rafael

[majnemer]

In D20258#430070, @rafael wrote:

As for naming, I would probably name it after what it checks, not what
it is currently used for.

How about making the attribute be just "address_not_used_in_module"?
The other properties (like being linkonce_odr) are easy to check
without having to walk all uses.

Should the verifier check if this the property is invalidly set?

Cheers,
Rafael

How about unnamed_addr_in_module?

[pcc]

I tried going that way to begin with (D20260) but after I was done it felt a little too complicated to me, so I redid it with just what we needed. If others disagree maybe we can go with that patch instead of this one.

[pcc]

Okay, let's go with D20260 then.

Should the verifier check if this the property is invalidly set?

Sounds like a good idea to me, I'll do that on the other patch.

docs/BitCodeFormat.rst

 The ``DEPLIB`` record (code 6) contains a variable number of values representing
 the bytes of a single dependent library name string, one of the libraries
 mentioned in a ``deplibs`` declaration.  There should be one ``DEPLIB`` record
 for each library name referenced.
 
 MODULE_CODE_GLOBALVAR Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[GLOBALVAR, pointer type, isconst, initid, linkage, alignment, section, visibility, threadlocal, unnamed_addr, externally_initialized, dllstorageclass, comdat]``
+``[GLOBALVAR, pointer type, isconst, initid, linkage, alignment, section, visibility, threadlocal, unnamed_addr, externally_initialized, dllstorageclass, comdat, can_omit_from_dynsym]``
 
 The ``GLOBALVAR`` record (code 7) marks the declaration or definition of a
 global variable. The operand fields are:
 
 * *pointer type*: The type index of the pointer type used to point to this
   global variable
 
 * *isconst*: Non-zero if the variable is treated as constant within the module,

 
 .. _visibility:
 
 * *visibility*: If present, an encoding of the visibility of this variable:
   * ``default``: code 0
   * ``hidden``: code 1
   * ``protected``: code 2
 
+.. _bcthreadlocal:
+
 * *threadlocal*: If present, an encoding of the thread local storage mode of the
   variable:
   * ``not thread local``: code 0
   * ``thread local; default TLS model``: code 1
   * ``localdynamic``: code 2
   * ``initialexec``: code 3
   * ``localexec``: code 4
 
 * *unnamed_addr*: If present and non-zero, indicates that the variable has
   ``unnamed_addr``
 
 .. _bcdllstorageclass:
 
 * *dllstorageclass*: If present, an encoding of the DLL storage class of this variable:
 
   * ``default``: code 0
   * ``dllimport``: code 1
   * ``dllexport``: code 2
 
+* *comdat*: An encoding of the COMDAT of this function
+
+* *can_omit_from_dynsym*: If present and non-zero, indicates that the variable has
+  ``can_omit_from_dynsym``.
+
 .. _FUNCTION:
 
 MODULE_CODE_FUNCTION Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata, personalityfn]``
+``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata, personalityfn, can_omit_from_dynsym]``
 
 The ``FUNCTION`` record (code 8) marks the declaration or definition of a
 function. The operand fields are:
 
 * *type*: The type index of the function type describing this function
 
 * *callingconv*: The calling convention number:
   * ``ccc``: code 0

 * *comdat*: An encoding of the COMDAT of this function
 
 * *prefixdata*: If non-zero, the value index of the prefix data for this function,
   plus 1.
 
 * *personalityfn*: If non-zero, the value index of the personality function for this function,
   plus 1.
 
+* *can_omit_from_dynsym*: If present and non-zero, indicates that the function has
+  ``can_omit_from_dynsym``.
+
 MODULE_CODE_ALIAS Record
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[ALIAS, alias type, aliasee val#, linkage, visibility, dllstorageclass]``
+``[ALIAS, alias type, aliasee val#, linkage, visibility, dllstorageclass, threadlocal, unnamed_addr]``
 
 The ``ALIAS`` record (code 9) marks the definition of an alias. The operand
 fields are
 
 * *alias type*: The type index of the alias
 
 * *aliasee val#*: The value index of the aliased value
 
 * *linkage*: An encoding of the `linkage type`_ for this alias
 
 * *visibility*: If present, an encoding of the `visibility`_ of the alias
 
 * *dllstorageclass*: If present, an encoding of the
   :ref:`dllstorageclass<bcdllstorageclass>` of the alias
 
+* *threadlocal*: If present, an encoding of the
+  :ref:`thread local property<bcthreadlocal>` of the alias
+
+* *unnamed_addr*: If present and non-zero, indicates that the alias has
+  ``unnamed_addr``
+
+* *can_omit_from_dynsym*: If present and non-zero, indicates that the alias has
+  ``can_omit_from_dynsym``.
+
 MODULE_CODE_PURGEVALS Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``[PURGEVALS, numvals]``
 
 The ``PURGEVALS`` record (code 10) resets the module-level value list to the
 size given by the single operand value. Module-level value list items are added
 by ``GLOBALVAR``, ``FUNCTION``, and ``ALIAS`` records.  After a ``PURGEVALS``

docs/LangRef.rst

 
 Global variables can be marked with ``unnamed_addr`` which indicates
 that the address is not significant, only the content. Constants marked
 like this can be merged with other constants if they have the same
 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 ``can_omit_from_dynsym`` attribute is given and all modules in the
+linkage unit have this attribute, this value may be omitted from the dynamic
+symbol table. This is set on constant linkonce_odr globals whose addresses
+are insignificant within the module. Because such globals must be defined
+in each linkage unit that uses them, a valid program would not be able to
+observe the absence of the symbol unless its address is significant.
+
 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
 instructions are used to access the variable. The default address space
 is zero. The address space qualifier must precede any other attributes.
 
 LLVM allows an explicit section to be specified for globals. If the
 target supports it, it will emit globals to the section specified.

 or if the alignment is set to zero, the alignment of the function is set
 by the target to whatever it feels convenient. If an explicit alignment
 is specified, the function is forced to have at least that much
 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 ``can_omit_from_dynsym`` attribute is given and all modules in the
+linkage unit have this attribute, this value may be omitted from the dynamic
+symbol table. This is set on constant linkonce_odr globals whose addresses
+are insignificant within the module. Because such globals must be defined
+in each linkage unit that uses them, a valid program would not be able to
+observe the absence of the symbol unless its address is significant.
+
 Syntax::
 
     define [linkage] [visibility] [DLLStorageClass]
            [cconv] [ret attrs]
            <ResultType> @<FunctionName> ([argument list])
            [unnamed_addr] [fn Attrs] [section "name"] [comdat [($name)]]
            [align N] [gc] [prefix Constant] [prologue Constant]
            [personality Constant] (!name !N)* { ... }

include/llvm/CodeGen/Analysis.h

 /// Test if given that the input instruction is in the tail call position if the
 /// return type or any attributes of the function will inhibit tail call
 /// optimization.
 bool returnTypeIsEligibleForTailCall(const Function *F,
                                      const Instruction *I,
                                      const ReturnInst *Ret,
                                      const TargetLoweringBase &TLI);
 
-// True if GV can be left out of the object symbol table. This is the case
-// for linkonce_odr values whose address is not significant. While legal, it is
-// not normally profitable to omit them from the .o symbol table. Using this
-// analysis makes sense when the information can be passed down to the linker
-// or we are in LTO.
-bool canBeOmittedFromSymbolTable(const GlobalValue *GV);
-
 DenseMap<const MachineBasicBlock *, int>
 getFuncletMembership(const MachineFunction &MF);
 
 } // End llvm namespace
 
 #endif

include/llvm/IR/GlobalValue.h

enum DLLStorageClassTypes {
     DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
   };
 
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               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) {
+        UnnamedAddr(0), CanOmitFromDynSym(0),
+        DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
+        IntID((Intrinsic::ID)0U), Parent(nullptr) {
     setName(Name);
   }
 
   Type *ValueType;
   // All bitfields use unsigned as the underlying type so that MSVC will pack
   // 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 CanOmitFromDynSym : 1; // This value can be omitted from the dynamic
+                                  // symbol table
   unsigned DllStorageClass : 2; // DLL storage class
 
   unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
                             // the desired model?
   static const unsigned GlobalValueSubClassDataBits = 19;
 
 private:
   // Give subclasses access to what otherwise would be wasted padding.
-  // (19 + 3 + 2 + 1 + 2 + 5) == 32.
+  // (19 + 4 + 2 + 1 + 1 + 2 + 3) == 32.
   unsigned SubClassData : GlobalValueSubClassDataBits;
 
   friend class Constant;
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
   /// Returns true if the definition of this global may be replaced by a
   /// differently optimized variant of the same source level function at link
~GlobalValue() override {
     removeDeadConstantUsers();   // remove any dead constants using this.
   }
 
   unsigned getAlignment() const;
 
   bool hasUnnamedAddr() const { return UnnamedAddr; }
   void setUnnamedAddr(bool Val) { UnnamedAddr = Val; }
 
+  /// If this attribute is true and all modules in the linkage unit have this
+  /// attribute, this value may be omitted from the dynamic symbol table. This
+  /// is set on linkonce_odr globals whose addresses are insignificant within
+  /// the module. Because linkonce_odr globals must be defined in each linkage
+  /// unit that uses them, a valid program would not be able to observe the
+  /// absence of the symbol unless its address is significant.
+  ///
+  /// This attribute is intended to be used only by the code generator and LTO.
+  /// It should probably not be used by optimizer passes, as the value's address
+  /// may be used by other modules. Optimizers should use hasUnnamedAddr()
+  /// instead.
+  bool canOmitFromDynSym() const { return CanOmitFromDynSym; }
+  void setCanOmitFromDynSym(bool Val) { CanOmitFromDynSym = Val; }
+
   bool hasComdat() const { return getComdat() != nullptr; }
   Comdat *getComdat();
   const Comdat *getComdat() const {
     return const_cast<GlobalValue *>(this)->getComdat();
   }
 
   VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(appending);
   KEYWORD(dllimport);
   KEYWORD(dllexport);
   KEYWORD(common);
   KEYWORD(default);
   KEYWORD(hidden);
   KEYWORD(protected);
   KEYWORD(unnamed_addr);
+  KEYWORD(can_omit_from_dynsym);
   KEYWORD(externally_initialized);
   KEYWORD(extern_weak);
   KEYWORD(external);
   KEYWORD(thread_local);
   KEYWORD(localdynamic);
   KEYWORD(initialexec);
   KEYWORD(localexec);
   KEYWORD(zeroinitializer);

lib/AsmParser/LLParser.h

private:
 
     bool ParseStringAttribute(AttrBuilder &B);
 
     bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
     bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
     bool parseOptionalUnnamedAddr(bool &UnnamedAddr) {
       return ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr);
     }
+    bool parseOptionalCanOmitFromDynSym(bool &CanOmitFromDynSym) {
+      return ParseOptionalToken(lltok::kw_can_omit_from_dynsym,
+                                CanOmitFromDynSym);
+    }
     bool ParseOptionalAddrSpace(unsigned &AddrSpace);
     bool ParseOptionalParamAttrs(AttrBuilder &B);
     bool ParseOptionalReturnAttrs(AttrBuilder &B);
     bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage,
                               unsigned &Visibility, unsigned &DLLStorageClass);
     void ParseOptionalVisibility(unsigned &Visibility);
     void ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
     bool ParseOptionalCallingConv(unsigned &CC);
private:
     bool ParseDefine();
 
     bool ParseGlobalType(bool &IsConstant);
     bool ParseUnnamedGlobal();
     bool ParseNamedGlobal();
     bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage,
                      bool HasLinkage, unsigned Visibility,
                      unsigned DLLStorageClass,
-                     GlobalVariable::ThreadLocalMode TLM, bool UnnamedAddr);
+                     GlobalVariable::ThreadLocalMode TLM,
+                     bool UnnamedAddr, bool CanOmitFromDynSym);
     bool parseIndirectSymbol(const std::string &Name, LocTy Loc,
                              unsigned Linkage, unsigned Visibility,
                              unsigned DLLStorageClass,
                              GlobalVariable::ThreadLocalMode TLM,
-                             bool UnnamedAddr);
+                             bool UnnamedAddr, bool CanOmitFromDynSym);
     bool parseComdat();
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
     bool ParseMDNodeID(MDNode *&Result);
     bool ParseUnnamedAttrGrp();
     bool ParseFnAttributeValuePairs(AttrBuilder &B,
                                     std::vector<unsigned> &FwdRefAttrGrps,

lib/AsmParser/LLParser.cpp

if (Lex.getKind() == lltok::GlobalID) {
 
     if (ParseToken(lltok::equal, "expected '=' after name"))
       return true;
   }
 
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
   GlobalVariable::ThreadLocalMode TLM;
-  bool UnnamedAddr;
+  bool UnnamedAddr, CanOmitFromDynSym;
   if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
-      ParseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
+      ParseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr) ||
+      parseOptionalCanOmitFromDynSym(CanOmitFromDynSym))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
-                       DLLStorageClass, TLM, UnnamedAddr);
+                       DLLStorageClass, TLM, UnnamedAddr, CanOmitFromDynSym);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
-                             DLLStorageClass, TLM, UnnamedAddr);
+                             DLLStorageClass, TLM, UnnamedAddr, CanOmitFromDynSym);
 }
 
 /// ParseNamedGlobal:
 ///   GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
 ///   GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseNamedGlobal() {
   assert(Lex.getKind() == lltok::GlobalVar);
   LocTy NameLoc = Lex.getLoc();
   std::string Name = Lex.getStrVal();
   Lex.Lex();
 
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
   GlobalVariable::ThreadLocalMode TLM;
-  bool UnnamedAddr;
+  bool UnnamedAddr, CanOmitFromDynSym;
   if (ParseToken(lltok::equal, "expected '=' in global variable") ||
       ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
-      ParseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
+      ParseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr) ||
+      parseOptionalCanOmitFromDynSym(CanOmitFromDynSym))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
-                       DLLStorageClass, TLM, UnnamedAddr);
+                       DLLStorageClass, TLM, UnnamedAddr, CanOmitFromDynSym);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
-                             DLLStorageClass, TLM, UnnamedAddr);
+                             DLLStorageClass, TLM, UnnamedAddr,
+                             CanOmitFromDynSym);
 }
 
 bool LLParser::parseComdat() {
   assert(Lex.getKind() == lltok::ComdatVar);
   std::string Name = Lex.getStrVal();
   LocTy NameLoc = Lex.getLoc();
   Lex.Lex();
 

 ///                     OptionalDLLStorageClass OptionalThreadLocal
 ///                     OptionalUnnamedAddr 'alias|ifunc' IndirectSymbol
 ///
 /// IndirectSymbol
 ///   ::= TypeAndValue
 ///
 /// 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,
+    bool UnnamedAddr, bool CanOmitFromDynSym) {
   bool IsAlias;
   if (Lex.getKind() == lltok::kw_alias)
     IsAlias = true;
   else if (Lex.getKind() == lltok::kw_ifunc)
     IsAlias = false;
   else
     llvm_unreachable("Not an alias or ifunc!");
   Lex.Lex();
bool LLParser::parseIndirectSymbol(
   else
     GA.reset(GlobalIFunc::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
   GA->setThreadLocalMode(TLM);
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GA->setUnnamedAddr(UnnamedAddr);
+  GA->setCanOmitFromDynSym(CanOmitFromDynSym);
 
   if (Name.empty())
     NumberedVals.push_back(GA.get());
 
   if (GVal) {
     // Verify that types agree.
     if (GVal->getType() != GA->getType())
       return Error(

 ///
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.
 ///
 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
                            unsigned Linkage, bool HasLinkage,
                            unsigned Visibility, unsigned DLLStorageClass,
                            GlobalVariable::ThreadLocalMode TLM,
-                           bool UnnamedAddr) {
+                           bool UnnamedAddr, bool CanOmitFromDynSym) {
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
   unsigned AddrSpace;
   bool IsConstant, IsExternallyInitialized;
   LocTy IsExternallyInitializedLoc;
   LocTy TyLoc;
if (Init)
     GV->setInitializer(Init);
   GV->setConstant(IsConstant);
   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GV->setExternallyInitialized(IsExternallyInitialized);
   GV->setThreadLocalMode(TLM);
   GV->setUnnamedAddr(UnnamedAddr);
+  GV->setCanOmitFromDynSym(CanOmitFromDynSym);
 
   // Parse attributes on the global.
   while (Lex.getKind() == lltok::comma) {
     Lex.Lex();
 
     if (Lex.getKind() == lltok::kw_section) {
       Lex.Lex();
       GV->setSection(Lex.getStrVal());
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   SmallVector<ArgInfo, 8> ArgList;
   bool isVarArg;
   AttrBuilder FuncAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
   LocTy BuiltinLoc;
   std::string Section;
   unsigned Alignment;
   std::string GC;
-  bool UnnamedAddr;
+  bool UnnamedAddr = false;
+  bool CanOmitFromDynSym = false;
   LocTy UnnamedAddrLoc;
   Constant *Prefix = nullptr;
   Constant *Prologue = nullptr;
   Constant *PersonalityFn = nullptr;
   Comdat *C;
 
   if (ParseArgumentList(ArgList, isVarArg) ||
-      ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
-                         &UnnamedAddrLoc) ||
+      parseOptionalUnnamedAddr(UnnamedAddr) ||
+      parseOptionalCanOmitFromDynSym(CanOmitFromDynSym) ||
       ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
                                  BuiltinLoc) ||
       (EatIfPresent(lltok::kw_section) &&
        ParseStringConstant(Section)) ||
       parseOptionalComdat(FunctionName, C) ||
       ParseOptionalAlignment(Alignment) ||
       (EatIfPresent(lltok::kw_gc) &&
        ParseStringConstant(GC)) ||
if (FunctionName.empty())
     NumberedVals.push_back(Fn);
 
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
+  Fn->setCanOmitFromDynSym(CanOmitFromDynSym);
   Fn->setAlignment(Alignment);
   Fn->setSection(Section);
   Fn->setComdat(C);
   Fn->setPersonalityFn(PersonalityFn);
   if (!GC.empty()) Fn->setGC(GC.c_str());
   Fn->setPrefixData(Prefix);
   Fn->setPrologueData(Prologue);
   ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;

lib/AsmParser/LLToken.h

enum Kind {
   kw_dllimport,
   kw_dllexport,
   kw_common,
   kw_available_externally,
   kw_default,
   kw_hidden,
   kw_protected,
   kw_unnamed_addr,
+  kw_can_omit_from_dynsym,
   kw_externally_initialized,
   kw_extern_weak,
   kw_external,
   kw_thread_local,
   kw_localdynamic,
   kw_initialexec,
   kw_localexec,
   kw_zeroinitializer,

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name]
       Comdat *C = TheModule->getOrInsertComdat(ComdatName);
       C->setSelectionKind(SK);
       ComdatList.push_back(C);
       break;
     }
     // GLOBALVAR: [pointer type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat]
+    //             comdat, can_omit_from_dynsym]
     case bitc::MODULE_CODE_GLOBALVAR: {
       if (Record.size() < 6)
         return error("Invalid record");
       Type *Ty = getTypeByID(Record[0]);
       if (!Ty)
         return error("Invalid record");
       bool isConstant = Record[1] & 1;
       bool explicitType = Record[1] & 2;
case bitc::MODULE_CODE_GLOBALVAR: {
         if (unsigned ComdatID = Record[11]) {
           if (ComdatID > ComdatList.size())
             return error("Invalid global variable comdat ID");
           NewGV->setComdat(ComdatList[ComdatID - 1]);
         }
       } else if (hasImplicitComdat(RawLinkage)) {
         NewGV->setComdat(reinterpret_cast<Comdat *>(1));
       }
+
+      if (Record.size() > 12)
+        NewGV->setCanOmitFromDynSym(Record[12]);
+
       break;
     }
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,
     //             alignment, section, visibility, gc, unnamed_addr,
-    //             prologuedata, dllstorageclass, comdat, prefixdata]
+    //             prologuedata, dllstorageclass, comdat, prefixdata,
+    //             personality, can_omit_from_dynsym]
     case bitc::MODULE_CODE_FUNCTION: {
       if (Record.size() < 8)
         return error("Invalid record");
       Type *Ty = getTypeByID(Record[0]);
       if (!Ty)
         return error("Invalid record");
       if (auto *PTy = dyn_cast<PointerType>(Ty))
         Ty = PTy->getElementType();
case bitc::MODULE_CODE_FUNCTION: {
       }
 
       if (Record.size() > 13 && Record[13] != 0)
         FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1));
 
       if (Record.size() > 14 && Record[14] != 0)
         FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));
 
+      if (Record.size() > 15)
+        Func->setCanOmitFromDynSym(Record[15]);
+
       ValueList.push_back(Func);
 
       // If this is a function with a body, remember the prototype we are
       // creating now, so that we can match up the body with them later.
       if (!isProto) {
         Func->setIsMaterializable(true);
         FunctionsWithBodies.push_back(Func);
         DeferredFunctionInfo[Func] = 0;
       }
       break;
     }
     // ALIAS: [alias type, addrspace, aliasee val#, linkage]
-    // ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility, dllstorageclass]
-    // IFUNC: [alias type, addrspace, aliasee val#, linkage, visibility, dllstorageclass]
+    // ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility, dllstorageclass,
+    //         threadlocal, unnamed_addr, can_omit_from_dynsym]
+    // IFUNC: [alias type, addrspace, aliasee val#, linkage, visibility, dllstorageclass,
+    //         threadlocal, unnamed_addr, can_omit_from_dynsym]
     case bitc::MODULE_CODE_IFUNC:
     case bitc::MODULE_CODE_ALIAS:
     case bitc::MODULE_CODE_ALIAS_OLD: {
       bool NewRecord = BitCode != bitc::MODULE_CODE_ALIAS_OLD;
       if (Record.size() < (3 + (unsigned)NewRecord))
         return error("Invalid record");
       unsigned OpNum = 0;
       Type *Ty = getTypeByID(Record[OpNum++]);
case bitc::MODULE_CODE_ALIAS_OLD: {
       if (OpNum != Record.size())
         NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
       else
         upgradeDLLImportExportLinkage(NewGA, Linkage);
       if (OpNum != Record.size())
         NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
       if (OpNum != Record.size())
         NewGA->setUnnamedAddr(Record[OpNum++]);
+      if (OpNum != Record.size())
+        NewGA->setCanOmitFromDynSym(Record[OpNum++]);
       ValueList.push_back(NewGA);
       IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
       break;
     }
     /// MODULE_CODE_PURGEVALS: [numvals]
     case bitc::MODULE_CODE_PURGEVALS:
       // Trim down the value list to the specified size.
       if (Record.size() < 1 || Record[0] > ValueList.size())

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeModuleInfo() {
   // Emit the global variable information.
   SmallVector<unsigned, 64> Vals;
   for (const GlobalVariable &GV : M.globals()) {
     unsigned AbbrevToUse = 0;
 
     // GLOBALVAR: [type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat]
+    //             comdat, can_omit_from_dynsym]
     Vals.push_back(VE.getTypeID(GV.getValueType()));
     Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
     Vals.push_back(GV.isDeclaration() ? 0 :
                    (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(Log2_32(GV.getAlignment())+1);
     Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.hasUnnamedAddr() || GV.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
-        GV.hasComdat()) {
+        GV.hasComdat() || GV.canOmitFromDynSym()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(GV.hasUnnamedAddr());
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
+      Vals.push_back(GV.canOmitFromDynSym());
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the function proto information.
   for (const Function &F : M) {
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattrs, alignment,
     //             section, visibility, gc, unnamed_addr, prologuedata,
-    //             dllstorageclass, comdat, prefixdata, personalityfn]
+    //             dllstorageclass, comdat, prefixdata, personalityfn,
+    //             can_omit_from_dynsym]
     Vals.push_back(VE.getTypeID(F.getFunctionType()));
     Vals.push_back(F.getCallingConv());
     Vals.push_back(F.isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
     Vals.push_back(VE.getAttributeID(F.getAttributes()));
     Vals.push_back(Log2_32(F.getAlignment())+1);
     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(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
                                        : 0);
     Vals.push_back(getEncodedDLLStorageClass(F));
     Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
     Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                      : 0);
     Vals.push_back(
         F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
+    Vals.push_back(F.canOmitFromDynSym());
 
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // 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, can_omit_from_dynsym]
     Vals.push_back(VE.getTypeID(A.getValueType()));
     Vals.push_back(A.getType()->getAddressSpace());
     Vals.push_back(VE.getValueID(A.getAliasee()));
     Vals.push_back(getEncodedLinkage(A));
     Vals.push_back(getEncodedVisibility(A));
     Vals.push_back(getEncodedDLLStorageClass(A));
     Vals.push_back(getEncodedThreadLocalMode(A));
     Vals.push_back(A.hasUnnamedAddr());
+    Vals.push_back(A.canOmitFromDynSym());
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the ifunc information.
   for (const GlobalIFunc &I : M.ifuncs()) {
     // IFUNC: [ifunc type, address space, resolver val#, linkage, visibility]

lib/CodeGen/Analysis.cpp

if (!slotOnlyDiscardsData(RetVal, CallVal, TmpRetPath, TmpCallPath,
       return false;
 
     CallEmpty  = !nextRealType(CallSubTypes, CallPath);
   } while(nextRealType(RetSubTypes, RetPath));
 
   return true;
 }
 
-bool llvm::canBeOmittedFromSymbolTable(const GlobalValue *GV) {
-  if (!GV->hasLinkOnceODRLinkage())
-    return false;
-
-  if (GV->hasUnnamedAddr())
-    return true;
-
-  // If it is a non constant variable, it needs to be uniqued across shared
-  // objects.
-  if (const GlobalVariable *Var = dyn_cast<GlobalVariable>(GV)) {
-    if (!Var->isConstant())
-      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<GlobalAlias>(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;
-}
-
 static void collectFuncletMembers(
     DenseMap<const MachineBasicBlock *, int> &FuncletMembership, int Funclet,
     const MachineBasicBlock *MBB) {
   SmallVector<const MachineBasicBlock *, 16> Worklist = {MBB};
   while (!Worklist.empty()) {
     const MachineBasicBlock *Visiting = Worklist.pop_back_val();
     // Don't follow blocks which start new funclets.
     if (Visiting->isEHPad() && Visiting != MBB)

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (ES)
     Handlers.push_back(HandlerInfo(ES, EHTimerName, DWARFGroupName));
   return false;
 }
 
 static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) {
   if (!MAI.hasWeakDefCanBeHiddenDirective())
     return false;
 
-  return canBeOmittedFromSymbolTable(GV);
+  return GV->canOmitFromDynSym();
 }
 
 void AsmPrinter::EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const {
   GlobalValue::LinkageTypes Linkage = GV->getLinkage();
   switch (Linkage) {
   case GlobalValue::CommonLinkage:
   case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::LinkOnceODRLinkage:

lib/IR/AsmWriter.cpp

if (!GV->hasInitializer() && GV->hasExternalLinkage())
     Out << "external ";
 
   Out << getLinkagePrintName(GV->getLinkage());
   PrintVisibility(GV->getVisibility(), Out);
   PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
   if (GV->hasUnnamedAddr())
     Out << "unnamed_addr ";
+  if (GV->canOmitFromDynSym())
+    Out << "can_omit_from_dynsym ";
 
   if (unsigned AddressSpace = GV->getType()->getAddressSpace())
     Out << "addrspace(" << AddressSpace << ") ";
   if (GV->isExternallyInitialized()) Out << "externally_initialized ";
   Out << (GV->isConstant() ? "constant " : "global ");
   TypePrinter.print(GV->getValueType(), Out);
 
   if (GV->hasInitializer()) {
void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
   Out << " = ";
 
   Out << getLinkagePrintName(GIS->getLinkage());
   PrintVisibility(GIS->getVisibility(), Out);
   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
   if (GIS->hasUnnamedAddr())
     Out << "unnamed_addr ";
+  if (GIS->canOmitFromDynSym())
+    Out << "can_omit_from_dynsym ";
 
   if (isa<GlobalAlias>(GIS))
     Out << "alias ";
   else if (isa<GlobalIFunc>(GIS))
     Out << "ifunc ";
   else
     llvm_unreachable("Not an alias or ifunc!");
 
void AssemblyWriter::printFunction(const Function *F) {
   // Finish printing arguments...
   if (FT->isVarArg()) {
     if (FT->getNumParams()) Out << ", ";
     Out << "...";  // Output varargs portion of signature!
   }
   Out << ')';
   if (F->hasUnnamedAddr())
     Out << " unnamed_addr";
+  if (F->canOmitFromDynSym())
+    Out << " can_omit_from_dynsym";
   if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
     Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
   if (F->hasSection()) {
     Out << " section \"";
     PrintEscapedString(F->getSection(), Out);
     Out << '"';
   }
   maybePrintComdat(Out, *F);

lib/IR/Globals.cpp

Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
   llvm_unreachable("Unsupported class for handleOperandChange()!");
 }
 
 /// copyAttributesFrom - copy all additional attributes (those not needed to
 /// create a GlobalValue) from the GlobalValue Src to this one.
 void GlobalValue::copyAttributesFrom(const GlobalValue *Src) {
   setVisibility(Src->getVisibility());
   setUnnamedAddr(Src->hasUnnamedAddr());
+  setCanOmitFromDynSym(Src->canOmitFromDynSym());
   setDLLStorageClass(Src->getDLLStorageClass());
 }
 
 unsigned GlobalValue::getAlignment() const {
   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     // In general we cannot compute this at the IR level, but we try.
     if (const GlobalObject *GO = GA->getBaseObject())
       return GO->getAlignment();

lib/LTO/LTOModule.cpp

void LTOModule::addDefinedSymbol(const char *Name, const GlobalValue *def,
   // set scope part
   if (def->hasLocalLinkage())
     // Ignore visibility if linkage is local.
     attr |= LTO_SYMBOL_SCOPE_INTERNAL;
   else if (def->hasHiddenVisibility())
     attr |= LTO_SYMBOL_SCOPE_HIDDEN;
   else if (def->hasProtectedVisibility())
     attr |= LTO_SYMBOL_SCOPE_PROTECTED;
-  else if (canBeOmittedFromSymbolTable(def))
+  else if (def->canOmitFromDynSym())
     attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN;
   else
     attr |= LTO_SYMBOL_SCOPE_DEFAULT;
 
   if (def->hasComdat())
     attr |= LTO_SYMBOL_COMDAT;
 
   if (isa<GlobalAlias>(def))

lib/Linker/LinkModules.cpp

if (DGV && !GV.hasLocalLinkage() && !GV.hasAppendingLinkage()) {
     GlobalValue::VisibilityTypes Visibility =
         getMinVisibility(DGV->getVisibility(), GV.getVisibility());
     DGV->setVisibility(Visibility);
     GV.setVisibility(Visibility);
 
     bool HasUnnamedAddr = GV.hasUnnamedAddr() && DGV->hasUnnamedAddr();
     DGV->setUnnamedAddr(HasUnnamedAddr);
     GV.setUnnamedAddr(HasUnnamedAddr);
+
+    bool CanOmitFromDynSym = GV.canOmitFromDynSym() && DGV->canOmitFromDynSym();
+    DGV->setCanOmitFromDynSym(CanOmitFromDynSym);
+    GV.setCanOmitFromDynSym(CanOmitFromDynSym);
   }
 
   // Don't want to append to global_ctors list, for example, when we
   // are importing for ThinLTO, otherwise the global ctors and dtors
   // get executed multiple times for local variables (the latter causing
   // double frees).
   if (GV.hasAppendingLinkage() && isPerformingImport())
     return false;

lib/Transforms/IPO/GlobalOpt.cpp

if (Constant *SOVConstant = dyn_cast<Constant>(GS.StoredOnceValue)) {
         }
       }
     }
   }
 
   return false;
 }
 
+// Returns true if the GlobalValue could be omitted from the dynamic symbol
+// table if its address is not taken.
+static bool isCandidateForOmissionFromDynSym(GlobalValue &GV) {
+  if (!GV.hasLinkOnceODRLinkage())
+    return false;
+
+  if (auto *GVar = dyn_cast<GlobalVariable>(&GV))
+    return GVar->isConstant();
+
+  return isa<Function>(GV);
+}
+
 /// Analyze the specified global variable and optimize it if possible.  If we
 /// make a change, return true.
 static bool
 processGlobal(GlobalValue &GV, TargetLibraryInfo *TLI,
               function_ref<DominatorTree &(Function &)> LookupDomTree) {
-  // Do more involved optimizations if the global is internal.
-  if (!GV.hasLocalLinkage())
+  // Do more involved optimizations if the global is internal or could
+  // potentially be omitted from the dynamic symbol table.
+  if (!GV.hasLocalLinkage() && !isCandidateForOmissionFromDynSym(GV))
+    return false;
+
+  if (!GV.hasLocalLinkage()) {
+    // For omission candidates, unnamed_addr implies can_omit_from_dynsym.
+    if (GV.hasUnnamedAddr() && !GV.canOmitFromDynSym()) {
+      GV.setCanOmitFromDynSym(true);
+      return true;
+    }
+
+    // If we already know we can omit, there's nothing else to do.
+    if (GV.canOmitFromDynSym())
       return false;
+  }
 
   GlobalStatus GS;
 
   if (GlobalStatus::analyzeGlobal(&GV, GS))
     return false;
 
   bool Changed = false;
-  if (!GS.IsCompared && !GV.hasUnnamedAddr()) {
+  if (!GS.IsCompared) {
+    if (GV.hasLocalLinkage()) {
+      if (!GV.hasUnnamedAddr()) {
         GV.setUnnamedAddr(true);
         NumUnnamed++;
         Changed = true;
       }
+    } else if (!GV.canOmitFromDynSym()) {
+      GV.setCanOmitFromDynSym(true);
+      Changed = true;
+    }
+  }
+
+  if (!GV.hasLocalLinkage())
+    return Changed;
 
   auto *GVar = dyn_cast<GlobalVariable>(&GV);
   if (!GVar)
     return Changed;
 
   if (GVar->isConstant() || !GVar->hasInitializer())
     return Changed;
 

test/Assembler/can-omit-from-dynsym.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+; RUN: verify-uselistorder %s
+
+; CHECK: @c = can_omit_from_dynsym constant i32 0
+@c = can_omit_from_dynsym constant i32 0
+
+; CHECK: @a = can_omit_from_dynsym alias i32, i32* @c
+@a = can_omit_from_dynsym alias i32, i32* @c
+
+; CHECK: define void @f() can_omit_from_dynsym {
+define void @f() can_omit_from_dynsym {
+  ret void
+}

test/CodeGen/PowerPC/weak_def_can_be_hidden.ll

 ; taken from X86 version of the same test
 ; RUN: llc -mtriple=powerpc-apple-darwin10 -O0 < %s | FileCheck %s
 ; 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
+define linkonce_odr void @f1() can_omit_from_dynsym {
+  %x = load i32, i32 * @v1
+  %y = load i32, i32 * @v2
+  call void @f2()
+  ret void
+}
+; CHECK: .globl  _f1
+; CHECK: .weak_def_can_be_hidden _f1
+
+; CHECK-D89: .globl  _f1
+; CHECK-D89: .weak_definition _f1
+
+define linkonce_odr void @f2() {
+  %x = load i32, i32 * @v1
+  %y = load i32, i32 * @v2
+  call void @f1()
+  ret void
+}
+; CHECK: .globl  _f2
+; CHECK: .weak_definition _f2
+
+; CHECK-D89: .globl  _f2
+; CHECK-D89: .weak_definition _f2
+
+@v1 = linkonce_odr can_omit_from_dynsym constant i32 32
 ; CHECK: .globl  _v1
 ; CHECK: .weak_def_can_be_hidden _v1
 
 ; CHECK-D89: .globl  _v1
 ; CHECK-D89: .weak_definition _v1
 
-define i32 @f1() {
-  %x = load i32 , i32 * @v1
-  ret i32 %x
-}
-
 @v2 = linkonce_odr constant i32 32
 ; CHECK: .globl  _v2
 ; CHECK: .weak_definition _v2
 
 ; CHECK-D89: .globl  _v2
 ; CHECK-D89: .weak_definition _v2
-
-define i32* @f2() {
-  ret i32* @v2
-}
-
-@v3 = linkonce_odr unnamed_addr global i32 32
-; CHECK: .globl  _v3
-; CHECK: .weak_def_can_be_hidden _v3
-
-; CHECK-D89: .globl  _v3
-; CHECK-D89: .weak_definition _v3
-
-define i32* @f3() {
-  ret i32* @v3
-}
-
-@v4 = linkonce_odr global i32 32
-; CHECK: .globl  _v4
-; CHECK: .weak_definition _v4
-
-; CHECK-D89: .globl  _v4
-; CHECK-D89: .weak_definition _v4
-
-define i32 @f4() {
-  %x = load i32 , i32 * @v4
-  ret i32 %x
-}

test/CodeGen/X86/weak_def_can_be_hidden.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin11 -O0 < %s | FileCheck %s
 ; RUN: llc -mtriple=x86_64-apple-darwin10 -O0 < %s | FileCheck %s
 ; RUN: llc -mtriple=x86_64-apple-darwin9 -O0 < %s | FileCheck --check-prefix=CHECK-D89 %s
 ; 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
+define linkonce_odr void @f1() can_omit_from_dynsym {
+  %x = load i32, i32 * @v1
+  %y = load i32, i32 * @v2
+  call void @f2()
+  ret void
+}
+; CHECK: .globl  _f1
+; CHECK: .weak_def_can_be_hidden _f1
+
+; CHECK-D89: .globl  _f1
+; CHECK-D89: .weak_definition _f1
+
+define linkonce_odr void @f2() {
+  %x = load i32, i32 * @v1
+  %y = load i32, i32 * @v2
+  call void @f1()
+  ret void
+}
+; CHECK: .globl  _f2
+; CHECK: .weak_definition _f2
+
+; CHECK-D89: .globl  _f2
+; CHECK-D89: .weak_definition _f2
+
+@v1 = linkonce_odr can_omit_from_dynsym constant i32 32
 ; CHECK: .globl  _v1
 ; CHECK: .weak_def_can_be_hidden _v1
 
 ; CHECK-D89: .globl  _v1
 ; CHECK-D89: .weak_definition _v1
 
-define i32 @f1() {
-  %x = load i32 , i32 * @v1
-  ret i32 %x
-}
-
 @v2 = linkonce_odr constant i32 32
 ; CHECK: .globl  _v2
 ; CHECK: .weak_definition _v2
 
 ; CHECK-D89: .globl  _v2
 ; CHECK-D89: .weak_definition _v2
 
-define i32* @f2() {
-  ret i32* @v2
-}
-
-@v3 = linkonce_odr unnamed_addr global i32 32
-; CHECK: .globl  _v3
-; CHECK: .weak_def_can_be_hidden _v3
-
-; CHECK-D89: .globl  _v3
-; CHECK-D89: .weak_definition _v3
-
-define i32* @f3() {
-  ret i32* @v3
-}
-
-@v4 = linkonce_odr global i32 32
-; CHECK: .globl  _v4
-; CHECK: .weak_definition _v4
-
-; CHECK-D89: .globl  _v4
-; CHECK-D89: .weak_definition _v4
-
-define i32 @f4() {
-  %x = load i32 , i32 * @v4
-  ret i32 %x
-}

test/Feature/OperandBundles/pr26510.ll

 ; RUN: opt -S -globals-aa -functionattrs < %s | FileCheck %s
 ; RUN: opt -S -O3 < %s | FileCheck %s
 
 ; Apart from checking for the direct cause of the bug, we also check
 ; if any problematic aliasing rules have accidentally snuck into -O3.
 ;
 ; Since the "abc" operand bundle is not a special operand bundle that
 ; LLVM knows about, all of the stores and loads in @test below have to
 ; stay.
 
 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) ]
 ; CHECK:   %reload = load i8*, i8** %a, align 8
 ; CHECK:   ret i8* %reload
 ; CHECK: }
 
 define i8* @test(i8* %p) {
   %a = alloca i8*, align 8
   store i8* %p, i8** %a, align 8
   call void @foo() ["abc" (i8** %a)]
   %reload = load i8*, i8** %a, align 8
   ret i8* %reload
 }

test/LTO/X86/cfi_endproc.ll

 ; RUN: llvm-lto -o %t -dso-symbol=zed1 -dso-symbol=zed2 %t1 -O0
 ; RUN: llvm-nm %t | FileCheck %s -check-prefix=ZED1_AND_ZED2
 ; ZED1_AND_ZED2: V zed1
 @zed1 = linkonce_odr global i32 42
 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 can_omit_from_dynsym constant i32 42
 
 define i32 @useZed2() {
   %x = load i32, i32* @zed2
   ret i32 %x
 }

test/LTO/X86/linkonce_odr_func.ll

 ; 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: llvm-lto -o %t2 -dso-symbol=foo1 -dso-symbol=foo2 \
+; RUN:     -dso-symbol=v1 -dso-symbol=v2 %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() can_omit_from_dynsym noinline {
   ret void
 }
 
-; CHECK: t foo3
-define linkonce_odr void @foo3() 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 can_omit_from_dynsym constant i32 32
 
-; CHECK: V v2
-@v2 = linkonce_odr global i32 32
-
-define i32 @useV2() {
-  %x = load i32, i32* @v2
-  ret i32 %x
-}
-
-declare void @f(void()*)
-
-declare void @p()
-
-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()
+  %x1 = load i32, i32* @v1
+  %x2 = load i32, i32* @v2
   ret void
 }

test/Transforms/GlobalOpt/pr21191.ll

 ; RUN: opt < %s -globalopt -S | FileCheck %s
 
 $c = comdat any
 ; CHECK: $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() can_omit_from_dynsym 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() can_omit_from_dynsym comdat($c)
 
 define void @zed()  {
   call void @foo()
   ret void
 }

test/Transforms/GlobalOpt/unnamed-addr.ll

 ; RUN: opt -globalopt -S < %s | FileCheck %s
 
 @a = internal global i32 0, align 4
 @b = internal global i32 0, align 4
 @c = internal global i32 0, align 4
 @d = internal constant [4 x i8] c"foo\00", align 1
 @e = linkonce_odr global i32 0
+@f = linkonce_odr unnamed_addr constant i32 0
 
 ; CHECK: @a = internal global i32 0, align 4
 ; 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: @f = linkonce_odr unnamed_addr can_omit_from_dynsym constant i32 0
 
 ; CHECK: define internal fastcc void @used_internal() unnamed_addr {
 define internal void @used_internal() {
   ret void
 }
 
 define i32 @get_e() {
        call void @used_internal()
entry:
   store i32 %x, i32* @c, align 4
   ret void
 }
 
 define i32 @foo(i32* %x) nounwind readnone optsize ssp {
 entry:
   %cmp = icmp eq i32* %x, @a
   %conv = zext i1 %cmp to i32
+  %cmp2 = icmp eq i32* %x, @f
   ret i32 %conv
 }
 
 define i32 @bar() {
 entry:
   switch i64 ptrtoint (i32* @b to i64), label %sw.epilog [
     i64 1, label %return
     i64 0, label %return

test/tools/gold/X86/coff.ll

define void @f() {
   ret void
 }
 
 ; CHECK: define internal void @g() {
 define hidden void @g() {
   ret void
 }
 
-; CHECK: define internal void @h() {
-define linkonce_odr void @h() {
+; CHECK: define internal void @h() can_omit_from_dynsym {
+define linkonce_odr void @h() can_omit_from_dynsym {
   ret void
 }

test/tools/gold/X86/emit-llvm.ll

 ; RUN:     -m elf_x86_64 --plugin-opt=disable-output \
 ; RUN:    -shared %t.o -o %t4.o
 ; RUN: not test -a %t4.o
 
 ; NM: T f3
 
 target triple = "x86_64-unknown-linux-gnu"
 
-@g7 = extern_weak global i32
-; CHECK-DAG: @g7 = extern_weak global i32
+; CHECK-DAG: @g1 = linkonce_odr constant i32 32
+@g1 = linkonce_odr constant i32 32
 
-@g8 = external global i32
+; CHECK-DAG: @g2 = internal can_omit_from_dynsym constant i32 32
+@g2 = linkonce_odr can_omit_from_dynsym constant i32 32
+
+@g6 = extern_weak global i32
+; CHECK-DAG: @g6 = extern_weak global i32
+
+@g7 = external global i32
 
 ; CHECK-DAG: define internal void @f1()
 ; OPT2-NOT: @f1
 define hidden void @f1() {
   ret void
 }
 
 ; CHECK-DAG: define hidden void @f2()
 ; OPT-DAG: define hidden void @f2()
 define hidden void @f2() {
   ret void
 }
 
 @llvm.used = appending global [1 x i8*] [ i8* bitcast (void ()* @f2 to i8*)]
 
 ; CHECK-DAG: define void @f3()
 ; OPT-DAG: define void @f3()
 define void @f3() {
   call void @f4()
   ret void
 }
 
 ; CHECK-DAG: define internal void @f4()
 ; OPT2-NOT: @f4
-define linkonce_odr void @f4() {
+define linkonce_odr void @f4() can_omit_from_dynsym {
   ret void
 }
 
 ; CHECK-DAG: define linkonce_odr void @f5()
 ; OPT-DAG: define linkonce_odr void @f5()
 define linkonce_odr void @f5() {
   ret void
 }
-@g5 = global void()* @f5
+@g8 = 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
+define i32* @f6() {
+  ret i32* @g6
 }
-@g6 = global void()* @f6
 
 define i32* @f7() {
   ret i32* @g7
 }
 
-define i32* @f8() {
-  ret i32* @g8
-}
-
 ; API: f1 PREVAILING_DEF_IRONLY
 ; API: f2 PREVAILING_DEF_IRONLY
 ; API: f3 PREVAILING_DEF_IRONLY_EXP
 ; API: f4 PREVAILING_DEF_IRONLY_EXP
 ; API: f5 PREVAILING_DEF_IRONLY_EXP
 ; API: f6 PREVAILING_DEF_IRONLY_EXP
 ; API: f7 PREVAILING_DEF_IRONLY_EXP
-; API: f8 PREVAILING_DEF_IRONLY_EXP
+; API: g1 PREVAILING_DEF_IRONLY_EXP
+; API: g2 PREVAILING_DEF_IRONLY_EXP
+; API: g6 UNDEF
 ; API: g7 UNDEF
-; API: g8 UNDEF
-; API: g5 PREVAILING_DEF_IRONLY_EXP
-; API: g6 PREVAILING_DEF_IRONLY_EXP
+; API: g8 PREVAILING_DEF_IRONLY_EXP

tools/gold/gold-plugin.cpp

struct PluginInputFile {
   PluginInputFile &operator=(PluginInputFile &&RHS) = default;
 };
 
 struct ResolutionInfo {
   uint64_t CommonSize = 0;
   unsigned CommonAlign = 0;
   bool IsLinkonceOdr = true;
   bool UnnamedAddr = true;
+  bool CanOmitFromDynSym = true;
   GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
   bool CommonInternal = false;
   bool UseCommon = false;
 };
 
 /// Class to own information used by a task or during its cleanup for a
 /// ThinLTO backend instantiation.
 class ThinLTOTaskInfo {
for (auto &Sym : Obj->symbols()) {
 
     const GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
 
     ResolutionInfo &Res = ResInfo[sym.name];
 
     sym.visibility = LDPV_DEFAULT;
     if (GV) {
       Res.UnnamedAddr &= GV->hasUnnamedAddr();
+      Res.CanOmitFromDynSym &= GV->canOmitFromDynSym();
       Res.IsLinkonceOdr &= GV->hasLinkOnceLinkage();
       Res.Visibility = getMinVisibility(Res.Visibility, GV->getVisibility());
       switch (GV->getVisibility()) {
       case GlobalValue::DefaultVisibility:
         break;
       case GlobalValue::HiddenVisibility:
         sym.visibility = LDPV_HIDDEN;
         break;
getModuleSummaryIndexForFile(claimed_file &F, ld_plugin_input_file &Info) {
   object::ModuleSummaryIndexObjectFile &Obj = **ObjOrErr;
 
   return Obj.takeIndex();
 }
 
 static std::unique_ptr<Module>
 getModuleForFile(LLVMContext &Context, claimed_file &F, const void *View,
                  ld_plugin_input_file &Info, raw_fd_ostream *ApiFile,
-                 StringSet<> &Internalize, StringSet<> &Maybe,
-                 std::vector<GlobalValue *> &Keep,
+                 StringSet<> &Internalize, std::vector<GlobalValue *> &Keep,
                  StringMap<unsigned> &Realign) {
   MemoryBufferRef BufferRef(StringRef((const char *)View, Info.filesize),
                             Info.name);
   ErrorOr<std::unique_ptr<object::IRObjectFile>> ObjOrErr =
       object::IRObjectFile::create(BufferRef, Context);
 
   if (std::error_code EC = ObjOrErr.getError())
     message(LDPL_FATAL, "Could not read bitcode from file : %s",
case LDPR_PREVAILING_DEF:
         break;
       case GlobalValue::LinkOnceODRLinkage:
         GV->setLinkage(GlobalValue::WeakODRLinkage);
         break;
       }
       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 (Res.CanOmitFromDynSym)
+        Internalize.insert(GV->getName());
       break;
     }
     }
 
     freeSymName(Sym);
   }
 
   return Obj.takeModule();
void CodeGen::runAll() {
   else
     runSplitCodeGen(OptFilename);
 }
 
 /// Links the module in \p View from file \p F into the combined module
 /// saved in the IRMover \p L. Returns true on error, false on success.
 static bool linkInModule(LLVMContext &Context, IRMover &L, claimed_file &F,
                          const void *View, ld_plugin_input_file &File,
-                         raw_fd_ostream *ApiFile, StringSet<> &Internalize,
-                         StringSet<> &Maybe) {
+                         raw_fd_ostream *ApiFile, StringSet<> &Internalize) {
   std::vector<GlobalValue *> Keep;
   StringMap<unsigned> Realign;
   std::unique_ptr<Module> M = getModuleForFile(
-      Context, F, View, File, ApiFile, Internalize, Maybe, Keep, Realign);
+      Context, F, View, File, ApiFile, Internalize, Keep, Realign);
   if (!M.get())
     return false;
   if (!options::triple.empty())
     M->setTargetTriple(options::triple.c_str());
   else if (M->getTargetTriple().empty()) {
     M->setTargetTriple(DefaultTriple);
   }
 
Context.setDiscardValueNames(options::TheOutputType !=
                                options::OT_SAVE_TEMPS);
   Context.enableDebugTypeODRUniquing(); // Merge debug info types.
   Context.setDiagnosticHandler(diagnosticHandlerForContext, nullptr, true);
 
   std::unique_ptr<llvm::Module> NewModule(new llvm::Module(File.name, Context));
   IRMover L(*NewModule.get());
 
   StringSet<> Dummy;
-  if (linkInModule(Context, L, F, View, File, ApiFile, Dummy, Dummy))
+  if (linkInModule(Context, L, F, View, File, ApiFile, Dummy))
     message(LDPL_FATAL, "Failed to rename module for ThinLTO");
   if (renameModuleForThinLTO(*NewModule, CombinedIndex))
     message(LDPL_FATAL, "Failed to rename module for ThinLTO");
 
   CodeGen codeGen(std::move(NewModule), OS, TaskID, &CombinedIndex, File.name);
   codeGen.runAll();
 }
 
Context.setDiscardValueNames(options::TheOutputType !=
                                options::OT_SAVE_TEMPS);
   Context.enableDebugTypeODRUniquing(); // Merge debug info types.
   Context.setDiagnosticHandler(diagnosticHandlerForContext, nullptr, true);
 
   std::unique_ptr<Module> Combined(new Module("ld-temp.o", Context));
   IRMover L(*Combined);
 
   StringSet<> Internalize;
-  StringSet<> Maybe;
   for (claimed_file &F : Modules) {
     PluginInputFile InputFile(F.handle);
     const void *View = getSymbolsAndView(F);
     if (!View)
       continue;
     if (linkInModule(Context, L, F, View, InputFile.file(), ApiFile,
-                     Internalize, Maybe))
+                     Internalize))
       message(LDPL_FATAL, "Failed to link module");
   }
 
   for (const auto &Name : Internalize) {
     GlobalValue *GV = Combined->getNamedValue(Name.first());
     if (GV)
       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;
 
   if (options::TheOutputType != options::OT_NORMAL) {
     std::string path;
     if (options::TheOutputType == options::OT_BC_ONLY)
       path = output_name;
     else