[LCG] Add aliased functions as LCG roots

[Carrot]

Summary

Current LCG doesn't check aliased functions. So if an internal function has a public alias it will not be added to CG SCC, but it is still reachable from outside through the alias.
So this patch adds aliased functions to SCC.

[tejohnson]

lib/Analysis/LazyCallGraph.cpp

205

Presumably aliases with internal linkage themselves can be ignored.

[chandlerc]

Good catch!

lib/Analysis/LazyCallGraph.cpp

204

I would rewrite the comment to more closely match the patch description: "Externally visible aliases of internal functions are also viable entry edges to the module."

205–213

All of this should go above I think, right after we walk the module. We want to have the complete entry edge set before we visit globals and do the reference visit walk.

209–210

Include the fact that it is being added due to an alias, and the name of that alias?

test/Analysis/LazyCallGraph/alias.ll

4

Also test that internal aliases *don't* become reachable?

[Carrot]

ping

[chandlerc]

LGTM!

test/Analysis/LazyCallGraph/alias.ll

24

nit: can drop this comment.

31

nit: same

39

nit: same

[Carrot]

Will check in this version.

lib/Analysis/LazyCallGraph.cpp

for (Function &F : M) {
 
     // External linkage defined functions have edges to them from other
     // modules.
     LLVM_DEBUG(dbgs() << "  Adding '" << F.getName()
                       << "' to entry set of the graph.\n");
     addEdge(EntryEdges.Edges, EntryEdges.EdgeIndexMap, get(F), Edge::Ref);
   }
 
+  // Externally visible aliases of internal functions are also viable entry
+  // edges to the module.
+  for (auto &A : M.aliases()) {
+    if (A.hasLocalLinkage())
+      continue;
+    if (Function* F = dyn_cast<Function>(A.getAliasee())) {
+      LLVM_DEBUG(dbgs() << "  Adding '" << F->getName()
+                        << "' with alias '" << A.getName()
+                        << "' to entry set of the graph.\n");
+      addEdge(EntryEdges.Edges, EntryEdges.EdgeIndexMap, get(*F), Edge::Ref);
+    }
+  }
+
   // Now add entry nodes for functions reachable via initializers to globals.
   SmallVector<Constant *, 16> Worklist;
   SmallPtrSet<Constant *, 16> Visited;
   for (GlobalVariable &GV : M.globals())
     if (GV.hasInitializer())
       if (Visited.insert(GV.getInitializer()).second)
         Worklist.push_back(GV.getInitializer());
 
   LLVM_DEBUG(
       dbgs() << "  Adding functions referenced by global initializers to the "
                 "entry set.\n");
   visitReferences(Worklist, Visited, [&](Function &F) {
     addEdge(EntryEdges.Edges, EntryEdges.EdgeIndexMap, get(F),
             LazyCallGraph::Edge::Ref);
   });
 }
 
 LazyCallGraph::LazyCallGraph(LazyCallGraph &&G)
     : BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
       EntryEdges(std::move(G.EntryEdges)), SCCBPA(std::move(G.SCCBPA)),
       SCCMap(std::move(G.SCCMap)),
       LibFunctions(std::move(G.LibFunctions)) {
   updateGraphPtrs();
 }
 
 LazyCallGraph &LazyCallGraph::operator=(LazyCallGraph &&G) {
   BPA = std::move(G.BPA);
   NodeMap = std::move(G.NodeMap);
   EntryEdges = std::move(G.EntryEdges);
   SCCBPA = std::move(G.SCCBPA);
   SCCMap = std::move(G.SCCMap);
   LibFunctions = std::move(G.LibFunctions);
   updateGraphPtrs();
   return *this;

test/Analysis/LazyCallGraph/alias.ll

+; RUN: opt -disable-output -passes=print-lcg %s 2>&1 | FileCheck %s
+;
+; Aliased function should be reachable in CGSCC.
+
+target triple = "x86_64-grtev4-linux-gnu"
+
+; CHECK:        Edges in function: foo
+; CHECK:        Edges in function: bar
+; CHECK:        Edges in function: baz
+
+; CHECK:        RefSCC with 1 call SCCs:
+; CHECK-NEXT:     SCC with 1 functions:
+; CHECK-NEXT:       bar
+
+; CHECK:       RefSCC with 1 call SCCs:
+; CHECK-NEXT:    SCC with 1 functions:
+; CHECK-NEXT:      foo
+
+; CHECK-NOT:       baz
+
+@alias1 = weak dso_local alias i8* (i8*), i8* (i8*)* @foo
+
+define dso_local i8* @foo(i8* %returned) {
+  ret i8* %returned
+}
+
+@alias2 = weak dso_local alias i8* (i8*), i8* (i8*)* @bar
+
+define internal i8* @bar(i8* %returned) {
+  ret i8* %returned
+}
+
+; Internal alias is not reachable.
+@alias3 = internal alias i8* (i8*), i8* (i8*)* @baz
+
+define internal i8* @baz(i8* %returned) {
+  ret i8* %returned
+}