sootup.callgraph

Class AbstractCallGraphAlgorithm

java.lang.Object

sootup.callgraph.AbstractCallGraphAlgorithm

All Implemented Interfaces:

CallGraphAlgorithm

Direct Known Subclasses:

ClassHierarchyAnalysisAlgorithm, RapidTypeAnalysisAlgorithm

public abstract class AbstractCallGraphAlgorithm
extends Object
implements CallGraphAlgorithm

The AbstractCallGraphAlgorithm class is the super class of all call graph algorithm. It provides basic methods used in all call graph algorithm. It is abstract since it has no implemented functionality to resolve method calls because it is decided by the applied call graph algorithm

Field Summary

Fields

Modifier and Type	Field and Description
protected View	view

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractCallGraphAlgorithm(View view)

Method Summary

Modifier and Type	Method and Description
CallGraph	addClass(CallGraph oldCallGraph, JavaClassType classType) Adds a class to the call graph.
protected void	addImplicitEdgesOfEntryPoints(List<MethodSignature> entryPoints, MutableCallGraph cg, Deque<MethodSignature> workList) This method adds implicit edges of the entry points of the call graph algorithm.
static Optional<SootMethod>	findConcreteMethod(View view, MethodSignature sig) searches the method object in the given hierarchy
MethodSignature	findMainMethod() The method iterates over all classes present in view, and finds method with name main and SourceType - Library.
protected MutableCallGraph	initializeCallGraph() This method creates the mutable call graph which is used in the call graph algorithm.
protected abstract void	postProcessingMethod(View view, MethodSignature sourceMethod, Deque<MethodSignature> workList, MutableCallGraph cg) This method enables optional post-processing of a method in the call graph algorithm
protected abstract void	preProcessingMethod(View view, MethodSignature sourceMethod, Deque<MethodSignature> workList, MutableCallGraph cg) This method enables optional pre-processing of a method in the call graph algorithm
protected Stream<MethodSignature>	resolveAllImplicitCallsFromSourceMethod(View view, SootMethod sourceMethod) It resolves all implicit calls caused by the given source method
protected Stream<MethodSignature>	resolveAllStaticInitializerCallsFromSourceMethod(View view, SootMethod sourceMethod) It resolves all static initializer calls caused by the given source method
protected abstract Stream<MethodSignature>	resolveCall(SootMethod method, AbstractInvokeExpr invokeExpr) This method resolves the possible targets of a given invoke expression.
static Optional<MethodSignature>	resolveConcreteDispatch(View view, MethodSignature m) Searches for the signature of the method that is the concrete implementation of m.

Methods inherited from class java.lang.Object

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

Methods inherited from interface sootup.callgraph.CallGraphAlgorithm

initialize, initialize

Field Detail

view

@Nonnull
protected final View view

Constructor Detail

AbstractCallGraphAlgorithm

protected AbstractCallGraphAlgorithm(@Nonnull
                                     View view)

Method Detail

initializeCallGraph

protected MutableCallGraph initializeCallGraph()

This method creates the mutable call graph which is used in the call graph algorithm. Overwrite it to change the used mutable call graph

Returns:

the initialized call graph used in the call graph algorithm

addImplicitEdgesOfEntryPoints

protected void addImplicitEdgesOfEntryPoints(List<MethodSignature> entryPoints,
                                             MutableCallGraph cg,
                                             Deque<MethodSignature> workList)

This method adds implicit edges of the entry points of the call graph algorithm. It will add an edge to all static initializer of the entry points.

Parameters:

entryPoints - the entry points of the call graph algorithm

cg - the call graph which will save the added implicit edges.

workList - the implicit targets will be added to the work list to process in the call graph algorithm

resolveAllImplicitCallsFromSourceMethod

@Nonnull
protected Stream<MethodSignature> resolveAllImplicitCallsFromSourceMethod(View view,
                                                                                   SootMethod sourceMethod)

It resolves all implicit calls caused by the given source method

Parameters:

view - it contains the class data

sourceMethod - the inspected source method

Returns:

a stream containing all method signatures of targets of implicit calls.

resolveAllStaticInitializerCallsFromSourceMethod

@Nonnull
protected Stream<MethodSignature> resolveAllStaticInitializerCallsFromSourceMethod(View view,
                                                                                            SootMethod sourceMethod)

It resolves all static initializer calls caused by the given source method

Parameters:

view - it contains the class data

sourceMethod - the inspected source method

Returns:

a stream containing all method signatures of targets of implicit calls.

preProcessingMethod

protected abstract void preProcessingMethod(View view,
                                            MethodSignature sourceMethod,
                                            @Nonnull
                                            Deque<MethodSignature> workList,
                                            @Nonnull
                                            MutableCallGraph cg)

This method enables optional pre-processing of a method in the call graph algorithm

Parameters:

view - view

sourceMethod - the processed method

workList - the current work list that might be extended

cg - the current cg that might be extended

postProcessingMethod

protected abstract void postProcessingMethod(View view,
                                             MethodSignature sourceMethod,
                                             @Nonnull
                                             Deque<MethodSignature> workList,
                                             @Nonnull
                                             MutableCallGraph cg)

This method enables optional post-processing of a method in the call graph algorithm

Parameters:

view - it contains classes and the type hierarchy.

sourceMethod - the processed method

workList - the current work list that might be extended

cg - the current cg that might be extended

addClass

@Nonnull
public CallGraph addClass(@Nonnull
                                   CallGraph oldCallGraph,
                                   @Nonnull
                                   JavaClassType classType)

Description copied from interface: CallGraphAlgorithm

Adds a class to the call graph. All methods will be set as entry points in the call graph algorithm. Starts the call graph algorithm. The found edges will be added to the call graph.

Specified by:

addClass in interface CallGraphAlgorithm

Parameters:

oldCallGraph - the call graph which will be modified.

classType - the type of the calls.

Returns:

the modified call graph containing all methods of the given class

findMainMethod

public MethodSignature findMainMethod()

The method iterates over all classes present in view, and finds method with name main and SourceType - Library. This method is used by initialize() method used for creating call graph and the call graph is created by considering the main method as an entry point.

The method throws an exception if there is no main method in any of the classes or if there are more than one main method.

Returns:

- MethodSignature of main method.

resolveCall

@Nonnull
protected abstract Stream<MethodSignature> resolveCall(SootMethod method,
                                                                AbstractInvokeExpr invokeExpr)

This method resolves the possible targets of a given invoke expression. The results are dependable of the applied call graph algorithm. therefore, it is abstract.

Parameters:

method - the method object that contains the given invoke expression in the body.

invokeExpr - it contains the call which is resolved.

Returns:

a stream of all reachable method signatures defined by the applied call graph algorithm.

resolveConcreteDispatch

@Nonnull
public static Optional<MethodSignature> resolveConcreteDispatch(View view,
                                                                         MethodSignature m)

Searches for the signature of the method that is the concrete implementation of m. This is done by checking each superclass and the class itself for whether it contains the concrete implementation.

findConcreteMethod

public static Optional<SootMethod> findConcreteMethod(@Nonnull
                                                      View view,
                                                      @Nonnull
                                                      MethodSignature sig)

searches the method object in the given hierarchy

Parameters:

view - it contains all classes

sig - the signature of the searched method

Returns:

the found method object, or null if the method was not found.