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 and Description
java.util.Map<MethodSignature,java.util.Set<Call>>	incoming
java.util.Map<MethodSignature,java.util.Set<Call>>	outgoing

Constructor Summary

Constructors

Modifier	Constructor and 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 and 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) See reconstructCallGraph(ClassPool, MethodSignature, int, int)
Node	reconstructCallGraph(ClassPool programClassPool, MethodSignature start, int maxDepth, int maxWidth) Calculate the incoming call graph for a method of interest, showing how it can be reached.
Node	reconstructCallGraph(ClassPool programClassPool, MethodSignature start, java.util.Set<EntryPoint> entryPoints) Extension of reconstructCallGraph(ClassPool, MethodSignature) that also collects all EntryPoints found along the way.

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)

See reconstructCallGraph(ClassPool, MethodSignature, int, int)

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.

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)

Calculate the incoming call graph for a method of interest, showing how it can be reached.

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().

Generally, we still can't be sure whether the top most methods (leaves in the tree) can be reached themselves, if we don't find any incoming edges. But if these methods are EntryPoints of an Android app, they will most likely be called at some point in the app lifecycle.

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.

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<EntryPoint> entryPoints)

Extension of reconstructCallGraph(ClassPool, MethodSignature) that also collects all EntryPoints found along the way.

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.

entryPoints - A set that will be filled with all EntryPoints that are part of the incoming call graph.

Returns:

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