ThinLTO: Preserve alias-to-alias information (PR37884)

[vlad.tsyrklevich]

Summary

Change the BitcodeWriter/ModuleSummaryAnalysis to save the target of an
alias as the aliasee it points to, instead of the base object the alias
points to, e.g. without recursively dereferencing aliases until a
GlobalObject is reached. This is necessary for interprocedural analyses
that want to conservatively avoid evaluating call paths including
dso_preemptable symbols such as dso_local alias -> dso_preemptable alias
-> dso_local function.

Value::stripInBoundsOffsetsNoFollowAliases() is required to match the
logic of GlobalAlias::getBaseObject() without 'dereferencing' aliases,
its implementation matches that of stripPointerCastsNoFollowAliases().
The current stripInBoundsOffsets*() methods did not document that they
also strip aliases.

[pcc]

I think we should be going in the other direction and removing alias summaries from the summary index altogether.

Note that in your example it would be valid to consider AliasToAlias to point to func. This is because creating an alias to a dso_preemptable global does not cause the alias to become preemptible: an alias is just another name for the (section, offset) pair represented by the global that it refers to.

[vlad.tsyrklevich]

You're right, I misunderstood how aliases were represented.

include/llvm/IR/ModuleSummaryIndex.h

public:
   bool isDSOLocal() const { return Flags.DSOLocal; }
 
   /// Flag that this global value cannot be imported.
   void setNotEligibleToImport() { Flags.NotEligibleToImport = true; }
 
   /// Return the list of values referenced by this global value definition.
   ArrayRef<ValueInfo> refs() const { return RefEdgeList; }
 
-  /// If this is an alias summary, returns the summary of the aliased object (a
+  /// If this is an alias summary, returns the summary of the base object (a
   /// global variable or function), otherwise returns itself.
   GlobalValueSummary *getBaseObject();
   const GlobalValueSummary *getBaseObject() const;
 
   friend class ModuleSummaryIndex;
 };
 
 /// Alias summary information.
public:
   /// Check if this is an alias summary.
   static bool classof(const GlobalValueSummary *GVS) {
     return GVS->getSummaryKind() == AliasKind;
   }
 
   void setAliasee(GlobalValueSummary *Aliasee) { AliaseeSummary = Aliasee; }
   void setAliaseeGUID(GlobalValue::GUID GUID) { AliaseeGUID = GUID; }
 
+  /// Returns the summary of the aliasee, which could be another alias.
   const GlobalValueSummary &getAliasee() const {
     assert(AliaseeSummary && "Unexpected missing aliasee summary");
     return *AliaseeSummary;
   }
 
   GlobalValueSummary &getAliasee() {
     return const_cast<GlobalValueSummary &>(
                          static_cast<const AliasSummary *>(this)->getAliasee());
   }
   const GlobalValue::GUID &getAliaseeGUID() const {
     assert(AliaseeGUID && "Unexpected missing aliasee GUID");
     return AliaseeGUID;
   }
 };
 
 const inline GlobalValueSummary *GlobalValueSummary::getBaseObject() const {
-  if (auto *AS = dyn_cast<AliasSummary>(this))
-    return &AS->getAliasee();
-  return this;
+  const GlobalValueSummary *Summary = this;
+  while (isa<AliasSummary>(Summary))
+    Summary = &cast<AliasSummary>(Summary)->getAliasee();
+
+  return Summary;
 }
 
 inline GlobalValueSummary *GlobalValueSummary::getBaseObject() {
-  if (auto *AS = dyn_cast<AliasSummary>(this))
-    return &AS->getAliasee();
-  return this;
+  GlobalValueSummary *Summary = this;
+  while (isa<AliasSummary>(Summary))
+    Summary = &cast<AliasSummary>(Summary)->getAliasee();
+
+  return Summary;
 }
 
 /// Function summary information to aid decisions and implementation of
 /// importing.
 class FunctionSummary : public GlobalValueSummary {
 public:
   /// <CalleeValueInfo, CalleeInfo> call edge pair.
   using EdgeTy = std::pair<ValueInfo, CalleeInfo>;

include/llvm/IR/Value.h

#include "llvm/IR/Value.def"
   /// Returns the original uncasted value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripPointerCastsNoFollowAliases() const;
   Value *stripPointerCastsNoFollowAliases() {
     return const_cast<Value *>(
           static_cast<const Value *>(this)->stripPointerCastsNoFollowAliases());
   }
 
-  /// Strip off pointer casts and all-constant inbounds GEPs.
+  /// Strip off pointer casts, all-constant inbounds GEPs, and aliases.
   ///
   /// Returns the original pointer value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripInBoundsConstantOffsets() const;
   Value *stripInBoundsConstantOffsets() {
     return const_cast<Value *>(
               static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
   }
 
   /// Accumulate offsets from \a stripInBoundsConstantOffsets().
   ///
   /// Stores the resulting constant offset stripped into the APInt provided.
   /// The provided APInt will be extended or truncated as needed to be the
   /// correct bitwidth for an offset of this pointer type.
   ///
   /// If this is called on a non-pointer value, it returns 'this'.
   const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                          APInt &Offset) const;
   Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                    APInt &Offset) {
     return const_cast<Value *>(static_cast<const Value *>(this)
         ->stripAndAccumulateInBoundsConstantOffsets(DL, Offset));
   }
 
-  /// Strip off pointer casts and inbounds GEPs.
+  /// Strip off pointer casts, inbounds GEPs, and aliases.
   ///
   /// Returns the original pointer value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripInBoundsOffsets() const;
   Value *stripInBoundsOffsets() {
     return const_cast<Value *>(
-                      static_cast<const Value *>(this)->stripInBoundsOffsets());
   }
 
+  /// Strip off pointer casts and inbounds GEPs.
+  ///
+  /// Returns the original pointer value.  If this is called on a non-pointer
+  /// value, it returns 'this'.
+  const Value *stripInBoundsOffsetsNoFollowAliases() const;
+  Value *stripInBoundsOffsetsNoFollowAliases() {
+    return const_cast<Value *>(static_cast<const Value *>(this)
+                                   ->stripInBoundsOffsetsNoFollowAliases());
+  }
+
   /// Returns the number of bytes known to be dereferenceable for the
   /// pointer value.
   ///
   /// If CanBeNull is set by this function the pointer can either be null or be
   /// dereferenceable up to the returned number of bytes.
   uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
                                           bool &CanBeNull) const;
 

lib/Analysis/ModuleSummaryAnalysis.cpp

 
 static void
 computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A,
                     DenseSet<GlobalValue::GUID> &CantBePromoted) {
   bool NonRenamableLocal = isNonRenamableLocal(A);
   GlobalValueSummary::GVFlags Flags(A.getLinkage(), NonRenamableLocal,
                                     /* Live = */ false, A.isDSOLocal());
   auto AS = llvm::make_unique<AliasSummary>(Flags);
-  auto *Aliasee = A.getBaseObject();
+  auto *Aliasee = dyn_cast<GlobalValue>(
+      A.getAliasee()->stripInBoundsOffsetsNoFollowAliases());
   auto *AliaseeSummary = Index.getGlobalValueSummary(*Aliasee);
   assert(AliaseeSummary && "Alias expects aliasee summary to be parsed");
   AS->setAliasee(AliaseeSummary);
   if (NonRenamableLocal)
     CantBePromoted.insert(A.getGUID());
   Index.addGlobalValueSummary(A.getName(), std::move(AS));
 }
 

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
   }
 
   // Capture references from GlobalVariable initializers, which are outside
   // of a function scope.
   for (const GlobalVariable &G : M.globals())
     writeModuleLevelReferences(G, NameVals, FSModRefsAbbrev);
 
   for (const GlobalAlias &A : M.aliases()) {
-    auto *Aliasee = A.getBaseObject();
+    auto *Aliasee = A.getAliasee()->stripInBoundsOffsetsNoFollowAliases();
     if (!Aliasee->hasName())
       // Nameless function don't have an entry in the summary, skip it.
       continue;
     auto AliasId = VE.getValueID(&A);
     auto AliaseeId = VE.getValueID(Aliasee);
     NameVals.push_back(AliasId);
     auto *Summary = Index->getGlobalValueSummary(A);
     AliasSummary *AS = cast<AliasSummary>(Summary);

lib/IR/Value.cpp

 }
 
 namespace {
 // Various metrics for how much to strip off of pointers.
 enum PointerStripKind {
   PSK_ZeroIndices,
   PSK_ZeroIndicesAndAliases,
   PSK_ZeroIndicesAndAliasesAndInvariantGroups,
-  PSK_InBoundsConstantIndices,
-  PSK_InBounds
+  PSK_InBounds,
+  PSK_InBoundsAndAliases,
+  PSK_InBoundsConstantIndicesAndAliases
 };
 
 template <PointerStripKind StripKind>
 static const Value *stripPointerCastsAndOffsets(const Value *V) {
   if (!V->getType()->isPointerTy())
     return V;
 
   // Even though we don't look through PHI nodes, we could be called on an
   // instruction in an unreachable block, which may be on a cycle.
   SmallPtrSet<const Value *, 4> Visited;
 
   Visited.insert(V);
   do {
     if (auto *GEP = dyn_cast<GEPOperator>(V)) {
       switch (StripKind) {
       case PSK_ZeroIndicesAndAliases:
       case PSK_ZeroIndicesAndAliasesAndInvariantGroups:
       case PSK_ZeroIndices:
         if (!GEP->hasAllZeroIndices())
           return V;
         break;
-      case PSK_InBoundsConstantIndices:
+      case PSK_InBoundsConstantIndicesAndAliases:
         if (!GEP->hasAllConstantIndices())
           return V;
         LLVM_FALLTHROUGH;
       case PSK_InBounds:
+      case PSK_InBoundsAndAliases:
         if (!GEP->isInBounds())
           return V;
         break;
       }
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast ||
                Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (auto *GA = dyn_cast<GlobalAlias>(V)) {
-      if (StripKind == PSK_ZeroIndices || GA->isInterposable())
+      if (StripKind == PSK_ZeroIndices || StripKind == PSK_InBounds ||
+          GA->isInterposable())
         return V;
       V = GA->getAliasee();
     } else {
       if (auto CS = ImmutableCallSite(V)) {
         if (const Value *RV = CS.getReturnedArgOperand()) {
           V = RV;
           continue;
         }
const Value *Value::stripPointerCasts() const {
   return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndAliases>(this);
 }
 
 const Value *Value::stripPointerCastsNoFollowAliases() const {
   return stripPointerCastsAndOffsets<PSK_ZeroIndices>(this);
 }
 
 const Value *Value::stripInBoundsConstantOffsets() const {
-  return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(this);
+  return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndicesAndAliases>(
+      this);
 }
 
 const Value *Value::stripPointerCastsAndInvariantGroups() const {
   return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndAliasesAndInvariantGroups>(
       this);
 }
 
 const Value *
do {
     }
     assert(V->getType()->isPointerTy() && "Unexpected operand type!");
   } while (Visited.insert(V).second);
 
   return V;
 }
 
 const Value *Value::stripInBoundsOffsets() const {
+  return stripPointerCastsAndOffsets<PSK_InBoundsAndAliases>(this);
+}
+
+const Value *Value::stripInBoundsOffsetsNoFollowAliases() const {
   return stripPointerCastsAndOffsets<PSK_InBounds>(this);
 }
 
 uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
                                                bool &CanBeNull) const {
   assert(getType()->isPointerTy() && "must be pointer");
 
   uint64_t DerefBytes = 0;

lib/LTO/LTO.cpp

function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
         recordNewLinkage) {
   // We won't optimize the globals that are referenced by an alias for now
   // Ideally we should turn the alias into a global and duplicate the definition
   // when needed.
   DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
   for (auto &I : Index)
     for (auto &S : I.second.SummaryList)
       if (auto AS = dyn_cast<AliasSummary>(S.get()))
-        GlobalInvolvedWithAlias.insert(&AS->getAliasee());
+        GlobalInvolvedWithAlias.insert(AS->getBaseObject());
 
   for (auto &I : Index)
     thinLTOResolveWeakForLinkerGUID(I.second.SummaryList, I.first,
                                     GlobalInvolvedWithAlias, isPrevailing,
                                     recordNewLinkage);
 }
 
 static void thinLTOInternalizeAndPromoteGUID(

test/Bitcode/thinlto-alias-to-alias.ll

+; Test to check the aliases to aliases are represented correctly (e.g. that an alias to an alias is not shortcut to point to the base object.)
+
+; RUN: opt -module-summary %s -o %t.o
+; RUN: llvm-dis -o - %t.o | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@Alias = dso_preemptable alias void(), void()* @func
+@AliasToAlias = dso_local alias void(), void()* @Alias
+
+define dso_local void @func() {
+  ret void
+}
+
+; CHECK: ^0 = module: (path: "{{.*}}thinlto-alias-to-alias.ll.tmp.o", hash: (0, 0, 0, 0, 0))
+; CHECK: ^1 = gv: (name: "func", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1), insts: 1))) ; guid = 7289175272376759421
+; CHECK: ^2 = gv: (name: "AliasToAlias", summaries: (alias: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1), aliasee: ^3))) ; guid = 15479319319369236563
+; CHECK: ^3 = gv: (name: "Alias", summaries: (alias: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 0), aliasee: ^1))) ; guid = 16088086490780401135