Reland r313157, "ThinLTO: Correctly follow aliasee references when dead stripping." which was reverted in r313222.

[pcc]

Summary

This reland includes a fix for the LowerTypeTests pass so that it
looks past aliases when determining which type identifiers are live.

[tejohnson]

LGTM

llvm/include/llvm/IR/ModuleSummaryIndex.h

public:
   void setLive(bool Live) { Flags.Live = Live; }
 
   /// 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
+  /// global variable or function), otherwise returns itself.
+  GlobalValueSummary *getBaseObject();
+
   friend class ModuleSummaryIndex;
   friend void computeDeadSymbols(class ModuleSummaryIndex &,
                                  const DenseSet<GlobalValue::GUID> &);
 };
 
 /// \brief Alias summary information.
 class AliasSummary : public GlobalValueSummary {
   GlobalValueSummary *AliaseeSummary;
public:
   }
 
   GlobalValueSummary &getAliasee() {
     return const_cast<GlobalValueSummary &>(
                          static_cast<const AliasSummary *>(this)->getAliasee());
   }
 };
 
+inline GlobalValueSummary *GlobalValueSummary::getBaseObject() {
+  if (auto *AS = dyn_cast<AliasSummary>(this))
+    return &AS->getAliasee();
+  return this;
+}
+
 /// \brief 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>;
 
   /// An "identifier" for a virtual function. This contains the type identifier

llvm/lib/Transforms/IPO/FunctionImport.cpp

static void ComputeImportForModule(
 
   // Populate the worklist with the import for the functions in the current
   // module
   for (auto &GVSummary : DefinedGVSummaries) {
     if (!Index.isGlobalValueLive(GVSummary.second)) {
       DEBUG(dbgs() << "Ignores Dead GUID: " << GVSummary.first << "\n");
       continue;
     }
-    auto *Summary = GVSummary.second;
-    if (auto *AS = dyn_cast<AliasSummary>(Summary))
-      Summary = &AS->getAliasee();
-    auto *FuncSummary = dyn_cast<FunctionSummary>(Summary);
+    auto *FuncSummary =
+        dyn_cast<FunctionSummary>(GVSummary.second->getBaseObject());
     if (!FuncSummary)
       // Skip import for global variables
       continue;
     DEBUG(dbgs() << "Initialize import for " << GVSummary.first << "\n");
     computeImportForFunction(*FuncSummary, Index, ImportInstrLimit,
                              DefinedGVSummaries, Worklist, ImportList,
                              ExportLists);
   }
for (auto &S : VI.getSummaryList())
       S->setLive(true);
     ++LiveSymbols;
     Worklist.push_back(VI);
   };
 
   while (!Worklist.empty()) {
     auto VI = Worklist.pop_back_val();
     for (auto &Summary : VI.getSummaryList()) {
-      for (auto Ref : Summary->refs())
+      GlobalValueSummary *Base = Summary->getBaseObject();
+      for (auto Ref : Base->refs())
         visit(Ref);
-      if (auto *FS = dyn_cast<FunctionSummary>(Summary.get()))
+      if (auto *FS = dyn_cast<FunctionSummary>(Base))
         for (auto Call : FS->calls())
           visit(Call.first);
-      if (auto *AS = dyn_cast<AliasSummary>(Summary.get())) {
-        auto AliaseeGUID = AS->getAliasee().getOriginalName();
-        ValueInfo AliaseeVI = Index.getValueInfo(AliaseeGUID);
-        if (AliaseeVI)
-          visit(AliaseeVI);
-      }
     }
   }
   Index.setWithGlobalValueDeadStripping();
 
   unsigned DeadSymbols = Index.size() - LiveSymbols;
   DEBUG(dbgs() << LiveSymbols << " symbols Live, and " << DeadSymbols
                << " symbols Dead \n");
   NumDeadSymbols += DeadSymbols;

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

if (ExportSummary) {
     for (auto &P : TypeIdInfo) {
       if (auto *TypeId = dyn_cast<MDString>(P.first))
         MetadataByGUID[GlobalValue::getGUID(TypeId->getString())].push_back(
             TypeId);
     }
 
     for (auto &P : *ExportSummary) {
       for (auto &S : P.second.SummaryList) {
-        auto *FS = dyn_cast<FunctionSummary>(S.get());
-        if (!FS || !ExportSummary->isGlobalValueLive(FS))
+        if (!ExportSummary->isGlobalValueLive(S.get()))
           continue;
+        if (auto *FS = dyn_cast<FunctionSummary>(S->getBaseObject()))
           for (GlobalValue::GUID G : FS->type_tests())
             for (Metadata *MD : MetadataByGUID[G])
               AddTypeIdUse(MD).IsExported = true;
       }
     }
   }
 
   if (GlobalClasses.empty())
     return false;
 
   // Build a list of disjoint sets ordered by their maximum global index for

llvm/test/LTO/Resolution/X86/Inputs/dead-strip-alias.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@external = global i8 42

llvm/test/LTO/Resolution/X86/dead-strip-alias.ll

+; RUN: opt -module-summary -o %t %s
+; RUN: opt -module-summary -o %t2 %S/Inputs/dead-strip-alias.ll
+; RUN: llvm-lto2 run %t -r %t,main,px -r %t,alias,p -r %t,external, \
+; RUN:               %t2 -r %t2,external,p \
+; RUN: -save-temps -o %t3
+; RUN: llvm-nm %t3.1 | FileCheck %s
+
+; CHECK: D external
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@alias = alias i8*, i8** @internal
+
+@internal = internal global i8* @external
+@external = external global i8
+
+define i8** @main() {
+  ret i8** @alias
+}

llvm/test/LTO/Resolution/X86/lowertypetests.ll

 ; RUN: opt -thinlto-bc -o %t %s
-; RUN: llvm-lto2 run -r %t,f,plx -r %t,foo,lx -r %t,foo,plx -o %t1 %t
+; RUN: llvm-lto2 run -r %t,f,plx -r %t,g_alias,plx -r %t,foo,lx -r %t,foo,plx -r %t,bar,lx -r %t,bar,plx -o %t1 %t
 ; RUN: llvm-nm %t1.0 | FileCheck --check-prefix=MERGED %s
 ; RUN: llvm-nm %t1.1 | FileCheck %s
 
+; MERGED: R __typeid_bar_global_addr
 ; MERGED: R __typeid_foo_global_addr
+; CHECK: U __typeid_bar_global_addr
 ; CHECK: U __typeid_foo_global_addr
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = global i32 0, !type !0
+@bar = global i32 0, !type !1
 
 define i1 @f(i8* %ptr) {
   %p = call i1 @llvm.type.test(i8* %ptr, metadata !"foo")
   ret i1 %p
 }
 
+@g_alias = alias i1 (i8*), i1 (i8*)* @g
+
+define internal i1 @g(i8* %ptr) {
+  %p = call i1 @llvm.type.test(i8* %ptr, metadata !"bar")
+  ret i1 %p
+}
+
 declare i1 @llvm.type.test(i8* %ptr, metadata %typeid) nounwind readnone
 
 !0 = !{i32 0, !"foo"}
+!1 = !{i32 0, !"bar"}