IR: Introduce local_unnamed_addr attribute.

[• rafael]

I much prefer this version.

lib/CodeGen/Analysis.cpp

626

We should probably either disallow unnamed_addr on variables or says that whoever put it there knows what he is doing.

For now I would suggest just leaving this part here.

[majnemer]

include/llvm/IR/GlobalValue.h

163–165

I think it'd be more clear what this does if it were renamed hasGlobalUnnamedAddr. It's current name implies that UnnamedAddr != NotUnnamedAddr instead of UnnamedAddr == GlobalUnnamedAddr.

172–174

I'd expect this to be UnnamedAddr == LocalUnnamedAddr. I'd either choose a better name for this function or change the callers to check for both UnnamedAddrType values.

[majnemer]

include/llvm/IR/GlobalValue.h

157–188

NotUnnamedAddr is a little awkward.

Perhaps it'd be a little easier if we made UnnamedAddrType an enum class.
Something like:

enum class UnnamedAddr {
  None,
  Local,
  Global,
};

[pcc]

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

I discussed this a little with @majnemer on IRC. I think we cannot do this because passes should be allowed to introduce benign address comparisons. One example of this is speculative comparison of vtable addresses for devirtualization (vtables are unnamed_addr in C++, but imagine some other language where they weren't). If globalopt were to mark globals local_unnamed_addr, that would cause any speculative comparison to fail to verify.

One way to solve the problem could be to teach the devirtualizer to clear the local_unnamed_addr attribute, but imagine some case where some pass that runs after the devirtualizer uncovers the comparison (for example, if a constructor is inlined into a devirtualized call site, that might cause both sides of the comparison to become constant). This means that any number of passes would need to protect against this situation.

[pcc]

• Address review comments
• Add documentation to BitCodeFormat and LangRef

[pcc]

• Minimise the diff a little
• Add assembler/bitcode test

[• rafael]

You might want to add a case to compatibility.ll too.

docs/BitCodeFormat.rst

727

What are the white space changes? Can you commit them first if it is a cleanup?

836

Can you commit these first? (they LGTM).

lib/IR/AsmWriter.cpp

2427

This might look nicer with a function that returns "", "local_unamed_addr " or "unnamed_addr ".

2663

That way you get use the helper in here too.

[pcc]

• Add another use of helper function
• Update compatibility.ll

[pcc]

You might want to add a case to compatibility.ll too.

Done.

docs/BitCodeFormat.rst

727

Yes, r269857.

836

As above

[chandlerc]

Folks, llvm-commits wasn't even on the original version of this patch, and there is essentially no high-level description of the problem being solved or the motivation of the patch.

Can you start a fresh revision in phab and actually include a *lot* more context? I suspect many, many people will be very interested in something as impactful as a new variant of 'unnamed_addr' and they may (like me) have completely missed the discussion taking place here or lack significant context for it.

[pcc]

Hi Chandler, the initial patch/discussion/context was on D20258 which did start on the mailing list. Admittedly some of that didn't make it here, so I'll create a fresh revision with a better commit message.

[mehdi_amini]

Seriously I absolutely don't get the "start a new revision" thing because the initial email was not on llvm-commit. Really what is the rational?

We are losing the history and the threading for the review, this is really annoying.

So big -1

[pcc]

Created D20348

docs/BitCodeFormat.rst

* *isconst*: Non-zero if the variable is treated as constant within the module,
   or zero if it is not
 
 * *initid*: If non-zero, the value index of the initializer for this variable,
   plus 1.
 
 .. _linkage type:
 
 * *linkage*: An encoding of the linkage type for this variable:
+
   * ``external``: code 0
   * ``weak``: code 1
   * ``appending``: code 2
   * ``internal``: code 3
   * ``linkonce``: code 4
   * ``dllimport``: code 5
   * ``dllexport``: code 6
   * ``extern_weak``: code 7
   * ``common``: code 8
   * ``private``: code 9
   * ``weak_odr``: code 10
   * ``linkonce_odr``: code 11
   * ``available_externally``: code 12
   * deprecated : code 13
   * deprecated : code 14
 
 * alignment*: The logarithm base 2 of the variable's requested alignment, plus 1
 
 * *section*: If non-zero, the 1-based section index in the table of
   `MODULE_CODE_SECTIONNAME`_ entries.
 
 .. _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``
+.. _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:
 
 * *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
+
 .. _FUNCTION:
 
 MODULE_CODE_FUNCTION Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata, personalityfn]``
 
 The ``FUNCTION`` record (code 8) marks the declaration or definition of a

 * *section*: If non-zero, the 1-based section index in the table of
   `MODULE_CODE_SECTIONNAME`_ entries.
 
 * *visibility*: An encoding of the `visibility`_ of this function
 
 * *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<bcunnamedaddr>` attribute of this function
 
 * *prologuedata*: If non-zero, the value index of the prologue data for this function,
   plus 1.
 
 * *dllstorageclass*: An encoding of the
   :ref:`dllstorageclass<bcdllstorageclass>` of this function
 
 * *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.
 
 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, an encoding of the
+  :ref:`unnamed_addr<bcunnamedaddr>` attribute of this alias
+
 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 ``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
 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.

 Globals can also have a :ref:`DLL storage class <dllstorageclass>`.
 
 Variables and aliases can have a
 :ref:`Thread Local Storage Model <tls_model>`.
 
 Syntax::
 
       @<GlobalVarName> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
-                         [unnamed_addr] [AddrSpace] [ExternallyInitialized]
+                         [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
+                         [ExternallyInitialized]
                          <global | constant> <Type> [<InitializerConstant>]
                          [, section "name"] [, comdat [($name)]]
                          [, align <Alignment>]
 
 For example, the following defines a global in a numbered address space
 with an initializer, section, and alignment:
 
 .. code-block:: llvm

 an optional :ref:`comdat <langref_comdats>`,
 an optional :ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`,
 an optional :ref:`prologue <prologuedata>`,
 an optional :ref:`personality <personalityfn>`,
 an optional list of attached :ref:`metadata <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 <linkage>`, an optional :ref:`visibility
-style <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`,
-an optional :ref:`calling convention <callingconv>`,
-an optional ``unnamed_addr`` attribute, a return type, an optional
-:ref:`parameter attribute <paramattrs>` for the return type, a function
-name, a possibly empty list of arguments, an optional alignment, an optional
-:ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`,
-and an optional :ref:`prologue <prologuedata>`.
+optional :ref:`linkage type <linkage>`, an optional :ref:`visibility style
+<visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`, an
+optional :ref:`calling convention <callingconv>`, an optional ``unnamed_addr``
+or ``local_unnamed_addr`` attribute, a return type, an optional :ref:`parameter
+attribute <paramattrs>` for the return type, a function name, a possibly
+empty list of arguments, an optional alignment, an optional :ref:`garbage
+collector name <gc>`, an optional :ref:`prefix <prefixdata>`, and an optional
+:ref:`prologue <prologuedata>`.
 
 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
 (giving the basic block a symbol table entry), contains a list of instructions,
 and ends with a :ref:`terminator <terminators>` instruction (such as a branch or
 function return). If an explicit label is not provided, a block is assigned an
 implicit numbered label, using the next value from the same counter as used for
 unnamed temporaries (:ref:`see above<identifiers>`). For example, if a function

 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 ``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]
            <ResultType> @<FunctionName> ([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:
 
 Syntax::
 
    <type> [parameter Attrs] [name]
 

 constant expression.
 
 Aliases may have an optional :ref:`linkage type <linkage>`, an optional
 :ref:`visibility style <visibility>`, an optional :ref:`DLL storage class
 <dllstorageclass>` and an optional :ref:`tls model <tls_model>`.
 
 Syntax::
 
-    @<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] [unnamed_addr] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>
+    @<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>
 
 The linkage must be one of ``private``, ``internal``, ``linkonce``, ``weak``,
 ``linkonce_odr``, ``weak_odr``, ``external``. Note that some system linkers
 might not correctly handle dropping a weak symbol that is aliased.
 
 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:
 
 * The expression defining the aliasee must be computable at assembly
   time. Since it is just a name, no relocations can be used.
 
 * No alias in the expression can be weak as the possibility of the
   intermediate alias being overridden cannot be represented in an

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) {
+        UnnamedAddrVal(unsigned(UnnamedAddr::None)),
+        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 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
                             // 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 + 2 + 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
public:
   };
 
   ~GlobalValue() override {
     removeDeadConstantUsers();   // remove any dead constants using this.
   }
 
   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();
   const Comdat *getComdat() const {
     return const_cast<GlobalValue *>(this)->getComdat();
   }
 
   VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }

lib/Analysis/InstructionSimplify.cpp

if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) {
     // that might be resolve lazily to symbols in another dynamically-loaded
     // library (and, thus, could be malloc'ed by the implementation).
     auto IsAllocDisjoint = [](SmallVectorImpl<Value *> &Objects) {
       return std::all_of(Objects.begin(), Objects.end(), [](Value *V) {
         if (const AllocaInst *AI = dyn_cast<AllocaInst>(V))
           return AI->getParent() && AI->getFunction() && AI->isStaticAlloca();
         if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
           return (GV->hasLocalLinkage() || GV->hasHiddenVisibility() ||
-                  GV->hasProtectedVisibility() || GV->hasUnnamedAddr()) &&
+                  GV->hasProtectedVisibility() || GV->hasGlobalUnnamedAddr()) &&
                  !GV->isThreadLocal();
         if (const Argument *A = dyn_cast<Argument>(V))
           return A->hasByValAttr();
         return false;
       });
     };
 
     if ((IsNAC(LHSUObjs) && IsAllocDisjoint(RHSUObjs)) ||

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(local_unnamed_addr);
   KEYWORD(externally_initialized);
   KEYWORD(extern_weak);
   KEYWORD(external);
   KEYWORD(thread_local);
   KEYWORD(localdynamic);
   KEYWORD(initialexec);
   KEYWORD(localexec);
   KEYWORD(zeroinitializer);

lib/AsmParser/LLParser.h

bool ParseUInt64(uint64_t &Val, LocTy &Loc) {
       Loc = Lex.getLoc();
       return ParseUInt64(Val);
     }
 
     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 ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
     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,
+                     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();
     bool ParseMDString(MDString *&Result);
     bool ParseMDNodeID(MDNode *&Result);
     bool ParseUnnamedAttrGrp();
     bool ParseFnAttributeValuePairs(AttrBuilder &B,
                                     std::vector<unsigned> &FwdRefAttrGrps,

lib/AsmParser/LLParser.cpp

bool LLParser::ParseGlobalType(bool &IsConstant) {
   else {
     IsConstant = false;
     return TokError("expected 'global' or 'constant'");
   }
   Lex.Lex();
   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
 ///                                                     ...   -> global variable
 ///   GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
 ///   GlobalID '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseUnnamedGlobal() {
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;
+  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)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
                        DLLStorageClass, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
                              DLLStorageClass, TLM, UnnamedAddr);
 }
 
 /// 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;
+  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)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
                        DLLStorageClass, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
                              DLLStorageClass, TLM, UnnamedAddr);

 ///                     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,
+    GlobalVariable::UnnamedAddr UnnamedAddr) {
   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();

 ///
 /// 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) {
+                           GlobalVariable::UnnamedAddr UnnamedAddr) {
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
   unsigned AddrSpace;
   bool IsConstant, IsExternallyInitialized;
   LocTy IsExternallyInitializedLoc;
   LocTy TyLoc;
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;
+  GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
   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) ||
       ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
                                  BuiltinLoc) ||
       (EatIfPresent(lltok::kw_section) &&
        ParseStringConstant(Section)) ||
       parseOptionalComdat(FunctionName, C) ||
       ParseOptionalAlignment(Alignment) ||
       (EatIfPresent(lltok::kw_gc) &&
        ParseStringConstant(GC)) ||

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_local_unnamed_addr,
   kw_externally_initialized,
   kw_extern_weak,
   kw_external,
   kw_thread_local,
   kw_localdynamic,
   kw_initialexec,
   kw_localexec,
   kw_zeroinitializer,

lib/Bitcode/Reader/BitcodeReader.cpp

switch (Val) {
     default: // Map unknown non-zero value to general dynamic.
     case 1: return GlobalVariable::GeneralDynamicTLSModel;
     case 2: return GlobalVariable::LocalDynamicTLSModel;
     case 3: return GlobalVariable::InitialExecTLSModel;
     case 4: return GlobalVariable::LocalExecTLSModel;
   }
 }
 
+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;
   case bitc::CAST_TRUNC   : return Instruction::Trunc;
   case bitc::CAST_ZEXT    : return Instruction::ZExt;
   case bitc::CAST_SEXT    : return Instruction::SExt;
   case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
   case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
case bitc::MODULE_CODE_GLOBALVAR: {
       if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
         // FIXME: Change to an error if non-default in 4.0.
         Visibility = getDecodedVisibility(Record[6]);
 
       GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal;
       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)
         ExternallyInitialized = Record[9];
 
       GlobalVariable *NewGV =
         new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr,
                            TLM, AddressSpace, ExternallyInitialized);
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));
       }
+
       break;
     }
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,
     //             alignment, section, visibility, gc, unnamed_addr,
     //             prologuedata, dllstorageclass, comdat, prefixdata]
     case bitc::MODULE_CODE_FUNCTION: {
       if (Record.size() < 8)
         return error("Invalid record");
case bitc::MODULE_CODE_FUNCTION: {
       if (!Func->hasLocalLinkage())
         // FIXME: Change to an error if non-default in 4.0.
         Func->setVisibility(getDecodedVisibility(Record[7]));
       if (Record.size() > 8 && Record[8]) {
         if (Record[8]-1 >= GCTable.size())
           return error("Invalid ID");
         Func->setGC(GCTable[Record[8]-1].c_str());
       }
-      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));
 
       if (Record.size() > 11)
         Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
       else
         upgradeDLLImportExportLinkage(Func, RawLinkage);
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++]);
+        NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(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

static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
   case Comdat::NoDuplicates:
     return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;
   case Comdat::SameSize:
     return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;
   }
   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<unsigned, 64> Vals;
   for (const Comdat *C : VE.getComdats()) {
     // COMDAT: [selection_kind, name]
     Vals.push_back(getEncodedComdatSelectionKind(*C));
     size_t Size = C->getName().size();
     assert(isUInt<32>(Size));
     Vals.push_back(Size);
for (const GlobalVariable &GV : M.globals()) {
     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.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
-        GV.hasComdat()) {
+        GV.hasComdat() || GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None) {
       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);
     } 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,
+    //             local_unnamed_addr]
     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(getEncodedUnnamedAddr(F));
     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);
 
     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, local_unnamed_addr]
     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(getEncodedUnnamedAddr(A));
     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

bool llvm::returnTypeIsEligibleForTailCall(const Function *F,
 
   return true;
 }
 
 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
   // 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;
+  return GV->hasAtLeastLocalUnnamedAddr();
 }
 
 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();

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 /// handle cstexpr inside instructions. During global variable emission,
 /// candidates are skipped and are emitted later in case at least one cstexpr
 /// isn't replaced by a PC relative GOT entry access.
 static bool isGOTEquivalentCandidate(const GlobalVariable *GV,
                                      unsigned &NumGOTEquivUsers) {
   // 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<GlobalValue>(GV->getOperand(0)))
     return false;
 
   // To be a got equivalent, at least one of its users need to be a constant
   // expression used by another global variable.
   for (auto *U : GV->users())
     NumGOTEquivUsers += getNumGlobalVariableUses(dyn_cast<Constant>(U));
 

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
                                   KeySym);
 }
 
 const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
     const GlobalValue *LHS, const GlobalValue *RHS, Mangler &Mang,
     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.
   if (LHS->getType()->getPointerAddressSpace() != 0 ||
       RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
       RHS->isThreadLocal())
     return nullptr;
 

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

 
 static void raiseVisibilityOnValue(GlobalValue &V, GlobalRenamer &R) {
   if (V.hasLocalLinkage()) {
     if (R.needsRenaming(V))
       V.setName(R.getRename(V));
     V.setLinkage(GlobalValue::ExternalLinkage);
     V.setVisibility(GlobalValue::HiddenVisibility);
   }
-  V.setUnnamedAddr(false);
+  V.setUnnamedAddr(GlobalValue::UnnamedAddr::None);
   assert(!R.needsRenaming(V) && "Invalid global name.");
 }
 
 void makeAllSymbolsExternallyAccessible(Module &M) {
   GlobalRenamer Renamer;
 
   for (auto &F : M)
     raiseVisibilityOnValue(F, Renamer);

lib/IR/AsmWriter.cpp

case GlobalVariable::InitialExecTLSModel:
       Out << "thread_local(initialexec) ";
       break;
     case GlobalVariable::LocalExecTLSModel:
       Out << "thread_local(localexec) ";
       break;
   }
 }
 
+static void PrintUnnamedAddr(GlobalVariable::UnnamedAddr UA,
+                             formatted_raw_ostream &Out) {
+  switch (UA) {
+  case GlobalVariable::UnnamedAddr::None:
+    break;
+  case GlobalVariable::UnnamedAddr::Local:
+    Out << "local_unnamed_addr ";
+    break;
+  case GlobalVariable::UnnamedAddr::Global:
+    Out << "unnamed_addr ";
+    break;
+  }
+}
+
 static void maybePrintComdat(formatted_raw_ostream &Out,
                              const GlobalObject &GO) {
   const Comdat *C = GO.getComdat();
   if (!C)
     return;
 
   if (isa<GlobalVariable>(GO))
     Out << ',';
void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
 
   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 ";
+  PrintUnnamedAddr(GV->getUnnamedAddr(), Out);
 
   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) {
 
   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
   Out << " = ";
 
   Out << getLinkagePrintName(GIS->getLinkage());
   PrintVisibility(GIS->getVisibility(), Out);
   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
-  if (GIS->hasUnnamedAddr())
-    Out << "unnamed_addr ";
+  PrintUnnamedAddr(GIS->getUnnamedAddr(), Out);
 
   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())
+  switch (F->getUnnamedAddr()) {
+  case GlobalVariable::UnnamedAddr::None:
+    break;
+  case GlobalVariable::UnnamedAddr::Local:
+    Out << " local_unnamed_addr";
+    break;
+  case GlobalVariable::UnnamedAddr::Global:
     Out << " unnamed_addr";
+    break;
+  }
   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/Core.cpp

 }
 
 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) {
   unwrap<GlobalValue>(Global)->setDLLStorageClass(
       static_cast<GlobalValue::DLLStorageClassTypes>(Class));
 }
 
 LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) {
-  return unwrap<GlobalValue>(Global)->hasUnnamedAddr();
+  return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr();
 }
 
 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) {
-  unwrap<GlobalValue>(Global)->setUnnamedAddr(HasUnnamedAddr);
+  unwrap<GlobalValue>(Global)->setUnnamedAddr(
+      HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global
+                     : GlobalValue::UnnamedAddr::None);
 }
 
 /*--.. Operations on global variables, load and store instructions .........--*/
 
 unsigned LLVMGetAlignment(LLVMValueRef V) {
   Value *P = unwrap<Value>(V);
   if (GlobalValue *GV = dyn_cast<GlobalValue>(P))
     return GV->getAlignment();

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());
+  setUnnamedAddr(Src->getUnnamedAddr());
   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/IR/IRBuilder.cpp

GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str,
                                                   unsigned AddressSpace) {
   Constant *StrConstant = ConstantDataArray::getString(Context, Str);
   Module &M = *BB->getParent()->getParent();
   GlobalVariable *GV = new GlobalVariable(M, StrConstant->getType(),
                                           true, GlobalValue::PrivateLinkage,
                                           StrConstant, Name, nullptr,
                                           GlobalVariable::NotThreadLocal,
                                           AddressSpace);
-  GV->setUnnamedAddr(true);
+  GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   return GV;
 }
 
 Type *IRBuilderBase::getCurrentFunctionReturnType() const {
   assert(BB && BB->getParent() && "No current function!");
   return BB->getParent()->getReturnType();
 }
 

lib/IR/Verifier.cpp

if (Attrs.hasAttribute(AttributeSet::FunctionIndex,
 
     Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize),
            "Attributes 'minsize and optnone' are incompatible!", V);
   }
 
   if (Attrs.hasAttribute(AttributeSet::FunctionIndex,
                          Attribute::JumpTable)) {
     const GlobalValue *GV = cast<GlobalValue>(V);
-    Assert(GV->hasUnnamedAddr(),
+    Assert(GV->hasGlobalUnnamedAddr(),
            "Attribute 'jumptable' requires 'unnamed_addr'", V);
   }
 
   if (Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::AllocSize)) {
     std::pair<unsigned, Optional<unsigned>> Args =
         Attrs.getAllocSizeArgs(AttributeSet::FunctionIndex);
 
     auto CheckParam = [&](StringRef Name, unsigned ParamNo) {

lib/Linker/IRMover.cpp

if (DstGV) {
     }
 
     if (DstGV->getVisibility() != SrcGV->getVisibility()) {
       emitError(
           "Appending variables with different visibility need to be linked!");
       return nullptr;
     }
 
-    if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr()) {
+    if (DstGV->hasGlobalUnnamedAddr() != SrcGV->hasGlobalUnnamedAddr()) {
       emitError(
           "Appending variables with different unnamed_addr need to be linked!");
       return nullptr;
     }
 
     if (DstGV->getSection() != SrcGV->getSection()) {
       emitError(
           "Appending variables with different section name need to be linked!");

lib/Linker/LinkModules.cpp

if (DGVar && SGVar) {
       }
     }
 
     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);
+    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
   // 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/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

void AMDGPUPromoteAlloca::handleAlloca(AllocaInst &I) {
   Type *GVTy = ArrayType::get(I.getAllocatedType(), WorkGroupSize);
   GlobalVariable *GV = new GlobalVariable(
       *Mod, GVTy, false, GlobalValue::InternalLinkage,
       UndefValue::get(GVTy),
       Twine(F->getName()) + Twine('.') + I.getName(),
       nullptr,
       GlobalVariable::NotThreadLocal,
       AMDGPUAS::LOCAL_ADDRESS);
-  GV->setUnnamedAddr(true);
+  GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   GV->setAlignment(I.getAlignment());
 
   Value *TCntY, *TCntZ;
 
   std::tie(TCntY, TCntZ) = getLocalSizeYZ(Builder);
   Value *TIdX = getWorkitemID(Builder, 0);
   Value *TIdY = getWorkitemID(Builder, 1);
   Value *TIdZ = getWorkitemID(Builder, 2);

lib/Target/TargetLoweringObjectFile.cpp

SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV,
   if (GVar->isConstant()) {
     // If the initializer for the global contains something that requires a
     // relocation, then we may have to drop this into a writable data section
     // even though it is marked const.
     if (!C->needsRelocation()) {
       // 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"
       // section of the right width.
       if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
         if (IntegerType *ITy =
               dyn_cast<IntegerType>(ATy->getElementType())) {
           if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||

lib/Transforms/IPO/ConstantMerge.cpp

 static bool IsBetterCanonical(const GlobalVariable &A,
                               const GlobalVariable &B) {
   if (!A.hasLocalLinkage() && B.hasLocalLinkage())
     return true;
 
   if (A.hasLocalLinkage() && !B.hasLocalLinkage())
     return false;
 
-  return A.hasUnnamedAddr();
+  return A.hasGlobalUnnamedAddr();
 }
 
 static unsigned getAlignment(GlobalVariable *GV) {
   unsigned Align = GV->getAlignment();
   if (Align)
     return Align;
   return GV->getParent()->getDataLayout().getPreferredAlignment(GV);
 }
for (Module::global_iterator GVI = M.global_begin(), E = M.global_end();
       Constant *Init = GV->getInitializer();
 
       // Check to see if the initializer is already known.
       GlobalVariable *Slot = CMap[Init];
 
       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));
     }
 
     if (Replacements.empty())
       return MadeChange;
     CMap.clear();

lib/Transforms/IPO/GlobalOpt.cpp

static bool processInternalGlobal(
   return false;
 }
 
 /// 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())
+  if (GV.getName().startswith("llvm."))
     return false;
 
   GlobalStatus GS;
 
   if (GlobalStatus::analyzeGlobal(&GV, GS))
     return false;
 
   bool Changed = false;
-  if (!GS.IsCompared && !GV.hasUnnamedAddr()) {
-    GV.setUnnamedAddr(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<GlobalVariable>(&GV);
   if (!GVar)
     return Changed;
 
   if (GVar->isConstant() || !GVar->hasInitializer())
     return Changed;
 

lib/Transforms/IPO/MergeFunctions.cpp

if (CS && CS.isCallee(U)) {
       remove(CS.getInstruction()->getParent()->getParent());
       U->set(BitcastNew);
     }
   }
 }
 
 // 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);
       return;
     }
   }
 
   writeThunk(F, G);

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 static GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str,
                                                     bool AllowMerging) {
   Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);
   // We use private linkage for module-local strings. If they can be merged
   // with another one, we set the unnamed_addr attribute.
   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;
 }
 
 /// \brief Create a global describing a source location.
 static GlobalVariable *createPrivateGlobalForSourceLoc(Module &M,
                                                        LocationMetadata MD) {
   Constant *LocData[] = {
       createPrivateGlobalForString(M, MD.Filename, true),
       ConstantInt::get(Type::getInt32Ty(M.getContext()), MD.LineNo),
       ConstantInt::get(Type::getInt32Ty(M.getContext()), MD.ColumnNo),
   };
   auto LocStruct = ConstantStruct::getAnon(LocData);
   auto GV = new GlobalVariable(M, LocStruct->getType(), true,
                                GlobalValue::PrivateLinkage, LocStruct,
                                kAsanGenPrefix);
-  GV->setUnnamedAddr(true);
+  GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   return GV;
 }
 
 static bool GlobalWasGeneratedByAsan(GlobalVariable *G) {
   return G->getName().find(kAsanGenPrefix) == 0 ||
          G->getName().find(kSanCovGenPrefix) == 0 ||
          G->getName().find(kODRGenPrefix) == 0;
 }

lib/Transforms/Instrumentation/GCOVProfiling.cpp

for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
     Function *FlushF = insertFlush(CountersBySP);
 
     // Create a small bit of code that registers the "__llvm_gcov_writeout" to
     // be executed at exit and the "__llvm_gcov_flush" function to be executed
     // when "__gcov_flush" is called.
     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)
       F->addFnAttr(Attribute::NoRedZone);
 
     BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F);
     IRBuilder<> Builder(BB);
 
GlobalVariable *GCOVProfiler::buildEdgeLookupTable(
   }
 
   GlobalVariable *EdgeTableGV =
       new GlobalVariable(
           *M, EdgeTableTy, true, GlobalValue::InternalLinkage,
           ConstantArray::get(EdgeTableTy,
                              makeArrayRef(&EdgeTable[0],TableSize)),
           "__llvm_gcda_edge_table");
-  EdgeTableGV->setUnnamedAddr(true);
+  EdgeTableGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   return EdgeTableGV;
 }
 
 Constant *GCOVProfiler::getStartFileFunc() {
   Type *Args[] = {
     Type::getInt8PtrTy(*Ctx),  // const char *orig_filename
     Type::getInt8PtrTy(*Ctx),  // const char version[4]
     Type::getInt32Ty(*Ctx),    // uint32_t checksum

 GlobalVariable *GCOVProfiler::getEdgeStateValue() {
   GlobalVariable *GV = M->getGlobalVariable("__llvm_gcov_global_state_pred");
   if (!GV) {
     GV = new GlobalVariable(*M, Type::getInt32Ty(*Ctx), false,
                             GlobalValue::InternalLinkage,
                             ConstantInt::get(Type::getInt32Ty(*Ctx),
                                              0xffffffff),
                             "__llvm_gcov_global_state_pred");
-    GV->setUnnamedAddr(true);
+    GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   }
   return GV;
 }
 
 Function *GCOVProfiler::insertCounterWriteout(
     ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
   FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
   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);
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
   IRBuilder<> Builder(BB);
 
   Constant *StartFile = getStartFileFunc();
Function *GCOVProfiler::insertCounterWriteout(
 
   Builder.CreateRetVoid();
   return WriteoutF;
 }
 
 void GCOVProfiler::insertIndirectCounterIncrement() {
   Function *Fn =
     cast<Function>(GCOVProfiler::getIncrementIndirectCounterFunc());
-  Fn->setUnnamedAddr(true);
+  Fn->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   Fn->setLinkage(GlobalValue::InternalLinkage);
   Fn->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     Fn->addFnAttr(Attribute::NoRedZone);
 
   // Create basic blocks for function.
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", Fn);
   IRBuilder<> Builder(BB);

 insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *FlushF = M->getFunction("__llvm_gcov_flush");
   if (!FlushF)
     FlushF = Function::Create(FTy, GlobalValue::InternalLinkage,
                               "__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);
 
   BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", FlushF);
 
   // Write out the current counters.
   Constant *WriteoutF = M->getFunction("__llvm_gcov_writeout");

lib/Transforms/Instrumentation/InstrProfiling.cpp

void InstrProfiling::emitRegistration() {
 
   // Construct the function.
   auto *VoidTy = Type::getVoidTy(M->getContext());
   auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
   auto *Int64Ty = Type::getInt64Ty(M->getContext());
   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);
   auto *RuntimeRegisterF =
       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
                        getInstrProfRegFuncName(), M);
 
   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
void InstrProfiling::emitInitialization() {
   Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());
   if (!RegisterF && InstrProfileOutput.empty()) return;
 
   // Create the initialization function.
   auto *VoidTy = Type::getVoidTy(M->getContext());
   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);
 
   // Add the basic block and the necessary calls.
   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
   if (RegisterF)
     IRB.CreateCall(RegisterF, {});
   if (!InstrProfileOutput.empty()) {

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

Value *MSP =
                                Int8PtrTy, Int8PtrTy, IntPtr, (void *)nullptr);
     inferLibFuncAttributes(*M->getFunction("memset_pattern16"), *TLI);
 
     // Otherwise we should form a memset_pattern16.  PatternValue is known to be
     // an constant array of 16-bytes.  Plop the value into a mergable global.
     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});
   }
 
   DEBUG(dbgs() << "  Formed memset: " << *NewCall << "\n"
                << "    from store to: " << *Ev << " at: " << *TheStore << "\n");
   NewCall->setDebugLoc(TheStore->getDebugLoc());

lib/Transforms/Utils/FunctionImportUtils.cpp

bool FunctionImportGlobalProcessing::doPromoteLocalToGlobal(
   // Local const variables never need to be promoted unless they are address
   // taken. The imported uses can simply use the clone created in this module.
   // For now we are conservative in determining which variables are not
   // address taken by checking the unnamed addr flag. To be more aggressive,
   // the address taken information must be checked earlier during parsing
   // of the module and recorded in the summary index for use when importing
   // from that module.
   auto *GVar = dyn_cast<GlobalVariable>(SGV);
-  if (GVar && GVar->isConstant() && GVar->hasUnnamedAddr())
+  if (GVar && GVar->isConstant() && GVar->hasGlobalUnnamedAddr())
     return false;
 
   if (GVar && GVar->hasSection())
     // Some sections like "__DATA,__cfstring" are "magic" and promotion is not
     // allowed. Just disable promotion on any GVar with sections right now.
     return false;
 
   // Eventually we only need to promote functions in the exporting module that

lib/Transforms/Utils/GlobalStatus.cpp

if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(UR)) {
 
             if (Constant *C = dyn_cast<Constant>(StoredVal)) {
               if (C->isThreadDependent()) {
                 // The stored value changes between threads; don't track it.
                 return true;
               }
             }
 
-            if (StoredVal == GV->getInitializer()) {
+            if (GV->hasInitializer() && StoredVal == GV->getInitializer()) {
               if (GS.StoredType < GlobalStatus::InitializerStored)
                 GS.StoredType = GlobalStatus::InitializerStored;
             } else if (isa<LoadInst>(StoredVal) &&
                        cast<LoadInst>(StoredVal)->getOperand(0) == GV) {
               if (GS.StoredType < GlobalStatus::InitializerStored)
                 GS.StoredType = GlobalStatus::InitializerStored;
             } else if (GS.StoredType < GlobalStatus::StoredOnce) {
               GS.StoredType = GlobalStatus::StoredOnce;

lib/Transforms/Utils/SimplifyCFG.cpp

SwitchLookupTable::SwitchLookupTable(
   // Store the table in an array.
   ArrayType *ArrayTy = ArrayType::get(ValueType, TableSize);
   Constant *Initializer = ConstantArray::get(ArrayTy, TableContents);
 
   Array = new GlobalVariable(M, ArrayTy, /*constant=*/ true,
                              GlobalVariable::PrivateLinkage,
                              Initializer,
                              "switch.table");
-  Array->setUnnamedAddr(true);
+  Array->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   Kind = ArrayKind;
 }
 
 Value *SwitchLookupTable::BuildLookup(Value *Index, IRBuilder<> &Builder) {
   switch (Kind) {
     case SingleValueKind:
       return SingleValue;
     case LinearMapKind: {

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
+@v1 = linkonce_odr local_unnamed_addr 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
+@v3 = linkonce_odr unnamed_addr constant 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
+@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
 
 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
+@v1 = linkonce_odr local_unnamed_addr 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
+@v3 = linkonce_odr unnamed_addr constant 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
+@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
 
 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 unnamed_addr 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:     -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
 }

test/Other/constant-fold-gep.ll

 ; from instcombine and global opt can use targetdata.
 
 ; PLAIN: @G8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1)
 ; PLAIN: @G1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -1)
 ; PLAIN: @F8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -2)
 ; 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)
 @F8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -2)
 @F1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -2)
 @H8 = global i8* getelementptr (i8, i8* inttoptr (i32 0 to i8*), i32 -1)
 @H1 = global i1* getelementptr (i1, i1* inttoptr (i32 0 to i1*), i32 -1)
 
 ; The target-independent folder should be able to do some clever
 ; simplifications on sizeof, alignof, and offsetof expressions. The
 ; target-dependent folder should fold these down to constants.
 
 ; PLAIN: @a = constant i64 mul (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 2310)
 ; PLAIN: @b = constant i64 ptrtoint (double* getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) to i64)
 ; PLAIN: @c = constant i64 mul nuw (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 2)
 ; PLAIN: @d = constant i64 mul nuw (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 11)
 ; PLAIN: @e = constant i64 ptrtoint (double* getelementptr ({ double, float, double, double }, { double, float, double, double }* null, i64 0, i32 2) to i64)
 ; PLAIN: @f = constant i64 1
 ; 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)
 @c = constant i64 ptrtoint (double* getelementptr ({double, double, double, double}, {double, double, double, double}* null, i64 0, i32 2) to i64)
 @d = constant i64 ptrtoint (double* getelementptr ([13 x double], [13 x double]* null, i64 0, i32 11) to i64)
 @e = constant i64 ptrtoint (double* getelementptr ({double, float, double, double}, {double, float, double, double}* null, i64 0, i32 2) to i64)
 @f = constant i64 ptrtoint (<{ i16, i128 }>* getelementptr ({i1, <{ i16, i128 }>}, {i1, <{ i16, i128 }>}* null, i64 0, i32 1) to i64)
 @g = constant i64 ptrtoint ({double, double}* getelementptr ({i1, {double, double}}, {i1, {double, double}}* null, i64 0, i32 1) to i64)
 @h = constant i64 ptrtoint (double** getelementptr (double*, double** null, i64 1) to i64)
 @i = constant i64 ptrtoint (double** getelementptr ({i1, double*}, {i1, double*}* null, i64 0, i32 1) to i64)
 
 ; The target-dependent folder should cast GEP indices to integer-sized pointers.
 
 ; 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)
 @O = constant i64* getelementptr ([2 x i64], [2 x i64]* null, i32 0, i32 1)
 
 ; Fold GEP of a GEP. Very simple cases are folded without targetdata.
 
 ; 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)
 @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)
 
 ; Duplicate all of the above as function return values rather than
 ; global initializers.
 

 ; PLAIN: define i8* @hoo8() #0 {
 ; PLAIN:   %t = bitcast i8* getelementptr (i8, i8* null, i32 -1) to i8*
 ; PLAIN:   ret i8* %t
 ; PLAIN: }
 ; PLAIN: define i1* @hoo1() #0 {
 ; 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
 ; SCEV:   %t = bitcast i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1) to i8*
 ; SCEV:   -->  (-1 + inttoptr (i32 1 to i8*))
 ; SCEV: Classifying expressions for: @goo1
 ; SCEV:   %t = bitcast i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -1) to i1*
 ; SCEV:   -->  (-1 + inttoptr (i32 1 to i1*))

 ; PLAIN: define i64 @fh() #0 {
 ; PLAIN:   %t = bitcast i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64) to i64
 ; PLAIN:   ret i64 %t
 ; PLAIN: }
 ; PLAIN: define i64 @fi() #0 {
 ; 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
 ; SCEV:   %t = bitcast i64 mul (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 2310) to i64
 ; SCEV:   -->  (2310 * sizeof(double))
 ; SCEV: Classifying expressions for: @fb
 ; SCEV:   %t = bitcast i64 ptrtoint (double* getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) to i64) to i64
 ; SCEV:   -->  alignof(double)

 ; PLAIN: define i64* @fN() #0 {
 ; PLAIN:   %t = bitcast i64* getelementptr ({ i64, i64 }, { i64, i64 }* null, i32 0, i32 1) to i64*
 ; PLAIN:   ret i64* %t
 ; PLAIN: }
 ; PLAIN: define i64* @fO() #0 {
 ; 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
 ; SCEV:   %t = bitcast i64* getelementptr (i64, i64* null, i32 1) to i64*
 ; SCEV:   -->  8
 ; SCEV: Classifying expressions for: @fN
 ; SCEV:   %t = bitcast i64* getelementptr ({ i64, i64 }, { i64, i64 }* null, i32 0, i32 1) to i64*
 ; SCEV:   -->  8
define i64* @fO() nounwind {
   %t = bitcast i64* getelementptr ([2 x i64], [2 x i64]* null, i32 0, i32 1) to i64*
   ret i64* %t
 }
 
 ; PLAIN: define i32* @fZ() #0 {
 ; 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
 ; SCEV:   %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*
 ; SCEV:   -->  (12 + @ext)
 
 define i32* @fZ() nounwind {
   %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*

test/Transforms/GlobalOpt/2010-10-19-WeakOdr.ll

 ; RUN: opt < %s -globalopt -S | FileCheck %s
 
 ; 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
 
 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [ { i32, void ()* } { i32 65535, void ()* @CTOR } ]
 
 define internal void @CTOR() {
   store i32 23, i32* @SomeVar
   ret void
 }
 
 

test/Transforms/GlobalOpt/alias-used-address-space.ll

 
 @llvm.used = appending global [1 x i8*] [i8* addrspacecast (i8 addrspace(1)* @ca to i8*)], section "llvm.metadata"
 ; CHECK-DAG: @llvm.used = appending global [1 x i8*] [i8* addrspacecast (i8 addrspace(1)* @ca to i8*)], section "llvm.metadata"
 
 @llvm.compiler.used = appending global [2 x i8*] [i8* addrspacecast(i8 addrspace(1)* @ia to i8*), i8* addrspacecast (i8 addrspace(1)* @i to i8*)], section "llvm.metadata"
 ; 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
 
 define i8 addrspace(1)* @h() {
   ret i8 addrspace(1)* @ca
 }

test/Transforms/GlobalOpt/alias-used.ll

 ; RUN: opt < %s -globalopt -S | FileCheck %s
 
 @c = global i8 42
 
 @i = internal global i8 42
 ; CHECK: @ia = internal global i8 42
 @ia = internal alias i8, i8* @i
 
 @llvm.used = appending global [3 x i8*] [i8* bitcast (void ()* @fa to i8*), i8* bitcast (void ()* @f to i8*), i8* @ca], section "llvm.metadata"
 ; CHECK-DAG: @llvm.used = appending global [3 x i8*] [i8* @ca, i8* bitcast (void ()* @f to i8*), i8* bitcast (void ()* @fa to i8*)], section "llvm.metadata"
 
 @llvm.compiler.used = appending global [4 x i8*] [i8* bitcast (void ()* @fa3 to i8*), i8* bitcast (void ()* @fa to i8*), i8* @ia, i8* @i], section "llvm.metadata"
 ; 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
 
 @fa2 = internal alias void (), void ()* @f
 ; CHECK-NOT: @fa2
 
 @fa3 = internal alias void (), void ()* @f

test/Transforms/GlobalOpt/assume.ll

 ; 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
 
 define i32 @TheAnswerToLifeTheUniverseAndEverything() {
   ret i32 42
 }
 

test/Transforms/GlobalOpt/constantfold-initializers.ll

 ; RUN: opt < %s -S -globalopt | 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"
 
 @.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 }
 @PR12642.s = global <{}> zeroinitializer, align 1
 @PR12642.p = constant %PR12642.struct* bitcast (i8* getelementptr (i8, i8* bitcast (<{}>* @PR12642.s to i8*), i64 1) to %PR12642.struct*), align 8
 
 define internal void @test1() {
 entry:
   store i32 1, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @xs, i64 0, i64 0)
   %0 = load i32, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @xs, i32 0, i64 0), align 4
   store i32 %0, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @xs, i64 0, i64 1)
   ret void
 }
 
 ; PR12060
 
 %closure = type { i32 }
 
 @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:
   %0 = getelementptr inbounds %closure, %closure* %this, i32 0, i32 0
   %1 = load i32, i32* %0, align 4
   %add = add nsw i32 %1, %b
   ret i32 %add
 }
 
 define internal void @test2() {
 entry:
   store i32 4, i32* getelementptr inbounds (%closure, %closure* @f, i32 0, i32 0)
   %call = call i32 @test2_helper(%closure* @f, i32 9)
   store i32 %call, i32* @m, align 4
   ret void
 }
 
 ; 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:
   store i32* @dllimportvar, i32** @dllimportptr, align 4
   ret void
 }
 
 @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() {
 entry:
   store i32 20, i32* @dllexportvar, align 4
   store i32* @dllexportvar, i32** @dllexportptr, align 4
   ret void
 }
 
 @threadlocalptr = global i32* null, align 4
 ; CHECK: @threadlocalptr = global i32* null, align 4
 @threadlocalvar = external thread_local global i32
 define internal void @test5() {
 entry:
   store i32* @threadlocalvar, i32** @threadlocalptr, align 4
   ret void
 }
 
 @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
   %iv = insertvalue { i32, i32 } %load, i32 %xv0, 1
   %xv1 = extractvalue { i32, i32 } %iv, 1
   store i32 %xv1, i32* @test6_v2, align 4
   ret void
 }

test/Transforms/GlobalOpt/ctor-list-opt-inbounds.ll

 ; RUN: opt < %s -globalopt -S | FileCheck %s
 
 ; 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
 @G = internal global [6 x [5 x i32]] zeroinitializer
 @H = global i32 80
 @I = global i32 90
 
 define internal void @CTOR() {
   store i32 1, i32* getelementptr ([6 x [5 x i32]], [6 x [5 x i32]]* @G, i64 0, i64 0, i64 0)
   store i32 2, i32* getelementptr inbounds ([6 x [5 x i32]], [6 x [5 x i32]]* @G, i64 0, i64 0, i64 0)
   %t = load i32, i32* getelementptr ([6 x [5 x i32]], [6 x [5 x i32]]* @G, i64 0, i64 0, i64 0)
   store i32 %t, i32* @H
   %s = load i32, i32* getelementptr inbounds ([6 x [5 x i32]], [6 x [5 x i32]]* @G, i64 0, i64 0, i64 0)
   store i32 %s, i32* @I
   ret void
 }

test/Transforms/GlobalOpt/invariant.group.barrier.ll

 ; RUN: opt -S -globalopt < %s | FileCheck %s
 
 ; 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
 @tmp2 = global i32 0
 @tmp3 = global i32 0
 @ptrToTmp3 = global i32* null
 
 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }]

test/Transforms/GlobalOpt/invoke.ll

 ; RUN: opt -S -globalopt < %s | FileCheck %s
 ; 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
 
 define i32 @one() {
   ret i32 1
 }
 

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() 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()
   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
 
 ; 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: @e = linkonce_odr local_unnamed_addr global 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()

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() local_unnamed_addr {
+define linkonce_odr void @h() local_unnamed_addr {
   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"
 
+; 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
 
 @g8 = external global i32
 
 ; CHECK-DAG: define internal void @f1()
 ; OPT2-NOT: @f1
 define hidden void @f1() {

 ; 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() local_unnamed_addr {
   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
+@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
 }
 
 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: 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

tools/gold/gold-plugin.cpp

struct PluginInputFile {
   PluginInputFile(PluginInputFile &&RHS) = default;
   PluginInputFile &operator=(PluginInputFile &&RHS) = default;
 };
 
 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;
 };
 
 /// Class to own information used by a task or during its cleanup for a
 /// ThinLTO backend instantiation.
 class ThinLTOTaskInfo {
for (auto &Sym : Obj->symbols()) {
     sym.name = strdup(Name.c_str());
 
     const GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
 
     ResolutionInfo &Res = ResInfo[sym.name];
 
     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()) {
       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 (canBeOmittedFromSymbolTable(GV))
+        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