Introduce GlobalAlias::mayBeResolved().

[pcc]

Summary

This controls whether the aliasee may be used instead of the alias.
Normally the same as mayBeOverridden(), except in the case where the
alias's visibility differs from the aliasee, as the visibility controls
whether accesses use the global offset table (which can be important).

[asl]

I'm not sure that changing mayBeOverriden() to mayBeResolved() everywhere is fine. E.g. change to getUnderlyingObject() might not be correct. Ditto for SCEV / Inliner changes.

[• rafael]

Needs a testcase.

[• rafael]

I don' think "may" is the best term in here. Resolving an alias should be legal. It only causes problem in very special cases (like the got not being available yet ). The question is if it is profitable to do so.

In the globalopt case it is not. I have not investigated what the other passes are doing.

[pcc]

• Add test case

[pcc]

Needs a testcase.

Hmm. I wonder where the test case should live, then. The purpose of the test case should be to check that no (standard) pass resolves the alias, so I don't think it should belong to a specific pass, such as globalopt. For now I added it under test/Other. (Existing globalopt tests already check that aliases are resolved when they should be, so my test only checks that aliases aren't resolved when they shouldn't be.)

I don' think "may" is the best term in here. Resolving an alias should be legal. It only causes problem in very special cases (like the got not being available yet ). The question is if it is profitable to do so.

Well, the choice of whether to resolve an alias can also affect the semantics of symbol interpositioning. While we normally don't care about interpositioning semantics, I think that if the user has gone to the trouble of creating an alias whose visibility differs from the aliasee, that's a pretty strong signal that the user cares about those semantics, and we should respect the user's wishes.

[pcc]

Ping.

[• rafael]

include/llvm/IR/GlobalAlias.h

82

I would still prefer to state this as a profitability issue. We really don't model interposition of non weak symbols, and a partial implementation would do more harm than good IMHO.

In particular, please call this function something like shouldBeResolved or isProfitableToResolve. The function should also return true if the Aliasee is "more hidden" than the alias.

test/Other/alias-resolution.ll

2

This is a reasonable use of -O3. Please just add a comment saying why (we want to make sure no pass resolves the alias).

[MaskRay]

I like the idea. 7 years have passed... We still miss the optimization opportunity:

int _rtld_global;
extern int _rtld_local __attribute__((visibility("hidden"), alias("_rtld_global")));

int get() { return _rtld_local; }

gcc -fPIC -O3 -fno-common -c a.c => R_X86_64_PC32
clang -fPIC -O3 -fno-common -c a.c => R_X86_64_GOTPCREL

include/llvm/IR/GlobalAlias.h

public:
 
   /// resolveAliasedGlobal() - This method tries to ultimately resolve the alias
   /// by going through the aliasing chain and trying to find the very last
   /// global. Returns NULL if a cycle was found. If stopOnWeak is false, then
   /// the whole chain aliasing chain is traversed, otherwise - only strong
   /// aliases.
   const GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true) const;
 
+  /// Whether the aliasee may be used instead of the alias.  Normally the same
+  /// as mayBeOverridden(), except in the case where the alias's visibility
+  /// differs from the aliasee, as the visibility controls whether accesses use
+  /// the global offset table (which can be important).
+  bool mayBeResolved() const {
+    return !mayBeOverridden() &&
+           getVisibility() == getAliasedGlobal()->getVisibility();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalAliasVal;
   }
 };
 
 template <>
 struct OperandTraits<GlobalAlias> :
   public FixedNumOperandTraits<GlobalAlias, 1> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
 
 } // End llvm namespace
 
 #endif

lib/Analysis/BasicAliasAnalysis.cpp

DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
   
   BaseOffs = 0;
   do {
     // See if this is a bitcast or GEP.
     const Operator *Op = dyn_cast<Operator>(V);
     if (Op == 0) {
       // The only non-operator case we can handle are GlobalAliases.
       if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
-        if (!GA->mayBeOverridden()) {
+        if (GA->mayBeResolved()) {
           V = GA->getAliasee();
           continue;
         }
       }
       return V;
     }
     
     if (Op->getOpcode() == Instruction::BitCast) {

lib/Analysis/IPA/InlineCost.cpp

ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) {
   do {
     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
       if (!GEP->isInBounds() || !accumulateGEPOffset(*GEP, Offset))
         return 0;
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
-      if (GA->mayBeOverridden())
+      if (!GA->mayBeResolved())
         break;
       V = GA->getAliasee();
     } else {
       break;
     }
     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
   } while (Visited.insert(V));
 

lib/Analysis/InstructionSimplify.cpp

static Constant *stripAndComputeConstantOffsets(const DataLayout *TD,
   do {
     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
       if (!GEP->isInBounds() || !GEP->accumulateConstantOffset(*TD, Offset))
         break;
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
-      if (GA->mayBeOverridden())
+      if (!GA->mayBeResolved())
         break;
       V = GA->getAliasee();
     } else {
       break;
     }
     assert(V->getType()->getScalarType()->isPointerTy() &&
            "Unexpected operand type!");
   } while (Visited.insert(V));

lib/Analysis/MemoryBuiltins.cpp

SizeOffsetType ObjectSizeOffsetVisitor::visitGEPOperator(GEPOperator &GEP) {
   APInt Offset(IntTyBits, 0);
   if (!bothKnown(PtrData) || !GEP.accumulateConstantOffset(*TD, Offset))
     return unknown();
 
   return std::make_pair(PtrData.first, PtrData.second + Offset);
 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitGlobalAlias(GlobalAlias &GA) {
-  if (GA.mayBeOverridden())
+  if (!GA.mayBeResolved())
     return unknown();
   return compute(GA.getAliasee());
 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitGlobalVariable(GlobalVariable &GV){
   if (!GV.hasDefinitiveInitializer())
     return unknown();
 

lib/Analysis/ScalarEvolution.cpp

if (!DT->isReachableFromEntry(I->getParent()))
       return getUnknown(V);
   } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
     Opcode = CE->getOpcode();
   else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
     return getConstant(CI);
   else if (isa<ConstantPointerNull>(V))
     return getConstant(V->getType(), 0);
   else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
-    return GA->mayBeOverridden() ? getUnknown(V) : getSCEV(GA->getAliasee());
+    return GA->mayBeResolved() ? getSCEV(GA->getAliasee()) : getUnknown(V);
   else
     return getUnknown(V);
 
   Operator *U = cast<Operator>(V);
   switch (Opcode) {
   case Instruction::Add: {
     // The simple thing to do would be to just call getSCEV on both operands
     // and call getAddExpr with the result. However if we're looking at a

lib/Analysis/ValueTracking.cpp

if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
     else
       KnownZero.clearAllBits();
     KnownOne.clearAllBits();
     return;
   }
   // A weak GlobalAlias is totally unknown. A non-weak GlobalAlias has
   // the bits of its aliasee.
   if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
-    if (GA->mayBeOverridden()) {
+    if (!GA->mayBeResolved()) {
       KnownZero.clearAllBits(); KnownOne.clearAllBits();
     } else {
       ComputeMaskedBits(GA->getAliasee(), KnownZero, KnownOne, TD, Depth+1);
     }
     return;
   }
 
   if (Argument *A = dyn_cast<Argument>(V)) {
if (GEPOperator *GEP = dyn_cast<GEPOperator>(Ptr)) {
       APInt GEPOffset(BitWidth, 0);
       if (TD && !GEP->accumulateConstantOffset(*TD, GEPOffset))
         break;
       ByteOffset += GEPOffset;
       Ptr = GEP->getPointerOperand();
     } else if (Operator::getOpcode(Ptr) == Instruction::BitCast) {
       Ptr = cast<Operator>(Ptr)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(Ptr)) {
-      if (GA->mayBeOverridden())
+      if (!GA->mayBeResolved())
         break;
       Ptr = GA->getAliasee();
     } else {
       break;
     }
   }
   Offset = ByteOffset.getSExtValue();
   return Ptr;
llvm::GetUnderlyingObject(Value *V, const DataLayout *TD, unsigned MaxLookup) {
   if (!V->getType()->isPointerTy())
     return V;
   for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
-      if (GA->mayBeOverridden())
+      if (!GA->mayBeResolved())
         return V;
       V = GA->getAliasee();
     } else {
       // See if InstructionSimplify knows any relevant tricks.
       if (Instruction *I = dyn_cast<Instruction>(V))
         // TODO: Acquire a DominatorTree and use it.
         if (Value *Simplified = SimplifyInstruction(I, TD, 0)) {
           V = Simplified;

lib/IR/Globals.cpp

const GlobalValue *GlobalAlias::getAliasedGlobal() const {
   
   return cast<GlobalValue>(CE->getOperand(0));
 }
 
 const GlobalValue *GlobalAlias::resolveAliasedGlobal(bool stopOnWeak) const {
   SmallPtrSet<const GlobalValue*, 3> Visited;
 
   // Check if we need to stop early.
-  if (stopOnWeak && mayBeOverridden())
+  if (stopOnWeak && !mayBeResolved())
     return this;
 
   const GlobalValue *GV = getAliasedGlobal();
   Visited.insert(GV);
 
   // Iterate over aliasing chain, stopping on weak alias if necessary.
   while (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV)) {
-    if (stopOnWeak && GA->mayBeOverridden())
+    if (stopOnWeak && !GA->mayBeResolved())
       break;
 
     GV = GA->getAliasedGlobal();
 
     if (!Visited.insert(GV))
       return 0;
   }
 
   return GV;
 }

lib/IR/Value.cpp

if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
         if (!GEP->isInBounds())
           return V;
         break;
       }
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
-      if (StripKind == PSK_ZeroIndices || GA->mayBeOverridden())
+      if (StripKind == PSK_ZeroIndices || !GA->mayBeResolved())
         return V;
       V = GA->getAliasee();
     } else {
       return V;
     }
     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
   } while (Visited.insert(V));
 

lib/Transforms/IPO/GlobalOpt.cpp

bool GlobalOpt::OptimizeGlobalAliases(Module &M) {
 
   for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
        I != E;) {
     Module::alias_iterator J = I++;
     // Aliases without names cannot be referenced outside this module.
     if (!J->hasName() && !J->isDeclaration())
       J->setLinkage(GlobalValue::InternalLinkage);
     // If the aliasee may change at link time, nothing can be done - bail out.
-    if (J->mayBeOverridden())
+    if (!J->mayBeResolved())
       continue;
 
     Constant *Aliasee = J->getAliasee();
     GlobalValue *Target = cast<GlobalValue>(Aliasee->stripPointerCasts());
     Target->removeDeadConstantUsers();
     bool hasOneUse = Target->hasOneUse() && Aliasee->hasOneUse();
 
     // Make all users of the alias use the aliasee instead.

lib/Transforms/ObjCARC/ObjCARCContract.cpp

for (;;) {
 
       // If Arg is a no-op casted pointer, strip one level of casts and iterate.
       if (const BitCastInst *BI = dyn_cast<BitCastInst>(Arg))
         Arg = BI->getOperand(0);
       else if (isa<GEPOperator>(Arg) &&
                cast<GEPOperator>(Arg)->hasAllZeroIndices())
         Arg = cast<GEPOperator>(Arg)->getPointerOperand();
       else if (isa<GlobalAlias>(Arg) &&
-               !cast<GlobalAlias>(Arg)->mayBeOverridden())
+               cast<GlobalAlias>(Arg)->mayBeResolved())
         Arg = cast<GlobalAlias>(Arg)->getAliasee();
       else
         break;
     }
   }
 
   // If this function has no escaping allocas or suspicious vararg usage,
   // objc_storeStrong calls can be marked with the "tail" keyword.
   if (TailOkForStoreStrongs)
     for (SmallPtrSet<CallInst *, 8>::iterator I = StoreStrongCalls.begin(),
          E = StoreStrongCalls.end(); I != E; ++I)
       (*I)->setTailCall();
   StoreStrongCalls.clear();
 
   return Changed;
 }

lib/Transforms/Scalar/SROA.cpp

if (Ptr->getType()->isIntegerTy(8)) {
       Int8Ptr = Ptr;
       Int8PtrOffset = Offset;
     }
 
     // Peel off a layer of the pointer and update the offset appropriately.
     if (Operator::getOpcode(Ptr) == Instruction::BitCast) {
       Ptr = cast<Operator>(Ptr)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(Ptr)) {
-      if (GA->mayBeOverridden())
+      if (!GA->mayBeResolved())
         break;
       Ptr = GA->getAliasee();
     } else {
       break;
     }
     assert(Ptr->getType()->isPointerTy() && "Unexpected operand type!");
   } while (Visited.insert(Ptr));
 

test/Other/alias-resolution.ll

+; RUN: opt < %s -O3 -S | FileCheck %s
+
+@a = hidden global i32 1
+@aa = alias i32* @a
+
+; CHECK: @get_a
+define i32 @get_a() {
+  ; CHECK: load i32* @aa
+  %a = load i32* @aa
+  ret i32 %a
+}
+
+@b = global i32 1
+@ba = hidden alias i32* @b
+
+; CHECK: @get_b
+define i32 @get_b() {
+  ; CHECK: load i32* @ba
+  %b = load i32* @ba
+  ret i32 %b
+}