Package sootup.core.graph

Class MutableBlockStmtGraph

java.lang.Object

sootup.core.graph.StmtGraph<MutableBasicBlock>

sootup.core.graph.MutableStmtGraph

sootup.core.graph.MutableBlockStmtGraph

All Implemented Interfaces:

Iterable<Stmt>

public class MutableBlockStmtGraph
extends MutableStmtGraph

Nested Class Summary

Nested classes/interfaces inherited from class sootup.core.graph.StmtGraph

StmtGraph.BlockGraphIterator, StmtGraph.BlockGraphIteratorAndTrapAggregator

Constructor Summary

Constructors

Constructor	Description
MutableBlockStmtGraph()
MutableBlockStmtGraph(boolean isStatic, MethodSignature sig, LocalGenerator localgen)
MutableBlockStmtGraph(StmtGraph<? extends BasicBlock<?>> graph)	copies a StmtGraph into this Mutable instance

Method Summary

Modifier and Type	Method	Description
void	addBlock(List<Stmt> stmts, Map<ClassType,Stmt> trapMap)	The list of Stmts must contain only fallsthrough Stmts; A flow manipulating Stmt (BranchingStmt, return, throw) is only allowed at the Tail.
void	addExceptionalEdge(Stmt stmt, ClassType exceptionType, Stmt traphandlerStmt)	Adds an exceptional flow with the type "exception" to a "stmt" which will reach "traphandlerStmt"
void	addNode(Stmt stmt, Map<ClassType,Stmt> exceptions)	inserts a "stmt" with exceptional flows "traps" into the StmtGraph
protected org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock>	addNodeToBlock(MutableBasicBlock block, Stmt stmt)	Adds a Stmt to the end of a block i.e.
List<Trap>	buildTraps()	hint: little expensive getter - its more of a build/create - currently no overlaps
void	clearExceptionalEdges(Stmt node)	Modifications of exceptional flows removes all exceptional flows from "stmt"
boolean	containsNode(Stmt node)
protected org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock>	createStmtsBlock(Stmt stmt)	creates a Block and inserts the given Stmt.
static StmtGraph<?>	createUnmodifiableStmtGraph(StmtGraph<?> stmtGraph)
List<? extends BasicBlock<?>>	exceptionalPredecessorBlocks(BasicBlock<?> block)
List<Stmt>	exceptionalPredecessors(MutableBasicBlock block)
List<Stmt>	exceptionalPredecessors(Stmt node)	it is possible to reach traphandlers through inline code i.e.
Map<ClassType,Stmt>	exceptionalSuccessors(Stmt node)
BasicBlock<?>	getBlockOf(Stmt stmt)
Set<? extends BasicBlock<?>>	getBlocks()
List<? extends BasicBlock<?>>	getBlocksSorted()
Set<Stmt>	getNodes()	returns the nodes in this graph in a non-deterministic order (->Set) to get the nodes in linearized, ordered manner use iterator() or getStmts.
Stmt	getStartingStmt()
BasicBlock<?>	getStartingStmtBlock()
Comparator<Trap>	getTrapComparator(Map<Stmt,Integer> stmtsBlockIdx)	Comparator which sorts the trap output in getTraps()
boolean	hasEdgeConnecting(Stmt source, Stmt target)	returns true if there is a flow between source and target throws an Exception if at least one of the parameters is not contained in the graph.
int	inDegree(Stmt node)	returns the amount of ingoing flows into node
void	initializeWith(List<List<Stmt>> blocks, Map<BranchingStmt,List<Stmt>> successorMap, List<Trap> traps)	Creates a Graph representation from the 'legacy' representation i.e.
void	insertBefore(Stmt beforeStmt, List<FallsThroughStmt> stmts, Map<ClassType,Stmt> exceptionMap)
protected boolean	isMergeable(MutableBasicBlock firstBlock, MutableBasicBlock followingBlock)
int	outDegree(Stmt node)	returns the amount of flows that start from node
List<Stmt>	predecessors(Stmt node)	returns the ingoing flows to node as an List with no reliable/specific order and possibly duplicate entries i.e.
void	putEdge(BranchingStmt stmtA, int succesorIdx, Stmt stmtB)
void	putEdge(FallsThroughStmt stmtA, Stmt stmtB)	Modifications of unexceptional flows
protected void	putEdge_internal(Stmt stmtA, int succesorIdx, Stmt stmtB)
void	removeBlock(BasicBlock<?> block)
List<Integer>	removeEdge(Stmt from, Stmt to)	removes the current outgoing flows of "from" to "to"
void	removeExceptionalEdge(Stmt node, ClassType exceptionType)	removes an exceptional flow of the type "exception" flow from "stmt"
void	removeExceptionalFlowFromAllBlocks(ClassType exceptionType, Stmt exceptionHandlerStmt)	Removes the specified exceptional flow from all blocks.
void	removeNode(Stmt stmt)	removes "stmt" from the StmtGraph
void	removeNode(Stmt stmt, boolean keepFlow)	Removes a Stmt from the StmtGraph.
void	replaceNode(Stmt oldStmt, Stmt newStmt)	Modification of stmts (without manipulating any flows; possible assigned exceptional flows stay the same as well)
boolean	replaceSucessorEdge(Stmt from, Stmt oldTo, Stmt newTo)	Replaces all SuccessorEdge(s) of from to oldTo by mewTo
void	setEdges(BranchingStmt fromStmt, List<Stmt> targets)	replaces the current outgoing flows of "from" to "targets"
void	setStartingStmt(Stmt startingStmt)
List<Stmt>	successors(Stmt node)	returns the outgoing flows of node as ordered List.
protected boolean	tryMergeBlocks(MutableBasicBlock firstBlock, MutableBasicBlock followingBlock)	trys to merge the second block into the first one if possible
StmtGraph<?>	unmodifiableStmtGraph()
protected void	updateIndexRangeAfterMerge(MutableBasicBlock firstBlock, MutableBasicBlock secondBlock)
void	validateBlocks()

Methods inherited from class sootup.core.graph.MutableStmtGraph

addBlock, addNode, insertBefore, setEdges

Methods inherited from class sootup.core.graph.StmtGraph

degree, equals, getAllSuccessors, getBlockIterator, getBranchTargetsOf, getEntrypoints, getExtendedBasicBlockPathBetween, getLabeledStmts, getStmts, getTails, isStmtBranchTarget, iterator, toString, validateStmtConnectionsInGraph

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Details

MutableBlockStmtGraph

public MutableBlockStmtGraph()

MutableBlockStmtGraph

public MutableBlockStmtGraph(boolean isStatic,
 MethodSignature sig,
 LocalGenerator localgen)

MutableBlockStmtGraph

public MutableBlockStmtGraph(@Nonnull
 StmtGraph<? extends BasicBlock<?>> graph)

copies a StmtGraph into this Mutable instance

Method Details

createUnmodifiableStmtGraph

public static StmtGraph<?> createUnmodifiableStmtGraph(StmtGraph<?> stmtGraph)

initializeWith

public void initializeWith(@Nonnull
 List<List<Stmt>> blocks,
 @Nonnull
 Map<BranchingStmt,List<Stmt>> successorMap,
 @Nonnull
 List<Trap> traps)

Creates a Graph representation from the 'legacy' representation i.e. a List of Stmts and Traps.

addExceptionalEdge

public void addExceptionalEdge(@Nonnull
 Stmt stmt,
 @Nonnull
 ClassType exceptionType,
 @Nonnull
 Stmt traphandlerStmt)

Description copied from class: MutableStmtGraph

Adds an exceptional flow with the type "exception" to a "stmt" which will reach "traphandlerStmt"

Specified by:

addExceptionalEdge in class MutableStmtGraph

removeExceptionalEdge

public void removeExceptionalEdge(@Nonnull
 Stmt node,
 @Nonnull
 ClassType exceptionType)

Description copied from class: MutableStmtGraph

removes an exceptional flow of the type "exception" flow from "stmt"

Specified by:

removeExceptionalEdge in class MutableStmtGraph

clearExceptionalEdges

public void clearExceptionalEdges(@Nonnull
 Stmt node)

Description copied from class: MutableStmtGraph

Modifications of exceptional flows removes all exceptional flows from "stmt"

Specified by:

clearExceptionalEdges in class MutableStmtGraph

getBlocks

@Nonnull
public Set<? extends BasicBlock<?>> getBlocks()

Specified by:

getBlocks in class StmtGraph<MutableBasicBlock>

getBlocksSorted

@Nonnull
public List<? extends BasicBlock<?>> getBlocksSorted()

Specified by:

getBlocksSorted in class StmtGraph<MutableBasicBlock>

addBlock

public void addBlock(@Nonnull
 List<Stmt> stmts,
 @Nonnull
 Map<ClassType,Stmt> trapMap)

The list of Stmts must contain only fallsthrough Stmts; A flow manipulating Stmt (BranchingStmt, return, throw) is only allowed at the Tail. (like the conditions of a Block)

Specified by:

addBlock in class MutableStmtGraph

removeBlock

public void removeBlock(BasicBlock<?> block)

Specified by:

removeBlock in class MutableStmtGraph

addNode

public void addNode(@Nonnull
 Stmt stmt,
 @Nonnull
 Map<ClassType,Stmt> exceptions)

Description copied from class: MutableStmtGraph

inserts a "stmt" with exceptional flows "traps" into the StmtGraph

Specified by:

addNode in class MutableStmtGraph

updateIndexRangeAfterMerge

protected void updateIndexRangeAfterMerge(@Nonnull
 MutableBasicBlock firstBlock,
 @Nonnull
 MutableBasicBlock secondBlock)

isMergeable

protected boolean isMergeable(@Nonnull
 MutableBasicBlock firstBlock,
 @Nonnull
 MutableBasicBlock followingBlock)

tryMergeBlocks

protected boolean tryMergeBlocks(@Nonnull
 MutableBasicBlock firstBlock,
 @Nonnull
 MutableBasicBlock followingBlock)

trys to merge the second block into the first one if possible

createStmtsBlock

@Nonnull
protected org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock> createStmtsBlock(@Nonnull
 Stmt stmt)

creates a Block and inserts the given Stmt.

Returns:

-1 if Stmt is already in the graph!

addNodeToBlock

protected org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock> addNodeToBlock(@Nonnull
 MutableBasicBlock block,
 @Nonnull
 Stmt stmt)

Adds a Stmt to the end of a block i.e. stmt will become the new tail.

removeNode

public void removeNode(@Nonnull
 Stmt stmt)

Description copied from class: MutableStmtGraph

removes "stmt" from the StmtGraph

Specified by:

removeNode in class MutableStmtGraph

removeNode

public void removeNode(@Nonnull
 Stmt stmt,
 boolean keepFlow)

Removes a Stmt from the StmtGraph.

It can optionally keep the flow (edges) of the statement by connecting the predecessors of the statement with successors of the statement. Keeping the flow does not work when the statement has multiple successors.

Specified by:

removeNode in class MutableStmtGraph

Parameters:

stmt - the Stmt to be removed

keepFlow - flag indicating whether to keep the flow or not

Throws:

IllegalArgumentException - if keepFlow is true but the stmt has multiple successors

replaceNode

public void replaceNode(@Nonnull
 Stmt oldStmt,
 @Nonnull
 Stmt newStmt)

Description copied from class: MutableStmtGraph

Modification of stmts (without manipulating any flows; possible assigned exceptional flows stay the same as well)

Specified by:

replaceNode in class MutableStmtGraph

validateBlocks

public void validateBlocks()

insertBefore

public void insertBefore(@Nonnull
 Stmt beforeStmt,
 @Nonnull
 List<FallsThroughStmt> stmts,
 @Nonnull
 Map<ClassType,Stmt> exceptionMap)

Specified by:

insertBefore in class MutableStmtGraph

replaceSucessorEdge

public boolean replaceSucessorEdge(@Nonnull
 Stmt from,
 @Nonnull
 Stmt oldTo,
 @Nonnull
 Stmt newTo)

Replaces all SuccessorEdge(s) of from to oldTo by mewTo

Specified by:

replaceSucessorEdge in class MutableStmtGraph

putEdge

public void putEdge(@Nonnull
 FallsThroughStmt stmtA,
 @Nonnull
 Stmt stmtB)

Description copied from class: MutableStmtGraph

Modifications of unexceptional flows

Adds a flow "from" to "to". if at least one of the parameter Stmts is not already in the StmtGraph it will be added. if "to" needs to be added to the StmtGraph i.e. "to" is not already in the StmtGraph the method assumes "to" has the same exceptional flows as "from".

Specified by:

putEdge in class MutableStmtGraph

putEdge

public void putEdge(@Nonnull
 BranchingStmt stmtA,
 int succesorIdx,
 @Nonnull
 Stmt stmtB)

Specified by:

putEdge in class MutableStmtGraph

putEdge_internal

protected void putEdge_internal(@Nonnull
 Stmt stmtA,
 int succesorIdx,
 @Nonnull
 Stmt stmtB)

removeEdge

public List<Integer> removeEdge(@Nonnull
 Stmt from,
 @Nonnull
 Stmt to)

Description copied from class: MutableStmtGraph

removes the current outgoing flows of "from" to "to"

Specified by:

removeEdge in class MutableStmtGraph

Returns:

returns List of the successor indices of "from" that were connected to "to" - items are 0 in case of FallsThroughStmts or idx > 0 in case of BranchingStmts with multiple successors

setEdges

public void setEdges(@Nonnull
 BranchingStmt fromStmt,
 @Nonnull
 List<Stmt> targets)

Description copied from class: MutableStmtGraph

replaces the current outgoing flows of "from" to "targets"

Specified by:

setEdges in class MutableStmtGraph

getStartingStmt

@Nullable
public Stmt getStartingStmt()

Specified by:

getStartingStmt in class StmtGraph<MutableBasicBlock>

getStartingStmtBlock

@Nullable
public BasicBlock<?> getStartingStmtBlock()

Specified by:

getStartingStmtBlock in class StmtGraph<MutableBasicBlock>

getBlockOf

@Nullable
public BasicBlock<?> getBlockOf(@Nonnull
 Stmt stmt)

Specified by:

getBlockOf in class StmtGraph<MutableBasicBlock>

unmodifiableStmtGraph

@Nonnull
public StmtGraph<?> unmodifiableStmtGraph()

Specified by:

unmodifiableStmtGraph in class MutableStmtGraph

setStartingStmt

public void setStartingStmt(@Nonnull
 Stmt startingStmt)

Specified by:

setStartingStmt in class MutableStmtGraph

getNodes

@Nonnull
public Set<Stmt> getNodes()

Description copied from class: StmtGraph

returns the nodes in this graph in a non-deterministic order (->Set) to get the nodes in linearized, ordered manner use iterator() or getStmts.

Specified by:

getNodes in class StmtGraph<MutableBasicBlock>

containsNode

public boolean containsNode(@Nonnull
 Stmt node)

Specified by:

containsNode in class StmtGraph<MutableBasicBlock>

predecessors

@Nonnull
public List<Stmt> predecessors(@Nonnull
 Stmt node)

Description copied from class: StmtGraph

returns the ingoing flows to node as an List with no reliable/specific order and possibly duplicate entries i.e. if a JSwitchStmt has multiple cases that brnach to `node`

Specified by:

predecessors in class StmtGraph<MutableBasicBlock>

exceptionalPredecessors

@Nonnull
public List<Stmt> exceptionalPredecessors(@Nonnull
 Stmt node)

Description copied from class: StmtGraph

it is possible to reach traphandlers through inline code i.e. without any exceptional flow

Specified by:

exceptionalPredecessors in class StmtGraph<MutableBasicBlock>

exceptionalPredecessors

public List<Stmt> exceptionalPredecessors(@Nonnull
 MutableBasicBlock block)

exceptionalPredecessorBlocks

public List<? extends BasicBlock<?>> exceptionalPredecessorBlocks(@Nonnull
 BasicBlock<?> block)

successors

@Nonnull
public List<Stmt> successors(@Nonnull
 Stmt node)

Description copied from class: StmtGraph

returns the outgoing flows of node as ordered List. The List can have duplicate entries!

Specified by:

successors in class StmtGraph<MutableBasicBlock>

exceptionalSuccessors

@Nonnull
public Map<ClassType,Stmt> exceptionalSuccessors(@Nonnull
 Stmt node)

Specified by:

exceptionalSuccessors in class StmtGraph<MutableBasicBlock>

inDegree

public int inDegree(@Nonnull
 Stmt node)

Description copied from class: StmtGraph

returns the amount of ingoing flows into node

Specified by:

inDegree in class StmtGraph<MutableBasicBlock>

outDegree

public int outDegree(@Nonnull
 Stmt node)

Description copied from class: StmtGraph

returns the amount of flows that start from node

Specified by:

outDegree in class StmtGraph<MutableBasicBlock>

hasEdgeConnecting

public boolean hasEdgeConnecting(@Nonnull
 Stmt source,
 @Nonnull
 Stmt target)

Description copied from class: StmtGraph

returns true if there is a flow between source and target throws an Exception if at least one of the parameters is not contained in the graph.

Specified by:

hasEdgeConnecting in class StmtGraph<MutableBasicBlock>

getTrapComparator

public Comparator<Trap> getTrapComparator(@Nonnull
 Map<Stmt,Integer> stmtsBlockIdx)

Comparator which sorts the trap output in getTraps()

buildTraps

public List<Trap> buildTraps()

hint: little expensive getter - its more of a build/create - currently no overlaps

Specified by:

buildTraps in class StmtGraph<MutableBasicBlock>

removeExceptionalFlowFromAllBlocks

public void removeExceptionalFlowFromAllBlocks(@Nonnull
 ClassType exceptionType,
 @Nonnull
 Stmt exceptionHandlerStmt)

Description copied from class: StmtGraph

Removes the specified exceptional flow from all blocks.

Specified by:

removeExceptionalFlowFromAllBlocks in class StmtGraph<MutableBasicBlock>

Parameters:

exceptionType - The class type of the exceptional flow.

exceptionHandlerStmt - The handler statement of the exceptional flow.