Uses of Interface
sootup.core.jimple.common.stmt.Stmt

Packages that use Stmt

Package	Description
qilin.core
qilin.core.builder
qilin.core.builder.callgraph
qilin.core.pag
qilin.core.reflection
qilin.pta.toolkits.conch
qilin.stat
sootup.analysis.interprocedural.icfg
sootup.analysis.interprocedural.ide
sootup.analysis.interprocedural.ifds
sootup.analysis.intraprocedural
sootup.analysis.intraprocedural.reachingdefs
sootup.apk.frontend.instruction
sootup.apk.frontend.interceptors
sootup.apk.frontend.main
sootup.codepropertygraph.propertygraph.nodes
sootup.core.graph
sootup.core.jimple
sootup.core.jimple.basic
sootup.core.jimple.common.stmt
sootup.core.jimple.javabytecode.stmt
sootup.core.jimple.visitor
sootup.core.model
sootup.core.util.printer
sootup.core.validation
sootup.interceptors
sootup.interceptors.typeresolving
sootup.java.bytecode.frontend.conversion
sootup.java.core.exceptions

Uses of Stmt in qilin.core

Fields in qilin.core with type parameters of type Stmt

Modifier and Type	Field	Description
protected final List<Stmt>	ArtificialMethod.stmtList

Uses of Stmt in qilin.core.builder

Methods in qilin.core.builder with parameters of type Stmt

Modifier and Type	Method	Description
final void	MethodNodeFactory.handleStmt(Stmt s)	Adds the edges required for this statement to the graph.
LocalVarNode	MethodNodeFactory.makeInvokeStmtThrowVarNode(Stmt invoke, SootMethod method)

Uses of Stmt in qilin.core.builder.callgraph

Fields in qilin.core.builder.callgraph with type parameters of type Stmt

Modifier and Type	Field	Description
protected Map<Stmt,Edge>	OnFlyCallGraph.srcUnitToEdge

Methods in qilin.core.builder.callgraph with parameters of type Stmt

Modifier and Type	Method	Description
Iterator<Edge>	OnFlyCallGraph.edgesOutOf(Stmt u)	Returns an iterator over all edges that have u as their source unit.
Edge	OnFlyCallGraph.findEdge(Stmt u, SootMethod callee)	Find the specific call edge that is going out from the callsite u and the call target is callee.
boolean	OnFlyCallGraph.removeAllEdgesOutOf(Stmt u)	Removes all outgoing edges that start at the given unit

Uses of Stmt in qilin.core.pag

Fields in qilin.core.pag with type parameters of type Stmt

Modifier and Type	Field	Description
final Map<Node,Map<Stmt,List<Trap>>>	MethodPAG.node2wrapperedTraps
final Map<Stmt,List<Trap>>	MethodPAG.stmt2wrapperedTraps

Methods in qilin.core.pag that return Stmt

Modifier and Type	Method	Description
Stmt	ExceptionThrowSite.getUnit()

Constructors in qilin.core.pag with parameters of type Stmt

Modifier	Constructor	Description
	ExceptionThrowSite(VarNode throwNode, Stmt unit, ContextMethod container)

Uses of Stmt in qilin.core.reflection

Fields in qilin.core.reflection with type parameters of type Stmt

Modifier and Type	Field	Description
protected Map<ReflectionKind,Map<Stmt,Set<String>>>	TamiflexModel.reflectionMap

Methods in qilin.core.reflection that return types with arguments of type Stmt

Modifier and Type	Method	Description
protected Collection<Stmt>	TamiflexModel.transformArrayNewInstance(InvokableStmt s)
protected Collection<Stmt>	TamiflexModel.transformClassNewInstance(InvokableStmt s)
protected Collection<Stmt>	TamiflexModel.transformConstructorNewInstance(InvokableStmt s)
protected Collection<Stmt>	TamiflexModel.transformFieldGet(InvokableStmt s)
protected Collection<Stmt>	TamiflexModel.transformFieldSet(InvokableStmt s)
protected Collection<Stmt>	TamiflexModel.transformMethodInvoke(InvokableStmt s)

Uses of Stmt in qilin.pta.toolkits.conch

Fields in qilin.pta.toolkits.conch with type parameters of type Stmt

Modifier and Type	Field	Description
protected final Map<SootMethod,Map<Stmt,AllocNode>>	AbstractPAG.symbolicHeaps

Methods in qilin.pta.toolkits.conch with parameters of type Stmt

Modifier and Type	Method	Description
protected AllocNode	AbstractPAG.getSymbolicHeapOf(SootMethod method, Stmt invokeStmt)

Uses of Stmt in qilin.stat

Method parameters in qilin.stat with type arguments of type Stmt

Modifier and Type	Method	Description
void	Exporter.dumpMayFailCasts(Map<SootMethod,Set<Stmt>> casts)

Uses of Stmt in sootup.analysis.interprocedural.icfg

Fields in sootup.analysis.interprocedural.icfg with type parameters of type Stmt

Modifier and Type	Field	Description
protected final BiDiInterproceduralCFG<Stmt,SootMethod>	BackwardsInterproceduralCFG.delegate
protected com.google.common.cache.CacheLoader<SootMethod,Collection<Stmt>>	JimpleBasedInterproceduralCFG.loaderMethodToCallers
protected com.google.common.cache.CacheLoader<Stmt,Collection<SootMethod>>	JimpleBasedInterproceduralCFG.loaderUnitToCallees
protected final com.google.common.cache.LoadingCache<SootMethod,Collection<Stmt>>	JimpleBasedInterproceduralCFG.methodToCallers
protected com.google.common.cache.LoadingCache<SootMethod,Set<Stmt>>	AbstractJimpleBasedICFG.methodToCallsFromWithin
protected final com.google.common.cache.LoadingCache<Stmt,Collection<SootMethod>>	JimpleBasedInterproceduralCFG.stmtToCallees

Methods in sootup.analysis.interprocedural.icfg that return types with arguments of type Stmt

Modifier and Type	Method	Description
Set<Stmt>	AbstractJimpleBasedICFG.allNonCallEndNodes()
Set<Stmt>	BackwardsInterproceduralCFG.allNonCallEndNodes()
Set<Stmt>	AbstractJimpleBasedICFG.allNonCallStartNodes()
Set<Stmt>	BackwardsInterproceduralCFG.allNonCallStartNodes()
protected Map<Stmt,Body>	AbstractJimpleBasedICFG.createStmtToOwnerMap()
Collection<Stmt>	BackwardsInterproceduralCFG.getCallersOf(SootMethod m)
Collection<Stmt>	JimpleBasedInterproceduralCFG.getCallersOf(@NonNull SootMethod m)
Set<Stmt>	AbstractJimpleBasedICFG.getCallsFromWithin(SootMethod m)
Set<Stmt>	BackwardsInterproceduralCFG.getCallsFromWithin(SootMethod m)
protected Set<Stmt>	AbstractJimpleBasedICFG.getCallsFromWithinMethod(SootMethod method)
Collection<Stmt>	AbstractJimpleBasedICFG.getEndPointsOf(SootMethod m)
Collection<Stmt>	BackwardsInterproceduralCFG.getEndPointsOf(SootMethod m)
List<Stmt>	AbstractJimpleBasedICFG.getPredsOf(Stmt u)
List<Stmt>	BackwardsInterproceduralCFG.getPredsOf(Stmt u)
List<Stmt>	AbstractJimpleBasedICFG.getPredsOfCallAt(Stmt u)
List<Stmt>	BackwardsInterproceduralCFG.getPredsOfCallAt(Stmt u)
Collection<Stmt>	AbstractJimpleBasedICFG.getReturnSitesOfCallAt(Stmt u)
List<Stmt>	BackwardsInterproceduralCFG.getReturnSitesOfCallAt(Stmt n)
Collection<Stmt>	AbstractJimpleBasedICFG.getStartPointsOf(SootMethod m)
Collection<Stmt>	BackwardsInterproceduralCFG.getStartPointsOf(SootMethod m)
List<Stmt>	AbstractJimpleBasedICFG.getSuccsOf(Stmt stmt)
List<Stmt>	BackwardsInterproceduralCFG.getSuccsOf(Stmt n)

Methods in sootup.analysis.interprocedural.icfg with parameters of type Stmt

Modifier and Type	Method	Description
Body	AbstractJimpleBasedICFG.getBodyOf(Stmt stmt)
Collection<SootMethod>	BackwardsInterproceduralCFG.getCalleesOfCallAt(Stmt n)
Collection<SootMethod>	JimpleBasedInterproceduralCFG.getCalleesOfCallAt(@NonNull Stmt u)
SootMethod	AbstractJimpleBasedICFG.getMethodOf(Stmt stmt)
SootMethod	BackwardsInterproceduralCFG.getMethodOf(Stmt n)
List<Stmt>	AbstractJimpleBasedICFG.getPredsOf(Stmt u)
List<Stmt>	BackwardsInterproceduralCFG.getPredsOf(Stmt u)
List<Stmt>	AbstractJimpleBasedICFG.getPredsOfCallAt(Stmt u)
List<Stmt>	BackwardsInterproceduralCFG.getPredsOfCallAt(Stmt u)
Collection<Stmt>	AbstractJimpleBasedICFG.getReturnSitesOfCallAt(Stmt u)
List<Stmt>	BackwardsInterproceduralCFG.getReturnSitesOfCallAt(Stmt n)
List<Stmt>	AbstractJimpleBasedICFG.getSuccsOf(Stmt stmt)
List<Stmt>	BackwardsInterproceduralCFG.getSuccsOf(Stmt n)
boolean	AbstractJimpleBasedICFG.isBranchTarget(Stmt u, Stmt succ)
boolean	BackwardsInterproceduralCFG.isBranchTarget(Stmt stmt, Stmt succ)
boolean	AbstractJimpleBasedICFG.isCallStmt(Stmt stmt)
boolean	BackwardsInterproceduralCFG.isCallStmt(Stmt stmt)
boolean	AbstractJimpleBasedICFG.isExitStmt(Stmt stmt)
boolean	BackwardsInterproceduralCFG.isExitStmt(Stmt stmt)
boolean	AbstractJimpleBasedICFG.isFallThroughSuccessor(Stmt stmt, Stmt successorCandidate)
boolean	BackwardsInterproceduralCFG.isFallThroughSuccessor(Stmt stmt, Stmt succ)
boolean	AbstractJimpleBasedICFG.isReachable(Stmt u)
boolean	BackwardsInterproceduralCFG.isReachable(Stmt u)
boolean	AbstractJimpleBasedICFG.isReturnSite(Stmt n)
boolean	BackwardsInterproceduralCFG.isReturnSite(Stmt n)
boolean	AbstractJimpleBasedICFG.isStartPoint(Stmt stmt)
boolean	BackwardsInterproceduralCFG.isStartPoint(Stmt stmt)
boolean	AbstractJimpleBasedICFG.setOwnerStatement(Stmt u, Body b)

Constructor parameters in sootup.analysis.interprocedural.icfg with type arguments of type Stmt

Modifier	Constructor	Description
	BackwardsInterproceduralCFG(BiDiInterproceduralCFG<Stmt,SootMethod> fwICFG)

Uses of Stmt in sootup.analysis.interprocedural.ide

Classes in sootup.analysis.interprocedural.ide with type parameters of type Stmt

Modifier and Type	Class	Description
class	DefaultJimpleIDETabulationProblem<D,V,I extends heros.InterproceduralCFG<Stmt,SootMethod>>
class	JimpleIDESolver<D,V,I extends heros.InterproceduralCFG<Stmt,SootMethod>>

Constructor parameters in sootup.analysis.interprocedural.ide with type arguments of type Stmt

Modifier	Constructor	Description
	JimpleIDESolver(heros.IDETabulationProblem<Stmt,D,SootMethod,V,I> problem)

Uses of Stmt in sootup.analysis.interprocedural.ifds

Classes in sootup.analysis.interprocedural.ifds with type parameters of type Stmt

Modifier and Type	Class	Description
class	DefaultJimpleIFDSTabulationProblem<D,I extends heros.InterproceduralCFG<Stmt,SootMethod>>
class	JimpleIFDSSolver<D,I extends heros.InterproceduralCFG<Stmt,SootMethod>>

Constructor parameters in sootup.analysis.interprocedural.ifds with type arguments of type Stmt

Modifier	Constructor	Description
	JimpleIFDSSolver(heros.IFDSTabulationProblem<Stmt,D,SootMethod,I> problem)

Uses of Stmt in sootup.analysis.intraprocedural

Fields in sootup.analysis.intraprocedural with type parameters of type Stmt

Modifier and Type	Field	Description
protected @NonNull Map<Stmt,A>	FlowAnalysis.filterStmtToAfterFlow	Filtered: Maps graph nodes to OUT sets.
protected final @NonNull Map<Stmt,A>	FlowAnalysis.stmtToAfterFlow	Maps graph nodes to OUT sets.
protected final Map<Stmt,F>	AbstractFlowAnalysis.stmtToBeforeFlow	Maps graph nodes to IN sets.

Methods in sootup.analysis.intraprocedural with parameters of type Stmt

Modifier and Type	Method	Description
protected abstract void	FlowAnalysis.flowThrough(@NonNull A in, Stmt d, @NonNull A out)	Given the merge of the out sets, compute the in set for s (or in to out, depending on direction).
protected FlowAnalysis.Flow	FlowAnalysis.getFlow(@NonNull Stmt from, @NonNull Stmt mergeNode)	You can specify which flow set you would like to use of node from
A	FlowAnalysis.getFlowAfter(@NonNull Stmt s)	Accessor function returning value of OUT set for s.
@NonNull F	AbstractFlowAnalysis.getFlowBefore(@NonNull Stmt s)	Accessor function returning value of IN set for s.
@NonNull A	FlowAnalysis.getFlowBefore(@NonNull Stmt s)
protected void	AbstractFlowAnalysis.merge(@NonNull Stmt succNode, @NonNull F in1, @NonNull F in2, @NonNull F out)	Merges in1 and in2 into out, just before node succNode.
protected void	AbstractFlowAnalysis.mergeInto(@NonNull Stmt succNode, @NonNull F inout, @NonNull F in)	Merges in into inout, just before node succNode.
protected boolean	FlowAnalysis.omissible(@NonNull Stmt stmt)	If a flow node can be omitted return true, otherwise false.

Uses of Stmt in sootup.analysis.intraprocedural.reachingdefs

Methods in sootup.analysis.intraprocedural.reachingdefs that return types with arguments of type Stmt

Modifier and Type	Method	Description
Map<Stmt,List<Stmt>>	ReachingDefs.getReachingDefs()
Map<Stmt,List<Stmt>>	ReachingDefs.getReachingDefs()

Uses of Stmt in sootup.apk.frontend.instruction

Fields in sootup.apk.frontend.instruction declared as Stmt

Modifier and Type	Field	Description
protected Stmt	JumpInstruction.markerUnit
protected Stmt	SwitchInstruction.markerUnit
protected Stmt	DexLibAbstractInstruction.stmt

Methods in sootup.apk.frontend.instruction that return Stmt

Modifier and Type	Method	Description
Stmt	DexLibAbstractInstruction.getStmt()
protected Stmt	PackedSwitchInstruction.switchStatement(DexBody body, org.jf.dexlib2.iface.instruction.Instruction targetData, Local key)
protected Stmt	SparseSwitchInstruction.switchStatement(DexBody body, org.jf.dexlib2.iface.instruction.Instruction targetData, Local key)
protected abstract Stmt	SwitchInstruction.switchStatement(DexBody body, org.jf.dexlib2.iface.instruction.Instruction targetData, Local key)

Methods in sootup.apk.frontend.instruction with parameters of type Stmt

Modifier and Type	Method	Description
protected void	DexLibAbstractInstruction.setStmt(Stmt stmt)

Uses of Stmt in sootup.apk.frontend.interceptors

Fields in sootup.apk.frontend.interceptors with type parameters of type Stmt

Modifier and Type	Field	Description
protected List<Stmt>	DexDefUseAnalysis.stmtList

Methods in sootup.apk.frontend.interceptors that return types with arguments of type Stmt

Modifier and Type	Method	Description
protected Set<Stmt>	DexDefUseAnalysis.collectDefinitionsWithAliases(Local l)	Collect definitions of l in body including the definitions of aliases of l.
List<Stmt>	DexDefUseAnalysis.getDefsOf(Local l)
Set<Stmt>	DexDefUseAnalysis.getUsesOf(Local l)

Methods in sootup.apk.frontend.interceptors with parameters of type Stmt

Modifier and Type	Method	Description
protected Type	DexTransformer.findArrayType(DexDefUseAnalysis dexDefUseAnalysis, Stmt arrayStmt, int depth, Set<Stmt> alreadyVisitedDefs)
protected void	AbstractNullTransformer.replaceWithNull(Stmt stmt)	Replace 0 with null in the given unit.

Method parameters in sootup.apk.frontend.interceptors with type arguments of type Stmt

Modifier and Type	Method	Description
protected Type	DexTransformer.findArrayType(DexDefUseAnalysis dexDefUseAnalysis, Stmt arrayStmt, int depth, Set<Stmt> alreadyVisitedDefs)

Uses of Stmt in sootup.apk.frontend.main

Methods in sootup.apk.frontend.main that return types with arguments of type Stmt

Modifier and Type	Method	Description
Map<BranchingStmt,List<Stmt>>	DexBody.convertMultimap(com.google.common.collect.LinkedListMultimap<BranchingStmt,List<Stmt>> multimap)
com.google.common.collect.LinkedListMultimap<BranchingStmt,List<Stmt>>	DexBody.getBranchingMap()

Methods in sootup.apk.frontend.main with parameters of type Stmt

Modifier and Type	Method	Description
void	DexBody.add(Stmt stmt)
void	DexBody.insertAfter(Stmt tobeInserted, Stmt afterThisStmt)
void	DexBody.insertBefore(Stmt tobeInserted, Stmt beforeThisStmt)
void	DexBody.replaceStmt(Stmt toBeReplaced, Stmt newStmt)

Method parameters in sootup.apk.frontend.main with type arguments of type Stmt

Modifier and Type	Method	Description
void	DexBody.addBranchingStmt(BranchingStmt branchingStmt, List<Stmt> stmt)
Map<BranchingStmt,List<Stmt>>	DexBody.convertMultimap(com.google.common.collect.LinkedListMultimap<BranchingStmt,List<Stmt>> multimap)

Uses of Stmt in sootup.codepropertygraph.propertygraph.nodes

Methods in sootup.codepropertygraph.propertygraph.nodes that return Stmt

Modifier and Type	Method	Description
Stmt	StmtGraphNode.getStmt()

Constructors in sootup.codepropertygraph.propertygraph.nodes with parameters of type Stmt

Modifier	Constructor	Description
	StmtGraphNode(Stmt stmt)

Uses of Stmt in sootup.core.graph

Methods in sootup.core.graph that return Stmt

Modifier and Type	Method	Description
@NonNull Stmt	BasicBlock.getHead()
@NonNull Stmt	ForwardingBasicBlock.getHead()
@NonNull Stmt	ImmutableBasicBlock.getHead()
@NonNull Stmt	ImmutableBlockStmtGraph.ImmutableBasicBlock.getHead()
@NonNull Stmt	MutableBasicBlock.getHead()
@NonNull Stmt	MutableBasicBlockImpl.getHead()
Stmt	BackwardsStmtGraph.getStartingStmt()
Stmt	ForwardingStmtGraph.getStartingStmt()
@Nullable Stmt	ImmutableBlockStmtGraph.getStartingStmt()
@Nullable Stmt	MutableBlockStmtGraph.getStartingStmt()
abstract Stmt	StmtGraph.getStartingStmt()
@NonNull Stmt	BasicBlock.getTail()
@NonNull Stmt	ForwardingBasicBlock.getTail()
@NonNull Stmt	ImmutableBasicBlock.getTail()
@NonNull Stmt	ImmutableBlockStmtGraph.ImmutableBasicBlock.getTail()
@NonNull Stmt	MutableBasicBlock.getTail()
@NonNull Stmt	MutableBasicBlockImpl.getTail()
@NonNull Stmt	StmtGraphBlockIterator.next()

Methods in sootup.core.graph that return types with arguments of type Stmt

Modifier and Type	Method	Description
@NonNull List<Stmt>	ForwardingStmtGraph.exceptionalPredecessors(@NonNull Stmt node)
@NonNull List<Stmt>	ImmutableBlockStmtGraph.exceptionalPredecessors(@NonNull Stmt node)
List<Stmt>	MutableBlockStmtGraph.exceptionalPredecessors(@NonNull MutableBasicBlock block)
@NonNull List<Stmt>	MutableBlockStmtGraph.exceptionalPredecessors(@NonNull Stmt node)
abstract @NonNull List<Stmt>	StmtGraph.exceptionalPredecessors(@NonNull Stmt node)	it is possible to reach traphandlers through inline code i.e. without any exceptional flow
@NonNull Map<ClassType,Stmt>	ForwardingStmtGraph.exceptionalSuccessors(@NonNull Stmt node)
@NonNull Map<ClassType,Stmt>	ImmutableBlockStmtGraph.exceptionalSuccessors(@NonNull Stmt node)
@NonNull Map<ClassType,Stmt>	MutableBlockStmtGraph.exceptionalSuccessors(@NonNull Stmt node)
abstract @NonNull Map<ClassType,Stmt>	StmtGraph.exceptionalSuccessors(@NonNull Stmt node)
@NonNull List<Stmt>	StmtGraph.getAllSuccessors(@NonNull Stmt stmt)	Collects all successors i.e. unexceptional and exceptional successors of a given stmt into a list.
List<Stmt>	StmtGraph.getBranchTargetsOf(BranchingStmt fromStmt)
@NonNull Collection<Stmt>	StmtGraph.getEntrypoints()	returns a Collection of all stmt in the graph that are either the starting stmt or only have an exceptional ingoing flow
@Nullable List<Stmt>	StmtGraph.getExtendedBasicBlockPathBetween(@NonNull Stmt from, @NonNull Stmt to)	Look for a path in graph, from def to use.
@NonNull Collection<Stmt>	BackwardsStmtGraph.getNodes()
@NonNull Collection<Stmt>	ForwardingStmtGraph.getNodes()
@NonNull List<Stmt>	ImmutableBlockStmtGraph.getNodes()
@NonNull Set<Stmt>	MutableBlockStmtGraph.getNodes()
abstract @NonNull Collection<Stmt>	StmtGraph.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.
@NonNull List<Stmt>	BackwardsStmtGraph.getStartingStmts()
@NonNull List<Stmt>	BasicBlock.getStmts()
@NonNull List<Stmt>	ForwardingBasicBlock.getStmts()
@NonNull List<Stmt>	ImmutableBasicBlock.getStmts()
@NonNull List<Stmt>	ImmutableBlockStmtGraph.ImmutableBasicBlock.getStmts()
@NonNull List<Stmt>	MutableBasicBlock.getStmts()
@NonNull List<Stmt>	MutableBasicBlockImpl.getStmts()
List<Stmt>	StmtGraph.getStmts()
@NonNull List<Stmt>	StmtGraph.getTails()	returns a Collection of Stmts that leave the body (i.e.
@NonNull Iterator<Stmt>	ForwardingStmtGraph.iterator()
@NonNull Iterator<Stmt>	ImmutableBlockStmtGraph.iterator()
@NonNull Iterator<Stmt>	StmtGraph.iterator()
@NonNull List<Stmt>	BackwardsStmtGraph.predecessors(@NonNull Stmt node)
@NonNull List<Stmt>	ForwardingStmtGraph.predecessors(@NonNull Stmt stmt)
@NonNull List<Stmt>	ImmutableBlockStmtGraph.predecessors(@NonNull Stmt node)
@NonNull List<Stmt>	MutableBlockStmtGraph.predecessors(@NonNull Stmt node)
abstract @NonNull List<Stmt>	StmtGraph.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`
@NonNull List<Stmt>	BackwardsStmtGraph.successors(@NonNull Stmt node)
@NonNull List<Stmt>	ForwardingStmtGraph.successors(@NonNull Stmt stmt)
@NonNull List<Stmt>	ImmutableBlockStmtGraph.successors(@NonNull Stmt node)
@NonNull List<Stmt>	MutableBlockStmtGraph.successors(@NonNull Stmt node)
abstract @NonNull List<Stmt>	StmtGraph.successors(@NonNull Stmt node)	returns the outgoing flows of node as ordered List.

Methods in sootup.core.graph with parameters of type Stmt

Modifier and Type	Method	Description
void	MutableBlockStmtGraph.addExceptionalEdge(@NonNull Stmt stmt, @NonNull ClassType exceptionType, @NonNull Stmt traphandlerStmt)
abstract void	MutableStmtGraph.addExceptionalEdge(@NonNull Stmt stmt, @NonNull ClassType exception, @NonNull Stmt traphandlerStmt)	Adds an exceptional flow with the type "exception" to a "stmt" which will reach "traphandlerStmt"
void	MutableBlockStmtGraph.addNode(@NonNull Stmt stmt, @NonNull Map<ClassType,Stmt> exceptions)
void	MutableStmtGraph.addNode(@NonNull Stmt stmt)	inserts a "stmt" into the StmtGraph
abstract void	MutableStmtGraph.addNode(@NonNull Stmt stmt, @NonNull Map<ClassType,Stmt> traps)	inserts a "stmt" with exceptional flows "traps" into the StmtGraph
protected org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock>	MutableBlockStmtGraph.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	MutableBasicBlock.addStmt(@NonNull Stmt newStmt)
void	MutableBasicBlockImpl.addStmt(@NonNull Stmt newStmt)
void	MutableBlockStmtGraph.clearExceptionalEdges(@NonNull Stmt node)
abstract void	MutableStmtGraph.clearExceptionalEdges(@NonNull Stmt stmt)	Modifications of exceptional flows removes all exceptional flows from "stmt"
boolean	ForwardingStmtGraph.containsNode(@NonNull Stmt node)
boolean	ImmutableBlockStmtGraph.containsNode(@NonNull Stmt node)
boolean	MutableBlockStmtGraph.containsNode(@NonNull Stmt node)
abstract boolean	StmtGraph.containsNode(@NonNull Stmt node)
protected @NonNull org.apache.commons.lang3.tuple.Pair<Integer,MutableBasicBlock>	MutableBlockStmtGraph.createStmtsBlock(@NonNull Stmt stmt)	creates a Block and inserts the given Stmt.
int	ForwardingStmtGraph.degree(@NonNull Stmt stmt)
int	StmtGraph.degree(@NonNull Stmt node)	returns the amount of flows with node as source or target.
@NonNull List<Stmt>	ForwardingStmtGraph.exceptionalPredecessors(@NonNull Stmt node)
@NonNull List<Stmt>	ImmutableBlockStmtGraph.exceptionalPredecessors(@NonNull Stmt node)
@NonNull List<Stmt>	MutableBlockStmtGraph.exceptionalPredecessors(@NonNull Stmt node)
abstract @NonNull List<Stmt>	StmtGraph.exceptionalPredecessors(@NonNull Stmt node)	it is possible to reach traphandlers through inline code i.e. without any exceptional flow
@NonNull Map<ClassType,Stmt>	ForwardingStmtGraph.exceptionalSuccessors(@NonNull Stmt node)
@NonNull Map<ClassType,Stmt>	ImmutableBlockStmtGraph.exceptionalSuccessors(@NonNull Stmt node)
@NonNull Map<ClassType,Stmt>	MutableBlockStmtGraph.exceptionalSuccessors(@NonNull Stmt node)
abstract @NonNull Map<ClassType,Stmt>	StmtGraph.exceptionalSuccessors(@NonNull Stmt node)
@NonNull List<Stmt>	StmtGraph.getAllSuccessors(@NonNull Stmt stmt)	Collects all successors i.e. unexceptional and exceptional successors of a given stmt into a list.
BasicBlock<?>	ForwardingStmtGraph.getBlockOf(@NonNull Stmt stmt)
BasicBlock<ImmutableBlockStmtGraph.ImmutableBasicBlock>	ImmutableBlockStmtGraph.getBlockOf(@NonNull Stmt stmt)
@Nullable BasicBlock<?>	MutableBlockStmtGraph.getBlockOf(@NonNull Stmt stmt)
abstract BasicBlock<?>	StmtGraph.getBlockOf(@NonNull Stmt stmt)
@Nullable List<Stmt>	StmtGraph.getExtendedBasicBlockPathBetween(@NonNull Stmt from, @NonNull Stmt to)	Look for a path in graph, from def to use.
boolean	BackwardsStmtGraph.hasEdgeConnecting(@NonNull Stmt source, @NonNull Stmt target)
boolean	ForwardingStmtGraph.hasEdgeConnecting(@NonNull Stmt from, @NonNull Stmt to)
boolean	ImmutableBlockStmtGraph.hasEdgeConnecting(@NonNull Stmt source, @NonNull Stmt target)
boolean	MutableBlockStmtGraph.hasEdgeConnecting(@NonNull Stmt source, @NonNull Stmt target)
abstract boolean	StmtGraph.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	BackwardsStmtGraph.inDegree(@NonNull Stmt node)
int	ForwardingStmtGraph.inDegree(@NonNull Stmt stmt)
int	ImmutableBlockStmtGraph.inDegree(@NonNull Stmt node)
int	MutableBlockStmtGraph.inDegree(@NonNull Stmt node)
abstract int	StmtGraph.inDegree(@NonNull Stmt node)	returns the amount of ingoing flows into node
@NonNull BasicBlock<?>	MutableBlockStmtGraph.insertAfter(@NonNull Stmt existingStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
abstract BasicBlock<?>	MutableStmtGraph.insertAfter(@NonNull Stmt afterStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
BasicBlock<?>	MutableStmtGraph.insertAfter(@NonNull Stmt afterStmt, @NonNull FallsThroughStmt newStmt)	inserts the "newStmt" after the position of "afterStmt"
@NonNull BasicBlock<?>	MutableBlockStmtGraph.insertBefore(@NonNull Stmt existingStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
abstract BasicBlock<?>	MutableStmtGraph.insertBefore(@NonNull Stmt beforeStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
BasicBlock<?>	MutableStmtGraph.insertBefore(@NonNull Stmt beforeStmt, @NonNull FallsThroughStmt newStmt)	inserts the "newStmt" before the position of "beforeStmt" i.e.
boolean	StmtGraph.isStmtBranchTarget(@NonNull Stmt targetStmt)
int	BackwardsStmtGraph.outDegree(@NonNull Stmt node)
int	ForwardingStmtGraph.outDegree(@NonNull Stmt stmt)
int	ImmutableBlockStmtGraph.outDegree(@NonNull Stmt node)
int	MutableBlockStmtGraph.outDegree(@NonNull Stmt node)
abstract int	StmtGraph.outDegree(@NonNull Stmt node)	returns the amount of flows that start from node
@NonNull List<Stmt>	BackwardsStmtGraph.predecessors(@NonNull Stmt node)
@NonNull List<Stmt>	ForwardingStmtGraph.predecessors(@NonNull Stmt stmt)
@NonNull List<Stmt>	ImmutableBlockStmtGraph.predecessors(@NonNull Stmt node)
@NonNull List<Stmt>	MutableBlockStmtGraph.predecessors(@NonNull Stmt node)
abstract @NonNull List<Stmt>	StmtGraph.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	MutableBlockStmtGraph.putEdge(@NonNull BranchingStmt stmtA, int succesorIdx, @NonNull Stmt stmtB)
void	MutableBlockStmtGraph.putEdge(@NonNull FallsThroughStmt stmtA, @NonNull Stmt stmtB)
abstract void	MutableStmtGraph.putEdge(@NonNull BranchingStmt from, int successorIdx, @NonNull Stmt to)
abstract void	MutableStmtGraph.putEdge(@NonNull FallsThroughStmt from, @NonNull Stmt to)	Modifications of unexceptional flows
protected void	MutableBlockStmtGraph.putEdge_internal(@NonNull Stmt stmtA, int succesorIdx, @NonNull Stmt stmtB)
List<Integer>	MutableBlockStmtGraph.removeEdge(@NonNull Stmt from, @NonNull Stmt to)
abstract List<Integer>	MutableStmtGraph.removeEdge(@NonNull Stmt from, @NonNull Stmt to)	removes the current outgoing flows of "from" to "to"
void	MutableBlockStmtGraph.removeExceptionalEdge(@NonNull Stmt node, @NonNull ClassType exceptionType)
abstract void	MutableStmtGraph.removeExceptionalEdge(@NonNull Stmt stmt, @NonNull ClassType exception)	removes an exceptional flow of the type "exception" flow from "stmt"
void	ForwardingStmtGraph.removeExceptionalFlowFromAllBlocks(@NonNull ClassType exceptionType, @NonNull Stmt exceptionHandlerStmt)
void	ImmutableBlockStmtGraph.removeExceptionalFlowFromAllBlocks(ClassType classType, Stmt exceptionHandlerStmt)
void	MutableBlockStmtGraph.removeExceptionalFlowFromAllBlocks(@NonNull ClassType exceptionType, @NonNull Stmt exceptionHandlerStmt)
abstract void	StmtGraph.removeExceptionalFlowFromAllBlocks(ClassType exceptionType, Stmt exceptionHandlerStmt)	Removes the specified exceptional flow from all blocks.
void	MutableBlockStmtGraph.removeNode(@NonNull Stmt stmt)
void	MutableBlockStmtGraph.removeNode(@NonNull Stmt stmt, boolean keepFlow)	Removes a Stmt from the StmtGraph.
abstract void	MutableStmtGraph.removeNode(@NonNull Stmt stmt)	removes "stmt" from the StmtGraph
abstract void	MutableStmtGraph.removeNode(@NonNull Stmt stmt, boolean keepFlow)
void	MutableBasicBlock.removeStmt(@NonNull Stmt stmt)
void	MutableBasicBlockImpl.removeStmt(@NonNull Stmt stmt)
void	MutableBlockStmtGraph.replaceNode(@NonNull Stmt oldStmt, @NonNull Stmt newStmt)
abstract void	MutableStmtGraph.replaceNode(@NonNull Stmt oldStmt, @NonNull Stmt newStmt)	Modification of stmts (without manipulating any flows; possible assigned exceptional flows stay the same as well)
void	MutableBasicBlock.replaceStmt(int idx, Stmt newStmt)
void	MutableBasicBlock.replaceStmt(Stmt oldStmt, Stmt newStmt)
void	MutableBasicBlockImpl.replaceStmt(int idx, Stmt newStmt)
void	MutableBasicBlockImpl.replaceStmt(Stmt oldStmt, Stmt newStmt)
boolean	MutableBlockStmtGraph.replaceSucessorEdge(@NonNull Stmt from, @NonNull Stmt oldTo, @NonNull Stmt newTo)	Replaces all SuccessorEdge(s) of from to oldTo by mewTo
abstract boolean	MutableStmtGraph.replaceSucessorEdge(@NonNull Stmt from, @NonNull Stmt oldTo, @NonNull Stmt newTo)
void	MutableStmtGraph.setEdges(@NonNull BranchingStmt from, @NonNull Stmt... targets)	replaces the current outgoing flows of "from" to each target of "targets"
void	MutableBlockStmtGraph.setStartingStmt(@NonNull Stmt startingStmt)
abstract void	MutableStmtGraph.setStartingStmt(@NonNull Stmt firstStmt)
@NonNull MutableBasicBlock	MutableBasicBlock.splitBlockLinked(@NonNull Stmt splitStmt, boolean shouldBeNewHead)
@NonNull MutableBasicBlockImpl	MutableBasicBlockImpl.splitBlockLinked(@NonNull Stmt splitStmt, boolean shouldBeNewHead)	splits a BasicBlock into first|second we know splitStmt must be a FallsThroughStmt
MutableBasicBlock	MutableBasicBlock.splitBlockUnlinked(@NonNull Stmt newTail, @NonNull Stmt newHead)
MutableBasicBlockImpl	MutableBasicBlockImpl.splitBlockUnlinked(@NonNull Stmt newTail, @NonNull Stmt newHead)	splits a single MutableBasicBlock into two at splitIndex position, so that the Stmt at the splitIdx is the Head of the second MutableBasicBlock. this method does not link the splitted blocks.
@NonNull List<Stmt>	BackwardsStmtGraph.successors(@NonNull Stmt node)
@NonNull List<Stmt>	ForwardingStmtGraph.successors(@NonNull Stmt stmt)
@NonNull List<Stmt>	ImmutableBlockStmtGraph.successors(@NonNull Stmt node)
@NonNull List<Stmt>	MutableBlockStmtGraph.successors(@NonNull Stmt node)
abstract @NonNull List<Stmt>	StmtGraph.successors(@NonNull Stmt node)	returns the outgoing flows of node as ordered List.
protected void	MutableBasicBlockImpl.updateSuccessorContainer(@NonNull Stmt newStmt)

Method parameters in sootup.core.graph with type arguments of type Stmt

Modifier and Type	Method	Description
void	MutableBlockStmtGraph.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	MutableBlockStmtGraph.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	MutableStmtGraph.addBlock(@NonNull List<Stmt> stmts)	creates a whole BasicBlock which contains the sequence of (n-1)*fallsthrough()-stmt + optional a non-fallsthrough() stmt at the end of the list
abstract void	MutableStmtGraph.addBlock(@NonNull List<Stmt> stmts, @NonNull Map<ClassType,Stmt> traps)	creates a whole BasicBlock with the details from the parameters
abstract void	MutableStmtGraph.addBlock(@NonNull List<Stmt> stmts, @NonNull Map<ClassType,Stmt> traps)	creates a whole BasicBlock with the details from the parameters
void	MutableBlockStmtGraph.addNode(@NonNull Stmt stmt, @NonNull Map<ClassType,Stmt> exceptions)
abstract void	MutableStmtGraph.addNode(@NonNull Stmt stmt, @NonNull Map<ClassType,Stmt> traps)	inserts a "stmt" with exceptional flows "traps" into the StmtGraph
void	MutableBlockStmtGraph.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.
void	MutableBlockStmtGraph.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<?>	MutableBlockStmtGraph.insertAfter(@NonNull Stmt existingStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
abstract BasicBlock<?>	MutableStmtGraph.insertAfter(@NonNull Stmt afterStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
@NonNull BasicBlock<?>	MutableBlockStmtGraph.insertBefore(@NonNull Stmt existingStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
abstract BasicBlock<?>	MutableStmtGraph.insertBefore(@NonNull Stmt beforeStmt, @NonNull List<FallsThroughStmt> stmts, @NonNull Map<ClassType,Stmt> exceptionMap)
void	MutableBlockStmtGraph.setEdges(@NonNull BranchingStmt fromStmt, @NonNull List<Stmt> targets)
abstract void	MutableStmtGraph.setEdges(@NonNull BranchingStmt from, @NonNull List<Stmt> targets)	replaces the current outgoing flows of "from" to "targets"

Constructor parameters in sootup.core.graph with type arguments of type Stmt

Modifier	Constructor	Description
	MutableBasicBlockImpl(List<Stmt> stmts, Map<ClassType,MutableBasicBlock> exceptionMap)

Uses of Stmt in sootup.core.jimple

Methods in sootup.core.jimple with parameters of type Stmt

Modifier and Type	Method	Description
static Trap	Jimple.newTrap(ClassType exception, Stmt beginStmt, Stmt endStmt, Stmt handlerStmt)

Uses of Stmt in sootup.core.jimple.basic

Methods in sootup.core.jimple.basic that return Stmt

Modifier and Type	Method	Description
@NonNull Stmt	Trap.getBeginStmt()
@NonNull Stmt	Trap.getEndStmt()
@NonNull Stmt	Trap.getHandlerStmt()

Methods in sootup.core.jimple.basic that return types with arguments of type Stmt

Modifier and Type	Method	Description
List<Stmt>	Local.getDefsForLocalUse(StmtGraph<?> graph, Stmt stmt)	Get all definition-stmts which define the given local used by the given stmt.
List<Stmt>	Local.getStmtsUsingOrDefiningthisLocal(Collection<Stmt> stmts, Stmt removedStmt)

Methods in sootup.core.jimple.basic with parameters of type Stmt

Modifier and Type	Method	Description
boolean	JimpleComparator.caseStmt(Stmt stmt, Object o)
List<Stmt>	Local.getDefsForLocalUse(StmtGraph<?> graph, Stmt stmt)	Get all definition-stmts which define the given local used by the given stmt.
List<Stmt>	Local.getStmtsUsingOrDefiningthisLocal(Collection<Stmt> stmts, Stmt removedStmt)
@NonNull Trap	Trap.withBeginStmt(@NonNull Stmt beginStmt)
@NonNull Trap	Trap.withEndStmt(@NonNull Stmt endStmt)
@NonNull Trap	Trap.withHandlerStmt(@NonNull Stmt handlerStmt)

Method parameters in sootup.core.jimple.basic with type arguments of type Stmt

Modifier and Type	Method	Description
List<AbstractDefinitionStmt>	Local.getDefs(Collection<Stmt> defs)	returns a List that can contain: Locals, JFieldRefs, JArrayRefs
List<Stmt>	Local.getStmtsUsingOrDefiningthisLocal(Collection<Stmt> stmts, Stmt removedStmt)

Constructors in sootup.core.jimple.basic with parameters of type Stmt

Modifier	Constructor	Description
	Trap(@NonNull ClassType exception, @NonNull Stmt beginStmt, @NonNull Stmt endStmt, @NonNull Stmt handlerStmt)	Creates a Trap with the given exception, handler, begin and end stmts.

Uses of Stmt in sootup.core.jimple.common.stmt

Subinterfaces of Stmt in sootup.core.jimple.common.stmt

Modifier and Type	Interface	Description
interface	BranchingStmt	Interface for Stmts at which the execution does not necessarily continue with the following Stmt in the List
interface	FallsThroughStmt	as an equivalent to BranchingStmt
interface	InvokableStmt	Interface for Stmts that could invoke a different method which will be executed before the next statement is executed

Classes in sootup.core.jimple.common.stmt that implement Stmt

Modifier and Type	Class	Description
class	AbstractDefinitionStmt
class	AbstractStmt
final class	JAssignStmt	Represents the assignment of one value to another
class	JGotoStmt	Unconditionally jumps to a target Stmt
final class	JIdentityStmt
final class	JIfStmt	If the condition is true, jumps to the target, otherwise continues to the next stmt.
final class	JInvokeStmt	A method call
final class	JNopStmt	A no-operation statement.
final class	JReturnStmt	A statement that ends the method, returning a value.
final class	JReturnVoidStmt	A statement that ends the method, returning no value.
final class	JThrowStmt	A statement that throws an Exception

Methods in sootup.core.jimple.common.stmt that return Stmt

Modifier and Type	Method	Description
Stmt	AbstractStmt.withNewUse(@NonNull Value oldUse, @NonNull Value newUse)	Use newUse to replace the oldUse in oldStmt.
Stmt	Stmt.withNewUse(@NonNull Value oldUse, @NonNull Value newUse)

Methods in sootup.core.jimple.common.stmt that return types with arguments of type Stmt

Modifier and Type	Method	Description
List<Stmt>	BranchingStmt.getTargetStmts(Body body)
@NonNull List<Stmt>	JGotoStmt.getTargetStmts(@NonNull Body body)
@NonNull List<Stmt>	JIfStmt.getTargetStmts(@NonNull Body body)

Uses of Stmt in sootup.core.jimple.javabytecode.stmt

Classes in sootup.core.jimple.javabytecode.stmt that implement Stmt

Modifier and Type	Class	Description
final class	JBreakpointStmt
final class	JEnterMonitorStmt	A statement that enters a JVM monitor, thereby synchronizing its following statements.
final class	JExitMonitorStmt	A statement that exits a JVM monitor, thereby ending synchronization.
final class	JRetStmt	Represents the deprecated JVM ret statement (< java 1.6) - which is used in JSR Context - which is deprecated as well.
class	JSwitchStmt

Methods in sootup.core.jimple.javabytecode.stmt that return types with arguments of type Stmt

Modifier and Type	Method	Description
@NonNull Optional<Stmt>	JSwitchStmt.getDefaultTarget(@NonNull Body body)
@NonNull List<Stmt>	JSwitchStmt.getTargetStmts(Body body)

Uses of Stmt in sootup.core.jimple.visitor

Fields in sootup.core.jimple.visitor declared as Stmt

Modifier and Type	Field	Description
protected Stmt	ReplaceUseStmtVisitor.result

Methods in sootup.core.jimple.visitor that return Stmt

Modifier and Type	Method	Description
Stmt	ReplaceUseStmtVisitor.getResult()

Methods in sootup.core.jimple.visitor with parameters of type Stmt

Modifier and Type	Method	Description
void	AbstractStmtVisitor.defaultCaseStmt(@NonNull Stmt stmt)
void	ReplaceUseStmtVisitor.defaultCaseStmt(@NonNull Stmt stmt)
void	StmtVisitor.defaultCaseStmt(Stmt stmt)
protected void	ReplaceUseStmtVisitor.setResult(Stmt result)

Uses of Stmt in sootup.core.model

Methods in sootup.core.model that return Stmt

Modifier and Type	Method	Description
@NonNull Stmt	Body.getFirstNonIdentityStmt()	Returns the first non-identity stmt in this body.
@Nullable Stmt	Body.getThisStmt()	Return unit containing the \@this-assignment *

Methods in sootup.core.model that return types with arguments of type Stmt

Modifier and Type	Method	Description
static Map<LValue,Collection<Stmt>>	Body.collectDefs(Collection<Stmt> stmts)	Collects all defining statements of a Local from a list of statements
static Map<Value,List<Stmt>>	Body.collectUses(Collection<Stmt> stmts)	Collects all using statements of a Values from a list of statements
@NonNull List<Stmt>	Body.getBranchTargetsOf(@NonNull BranchingStmt fromStmt)	returns a List of Branch targets of Branching Stmts
@NonNull List<Stmt>	Body.BodyBuilder.getStmts()
@NonNull List<Stmt>	Body.getStmts()	returns the control flow graph that represents this body into a linear List of statements. for more detailed information of the underlying CFG - or just parts of it - have a look at getStmtGraph()

Methods in sootup.core.model with parameters of type Stmt

Modifier and Type	Method	Description
boolean	Body.isStmtBranchTarget(@NonNull Stmt targetStmt)
void	Body.BodyBuilder.removeDefLocalsOf(@NonNull Stmt stmt)

Method parameters in sootup.core.model with type arguments of type Stmt

Modifier and Type	Method	Description
static Map<LValue,Collection<Stmt>>	Body.collectDefs(Collection<Stmt> stmts)	Collects all defining statements of a Local from a list of statements
static Map<Value,List<Stmt>>	Body.collectUses(Collection<Stmt> stmts)	Collects all using statements of a Values from a list of statements

Uses of Stmt in sootup.core.util.printer

Fields in sootup.core.util.printer with type parameters of type Stmt

Modifier and Type	Field	Description
protected Map<Stmt,String>	LabeledStmtPrinter.labels	branch targets *
protected Map<Stmt,String>	LabeledStmtPrinter.references	for stmt references in Phi nodes (ms: and other occurences TODO: check and improve comment) *

Methods in sootup.core.util.printer that return types with arguments of type Stmt

Modifier and Type	Method	Description
@NonNull Collection<Stmt>	LabeledStmtPrinter.getLabeledStmts(StmtGraph stmtGraph, List<Trap> traps)	Returns the result of iterating through all Stmts in this body.
Map<Stmt,String>	LabeledStmtPrinter.getLabels()
Map<Stmt,String>	LabeledStmtPrinter.getReferences()
Iterable<Stmt>	LabeledStmtPrinter.initializeSootMethod(@NonNull StmtGraph<?> stmtGraph)	createLabelMaps

Methods in sootup.core.util.printer with parameters of type Stmt

Modifier and Type	Method	Description
void	AbstractStmtPrinter.endStmt(Stmt u)
abstract void	StmtPrinter.endStmt(Stmt u)
void	AbstractStmtPrinter.startStmt(Stmt u)
abstract void	StmtPrinter.startStmt(Stmt u)
void	AbstractStmtPrinter.stmt(Stmt currentStmt)
void	LegacyJimplePrinter.stmt(Stmt currentStmt)
void	LabeledStmtPrinter.stmtRef(Stmt stmt, boolean branchTarget)
abstract void	StmtPrinter.stmtRef(Stmt u, boolean branchTarget)

Method parameters in sootup.core.util.printer with type arguments of type Stmt

Modifier and Type	Method	Description
Comparator<Trap>	LabeledStmtPrinter.getTrapComparator(@NonNull Map<Stmt,Integer> stmtsBlockIdx)	Comparator which sorts the trap output in getTraps()

Uses of Stmt in sootup.core.validation

Constructors in sootup.core.validation with parameters of type Stmt

Modifier	Constructor	Description
	ValidationException(Stmt stmt, String s)

Uses of Stmt in sootup.interceptors

Methods in sootup.interceptors with parameters of type Stmt

Modifier and Type	Method	Description
@NonNull Set<Local>	LocalLivenessAnalyser.getLiveLocalsAfterStmt(@NonNull Stmt stmt)	Get all live locals after the given stmt.
@NonNull Set<Local>	LocalLivenessAnalyser.getLiveLocalsBeforeStmt(@NonNull Stmt stmt)	Get all live locals before the given stmt.

Uses of Stmt in sootup.interceptors.typeresolving

Fields in sootup.interceptors.typeresolving declared as Stmt

Modifier and Type	Field	Description
protected Stmt	TypeChecker.result

Methods in sootup.interceptors.typeresolving that return Stmt

Modifier and Type	Method	Description
Stmt	TypeChecker.getResult()
Stmt	StmtLocalPair.getStmt()

Methods in sootup.interceptors.typeresolving with parameters of type Stmt

Modifier and Type	Method	Description
@Nullable Type	AugEvalFunction.evaluate(@NonNull Typing typing, @NonNull Value value, @NonNull Stmt stmt, @NonNull StmtGraph<?> graph)	This method is used to evaluate the type of the given value which the given stmt and body belongs to.
Type	TypeChecker.selectArrayType(@Nullable Type preType, @NonNull Type newType, @NonNull Stmt stmt)
protected void	TypeChecker.setResult(Stmt result)
void	CastCounter.visit(@NonNull Value value, @NonNull Type stdType, @NonNull Stmt stmt)	This method is used to check whether a value in a stmt needs a cast.
abstract void	TypeChecker.visit(@NonNull Value value, @NonNull Type stdType, @NonNull Stmt stmt)
void	TypePromotionVisitor.visit(@NonNull Value value, @NonNull Type stdType, @NonNull Stmt stmt)

Constructors in sootup.interceptors.typeresolving with parameters of type Stmt

Modifier	Constructor	Description
	StmtLocalPair(Stmt stmt, Local local)

Uses of Stmt in sootup.java.bytecode.frontend.conversion

Methods in sootup.java.bytecode.frontend.conversion that return types with arguments of type Stmt

Modifier and Type	Method	Description
Stream<Stmt>	AsmMethodSource.getStmtsThatUse(@NonNull Value value)	* returns all stmts that use this expr

Uses of Stmt in sootup.java.core.exceptions

Methods in sootup.java.core.exceptions with parameters of type Stmt

Modifier and Type	Method	Description
void	ExceptionInferStmtVisitor.defaultCaseStmt(@NonNull Stmt stmt)
ExceptionInferResult	StmtExceptionAnalyzer.mightThrow(@NonNull Stmt stmt, @NonNull StmtGraph<? extends BasicBlock<?>> graph)
ExceptionInferResult	StmtExceptionAnalyzer.mightThrowImplicitly(Stmt stmt)