[llvm] r240039 - [CallGraph] Teach the CallGraph about non-leaf intrinsics.
Justin Bogner
mail at justinbogner.com
Fri Jun 19 13:12:50 PDT 2015
Sanjoy Das <sanjoy at playingwithpointers.com> writes:
> Author: sanjoy
> Date: Thu Jun 18 14:28:26 2015
> New Revision: 240039
>
> URL: http://llvm.org/viewvc/llvm-project?rev=240039&view=rev
> Log:
> [CallGraph] Teach the CallGraph about non-leaf intrinsics.
>
> Summary:
> Currently intrinsics don't affect the creation of the call graph.
> This is not accurate with respect to statepoint and patchpoint
> intrinsics -- these do call (or invoke) LLVM level functions.
>
> This change fixes this inconsistency by adding a call to the external
> node for call sites that call these non-leaf intrinsics. This coupled
> with the fact that these intrinsics also escape the function pointer
> they call gives us a conservatively correct call graph.
>
> Reviewers: reames, chandlerc, atrick, pgavlin
>
> Subscribers: llvm-commits
>
> Differential Revision: http://reviews.llvm.org/D10526
>
> Added:
> llvm/trunk/test/Analysis/CallGraph/non-leaf-intrinsics.ll
> Modified:
> llvm/trunk/include/llvm/Analysis/CallGraph.h
> llvm/trunk/include/llvm/IR/Intrinsics.h
> llvm/trunk/lib/Analysis/IPA/CallGraph.cpp
> llvm/trunk/lib/Analysis/IPA/CallGraphSCCPass.cpp
> llvm/trunk/lib/IR/Function.cpp
>
> Modified: llvm/trunk/include/llvm/Analysis/CallGraph.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/CallGraph.h?rev=240039&r1=240038&r2=240039&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/CallGraph.h (original)
> +++ llvm/trunk/include/llvm/Analysis/CallGraph.h Thu Jun 18 14:28:26 2015
> @@ -56,6 +56,7 @@
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/IR/CallSite.h"
> #include "llvm/IR/Function.h"
> +#include "llvm/IR/Intrinsics.h"
> #include "llvm/IR/ValueHandle.h"
> #include "llvm/Pass.h"
> #include <map>
> @@ -229,7 +230,8 @@ public:
> /// \brief Adds a function to the list of functions called by this one.
> void addCalledFunction(CallSite CS, CallGraphNode *M) {
> assert(!CS.getInstruction() || !CS.getCalledFunction() ||
> - !CS.getCalledFunction()->isIntrinsic());
> + !CS.getCalledFunction()->isIntrinsic() ||
> + !Intrinsic::isLeaf(CS.getCalledFunction()->getIntrinsicID()));
> CalledFunctions.emplace_back(CS.getInstruction(), M);
> M->AddRef();
> }
>
> Modified: llvm/trunk/include/llvm/IR/Intrinsics.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/Intrinsics.h?rev=240039&r1=240038&r2=240039&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/IR/Intrinsics.h (original)
> +++ llvm/trunk/include/llvm/IR/Intrinsics.h Thu Jun 18 14:28:26 2015
> @@ -52,6 +52,11 @@ namespace Intrinsic {
> /// Returns true if the intrinsic can be overloaded.
> bool isOverloaded(ID id);
>
> + /// Returns true if the intrinsic is a leaf, i.e. it does not make any calls
> + /// itself. Most intrinsics are leafs, the exceptions being the patchpoint
> + /// and statepoint intrinsics. These call (or invoke) their "target" argument.
> + bool isLeaf(ID id);
> +
> /// Return the attributes for an intrinsic.
> AttributeSet getAttributes(LLVMContext &C, ID id);
>
>
> Modified: llvm/trunk/lib/Analysis/IPA/CallGraph.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/IPA/CallGraph.cpp?rev=240039&r1=240038&r2=240039&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/IPA/CallGraph.cpp (original)
> +++ llvm/trunk/lib/Analysis/IPA/CallGraph.cpp Thu Jun 18 14:28:26 2015
> @@ -79,8 +79,10 @@ void CallGraph::addToCallGraph(Function
> CallSite CS(cast<Value>(II));
> if (CS) {
> const Function *Callee = CS.getCalledFunction();
> - if (!Callee)
> + if (!Callee || !Intrinsic::isLeaf(Callee->getIntrinsicID()))
> // Indirect calls of intrinsics are not allowed so no need to check.
> + // We can be more precise here by using TargetArg returned by
> + // Intrinsic::isLeaf.
> Node->addCalledFunction(CS, CallsExternalNode);
> else if (!Callee->isIntrinsic())
> Node->addCalledFunction(CS, getOrInsertFunction(Callee));
>
> Modified: llvm/trunk/lib/Analysis/IPA/CallGraphSCCPass.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/IPA/CallGraphSCCPass.cpp?rev=240039&r1=240038&r2=240039&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/IPA/CallGraphSCCPass.cpp (original)
> +++ llvm/trunk/lib/Analysis/IPA/CallGraphSCCPass.cpp Thu Jun 18 14:28:26 2015
> @@ -217,8 +217,10 @@ bool CGPassManager::RefreshCallGraph(Cal
> // another value. This can happen when constant folding happens
> // of well known functions etc.
> !CallSite(I->first) ||
> - (CallSite(I->first).getCalledFunction() &&
> - CallSite(I->first).getCalledFunction()->isIntrinsic())) {
> + (CallSite(I->first).getCalledFunction() &&
> + CallSite(I->first).getCalledFunction()->isIntrinsic() &&
> + Intrinsic::isLeaf(
> + CallSite(I->first).getCalledFunction()->getIntrinsicID()))) {
> assert(!CheckingMode &&
> "CallGraphSCCPass did not update the CallGraph correctly!");
>
>
> Modified: llvm/trunk/lib/IR/Function.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Function.cpp?rev=240039&r1=240038&r2=240039&view=diff
> ==============================================================================
> --- llvm/trunk/lib/IR/Function.cpp (original)
> +++ llvm/trunk/lib/IR/Function.cpp Thu Jun 18 14:28:26 2015
> @@ -846,6 +846,18 @@ bool Intrinsic::isOverloaded(ID id) {
> #undef GET_INTRINSIC_OVERLOAD_TABLE
> }
>
> +bool Intrinsic::isLeaf(ID id) {
> + switch (id) {
> + default:
> + return true;
> +
> + case Intrinsic::experimental_gc_statepoint:
> + case Intrinsic::experimental_patchpoint_void:
> + case Intrinsic::experimental_patchpoint_i64:
> + return false;
> + }
> +}
> +
> /// This defines the "Intrinsic::getAttributes(ID id)" method.
> #define GET_INTRINSIC_ATTRIBUTES
> #include "llvm/IR/Intrinsics.gen"
>
> Added: llvm/trunk/test/Analysis/CallGraph/non-leaf-intrinsics.ll
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CallGraph/non-leaf-intrinsics.ll?rev=240039&view=auto
> ==============================================================================
> --- llvm/trunk/test/Analysis/CallGraph/non-leaf-intrinsics.ll (added)
> +++ llvm/trunk/test/Analysis/CallGraph/non-leaf-intrinsics.ll Thu Jun 18 14:28:26 2015
> @@ -0,0 +1,32 @@
> +; RUN: opt -S -print-callgraph -disable-output < %s 2>&1 | FileCheck %s
> +
> +declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)
> +declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
> +
> +define private void @f() {
> + ret void
> +}
> +
> +define void @calls_statepoint(i8 addrspace(1)* %arg) gc "statepoint-example" {
> +entry:
> + %cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*
> + %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @f, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)
> + ret void
> +}
> +
> +define void @calls_patchpoint() {
> +entry:
> + %c = bitcast void()* @f to i8*
> + tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 1, i32 15, i8* %c, i32 0, i16 65535, i16 -1, i32 65536, i32 2000000000, i32 2147483647, i32 -1, i32 4294967295, i32 4294967296, i64 2147483648, i64 4294967295, i64 4294967296, i64 -1)
> + ret void
> +}
> +
> +
> +; CHECK: Call graph node <<null function>>
> +; CHECK: CS<0x0> calls function 'f'
> +
> +; CHECK: Call graph node for function: 'calls_statepoint'
> +; CHECK-NEXT: CS<[[addr_0:[^>]+]]> calls external node
> +
> +; CHECK: Call graph node for function: 'calls_patchpoint'
> +; CHECK-NEXT: CS<[[addr_1:[^>]+]]> calls external node
The order that these call graph nodes are emitted seems to change when I
run the tests under asan+ubsan. That is, the test outputs:
Call graph node <<null function>><<0x6040000041d0>> #uses=0
CS<0x0> calls function 'llvm.experimental.patchpoint.void'
CS<0x0> calls function 'llvm.experimental.gc.statepoint.p0f_isVoidf'
CS<0x0> calls function 'f'
CS<0x0> calls function 'calls_statepoint'
CS<0x0> calls function 'calls_patchpoint'
Call graph node for function: 'calls_patchpoint'<<0x604000003f10>> #uses=1
CS<0x61500000f218> calls external node
Call graph node for function: 'calls_statepoint'<<0x604000003f90>> #uses=1
CS<0x61500000f498> calls external node
Does it make sense loosen this test to accept the output in either
order, or does this look like an issue with -print-callgraph?
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list