IR: Teach GlobalIndirectSymbol::getBaseObject() to handle more kinds of expressions.

[pcc]

Summary

For aliases, any expression that lowers at the MC level to global_object or
global_object+constant is valid at the object file level. getBaseObject()
should return a result if the aliasee ends up being of that form even if
the IR used to produce it is somewhat unconventional.

Note that this is different from what stripInBoundsOffsets() and that family
of functions is doing. Those functions are concerned about semantic properties
of IR, whereas here we only care about the lowering result.

Therefore reimplement getBaseObject() in a way that matches the lowering
result. This fixes a crash when producing a summary for aliases such as
that in the included test case.

[tejohnson]

llvm/lib/IR/Globals.cpp

436 ↗

(On Diff #211189)

Why is this needed? Is it possible to have cycles in the indirection?

441 ↗

(On Diff #211189)

Is it possible for the other operand of the add (or subtract below) to be something that disqualifies this from analysis, i.e. that needs checking?

llvm/test/Linker/comdat8.ll

6 ↗

(On Diff #211189)

Why does this test change?

[pcc]

llvm/lib/IR/Globals.cpp

436 ↗

(On Diff #211189)

Yes, in invalid IR. Without this we hang when reading this IR instead of erroring in the verifier. See llvm/test/Verifier/alias.ll for one example.

441 ↗

(On Diff #211189)

Yes, A+B where both A and B refer to GlobalObjects would mean we need to return nullptr here. I'll add a case for that. For subtract we're already checking both operands.

llvm/test/Linker/comdat8.ll

6 ↗

(On Diff #211189)

Because now we can analyze the aliasee, so it needed to be replaced with something that doesn't refer to a base object. See http://llvm-cs.pcc.me.uk/lib/Linker/LinkModules.cpp#134 for the call that now succeeds.

[pcc]

• Check both operands of an add; follow GlobalAliases only

[tejohnson]

LGTM

llvm/trunk/include/llvm/IR/GlobalIndirectSymbol.h

public:
   const Constant *getIndirectSymbol() const {
     return getOperand(0);
   }
   Constant *getIndirectSymbol() {
     return const_cast<Constant *>(
           static_cast<const GlobalIndirectSymbol *>(this)->getIndirectSymbol());
   }
 
-  const GlobalObject *getBaseObject() const {
-    return dyn_cast<GlobalObject>(getIndirectSymbol()->stripInBoundsOffsets());
-  }
+  const GlobalObject *getBaseObject() const;
   GlobalObject *getBaseObject() {
     return const_cast<GlobalObject *>(
               static_cast<const GlobalIndirectSymbol *>(this)->getBaseObject());
   }
 
   const GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) const {
     return dyn_cast<GlobalObject>(
         getIndirectSymbol()->stripAndAccumulateInBoundsConstantOffsets(DL,

llvm/trunk/lib/IR/Globals.cpp

 
 GlobalIndirectSymbol::GlobalIndirectSymbol(Type *Ty, ValueTy VTy,
     unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name,
     Constant *Symbol)
     : GlobalValue(Ty, VTy, &Op<0>(), 1, Linkage, Name, AddressSpace) {
     Op<0>() = Symbol;
 }
 
+static const GlobalObject *
+findBaseObject(const Constant *C, DenseSet<const GlobalAlias *> &Aliases) {
+  if (auto *GO = dyn_cast<GlobalObject>(C))
+    return GO;
+  if (auto *GA = dyn_cast<GlobalAlias>(C))
+    if (Aliases.insert(GA).second)
+      return findBaseObject(GA->getOperand(0), Aliases);
+  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
+    switch (CE->getOpcode()) {
+    case Instruction::Add: {
+      auto *LHS = findBaseObject(CE->getOperand(0), Aliases);
+      auto *RHS = findBaseObject(CE->getOperand(1), Aliases);
+      if (LHS && RHS)
+        return nullptr;
+      return LHS ? LHS : RHS;
+    }
+    case Instruction::Sub: {
+      if (findBaseObject(CE->getOperand(1), Aliases))
+        return nullptr;
+      return findBaseObject(CE->getOperand(0), Aliases);
+    }
+    case Instruction::IntToPtr:
+    case Instruction::PtrToInt:
+    case Instruction::BitCast:
+    case Instruction::GetElementPtr:
+      return findBaseObject(CE->getOperand(0), Aliases);
+    default:
+      break;
+    }
+  }
+  return nullptr;
+}
+
+const GlobalObject *GlobalIndirectSymbol::getBaseObject() const {
+  DenseSet<const GlobalAlias *> Aliases;
+  return findBaseObject(getOperand(0), Aliases);
+}
 
 //===----------------------------------------------------------------------===//
 // GlobalAlias Implementation
 //===----------------------------------------------------------------------===//
 
 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
                          const Twine &Name, Constant *Aliasee,
                          Module *ParentModule)

llvm/trunk/test/Bitcode/thinlto-alias3.ll

+; Test that inttoptr, add and ptrtoint don't cause problems in alias summaries.
+; RUN: opt -module-summary %s -o - | llvm-dis | FileCheck %s
+
+; CHECK: ^1 = gv: (name: "a", {{.*}} aliasee: ^2
+; CHECK: ^2 = gv: (name: "b",
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@a = alias i32, i32* inttoptr (i64 add (i64 ptrtoint (i32* @b to i64), i64 1297036692682702848) to i32*)
+@b = global i32 1

llvm/trunk/test/Linker/comdat8.ll

 ; RUN: not llvm-link %s %p/Inputs/comdat8.ll -S -o - 2>&1 | FileCheck %s
 
 $c1 = comdat largest
 
-@some_name = private unnamed_addr constant i32 42, comdat($c1)
-@c1 = alias i8, inttoptr (i32 ptrtoint (i32* @some_name to i32) to i8*)
+@some_name = unnamed_addr constant i32 42, comdat($c1)
+@c1 = alias i8, inttoptr (i32 1 to i8*)
 
 ; CHECK: COMDAT key involves incomputable alias size.