Package boomerang.solver

Class AbstractBoomerangSolver<W extends wpds.impl.Weight>

java.lang.Object

sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W>

boomerang.solver.AbstractBoomerangSolver<W>

Direct Known Subclasses:

BackwardBoomerangSolver, ForwardBoomerangSolver

public abstract class AbstractBoomerangSolver<W extends wpds.impl.Weight>
extends sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W>

Nested Class Summary

Nested classes/interfaces inherited from class sync.pds.solver.SyncPDSSolver

sync.pds.solver.SyncPDSSolver.OnAddedSummaryListener<Stmt extends Object,Fact extends Object>, sync.pds.solver.SyncPDSSolver.PDSSystem

Field Summary

Fields

Modifier and Type	Field	Description
protected ObservableControlFlowGraph	cfg
protected DataFlowScope	dataFlowScope
protected Map<Map.Entry<sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,Field>,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>>	generatedFieldState
protected ObservableICFG<Statement,Method>	icfg
protected boolean	INTERPROCEDURAL
protected BoomerangOptions	options
protected com.google.common.collect.Multimap<ControlFlowGraph.Edge,wpds.impl.Transition<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>>>	perStatementFieldTransitions
protected Type	type

Fields inherited from class sync.pds.solver.SyncPDSSolver

callAutomaton, callingPDS, fieldAutomaton, fieldPDS, generatedCallState

Constructor Summary

Constructors

Constructor

Description

AbstractBoomerangSolver(ObservableICFG<Statement,Method> icfg, ObservableControlFlowGraph cfg, Map<Map.Entry<sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,Field>,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>> genField, BoomerangOptions options, wpds.impl.NestedWeightedPAutomatons<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W> callSummaries, wpds.impl.NestedWeightedPAutomatons<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W> fieldSummaries, DataFlowScope scope, Type propagationType)

Method Summary

Modifier and Type	Method	Description
void	addCallRule(wpds.impl.Rule<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W> rule)
void	addFieldRule(wpds.impl.Rule<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W> rule)
protected void	addPotentialUnbalancedFlow(Method callee, wpds.impl.Transition<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>> trans, W weight)
void	allowUnbalanced(Method callee, Statement callSite)
com.google.common.collect.Table<ControlFlowGraph.Edge,Val,W>	asEdgeValWeightTable()
com.google.common.collect.Table<Statement,Val,W>	asStatementValWeightTable()
protected abstract Collection<wpds.interfaces.State>	computeNormalFlow(Method method, ControlFlowGraph.Edge currEdge, Val value)
protected abstract Collection<? extends wpds.interfaces.State>	computeReturnFlow(Method method, Statement curr, Val value)
sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>	createQueryNodeField(Query query)
void	debugFieldAutomaton(Statement stmt)
Field	emptyField()
Field	epsilonField()
ControlFlowGraph.Edge	epsilonStmt()
Field	exclusionFieldWildCard(Field exclusion)
Field	fieldWildCard()
protected boolean	forceUnbalanced(sync.pds.solver.nodes.INode<Val> iNode, Collection<sync.pds.solver.nodes.INode<Val>> collection)
sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>	generateFieldState(sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>> d, Field loc)
wpds.impl.WeightedPAutomaton<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W>	getCallAutomaton()
wpds.impl.WeightedPushdownSystem<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W>	getCallPDS()
wpds.impl.WeightedPAutomaton<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W>	getFieldAutomaton()
wpds.impl.WeightedPushdownSystem<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W>	getFieldPDS()
int	getNumberOfRules()
com.google.common.collect.Table<ControlFlowGraph.Edge,RegExAccessPath,W>	getResults(Method m)
Map<RegExAccessPath,W>	getResultsAt(Statement stmt)
protected boolean	isMatchingCallSiteCalleePair(Statement callSite, Method method)
protected boolean	preventCallTransitionAdd(wpds.impl.Transition<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>> t, W weight)
protected boolean	preventFieldTransitionAdd(wpds.impl.Transition<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>> t, W weight)
protected abstract void	propagateUnbalancedToCallSite(Statement callSiteEdge, wpds.impl.Transition<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>> transInCallee)
boolean	reachesNodeWithEmptyField(sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> node)
void	registerFieldTransitionListener(MethodBasedFieldTransitionListener<W> l)
void	registerStatementCallTransitionListener(ControlFlowEdgeBasedCallTransitionListener<W> l)
void	registerStatementFieldTransitionListener(ControlFlowEdgeBasedFieldTransitionListener<W> l)
protected void	returnFlow(Method method, sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> currNode)
void	synchedEmptyStackReachable(sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> sourceNode, sync.pds.solver.EmptyStackWitnessListener<ControlFlowGraph.Edge,Val> listener)
void	synchedReachable(sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> sourceNode, sync.pds.solver.WitnessListener<ControlFlowGraph.Edge,Val,Field> listener)
void	unregisterAllListeners()

Methods inherited from class sync.pds.solver.SyncPDSSolver

addApplySummaryListener, addGeneratedFieldState, addNormalCallFlow, addNormalFieldFlow, applyCallSummary, asFieldFact, computeSuccessor, debugOutput, generateCallState, getCallWeights, getFieldWeights, getReachedStates, processNode, processNormal, processPop, processPush, propagate, registerListener, registerListener, solve, solve, wrap

Methods inherited from class java.lang.Object

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

Field Detail

icfg

protected final ObservableICFG<Statement,Method> icfg

cfg

protected final ObservableControlFlowGraph cfg

INTERPROCEDURAL

protected boolean INTERPROCEDURAL

generatedFieldState

protected final Map<Map.Entry<sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,Field>,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>> generatedFieldState

perStatementFieldTransitions

protected com.google.common.collect.Multimap<ControlFlowGraph.Edge,wpds.impl.Transition<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>>> perStatementFieldTransitions

dataFlowScope

protected final DataFlowScope dataFlowScope

options

protected final BoomerangOptions options

type

protected final Type type

Constructor Detail

AbstractBoomerangSolver

public AbstractBoomerangSolver(ObservableICFG<Statement,Method> icfg,
                               ObservableControlFlowGraph cfg,
                               Map<Map.Entry<sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,Field>,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>> genField,
                               BoomerangOptions options,
                               wpds.impl.NestedWeightedPAutomatons<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W> callSummaries,
                               wpds.impl.NestedWeightedPAutomatons<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W> fieldSummaries,
                               DataFlowScope scope,
                               Type propagationType)

Method Detail

reachesNodeWithEmptyField

public boolean reachesNodeWithEmptyField(sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> node)

createQueryNodeField

public sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>> createQueryNodeField(Query query)

synchedEmptyStackReachable

public void synchedEmptyStackReachable(sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> sourceNode,
                                       sync.pds.solver.EmptyStackWitnessListener<ControlFlowGraph.Edge,Val> listener)

synchedReachable

public void synchedReachable(sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> sourceNode,
                             sync.pds.solver.WitnessListener<ControlFlowGraph.Edge,Val,Field> listener)

asEdgeValWeightTable

public com.google.common.collect.Table<ControlFlowGraph.Edge,Val,W> asEdgeValWeightTable()

asStatementValWeightTable

public com.google.common.collect.Table<Statement,Val,W> asStatementValWeightTable()

addPotentialUnbalancedFlow

protected void addPotentialUnbalancedFlow(Method callee,
                                          wpds.impl.Transition<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>> trans,
                                          W weight)

forceUnbalanced

protected boolean forceUnbalanced(sync.pds.solver.nodes.INode<Val> iNode,
                                  Collection<sync.pds.solver.nodes.INode<Val>> collection)

allowUnbalanced

public void allowUnbalanced(Method callee,
                            Statement callSite)

isMatchingCallSiteCalleePair

protected boolean isMatchingCallSiteCalleePair(Statement callSite,
                                               Method method)

propagateUnbalancedToCallSite

protected abstract void propagateUnbalancedToCallSite(Statement callSiteEdge,
                                                      wpds.impl.Transition<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>> transInCallee)

preventCallTransitionAdd

protected boolean preventCallTransitionAdd(wpds.impl.Transition<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>> t,
                                           W weight)

Overrides:

preventCallTransitionAdd in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

addCallRule

public void addCallRule(wpds.impl.Rule<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W> rule)

Overrides:

addCallRule in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

addFieldRule

public void addFieldRule(wpds.impl.Rule<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W> rule)

Overrides:

addFieldRule in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

registerFieldTransitionListener

public void registerFieldTransitionListener(MethodBasedFieldTransitionListener<W> l)

registerStatementFieldTransitionListener

public void registerStatementFieldTransitionListener(ControlFlowEdgeBasedFieldTransitionListener<W> l)

registerStatementCallTransitionListener

public void registerStatementCallTransitionListener(ControlFlowEdgeBasedCallTransitionListener<W> l)

generateFieldState

public sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>> generateFieldState(sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>> d,
                                                                                                                   Field loc)

Overrides:

generateFieldState in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

computeReturnFlow

protected abstract Collection<? extends wpds.interfaces.State> computeReturnFlow(Method method,
                                                                                 Statement curr,
                                                                                 Val value)

returnFlow

protected void returnFlow(Method method,
                          sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val> currNode)

computeNormalFlow

protected abstract Collection<wpds.interfaces.State> computeNormalFlow(Method method,
                                                                       ControlFlowGraph.Edge currEdge,
                                                                       Val value)

epsilonField

public Field epsilonField()

Specified by:

epsilonField in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

emptyField

public Field emptyField()

Specified by:

emptyField in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

epsilonStmt

public ControlFlowGraph.Edge epsilonStmt()

Specified by:

epsilonStmt in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

fieldWildCard

public Field fieldWildCard()

Specified by:

fieldWildCard in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

exclusionFieldWildCard

public Field exclusionFieldWildCard(Field exclusion)

Specified by:

exclusionFieldWildCard in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

getFieldAutomaton

public wpds.impl.WeightedPAutomaton<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W> getFieldAutomaton()

getCallAutomaton

public wpds.impl.WeightedPAutomaton<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W> getCallAutomaton()

getCallPDS

public wpds.impl.WeightedPushdownSystem<ControlFlowGraph.Edge,sync.pds.solver.nodes.INode<Val>,W> getCallPDS()

getFieldPDS

public wpds.impl.WeightedPushdownSystem<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>,W> getFieldPDS()

getNumberOfRules

public int getNumberOfRules()

preventFieldTransitionAdd

protected boolean preventFieldTransitionAdd(wpds.impl.Transition<Field,sync.pds.solver.nodes.INode<sync.pds.solver.nodes.Node<ControlFlowGraph.Edge,Val>>> t,
                                            W weight)

Overrides:

preventFieldTransitionAdd in class sync.pds.solver.SyncPDSSolver<ControlFlowGraph.Edge,Val,Field,W extends wpds.impl.Weight>

getResultsAt

public Map<RegExAccessPath,W> getResultsAt(Statement stmt)

getResults

public com.google.common.collect.Table<ControlFlowGraph.Edge,RegExAccessPath,W> getResults(Method m)

debugFieldAutomaton

public void debugFieldAutomaton(Statement stmt)

unregisterAllListeners

public void unregisterAllListeners()