[IR] Allow available_externally GlobalAlias

[MaskRay]

Summary

GlobalVariable and Function can be available_externally. GlobalAlias is used
similarly. Allowing available_externally is a natural extension and helps
ThinLTO discard GlobalAlias in a non-prevailing COMDAT (see D135427).

For now, available_externally GlobalAlias must point to an
available_externally GlobalValue (not ConstantExpr).

[nikic]

llvm/lib/IR/Verifier.cpp

826

Why is an available_externally alias allowed to point to a declaration?

860

This looks unnecessary, as you adjusted isValidLinkage()?

[MaskRay]

address comments

llvm/lib/IR/Verifier.cpp

826

An available_externally alias may refer to another available_externally GlobalValue. This is the case when an alias is in a non-prevailing COMDAT after my pending ThinLTO change.

[tejohnson]

llvm/lib/IR/Verifier.cpp

826

If the aliasee is available_externally you should check that the alias is as well.

[MaskRay]

enhance verifier

[tejohnson]

lgtm but wait to see if @nikic has any follow on questions

[nikic]

For the record, the current restriction was introduced in https://github.com/llvm/llvm-project/commit/8934577171b967cc23186c2ffa0a0c4b54a8d992. The commit message mentions that available_externally aliases, if introduced, should always have a declaration-for-linker aliasee. Just want to confirm that it is fine to not have that restriction, as implemented here.

llvm/lib/IR/Verifier.cpp

830

Shouldn't this be isDeclarationForLinker?

[nikic]

llvm/docs/LangRef.rst

910–913

This needs to be updated.

[MaskRay]

make available_externally alias stricter

[MaskRay]

llvm/lib/IR/Verifier.cpp

830

hasAvailableExternallyLinkage has precluded one condition of isDeclarationForLinker so isDeclaration suffices.

[MaskRay]

fix typo in LangRef: alias=>aliasee

[nikic]

Looks reasonable to me.

llvm/docs/LangRef.rst

912

not -> no?

llvm/lib/IR/Verifier.cpp

828

I think it would be slightly more elegant to put this into an else branch rather than check for available_externally again here.

[MaskRay]

address comments

llvm/docs/LangRef.rst

 <dllstorageclass>` and an optional :ref:`tls model <tls_model>`.
 
 Syntax::
 
     @<Name> = [Linkage] [PreemptionSpecifier] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>
               [, partition "name"]
 
 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.
+``linkonce_odr``, ``weak_odr``, ``external``, ``available_externally``. 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
   object file.
 
-* No global value in the expression can be a declaration, since that
-  would require a relocation, which is not possible.
+* If the alias has the ``available_externally`` linkage, the aliasee must be an
+  ``available_externally`` global value; otherwise the aliasee can be an
+  expression but no global value in the expression can be a declaration, since
+  that would require a relocation, which is not possible.
 
 * If either the alias or the aliasee may be replaced by a symbol outside the
   module at link time or runtime, any optimization cannot replace the alias with
   the aliasee, since the behavior may be different. The alias may be used as a
   name guaranteed to point to the content in the current module.
 
 .. _langref_ifunc:
 

llvm/include/llvm/IR/GlobalAlias.h

public:
 
   const GlobalObject *getAliaseeObject() const;
   GlobalObject *getAliaseeObject() {
     return const_cast<GlobalObject *>(
         static_cast<const GlobalAlias *>(this)->getAliaseeObject());
   }
 
   static bool isValidLinkage(LinkageTypes L) {
-    return isExternalLinkage(L) || isLocalLinkage(L) ||
-      isWeakLinkage(L) || isLinkOnceLinkage(L);
+    return isExternalLinkage(L) || isLocalLinkage(L) || isWeakLinkage(L) ||
+           isLinkOnceLinkage(L) || isAvailableExternallyLinkage(L);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalAliasVal;
   }
 };
 

llvm/lib/IR/Verifier.cpp

 void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
   SmallPtrSet<const GlobalAlias*, 4> Visited;
   Visited.insert(&GA);
   visitAliaseeSubExpr(Visited, GA, C);
 }
 
 void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
                                    const GlobalAlias &GA, const Constant &C) {
+  if (GA.hasAvailableExternallyLinkage()) {
+    Check(isa<GlobalValue>(C) &&
+              cast<GlobalValue>(C).hasAvailableExternallyLinkage(),
+          "available_externally alias must point to available_externally "
+          "global value",
+          &GA);
+  }
   if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
+    if (!GA.hasAvailableExternallyLinkage()) {
       Check(!GV->isDeclarationForLinker(), "Alias must point to a definition",
             &GA);
+    }
 
     if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
       Check(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
 
       Check(!GA2->isInterposable(),
             "Alias cannot point to an interposable alias", &GA);
     } else {
       // Only continue verifying subexpressions of GlobalAliases.
for (const Use &U : C.operands()) {
     else if (const auto *C2 = dyn_cast<Constant>(V))
       visitAliaseeSubExpr(Visited, GA, *C2);
   }
 }
 
 void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
   Check(GlobalAlias::isValidLinkage(GA.getLinkage()),
         "Alias should have private, internal, linkonce, weak, linkonce_odr, "
-        "weak_odr, or external linkage!",
+        "weak_odr, external, or available_externally linkage!",
         &GA);
   const Constant *Aliasee = GA.getAliasee();
   Check(Aliasee, "Aliasee cannot be NULL!", &GA);
   Check(GA.getType() == Aliasee->getType(),
         "Alias and aliasee types should match!", &GA);
 
   Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
         "Aliasee should be either GlobalValue or ConstantExpr", &GA);

llvm/test/Verifier/alias.ll

-; RUN:  not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
+; RUN:  not llvm-as %s -o /dev/null 2>&1 | FileCheck %s --implicit-check-not=alias --implicit-check-not=Alias
 
 
 declare void @f()
 @fa = alias void (), void ()* @f
 ; CHECK: Alias must point to a definition
 ; CHECK-NEXT: @fa
 
 @g = external global i32

 ; 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 = available_externally global i32 42
+@test4_b = available_externally alias i32, i32* @test4_a
+@test4_c = available_externally alias void(), void()* @f2
+@test4_d = available_externally alias i32, i32* @test4_b
+
+@test4_e = available_externally alias i32, i32* @test3_a
+@test4_f = available_externally alias i32, inttoptr (i64 sub (i64 ptrtoint (i32* @test4_a to i64), i64 ptrtoint (i32* @test4_a to i64)) to i32*)
+; CHECK:      available_externally alias must point to available_externally global value
+; CHECK-NEXT: i32* @test4_e
+; CHECK:      available_externally alias must point to available_externally global value
+; CHECK-NEXT: i32* @test4_f