AbstractInterproceduralAnalysis

java.lang.Object
- soot.jimple.toolkits.annotation.purity.AbstractInterproceduralAnalysis<S>

Type Parameters:

S -

Direct Known Subclasses:

PurityInterproceduralAnalysis
```
public abstract class AbstractInterproceduralAnalysis<S>
extends java.lang.Object
```
Inter-procedural iterator skeleton for summary-based analysis A "summary" is an abstract element associated to each method that fully models the effect of calling the method. In a summary-based analysis, the summary of a method can be computed using solely the summary of all methods it calls: the summary does not depend upon the context in which a method is called. The inter-procedural analysis interacts with a intra-procedural analysis that is able to compute the summary of one method, given the summary of all the method it calls. The inter-procedural analysis calls the intra-procedural analysis in a reverse topological order of method dependencies to resolve unknown summaries. It iterates over recursively dependant methods. Generally, the intra-procedural works by maintaining an abstract value that represent the effect of the method from its entry point and up to the current point. At the entry point, this value is empty. The summary of the method is then the merge of the abstract values at all its return points. You can provide off-the-shelf summaries for methods you do not which to analyse. Any method using these "filtered-out" methods will use the off-the-shelf summary instead of performing an intra-procedural analysis. This is useful for native methods, incremental analysis, or when you hand-made summary. Methods that are called solely by filtered-out ones will never be analysed, effectively trimming the call-graph dependencies. This class tries to use the same abstract methods and data management policy as regular FlowAnalysis classes.

Field Summary

Fields
Modifier and Type	Field and Description
`protected CallGraph`	`cg`
`protected java.util.Map<SootMethod,S>`	`data`
`protected DirectedGraph<SootMethod>`	`dg`
`static boolean`	`doCheck`
`protected java.util.Map<SootMethod,java.lang.Integer>`	`order`
`protected java.util.Map<SootMethod,S>`	`unanalysed`

Constructor Summary

Constructors
Constructor and Description
`AbstractInterproceduralAnalysis(CallGraph cg, SootMethodFilter filter, java.util.Iterator<SootMethod> heads, boolean verbose)` The constructor performs some preprocessing, but you have to call doAnalysis to preform the real stuff.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`analyseCall(S src, Stmt callStmt, S dst)` Analyse the call `callStmt` in the context `src`, and put the result into `dst`.
`protected abstract void`	`analyseMethod(SootMethod method, S dst)` Compute the summary for a method by analysing its body.
`protected abstract void`	`applySummary(S src, Stmt callStmt, S summary, S dst)` Interprocedural analysis will call applySummary repeatedly as a consequence to `analyseCall(Object, Stmt, Object)`, once for each possible target method of the `callStmt`, provided with its summary.
`protected abstract void`	`copy(S sr, S dst)` Copy src into dst.
`protected void`	`doAnalysis(boolean verbose)` Carry out the analysis.
`void`	`drawAsManyDot(java.lang.String prefix, boolean drawUnanalysed)` Dump the each summary computed by the interprocedural analysis as a separate graph.
`void`	`drawAsOneDot(java.lang.String name)` Dump the interprocedural analysis result as a graph.
`protected void`	`fillDotGraph(java.lang.String prefix, S o, DotGraph out)` Called by drawAsOneDot to fill dot subgraph out with the contents of summary o.
`java.util.Iterator<SootMethod>`	`getAnalysedMethods()` Get an iterator over the list of SootMethod with an associated summary.
`S`	`getSummaryFor(SootMethod m)` Query the analysis result.
`protected abstract void`	`merge(S in1, S in2, S out)` Merge in1 and in2 into out.
`protected abstract S`	`newInitialSummary()` Initial summary value for analysed functions.
`protected abstract S`	`summaryOfUnanalysedMethod(SootMethod method)` Whenever the analyse requires the summary of a method you filtered-out, this function is called instead of analyseMethod.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - doCheck
```
public static final boolean doCheck
```
    See Also:
    
    Constant Field Values
  - cg
```
protected final CallGraph cg
```
  - dg
```
protected final DirectedGraph<SootMethod> dg
```
  - data
```
protected final java.util.Map<SootMethod,S> data
```
  - order
```
protected final java.util.Map<SootMethod,java.lang.Integer> order
```
  - unanalysed
```
protected final java.util.Map<SootMethod,S> unanalysed
```
- Constructor Detail
  - AbstractInterproceduralAnalysis
```
public AbstractInterproceduralAnalysis(CallGraph cg,
                                       SootMethodFilter filter,
                                       java.util.Iterator<SootMethod> heads,
                                       boolean verbose)
```
    The constructor performs some preprocessing, but you have to call doAnalysis to preform the real stuff.
    
    Parameters:
    
    cg -
    
    filter -
    
    verbose -
    
    heads -
- Method Detail
  - newInitialSummary
```
protected abstract S newInitialSummary()
```
    Initial summary value for analysed functions.
    
    Returns:
  - summaryOfUnanalysedMethod
```
protected abstract S summaryOfUnanalysedMethod(SootMethod method)
```
    Whenever the analyse requires the summary of a method you filtered-out, this function is called instead of analyseMethod.
    Note: This function is called at most once per filtered-out method. It is the equivalent of entryInitialFlow!
    
    Parameters:
    
    method -
    
    Returns:
  - analyseMethod
```
protected abstract void analyseMethod(SootMethod method,
                                      S dst)
```
    Compute the summary for a method by analysing its body. Will be called only on methods not filtered-out.
    
    Parameters:
    
    method - is the method to be analysed
    
    dst - is where to put the computed method summary
  - applySummary
```
protected abstract void applySummary(S src,
                                     Stmt callStmt,
                                     S summary,
                                     S dst)
```
    Interprocedural analysis will call applySummary repeatedly as a consequence to analyseCall(Object, Stmt, Object), once for each possible target method of the callStmt, provided with its summary.
    
    Parameters:
    
    src - summary valid before the call statement
    
    callStmt - a statement containing a InvokeStmt or InvokeExpr
    
    summary - summary of the possible target of callStmt considered here
    
    dst - where to put the result
    
    See Also:
    
    analyseCall
  - merge
```
protected abstract void merge(S in1,
                              S in2,
                              S out)
```
    Merge in1 and in2 into out. Note: in1 or in2 can be aliased to out (e.g., analyseCall).
    
    Parameters:
    
    in1 -
    
    in2 -
    
    out -
  - copy
```
protected abstract void copy(S sr,
                             S dst)
```
    Copy src into dst.
    
    Parameters:
    
    sr -
    
    dst -
  - fillDotGraph
```
protected void fillDotGraph(java.lang.String prefix,
                            S o,
                            DotGraph out)
```
    Called by drawAsOneDot to fill dot subgraph out with the contents of summary o.
    
    Parameters:
    
    prefix - gives you a unique string to prefix your node names and avoid name-clash
    
    o -
    
    out -
  - analyseCall
```
public void analyseCall(S src,
                        Stmt callStmt,
                        S dst)
```
    Analyse the call callStmt in the context src, and put the result into dst. For each possible target of the call, this will get the summary for the target method (possibly summaryOfUnanalysedMethod(SootMethod)) and applySummary(Object, Stmt, Object, Object), then merge the results into dst using merge(Object, Object, Object).
    
    Parameters:
    
    src -
    
    dst -
    
    callStmt -
    
    See Also:
    
    summaryOfUnanalysedMethod(SootMethod), applySummary(Object, Stmt, Object, Object)
  - drawAsOneDot
```
public void drawAsOneDot(java.lang.String name)
```
    Dump the interprocedural analysis result as a graph. One node / subgraph for each analysed method that contains the method summary, and call-to edges. Note: this graph does not show filtered-out methods for which a conservative summary was asked via summaryOfUnanalysedMethod.
    
    Parameters:
    
    name - output filename
    
    See Also:
    
    fillDotGraph
  - drawAsManyDot
```
public void drawAsManyDot(java.lang.String prefix,
                          boolean drawUnanalysed)
```
    Dump the each summary computed by the interprocedural analysis as a separate graph.
    
    Parameters:
    
    prefix - is prepended before method name in output filename
    
    drawUnanalysed - do you also want info for the unanalysed methods required by the analysis via summaryOfUnanalysedMethod ?
    
    See Also:
    
    fillDotGraph
  - getSummaryFor
```
public S getSummaryFor(SootMethod m)
```
    Query the analysis result.
    
    Parameters:
    
    m -
    
    Returns:
  - getAnalysedMethods
```
public java.util.Iterator<SootMethod> getAnalysedMethods()
```
    Get an iterator over the list of SootMethod with an associated summary. (Does not contain filtered-out or native methods.)
    
    Returns:
  - doAnalysis
```
protected void doAnalysis(boolean verbose)
```
    Carry out the analysis. Call this from your InterproceduralAnalysis constructor, just after super(cg). Then , you will be able to call drawAsDot, for instance.
    
    Parameters:
    
    verbose -

Class AbstractInterproceduralAnalysis<S>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

doCheck

cg

dg

data

order

unanalysed

Constructor Detail

AbstractInterproceduralAnalysis

Method Detail

newInitialSummary

summaryOfUnanalysedMethod

analyseMethod

applySummary

merge

copy

fillDotGraph

analyseCall

drawAsOneDot

drawAsManyDot

getSummaryFor

getAnalysedMethods

doAnalysis