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

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
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.
void	addExceptionalEdge(@NonNull Stmt stmt, @NonNull ClassType exceptionType, @NonNull Stmt traphandlerStmt)	Adds an exceptional flow with the type "exception" to a "stmt" which will reach "traphandlerStmt"
void	addNode(@NonNull Stmt stmt, @NonNull Map<ClassType,Stmt> exceptions)	inserts a "stmt" with exceptional flows "traps" into the StmtGraph
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.
void	clearBlockFromAllExceptionalBlocks(MutableBasicBlock blockOfRemovedStmt)
void	clearExceptionalEdges(@NonNull Stmt node)	Modifications of exceptional flows removes all exceptional flows from "stmt"
boolean	containsNode(@NonNull Stmt node)
protected @NonNull org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock>	createStmtsBlock(@NonNull Stmt stmt)	creates a Block and inserts the given Stmt.
static StmtGraph<?>	createUnmodifiableStmtGraph(StmtGraph<?> stmtGraph)
List<? extends BasicBlock<?>>	exceptionalPredecessorBlocks(@NonNull BasicBlock<?> block)
List<Stmt>	exceptionalPredecessors(@NonNull MutableBasicBlock block)
@NonNull List<Stmt>	exceptionalPredecessors(@NonNull Stmt node)	it is possible to reach traphandlers through inline code i.e. without any exceptional flow
@NonNull Map<ClassType,Stmt>	exceptionalSuccessors(@NonNull Stmt node)
@Nullable BasicBlock<?>	getBlockOf(@NonNull Stmt stmt)
@NonNull Set<? extends BasicBlock<?>>	getBlocks()
@NonNull List<? extends BasicBlock<?>>	getBlocksSorted()
@NonNull 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.
@Nullable Stmt	getStartingStmt()
@Nullable BasicBlock<?>	getStartingStmtBlock()
@NonNull List<BasicBlock<?>>	getTailStmtBlocks()
boolean	hasEdgeConnecting(@NonNull Stmt source, @NonNull 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(@NonNull Stmt node)	returns the amount of ingoing flows into node
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.
@NonNull BasicBlock<?>	insertAfter(@NonNull Stmt existingStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
@NonNull BasicBlock<?>	insertBefore(@NonNull Stmt existingStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
protected boolean	isMergeable(@NonNull MutableBasicBlock firstBlock, @NonNull MutableBasicBlock followingBlock)
int	outDegree(@NonNull Stmt node)	returns the amount of flows that start from node
@NonNull List<Stmt>	predecessors(@NonNull Stmt node)	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`
void	putEdge(@NonNull BranchingStmt stmtA, int succesorIdx, @NonNull Stmt stmtB)
void	putEdge(@NonNull FallsThroughStmt stmtA, @NonNull Stmt stmtB)	Modifications of unexceptional flows
protected void	putEdge_internal(@NonNull Stmt stmtA, int succesorIdx, @NonNull Stmt stmtB)
void	removeBlock(BasicBlock<?> block)
List<Integer>	removeEdge(@NonNull Stmt from, @NonNull Stmt to)	removes the current outgoing flows of "from" to "to"
void	removeExceptionalEdge(@NonNull Stmt node, @NonNull ClassType exceptionType)	removes an exceptional flow of the type "exception" flow from "stmt"
void	removeExceptionalFlowFromAllBlocks(@NonNull ClassType exceptionType, @NonNull Stmt exceptionHandlerStmt)	Removes the specified exceptional flow from all blocks.
void	removeNode(@NonNull Stmt stmt)	removes "stmt" from the StmtGraph
void	removeNode(@NonNull Stmt stmt, boolean keepFlow)	Removes a Stmt from the StmtGraph.
void	replaceNode(@NonNull Stmt oldStmt, @NonNull Stmt newStmt)	Modification of stmts (without manipulating any flows; possible assigned exceptional flows stay the same as well)
boolean	replaceSucessorEdge(@NonNull Stmt from, @NonNull Stmt oldTo, @NonNull Stmt newTo)	Replaces all SuccessorEdge(s) of from to oldTo by mewTo
void	setEdges(@NonNull BranchingStmt fromStmt, @NonNull List<Stmt> targets)	replaces the current outgoing flows of "from" to "targets"
void	setStartingStmt(@NonNull Stmt startingStmt)
@NonNull List<Stmt>	successors(@NonNull Stmt node)	returns the outgoing flows of node as ordered List.
protected boolean	tryMergeBlocks(@NonNull MutableBasicBlock firstBlock, @NonNull MutableBasicBlock followingBlock)	trys to merge the second block into the first one if possible
@NonNull StmtGraph<?>	unmodifiableStmtGraph()
protected void	updateIndexRangeAfterMerge(@NonNull MutableBasicBlock firstBlock, @NonNull MutableBasicBlock secondBlock)
void	validateBlocks()

Methods inherited from class sootup.core.graph.MutableStmtGraph

addBlock, addNode, insertAfter, insertBefore, setEdges

Methods inherited from class sootup.core.graph.StmtGraph

degree, equals, getAllSuccessors, getBlockIterator, getBranchTargetsOf, getEntrypoints, getExtendedBasicBlockPathBetween, 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

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

Specified by:

getBlocks in class StmtGraph<MutableBasicBlock>

getBlocksSorted

public @NonNull 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

protected @NonNull 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

clearBlockFromAllExceptionalBlocks

public void clearBlockFromAllExceptionalBlocks(MutableBasicBlock blockOfRemovedStmt)

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 @NonNull BasicBlock<?> insertBefore(@NonNull Stmt existingStmt,
 @NonNull List<FallsThroughStmt> stmts,
 @NonNull Map<ClassType,Stmt> exceptionMap)

Specified by:

insertBefore in class MutableStmtGraph

insertAfter

public @NonNull BasicBlock<?> insertAfter(@NonNull Stmt existingStmt,
 @NonNull List<FallsThroughStmt> stmts,
 @NonNull Map<ClassType,Stmt> exceptionMap)

Specified by:

insertAfter 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

public @Nullable Stmt getStartingStmt()

Specified by:

getStartingStmt in class StmtGraph<MutableBasicBlock>

getStartingStmtBlock

public @Nullable BasicBlock<?> getStartingStmtBlock()

Specified by:

getStartingStmtBlock in class StmtGraph<MutableBasicBlock>

getTailStmtBlocks

public @NonNull List<BasicBlock<?>> getTailStmtBlocks()

Specified by:

getTailStmtBlocks in class StmtGraph<MutableBasicBlock>

getBlockOf

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

Specified by:

getBlockOf in class StmtGraph<MutableBasicBlock>

unmodifiableStmtGraph

public @NonNull StmtGraph<?> unmodifiableStmtGraph()

Specified by:

unmodifiableStmtGraph in class MutableStmtGraph

setStartingStmt

public void setStartingStmt(@NonNull Stmt startingStmt)

Specified by:

setStartingStmt in class MutableStmtGraph

getNodes

public @NonNull 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

public @NonNull 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

public @NonNull 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

public @NonNull 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

public @NonNull 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>

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.