[IR] Add significant_addr property.

[zequanwu]

Summary

GlobalValue::UnnamedAddr::None is the default property for global value, and
optimizer could update it to local_unnamed_addr or unnamed_addr in
GlobalOpt. Sometimes, we don't want this to happen. The new significant_addr
property doesn't allow optimizer to change it.

I'll add a clang attribute to map it to significant_addr.

[lebedev.ri]

How is significant_addr different from unspecified unnamed_addr/local_unnamed_addr?
I think there should be more langref changes.

[zequanwu]

Update LangRef.

[lebedev.ri]

Patch description states what this patch does, but not why it does what it does.

llvm/docs/BitCodeFormat.rst

 .. _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
+  * ``significant_addr``: code 3
 
 .. _bcdllstorageclass:
 
 * *dllstorageclass*: If present, an encoding of the DLL storage class of this variable:
 
   * ``default``: code 0
   * ``dllimport``: code 1
   * ``dllexport``: code 2

llvm/docs/LangRef.rst

 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.
 
+If the ``significant_addr`` attribute is given, the address is known to be 
+significant throughout the whole optimization process.
+
+By default, a global vairable is unspecified by 
+``unnamed_addr/local_unnamed_addr/significant_addr`` is significant but subject 
+to change to ``unnamed_addr/local_unnamed_addr`` depend on if it has local 
+linkage.
+
 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.

 arrays because their size is unknown at compile time. They are allowed in
 structs to facilitate intrinsics returning multiple values. Structs containing
 scalable vectors cannot be used in loads, stores, allocas, or GEPs.
 
 Syntax::
 
       @<GlobalVarName> = [Linkage] [PreemptionSpecifier] [Visibility]
                          [DLLStorageClass] [ThreadLocal]
-                         [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
-                         [ExternallyInitialized]
+                         [(unnamed_addr|local_unnamed_addr|significant_addr)] 
+                         [AddrSpace] [ExternallyInitialized]
                          <global | constant> <Type> [<InitializerConstant>]
                          [, section "name"] [, comdat [($name)]]
                          [, align <Alignment>] (, !name !N)*
 
 For example, the following defines a global in a numbered address space
 with an initializer, section, and alignment:
 
 .. code-block:: llvm

 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``
-or ``local_unnamed_addr`` attribute, an optional address space, 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:`calling convention <callingconv>`, an optional 
+``unnamed_addr/local_unnamed_addr/significant_addr`` attribute, 
+an optional address space, 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 name 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

 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.
 
+If the ``significant_addr`` attribute is given, the address is known to be 
+significant and cannot be changed during optimization.
+
 If an explicit address space is not given, it will default to the program
 address space from the :ref:`datalayout string<langref_datalayout>`.
 
 Syntax::
 
     define [linkage] [PreemptionSpecifier] [visibility] [DLLStorageClass]
            [cconv] [ret attrs]
            <ResultType> @<FunctionName> ([argument list])
-           [(unnamed_addr|local_unnamed_addr)] [AddrSpace] [fn Attrs]
+           [(unnamed_addr|local_unnamed_addr|significant_addr)] [AddrSpace] [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::
 

 ``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.
+not be significant within the module. Alias cannot have ``significant_addr``.
 
 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

llvm/include/llvm-c/Core.h

 
 typedef enum {
   LLVMDefaultVisibility,  /**< The GV is visible */
   LLVMHiddenVisibility,   /**< The GV is hidden */
   LLVMProtectedVisibility /**< The GV is protected */
 } LLVMVisibility;
 
 typedef enum {
-  LLVMNoUnnamedAddr,    /**< Address of the GV is significant. */
+  LLVMSignificantAddr,  /**< Address of the GV is significant (specified). */
+  LLVMNoUnnamedAddr,    /**< Address of the GV is significant (default). */
   LLVMLocalUnnamedAddr, /**< Address of the GV is locally insignificant. */
   LLVMGlobalUnnamedAddr /**< Address of the GV is globally insignificant. */
 } LLVMUnnamedAddr;
 
 typedef enum {
   LLVMDefaultStorageClass   = 0,
   LLVMDLLImportStorageClass = 1, /**< Function to be imported from DLL. */
   LLVMDLLExportStorageClass = 2  /**< Function to be accessible from DLL. */

llvm/include/llvm/IR/GlobalValue.h

enum ThreadLocalMode {
     LocalExecTLSModel
   };
 
   GlobalValue(const GlobalValue &) = delete;
 
   unsigned getAddressSpace() const;
 
   enum class UnnamedAddr {
+    Significant,
     None,
     Local,
     Global,
   };
 
   bool hasGlobalUnnamedAddr() const {
     return getUnnamedAddr() == UnnamedAddr::Global;
   }
 
+  bool hasSignificantAddr() const {
+    return getUnnamedAddr() == UnnamedAddr::Significant;
+  }
+
   /// 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;
+    return getUnnamedAddr() != UnnamedAddr::None &&
+           getUnnamedAddr() != UnnamedAddr::Significant;
   }
 
   UnnamedAddr getUnnamedAddr() const {
     return UnnamedAddr(UnnamedAddrVal);
   }
   void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); }
 
   static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) {
+    if (A == UnnamedAddr::Significant || B == UnnamedAddr::Significant)
+      return UnnamedAddr::Significant;
     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; }

llvm/lib/AsmParser/LLLexer.cpp

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

llvm/lib/AsmParser/LLParser.cpp

 }
 
 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 if (EatIfPresent(lltok::kw_significant_addr))
+    UnnamedAddr = GlobalValue::UnnamedAddr::Significant;
   else
     UnnamedAddr = GlobalValue::UnnamedAddr::None;
   return false;
 }
 
 /// parseUnnamedGlobal:
 ///   OptionalVisibility (ALIAS | IFUNC) ...
 ///   OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility

llvm/lib/AsmParser/LLToken.h

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

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

 }
 
 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;
+    case 3:
+      return GlobalVariable::UnnamedAddr::Significant;
   }
 }
 
 static int getDecodedCastOpcode(unsigned Val) {
   switch (Val) {
   default: return -1;
   case bitc::CAST_TRUNC   : return Instruction::Trunc;
   case bitc::CAST_ZEXT    : return Instruction::ZExt;

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
   llvm_unreachable("Invalid selection kind");
 }
 
 static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) {
   switch (GV.getUnnamedAddr()) {
   case GlobalValue::UnnamedAddr::None:   return 0;
   case GlobalValue::UnnamedAddr::Local:  return 2;
   case GlobalValue::UnnamedAddr::Global: return 1;
+  case GlobalValue::UnnamedAddr::Significant:
+    return 3;
   }
   llvm_unreachable("Invalid unnamed_addr");
 }
 
 size_t ModuleBitcodeWriter::addToStrtab(StringRef Str) {
   if (GenerateHash)
     Hasher.update(Str);
   return StrtabBuilder.add(Str);

llvm/lib/IR/AsmWriter.cpp

 static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA) {
   switch (UA) {
   case GlobalVariable::UnnamedAddr::None:
     return "";
   case GlobalVariable::UnnamedAddr::Local:
     return "local_unnamed_addr";
   case GlobalVariable::UnnamedAddr::Global:
     return "unnamed_addr";
+  case GlobalVariable::UnnamedAddr::Significant:
+    return "significant_addr";
   }
   llvm_unreachable("Unknown UnnamedAddr");
 }
 
 static void maybePrintComdat(formatted_raw_ostream &Out,
                              const GlobalObject &GO) {
   const Comdat *C = GO.getComdat();
   if (!C)

llvm/lib/IR/Core.cpp

 
 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) {
   unwrap<GlobalValue>(Global)->setDLLStorageClass(
       static_cast<GlobalValue::DLLStorageClassTypes>(Class));
 }
 
 LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global) {
   switch (unwrap<GlobalValue>(Global)->getUnnamedAddr()) {
+  case GlobalVariable::UnnamedAddr::Significant:
+    return LLVMSignificantAddr;
   case GlobalVariable::UnnamedAddr::None:
     return LLVMNoUnnamedAddr;
   case GlobalVariable::UnnamedAddr::Local:
     return LLVMLocalUnnamedAddr;
   case GlobalVariable::UnnamedAddr::Global:
     return LLVMGlobalUnnamedAddr;
   }
   llvm_unreachable("Unknown UnnamedAddr kind!");
 }
 
 void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr) {
   GlobalValue *GV = unwrap<GlobalValue>(Global);
 
   switch (UnnamedAddr) {
+  case LLVMSignificantAddr:
+    return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Significant);
   case LLVMNoUnnamedAddr:
     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::None);
   case LLVMLocalUnnamedAddr:
     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Local);
   case LLVMGlobalUnnamedAddr:
     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Global);
   }
 }

llvm/lib/IR/Verifier.cpp

for (const Value *TheNextUser : User->materialized_users())
     if (Callback(TheNextUser))
       forEachUser(TheNextUser, Visited, Callback);
 }
 
 void Verifier::visitGlobalValue(const GlobalValue &GV) {
   Assert(!GV.isDeclaration() || GV.hasValidDeclarationLinkage(),
          "Global is external, but doesn't have external or weak linkage!", &GV);
 
+  if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(&GV))
+    Assert(!GA->hasSignificantAddr(), "Aliases cannot have significant address",
+           GA);
+
   if (const GlobalObject *GO = dyn_cast<GlobalObject>(&GV))
     Assert(GO->getAlignment() <= Value::MaximumAlignment,
            "huge alignment values are unsupported", GO);
   Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
          "Only global variables can have appending linkage!", &GV);
 
   if (GV.hasAppendingLinkage()) {
     const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);

llvm/lib/Transforms/IPO/GlobalOpt.cpp

if (GV.getName().startswith("llvm."))
     return false;
 
   GlobalStatus GS;
 
   if (GlobalStatus::analyzeGlobal(&GV, GS))
     return false;
 
   bool Changed = false;
-  if (!GS.IsCompared && !GV.hasGlobalUnnamedAddr()) {
-    auto NewUnnamedAddr = GV.hasLocalLinkage() ? GlobalValue::UnnamedAddr::Global
-                                               : GlobalValue::UnnamedAddr::Local;
+  if (!GS.IsCompared && !GV.hasGlobalUnnamedAddr() &&
+      !GV.hasSignificantAddr()) {
+    auto NewUnnamedAddr = GV.hasLocalLinkage()
+                              ? GlobalValue::UnnamedAddr::Global
     if (NewUnnamedAddr != GV.getUnnamedAddr()) {
       GV.setUnnamedAddr(NewUnnamedAddr);
       NumUnnamed++;
       Changed = true;
     }
   }
 
   // Do more involved optimizations if the global is internal.

llvm/test/Assembler/significant-addr.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+; RUN: verify-uselistorder %s
+
+; CHECK: @c = significant_addr constant i32 0
+@c = significant_addr constant i32 0
+
+; CHECK: declare void @g() significant_addr
+declare void @g() significant_addr
+
+; CHECK: define void @f() significant_addr {
+define void @f() significant_addr {
+  ret void
+}

llvm/test/Bitcode/compatibility.ll

 @constant.vector.f16 = constant <3 x half> <half -0.0, half 1.0, half 0.0>
 ; CHECK: @constant.vector.f32 = constant <3 x float> <float -0.000000e+00, float 1.000000e+00, float 0.000000e+00>
 @constant.vector.f32 = constant <3 x float> <float -0.0, float 1.0, float 0.0>
 ; CHECK: @constant.vector.f64 = constant <3 x double> <double -0.000000e+00, double 1.000000e+00, double 0.000000e+00>
 @constant.vector.f64 = constant <3 x double> <double -0.0, double 1.0, double 0.0>
 
 ;; Global Variables
 ; Format: [@<GlobalVarName> =] [Linkage] [Visibility] [DLLStorageClass]
-;         [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] [AddrSpace] [ExternallyInitialized]
+;         [ThreadLocal] [(unnamed_addr|local_unnamed_addr|significant_addr)] [AddrSpace] [ExternallyInitialized]
 ;         <global | constant> <Type> [<InitializerConstant>]
 ;         [, section "name"] [, comdat [($name)]] [, align <Alignment>]
 
 ; Global Variables -- Simple
 @g1 = global i32 0
 ; CHECK: @g1 = global i32 0
 @g2 = constant i32 0
 ; CHECK: @g2 = constant i32 0

 ; CHECK: @g.generaldynamic = thread_local global i32 0
 @g.localdynamic = thread_local(localdynamic) global i32 0
 ; CHECK: @g.localdynamic = thread_local(localdynamic) global i32 0
 @g.initialexec = thread_local(initialexec) global i32 0
 ; CHECK: @g.initialexec = thread_local(initialexec) global i32 0
 @g.localexec = thread_local(localexec) global i32 0
 ; CHECK: @g.localexec = thread_local(localexec) global i32 0
 
-; Global Variables -- unnamed_addr and local_unnamed_addr
+; Global Variables -- unnamed_addr, local_unnamed_addr and significant_addr
 @g.unnamed_addr = unnamed_addr global i32 0
 ; CHECK: @g.unnamed_addr = unnamed_addr global i32 0
 @g.local_unnamed_addr = local_unnamed_addr global i32 0
 ; CHECK: @g.local_unnamed_addr = local_unnamed_addr global i32 0
[e-mail]_addr = significant_addr global i32 0
+; CHECK: @g.significant_addr = significant_addr global i32 0
 
 ; Global Variables -- AddrSpace
 @g.addrspace = addrspace(1) global i32 0
 ; CHECK: @g.addrspace = addrspace(1) global i32 0
 
 ; Global Variables -- ExternallyInitialized
 @g.externally_initialized = external externally_initialized global i32
 ; CHECK: @g.externally_initialized = external externally_initialized global i32

 entry:
   ret i8* null
 }
 
 ;; Functions
 ; Format: define [linkage] [visibility] [DLLStorageClass]
 ;         [cconv] [ret attrs]
 ;         <ResultType> @<FunctionName> ([argument list])
-;         [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"] [comdat [($name)]]
+;         [(unnamed_addr|local_unnamed_addr|significant_addr)] [fn Attrs] [section "name"] [comdat [($name)]]
 ;         [align N] [gc] [prefix Constant] [prologue Constant]
 ;         [personality Constant] { ... }
 
 ; Functions -- Simple
 declare void @f1 ()
 ; CHECK: declare void @f1()
 
 define void @f2 () {

 ; CHECK: declare i8* @f.param.returned(i8* returned)
 declare void @f.param.nonnull(i8* nonnull)
 ; CHECK: declare void @f.param.nonnull(i8* nonnull)
 declare void @f.param.dereferenceable(i8* dereferenceable(4))
 ; CHECK: declare void @f.param.dereferenceable(i8* dereferenceable(4))
 declare void @f.param.dereferenceable_or_null(i8* dereferenceable_or_null(4))
 ; CHECK: declare void @f.param.dereferenceable_or_null(i8* dereferenceable_or_null(4))
 
-; Functions -- unnamed_addr and local_unnamed_addr
+; Functions -- unnamed_addr, local_unnamed_addr and significant_addr
 declare void @f.unnamed_addr() unnamed_addr
 ; CHECK: declare void @f.unnamed_addr() unnamed_addr
 declare void @f.local_unnamed_addr() local_unnamed_addr
 ; CHECK: declare void @f.local_unnamed_addr() local_unnamed_addr
+declare void @f.significant_addr() significant_addr
+; CHECK: declare void @f.significant_addr() significant_addr
 
 ; Functions -- fn Attrs (Function attributes)
 declare void @f.alignstack4() alignstack(4)
 ; CHECK: declare void @f.alignstack4() #0
 declare void @f.alignstack8() alignstack(8)
 ; CHECK: declare void @f.alignstack8() #1
 declare void @f.alwaysinline() alwaysinline
 ; CHECK: declare void @f.alwaysinline() #2

llvm/test/Verifier/alias.ll

 ; CHECK-NEXT: i32* @test2_b
 
 
 @test3_a = global i32 42
 @test3_b = weak alias i32, i32* @test3_a
 @test3_c = alias i32, i32* @test3_b
 ; CHECK: Alias cannot point to an interposable alias
 ; CHECK-NEXT: i32* @test3_c
+
+@test4_a = global i32 42
+@test4_b = significant_addr alias i32, i32* @test4_a
+; CHECK: Aliases cannot have significant address