soot.dava.toolkits.base.AST.structuredAnalysis

Class StructuredAnalysis

java.lang.Object

soot.dava.toolkits.base.AST.structuredAnalysis.StructuredAnalysis

Direct Known Subclasses:

CP, MustMayInitialize, ReachingCopies, ReachingDefs, UnreachableCodeFinder

public abstract class StructuredAnalysis
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	DEBUG
static boolean	DEBUG_IF
static boolean	DEBUG_STATEMENTS
static boolean	DEBUG_TRY
static boolean	DEBUG_WHILE
int	MERGETYPE

Constructor Summary

Constructors

Constructor and Description
StructuredAnalysis()

Method Summary

Methods

Modifier and Type	Method and Description
abstract DavaFlowSet	cloneFlowSet(DavaFlowSet flowSet) Make a clone of the flowset The implementor should know when they want a shallow or deep clone
void	debug(java.lang.String debug)
void	debug(java.lang.String methodName, java.lang.String debug)
abstract DavaFlowSet	emptyFlowSet()
DavaFlowSet	getAfterSet(java.lang.Object afterThis)
DavaFlowSet	getBeforeSet(java.lang.Object beforeThis)
java.lang.String	getLabel(ASTNode node) returns label on the ASTNode null if the ASTNode cannot hold a label or if the label is null
DavaFlowSet	handleBreak(java.lang.String label, DavaFlowSet out, ASTNode node) Need to handleBreak stmts There can be explicit breaks (in which case label is non null) There can always be implicit breaks ASTNode is non null
DavaFlowSet	handleContinue(java.lang.String label, java.lang.Object output, ASTNode node) Need to handleContinue stmts There can be explicit continues (in which case label is non null) There can always be implicit continues ASTNode is non null
boolean	isDifferent(DavaFlowSet oldObj, DavaFlowSet newObj)
DavaFlowSet	merge(DavaFlowSet in1, DavaFlowSet in2)
DavaFlowSet	mergeExplicitAndImplicit(java.lang.String label, DavaFlowSet output, java.util.List<DavaFlowSet> explicitSet, java.util.List<DavaFlowSet> implicitSet)
abstract DavaFlowSet	newInitialFlow()
void	print(java.lang.Object toPrint)
DavaFlowSet	process(java.lang.Object body, DavaFlowSet input)
DavaFlowSet	processAbruptStatements(Stmt s, DavaFlowSet input) Whenever a statement has to be processed the first step is to invoke this method.
DavaFlowSet	processASTDoWhileNode(ASTDoWhileNode node, DavaFlowSet input)
DavaFlowSet	processASTForLoopNode(ASTForLoopNode node, DavaFlowSet input)
DavaFlowSet	processASTIfElseNode(ASTIfElseNode node, DavaFlowSet input)
DavaFlowSet	processASTIfNode(ASTIfNode node, DavaFlowSet input)
DavaFlowSet	processASTLabeledBlockNode(ASTLabeledBlockNode node, DavaFlowSet input)
DavaFlowSet	processASTMethodNode(ASTMethodNode node, DavaFlowSet input)
DavaFlowSet	processASTNode(ASTNode node, DavaFlowSet input)
DavaFlowSet	processASTStatementSequenceNode(ASTStatementSequenceNode node, DavaFlowSet input)
DavaFlowSet	processASTSwitchNode(ASTSwitchNode node, DavaFlowSet input)
DavaFlowSet	processASTSynchronizedBlockNode(ASTSynchronizedBlockNode node, DavaFlowSet input)
DavaFlowSet	processASTTryNode(ASTTryNode node, DavaFlowSet input)
DavaFlowSet	processASTUnconditionalLoopNode(ASTUnconditionalLoopNode node, DavaFlowSet input)
DavaFlowSet	processASTWhileNode(ASTWhileNode node, DavaFlowSet input)
DavaFlowSet	processCondition(ASTCondition cond, DavaFlowSet input) This implementation breaks down the aggregated condition to the terminal conditions which all have type ASTUnaryBinaryCondition.
DavaFlowSet	processSingleSubBodyNode(ASTNode node, DavaFlowSet input) This method is called from the specialized ASTNodes.
abstract DavaFlowSet	processStatement(Stmt s, DavaFlowSet input) Specific stmts within AST Constructs are processed through this method.
abstract DavaFlowSet	processSwitchKey(Value key, DavaFlowSet input) Deal with the key in the switch construct
abstract DavaFlowSet	processSynchronizedLocal(Local local, DavaFlowSet input) To deal with the local used for synch blocks
abstract DavaFlowSet	processUnaryBinaryCondition(ASTUnaryBinaryCondition cond, DavaFlowSet input) To have maximum flexibility in analyzing conditions the analysis API breaks down the aggregated conditions to simple unary or binary conditions user defined code can then deal with each condition separately.
abstract void	setMergeType()

Methods inherited from class java.lang.Object

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

Field Detail

DEBUG

public static boolean DEBUG

DEBUG_IF

public static boolean DEBUG_IF

DEBUG_WHILE

public static boolean DEBUG_WHILE

DEBUG_STATEMENTS

public static boolean DEBUG_STATEMENTS

DEBUG_TRY

public static boolean DEBUG_TRY

MERGETYPE

public int MERGETYPE

Constructor Detail

StructuredAnalysis

public StructuredAnalysis()

Method Detail

setMergeType

public abstract void setMergeType()

newInitialFlow

public abstract DavaFlowSet newInitialFlow()

emptyFlowSet

public abstract DavaFlowSet emptyFlowSet()

cloneFlowSet

public abstract DavaFlowSet cloneFlowSet(DavaFlowSet flowSet)

Make a clone of the flowset The implementor should know when they want a shallow or deep clone

processStatement

public abstract DavaFlowSet processStatement(Stmt s,
                           DavaFlowSet input)

Specific stmts within AST Constructs are processed through this method. It will be invoked everytime a stmt is encountered

processUnaryBinaryCondition

public abstract DavaFlowSet processUnaryBinaryCondition(ASTUnaryBinaryCondition cond,
                                      DavaFlowSet input)

To have maximum flexibility in analyzing conditions the analysis API breaks down the aggregated conditions to simple unary or binary conditions user defined code can then deal with each condition separately. To be able to deal with entire aggregated conditions the user should wite their own implementation of the method processCondition

processSynchronizedLocal

public abstract DavaFlowSet processSynchronizedLocal(Local local,
                                   DavaFlowSet input)

To deal with the local used for synch blocks

processSwitchKey

public abstract DavaFlowSet processSwitchKey(Value key,
                           DavaFlowSet input)

Deal with the key in the switch construct

print

public void print(java.lang.Object toPrint)

processCondition

public DavaFlowSet processCondition(ASTCondition cond,
                           DavaFlowSet input)

This implementation breaks down the aggregated condition to the terminal conditions which all have type ASTUnaryBinaryCondition. Once these are obtained the abstract method processUnaryBinaryCondition is invoked. For aggregated conditions the merging is done in a depth first order of the condition tree.

process

public DavaFlowSet process(java.lang.Object body,
                  DavaFlowSet input)

processASTNode

public DavaFlowSet processASTNode(ASTNode node,
                         DavaFlowSet input)

processSingleSubBodyNode

public final DavaFlowSet processSingleSubBodyNode(ASTNode node,
                                   DavaFlowSet input)

This method is called from the specialized ASTNodes. The purpose was to deal with different ASTNodes with similar structure in one go. The method will deal with retrieve the body of the ASTNode which are known to have only one subBody

getLabel

public java.lang.String getLabel(ASTNode node)

returns label on the ASTNode null if the ASTNode cannot hold a label or if the label is null

processAbruptStatements

public DavaFlowSet processAbruptStatements(Stmt s,
                                  DavaFlowSet input)

Whenever a statement has to be processed the first step is to invoke this method. This is to remove the tedious work of adding code to deal with abrupt control flow from the programmer of the analysis. The method invokes the processStatement method for all other statements A programmer can decide to override this method if they want to do something specific

processASTMethodNode

public DavaFlowSet processASTMethodNode(ASTMethodNode node,
                               DavaFlowSet input)

processASTStatementSequenceNode

public DavaFlowSet processASTStatementSequenceNode(ASTStatementSequenceNode node,
                                          DavaFlowSet input)

processASTLabeledBlockNode

public DavaFlowSet processASTLabeledBlockNode(ASTLabeledBlockNode node,
                                     DavaFlowSet input)

processASTSynchronizedBlockNode

public DavaFlowSet processASTSynchronizedBlockNode(ASTSynchronizedBlockNode node,
                                          DavaFlowSet input)

processASTIfNode

public DavaFlowSet processASTIfNode(ASTIfNode node,
                           DavaFlowSet input)

processASTIfElseNode

public DavaFlowSet processASTIfElseNode(ASTIfElseNode node,
                               DavaFlowSet input)

processASTWhileNode

public DavaFlowSet processASTWhileNode(ASTWhileNode node,
                              DavaFlowSet input)

processASTDoWhileNode

public DavaFlowSet processASTDoWhileNode(ASTDoWhileNode node,
                                DavaFlowSet input)

processASTUnconditionalLoopNode

public DavaFlowSet processASTUnconditionalLoopNode(ASTUnconditionalLoopNode node,
                                          DavaFlowSet input)

processASTForLoopNode

public DavaFlowSet processASTForLoopNode(ASTForLoopNode node,
                                DavaFlowSet input)

processASTSwitchNode

public DavaFlowSet processASTSwitchNode(ASTSwitchNode node,
                               DavaFlowSet input)

processASTTryNode

public DavaFlowSet processASTTryNode(ASTTryNode node,
                            DavaFlowSet input)

merge

public DavaFlowSet merge(DavaFlowSet in1,
                DavaFlowSet in2)

mergeExplicitAndImplicit

public DavaFlowSet mergeExplicitAndImplicit(java.lang.String label,
                                   DavaFlowSet output,
                                   java.util.List<DavaFlowSet> explicitSet,
                                   java.util.List<DavaFlowSet> implicitSet)

handleBreak

public DavaFlowSet handleBreak(java.lang.String label,
                      DavaFlowSet out,
                      ASTNode node)

Need to handleBreak stmts There can be explicit breaks (in which case label is non null) There can always be implicit breaks ASTNode is non null

handleContinue

public DavaFlowSet handleContinue(java.lang.String label,
                         java.lang.Object output,
                         ASTNode node)

Need to handleContinue stmts There can be explicit continues (in which case label is non null) There can always be implicit continues ASTNode is non null

isDifferent

public boolean isDifferent(DavaFlowSet oldObj,
                  DavaFlowSet newObj)

getBeforeSet

public DavaFlowSet getBeforeSet(java.lang.Object beforeThis)

getAfterSet

public DavaFlowSet getAfterSet(java.lang.Object afterThis)

debug

public void debug(java.lang.String methodName,
         java.lang.String debug)

debug

public void debug(java.lang.String debug)