Package proguard.analysis.datastructure.callgraph

Class CallGraph

java.lang.Object

proguard.analysis.datastructure.callgraph.CallGraph

public class CallGraph
extends java.lang.Object

Collection of all Calls in a program, optimized for retrieval of incoming and outgoing edges for any method in constant time.

Field Summary

Fields

Modifier and Type	Field	Description
java.util.Map<MethodSignature,java.util.Set<Call>>	incoming
java.util.Map<MethodSignature,java.util.Set<Call>>	outgoing

Constructor Summary

Constructors

Modifier	Constructor	Description
	CallGraph()	Create an empty call graph.
protected	CallGraph(java.util.Map<MethodSignature,java.util.Set<Call>> incoming, java.util.Map<MethodSignature,java.util.Set<Call>> outgoing, boolean concurrent)

Method Summary

Modifier and Type	Method	Description
void	addCall(Call call)	Add a Call to this call graph.
void	clear()	Clear the call graph references.
static CallGraph	concurrentCallGraph()	Provides concurrency ready CallGraph, backed by ConcurrentHashMaps and by synchronizedSets.
Node	reconstructCallGraph(ClassPool programClassPool, MethodSignature start, int maxDepth, int maxWidth, java.util.Set<MethodSignature> stopMethods)	Calculate the incoming call graph for a method of interest, showing how it can be reached from a given Set of stop methods, which typically are Android lifecycle methods such as an Activity's onCreate() method:
Node	reconstructCallGraph(ClassPool programClassPool, MethodSignature start, java.util.Set<MethodSignature> stopMethods)	See reconstructCallGraph(ClassPool, MethodSignature, int, int, Set)
Node	reconstructCallGraph(ClassPool programClassPool, MethodSignature start, java.util.Set<MethodSignature> stopMethods, java.util.Set<MethodSignature> reachedMethods)	Extension of reconstructCallGraph(ClassPool, MethodSignature, Set) that also collects all reached stop methods.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

incoming

public final java.util.Map<MethodSignature,java.util.Set<Call>> incoming

outgoing

public final java.util.Map<MethodSignature,java.util.Set<Call>> outgoing

Constructor Detail

CallGraph

public CallGraph()

Create an empty call graph.

CallGraph

protected CallGraph(java.util.Map<MethodSignature,java.util.Set<Call>> incoming,
                    java.util.Map<MethodSignature,java.util.Set<Call>> outgoing,
                    boolean concurrent)

Method Detail

concurrentCallGraph

public static CallGraph concurrentCallGraph()

Provides concurrency ready CallGraph, backed by ConcurrentHashMaps and by synchronizedSets. Not needed without multithreading.

addCall

public void addCall(Call call)

Add a Call to this call graph.

Parameters:

call - The call to be added.

clear

public void clear()

Clear the call graph references.

reconstructCallGraph

public Node reconstructCallGraph(ClassPool programClassPool,
                                 MethodSignature start,
                                 java.util.Set<MethodSignature> stopMethods)

See reconstructCallGraph(ClassPool, MethodSignature, int, int, Set)

Parameters:

programClassPool - The current ClassPool of the program that can be used for mapping. class names to the actual Clazz.

start - The MethodSignature of the method whose incoming call graph should be calculated.

stopMethods - Set of MethodSignature to stop exploration at, if desired.

Returns:

A Node that represents the single call graph root, i.e. the start method.

reconstructCallGraph

public Node reconstructCallGraph(ClassPool programClassPool,
                                 MethodSignature start,
                                 int maxDepth,
                                 int maxWidth,
                                 java.util.Set<MethodSignature> stopMethods)

Calculate the incoming call graph for a method of interest, showing how it can be reached from a given Set of stop methods, which typically are Android lifecycle methods such as an Activity's onCreate() method:

We have an inverted tree structure like the following example:

 onCreate() <-- predecessor -- proxy() <-- predecessor -- root()
                            onResume() <-- predecessor ----|  |
                        unusedMethod() <-- predecessor -------|

 

Here, root() is the method whose call graph is to be calculated, and the graph now shows that it can be reached from onCreate() via proxy(), and also directly from onResume() or unusedMethod().

Parameters:

programClassPool - The current ClassPool of the program that can be used for mapping. class names to the actual Clazz.

start - The MethodSignature of the method whose incoming call graph should be calculated.

maxDepth - maximal depth of reconstructed CallGraph similar to CallGraphWalker.MAX_DEPTH_DEFAULT.

maxWidth - maximal width of reconstructed CallGraph similar to CallGraphWalker.MAX_WIDTH_DEFAULT.

stopMethods - Set of method signatures to stop exploration, for example for entry points

Returns:

A Node that represents the single call graph root, i.e. the start method.

reconstructCallGraph

public Node reconstructCallGraph(ClassPool programClassPool,
                                 MethodSignature start,
                                 java.util.Set<MethodSignature> stopMethods,
                                 java.util.Set<MethodSignature> reachedMethods)

Extension of reconstructCallGraph(ClassPool, MethodSignature, Set) that also collects all reached stop methods.

Parameters:

programClassPool - The current ClassPool of the program that can be used for mapping.

start - The MethodSignature of the method whose incoming call graph should be calculated.

stopMethods - A set of MethodSignature to stop exploration, e.g. app entry points

reachedMethods - A set that will be filled with all reached stop methods

Returns:

A Node that represents the single call graph root, i.e. the start method.