[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

820

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

849

This looks unnecessary, as you adjusted isValidLinkage()?

[MaskRay]

address comments

llvm/lib/IR/Verifier.cpp

820

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

820

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

824

Shouldn't this be isDeclarationForLinker?

[nikic]

llvm/docs/LangRef.rst

911

This needs to be updated.

[MaskRay]

make available_externally alias stricter

[MaskRay]

llvm/lib/IR/Verifier.cpp

824

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

913

not -> no?

llvm/lib/IR/Verifier.cpp

822

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 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:
 
 IFuncs
 -------

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 (const auto *GV = dyn_cast<GlobalValue>(&C)) {
-    Check(!GV->isDeclarationForLinker(), "Alias must point to a definition",
-          &GA);
+    Check(GA.hasAvailableExternallyLinkage() || !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.
       // Do not recurse into global initializers.
       return;
     }
   }
 
   if (const auto *CE = dyn_cast<ConstantExpr>(&C))
     visitConstantExprsRecursively(CE);
 
   for (const Use &U : C.operands()) {
     Value *V = &*U;
     if (const auto *GA2 = dyn_cast<GlobalAlias>(V))
       visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
     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
 
 
 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 alias i32, i32* @test3_a
+@test4_b = available_externally alias void(), void()* @f2
+@test4_c = available_externally alias i32, i32* @test4_a