|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Body | |
soot | Base Soot classes, shared by different intermediate representations. |
soot.baf | Public classes for the Baf intermediate representation. |
soot.baf.toolkits.base | A toolkit to optimize the Baf IR. |
soot.coffi | Contains classes from the Coffi tool, by Clark Verbrugge. |
soot.dava | |
soot.dava.internal.AST | |
soot.grimp | Public classes for the Grimp intermediate representation. |
soot.grimp.toolkits.base | A toolkit to optimize the Grimp IR. |
soot.javaToJimple | |
soot.javaToJimple.toolkits | |
soot.jimple | Public classes for the Jimple intermediate representation. |
soot.jimple.parser | An interface to the Jimple parser. |
soot.jimple.spark.fieldrw | |
soot.jimple.toolkits.annotation | A toolkit to annotate classfiles with array and null bounds check information. |
soot.jimple.toolkits.annotation.arraycheck | Classes that carry out an analysis to determine whether or not array bounds checks are necessary. |
soot.jimple.toolkits.annotation.callgraph | |
soot.jimple.toolkits.annotation.defs | |
soot.jimple.toolkits.annotation.liveness | |
soot.jimple.toolkits.annotation.logic | |
soot.jimple.toolkits.annotation.nullcheck | Classes that carry out an analysis to determine whether or not null pointer checks are necessary. |
soot.jimple.toolkits.annotation.parity | |
soot.jimple.toolkits.annotation.profiling | |
soot.jimple.toolkits.base | A toolkit to optimize the Jimple IR. |
soot.jimple.toolkits.callgraph | |
soot.jimple.toolkits.graph | A set of utility classes for program transformation and optimizations. |
soot.jimple.toolkits.invoke | A toolkit to deal with Jimple and invoke statements. |
soot.jimple.toolkits.pointer | |
soot.jimple.toolkits.scalar | A toolkit for scalar optimization of Jimple. |
soot.jimple.toolkits.scalar.pre | Particial redundency elimination. |
soot.jimple.toolkits.typing | Implements a typing algorithm for Jimple. |
soot.shimple | Public classes for the SSA Shimple intermediate representation. |
soot.shimple.internal | Shimple internal messy stuff. |
soot.shimple.toolkits.scalar | Some analyses based on Shimple. |
soot.tagkit | Classes supporting classfile annotation in Soot. |
soot.toolkits.exceptions | |
soot.toolkits.graph | Toolkit to produce and manipulate various types of control flow graphs. |
soot.toolkits.graph.interaction | |
soot.toolkits.scalar | A number of scalar optimizations, and the flow analysis framework. |
soot.tools | Various extensions to Soot that can be executed instead of soot.Main. |
soot.util | Generally useful utility classes for Soot. |
soot.util.cfgcmd | |
soot.xml |
Uses of Body in soot |
Methods in soot that return Body | |
Body |
MethodSource.getBody(SootMethod m,
String phaseName)
Returns a filled-out body for the given SootMethod. |
Body |
SootMethod.getActiveBody()
Retrieves the active body for this method. |
Body |
SootMethod.retrieveActiveBody()
Returns the active body if present, else constructs an active body and returns that. |
Body |
UnknownMethodSource.getBody(SootMethod m,
String phaseName)
|
Methods in soot with parameters of type Body | |
protected void |
AbstractJasminClass.assignColorsToLocals(Body body)
|
Map |
Body.importBodyContentsFrom(Body b)
Copies the contents of the given Body into this one. |
protected void |
BodyPack.internalApply(Body b)
|
void |
BodyTransformer.transform(Body b,
String phaseName,
Map options)
Called by clients of the transformation. |
void |
BodyTransformer.transform(Body b,
String phaseName)
|
void |
BodyTransformer.transform(Body b)
|
protected abstract void |
BodyTransformer.internalTransform(Body b,
String phaseName,
Map options)
This method is called to perform the transformation itself. |
protected void |
JavaToJimpleBodyPack.internalApply(Body b)
|
protected void |
JimpleBodyPack.internalApply(Body b)
|
protected void |
Pack.internalApply(Body b)
|
void |
Pack.apply(Body b)
|
void |
Printer.printTo(Body b,
PrintWriter out)
Prints out the method corresponding to b Body, (declaration and body), in the textual format corresponding to the IR used to encode b body. |
void |
SootMethod.setActiveBody(Body body)
Sets the active body for this method. |
void |
Transform.apply(Body b)
|
static boolean |
TrapManager.isExceptionCaughtAt(SootClass e,
Unit u,
Body b)
If exception e is caught at unit u in body b, return true; otherwise, return false. |
static List |
TrapManager.getTrapsAt(Unit unit,
Body b)
Returns the list of traps caught at Unit u in Body b. |
static Set |
TrapManager.getTrappedUnitsOf(Body b)
Returns a set of units which lie inside the range of any trap. |
static void |
TrapManager.splitTrapsAgainst(Body b,
Unit rangeStart,
Unit rangeEnd)
Splits all traps so that they do not cross the range rangeStart - rangeEnd. |
static List |
TrapManager.getExceptionTypesOf(Unit u,
Body body)
Given a body and a unit handling an exception, returns the list of exception types possibly caught by the handler. |
Constructors in soot with parameters of type Body | |
BriefUnitPrinter(Body body)
|
|
LabeledUnitPrinter(Body b)
|
|
NormalUnitPrinter(Body body)
|
Uses of Body in soot.baf |
Subclasses of Body in soot.baf | |
class |
BafBody
|
Methods in soot.baf with parameters of type Body | |
BafBody |
Baf.newBody(Body b)
Returns a BafBody constructed from b. |
BafBody |
Baf.newBody(Body b,
String phase)
Returns a BafBody constructed from b. |
protected void |
JasminClass.assignColorsToLocals(Body body)
|
Constructors in soot.baf with parameters of type Body | |
BafBody(Body body,
Map options)
|
Uses of Body in soot.baf.toolkits.base |
Methods in soot.baf.toolkits.base with parameters of type Body | |
boolean |
ExamplePeephole.apply(Body b)
|
protected void |
LoadStoreOptimizer.internalTransform(Body body,
String phaseName,
Map options)
The method that drives the optimizations. |
boolean |
Peephole.apply(Body b)
Entry point for a peephole. |
protected void |
PeepholeOptimizer.internalTransform(Body body,
String phaseName,
Map options)
The method that drives the optimizations. |
Uses of Body in soot.coffi |
Methods in soot.coffi that return Body | |
Body |
CoffiMethodSource.getBody(SootMethod m,
String phaseName)
|
Methods in soot.coffi with parameters of type Body | |
Local |
Util.getLocal(Body b,
String name)
|
boolean |
Util.declaresLocal(Body b,
String localName)
|
Uses of Body in soot.dava |
Subclasses of Body in soot.dava | |
class |
DavaBody
|
Methods in soot.dava with parameters of type Body | |
DavaBody |
Dava.newBody(Body b)
Returns a DavaBody constructed from the given body b. |
Uses of Body in soot.dava.internal.AST |
Methods in soot.dava.internal.AST with parameters of type Body | |
void |
ASTMethodNode.storeLocals(Body OrigBody)
|
Uses of Body in soot.grimp |
Subclasses of Body in soot.grimp | |
class |
GrimpBody
Implementation of the Body class for the Grimp IR. |
Methods in soot.grimp with parameters of type Body | |
GrimpBody |
Grimp.newBody(Body b,
String phase)
Returns a GrimpBody constructed from b. |
Uses of Body in soot.grimp.toolkits.base |
Methods in soot.grimp.toolkits.base with parameters of type Body | |
protected void |
ConstructorFolder.internalTransform(Body b,
String phaseName,
Map options)
This method change all new Obj/ |
Uses of Body in soot.javaToJimple |
Methods in soot.javaToJimple that return Body | |
Body |
AnonClassInitMethodSource.getBody(SootMethod sootMethod,
String phaseName)
|
Body |
AssertClassMethodSource.getBody(SootMethod sootMethod,
String phaseName)
|
Body |
ClassLiteralMethodSource.getBody(SootMethod sootMethod,
String phaseName)
|
Body |
PolyglotMethodSource.getBody(SootMethod sm,
String phaseName)
|
Body |
PrivateFieldAccMethodSource.getBody(SootMethod sootMethod,
String phaseName)
|
Body |
PrivateFieldSetMethodSource.getBody(SootMethod sootMethod,
String phaseName)
|
Body |
PrivateMethodAccMethodSource.getBody(SootMethod sootMethod,
String phaseName)
|
Methods in soot.javaToJimple with parameters of type Body | |
void |
PolyglotMethodSource.addAssertInits(Body body)
|
static Local |
Util.getThis(Type sootType,
Body body,
HashMap getThisMap,
LocalGenerator lg)
|
static Local |
Util.getThisGivenOuter(Type sootType,
HashMap getThisMap,
Body body,
LocalGenerator lg,
Local t2)
|
static Local |
Util.getPrivateAccessFieldInvoke(SootMethodRef toInvoke,
ArrayList params,
Body body,
LocalGenerator lg)
|
Constructors in soot.javaToJimple with parameters of type Body | |
LocalGenerator(Body b)
|
Uses of Body in soot.javaToJimple.toolkits |
Methods in soot.javaToJimple.toolkits with parameters of type Body | |
protected void |
CondTransformer.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
GotoEliminator.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple |
Subclasses of Body in soot.jimple | |
class |
JimpleBody
Implementation of the Body class for the Jimple IR. |
class |
StmtBody
Abstract base class for Body's on Stmts (Jimple and Grimp). |
Methods in soot.jimple that return Body | |
Body |
JimpleMethodSource.getBody(SootMethod m,
String phaseName)
|
Methods in soot.jimple with parameters of type Body | |
protected void |
JasminClass.assignColorsToLocals(Body body)
|
Uses of Body in soot.jimple.parser |
Methods in soot.jimple.parser that return Body | |
Body |
JimpleAST.getBody(SootMethod m)
Returns a body corresponding to the parsed jimple for m. |
Uses of Body in soot.jimple.spark.fieldrw |
Methods in soot.jimple.spark.fieldrw with parameters of type Body | |
protected void |
FieldTagAggregator.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
FieldTagger.internalTransform(Body body,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.annotation |
Methods in soot.jimple.toolkits.annotation with parameters of type Body | |
protected void |
AvailExprTagger.internalTransform(Body b,
String phaseName,
Map opts)
|
protected void |
DominatorsTagger.internalTransform(Body b,
String phaseName,
Map opts)
|
Uses of Body in soot.jimple.toolkits.annotation.arraycheck |
Methods in soot.jimple.toolkits.annotation.arraycheck with parameters of type Body | |
protected void |
ArrayBoundsChecker.internalTransform(Body body,
String phaseName,
Map opts)
|
Uses of Body in soot.jimple.toolkits.annotation.callgraph |
Methods in soot.jimple.toolkits.annotation.callgraph with parameters of type Body | |
protected void |
CallGraphTagger.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.annotation.defs |
Methods in soot.jimple.toolkits.annotation.defs with parameters of type Body | |
protected void |
ReachingDefsTagger.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.annotation.liveness |
Methods in soot.jimple.toolkits.annotation.liveness with parameters of type Body | |
protected void |
LiveVarsTagger.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.annotation.logic |
Methods in soot.jimple.toolkits.annotation.logic with parameters of type Body | |
protected void |
LoopFinder.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
LoopInvariantFinder.internalTransform(Body b,
String phaseName,
Map options)
this one uses the side effect tester |
Uses of Body in soot.jimple.toolkits.annotation.nullcheck |
Methods in soot.jimple.toolkits.annotation.nullcheck with parameters of type Body | |
void |
NullCheckEliminator.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
NullPointerChecker.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
NullPointerColorer.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.annotation.parity |
Methods in soot.jimple.toolkits.annotation.parity with parameters of type Body | |
protected void |
ParityTagger.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.annotation.profiling |
Methods in soot.jimple.toolkits.annotation.profiling with parameters of type Body | |
protected void |
ProfilingGenerator.internalTransform(Body body,
String phaseName,
Map opts)
|
Uses of Body in soot.jimple.toolkits.base |
Methods in soot.jimple.toolkits.base with parameters of type Body | |
protected void |
Aggregator.internalTransform(Body b,
String phaseName,
Map options)
Traverse the statements in the given body, looking for aggregation possibilities; that is, given a def d and a use u, d has no other uses, u has no other defs, collapse d and u. |
protected void |
ExceptionChecker.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
ExceptionChecker.checkThrow(Body b,
ThrowStmt ts)
|
protected boolean |
ExceptionChecker.isThrowDeclared(Body b,
SootClass throwClass)
|
protected boolean |
ExceptionChecker.isExceptionCaught(Body b,
Stmt s,
RefType throwType)
|
protected boolean |
ExceptionChecker.isThrowInStmtRange(Body b,
Stmt begin,
Stmt end,
Stmt s)
|
protected void |
ExceptionChecker.checkInvoke(Body b,
InvokeStmt is)
|
protected void |
ExceptionChecker.checkInvokeExpr(Body b,
InvokeExpr ie,
Stmt s)
|
void |
JimpleConstructorFolder.internalTransform(Body b,
String phaseName,
Map options)
This method pushes all newExpr down to be the stmt directly before every invoke of the init |
void |
PartialConstructorFolder.internalTransform(Body b,
String phaseName,
Map options)
This method pushes all newExpr down to be the stmt directly before every invoke of the init only if they are in the types list |
void |
ThisInliner.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.callgraph |
Methods in soot.jimple.toolkits.callgraph with parameters of type Body | |
protected void |
ClinitElimTransformer.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
UnreachableMethodTransformer.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.graph |
Methods in soot.jimple.toolkits.graph with parameters of type Body | |
protected void |
CriticalEdgeRemover.internalTransform(Body b,
String phaseName,
Map options)
performs critical edge-removing. |
protected void |
LoopConditionUnroller.internalTransform(Body body,
String phaseName,
Map options)
unrolls conditions. |
Uses of Body in soot.jimple.toolkits.invoke |
Methods in soot.jimple.toolkits.invoke with parameters of type Body | |
static void |
AccessManager.createAccessorMethods(Body body,
Stmt before,
Stmt after)
Resolves illegal accesses in the interval ]before,after[ by creating accessor methods. |
Uses of Body in soot.jimple.toolkits.pointer |
Methods in soot.jimple.toolkits.pointer with parameters of type Body | |
protected void |
CastCheckEliminatorDumper.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
FieldRWTagger.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
ParameterAliasTagger.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
SideEffectTagger.internalTransform(Body body,
String phaseName,
Map options)
|
Uses of Body in soot.jimple.toolkits.scalar |
Methods in soot.jimple.toolkits.scalar with parameters of type Body | |
protected void |
CommonSubexpressionEliminator.internalTransform(Body b,
String phaseName,
Map options)
Common subexpression eliminator. |
protected void |
ConditionalBranchFolder.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
ConstantPropagatorAndFolder.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
CopyPropagator.internalTransform(Body b,
String phaseName,
Map opts)
Cascaded copy propagator. |
protected void |
DeadAssignmentEliminator.internalTransform(Body b,
String phaseName,
Map options)
Eliminates dead code in a linear fashion. |
protected void |
LocalNameStandardizer.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
NopEliminator.internalTransform(Body b,
String phaseName,
Map options)
Removes NopStmt s from the passed body (which must be
a JimpleBody ). |
protected void |
UnconditionalBranchFolder.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
UnreachableCodeEliminator.internalTransform(Body b,
String phaseName,
Map options)
|
Constructors in soot.jimple.toolkits.scalar with parameters of type Body | |
FastAvailableExpressions(Body b,
SideEffectTester st)
Wrapper for AvailableExpressionsAnalysis. |
|
SlowAvailableExpressions(Body b)
Wrapper for SlowAvailableExpressionsAnalysis. |
Uses of Body in soot.jimple.toolkits.scalar.pre |
Methods in soot.jimple.toolkits.scalar.pre with parameters of type Body | |
protected void |
BusyCodeMotion.internalTransform(Body b,
String phaseName,
Map opts)
performs the busy code motion. |
protected void |
LazyCodeMotion.internalTransform(Body b,
String phaseName,
Map opts)
performs the lazy code motion. |
Uses of Body in soot.jimple.toolkits.typing |
Methods in soot.jimple.toolkits.typing with parameters of type Body | |
protected void |
TypeAssigner.internalTransform(Body b,
String phaseName,
Map options)
Assign types to local variables. |
Uses of Body in soot.shimple |
Subclasses of Body in soot.shimple | |
class |
ShimpleBody
Implementation of the Body class for the SSA Shimple IR. |
Fields in soot.shimple declared as Body | |
protected Body |
DefaultShimpleFactory.body
|
Methods in soot.shimple that return Body | |
Body |
DefaultShimpleFactory.getBody()
|
Body |
ShimpleMethodSource.getBody(SootMethod m,
String phaseName)
|
Methods in soot.shimple with parameters of type Body | |
void |
DefaultShimpleFactory.setBody(Body body)
|
ShimpleBody |
Shimple.newBody(Body b)
Returns a ShimpleBody constructed from b, using default phase options. |
ShimpleBody |
Shimple.newBody(Body b,
Map options)
Returns a ShimpleBody constructed from b, using provided option Map. |
static void |
Shimple.redirectToPreds(Body body,
Unit remove)
If you are removing a Unit from a Unit chain which contains PhiExpr's, you might want to call this utility function in order to update any PhiExpr pointers to the Unit to point to the Unit's predecessor(s). |
void |
ShimpleFactory.setBody(Body body)
Some constructors may require a body. |
Uses of Body in soot.shimple.internal |
Constructors in soot.shimple.internal with parameters of type Body | |
SPatchingChain(Body aBody,
Chain aChain)
|
Uses of Body in soot.shimple.toolkits.scalar |
Methods in soot.shimple.toolkits.scalar with parameters of type Body | |
protected void |
SConstantPropagatorAndFolder.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.tagkit |
Methods in soot.tagkit with parameters of type Body | |
protected void |
TagAggregator.internalTransform(Body b,
String phaseName,
Map options)
|
Uses of Body in soot.toolkits.exceptions |
Methods in soot.toolkits.exceptions with parameters of type Body | |
protected void |
TrapTightener.internalTransform(Body body,
String phaseName,
Map options)
|
Uses of Body in soot.toolkits.graph |
Fields in soot.toolkits.graph declared as Body | |
protected Body |
UnitGraph.body
|
Methods in soot.toolkits.graph that return Body | |
Body |
Block.getBody()
Returns the Block's enclosing Body instance. |
Body |
BlockGraph.getBody()
Returns the Body this BlockGraph is derived from. |
Body |
ExceptionalGraph.getBody()
Returns the Body from which this graph was built. |
Body |
UnitGraph.getBody()
|
Constructors in soot.toolkits.graph with parameters of type Body | |
ArrayRefBlockGraph(Body body)
Constructs an ArrayRefBlockGraph from the given
Body . |
|
Block(Unit aHead,
Unit aTail,
Body aBody,
int aIndexInMethod,
int aBlockLength,
BlockGraph aBlockGraph)
Constructs a Block in the context of a BlockGraph, and enclosing Body instances. |
|
BriefBlockGraph(Body body)
Constructs a BriefBlockGraph from a given Body . |
|
BriefUnitGraph(Body body)
Constructs a BriefUnitGraph given a Body instance. |
|
ClassicCompleteBlockGraph(Body body)
Constructs a ClassicCompleteBlockGraph for the blocks found by partitioning the the units of the provided Body instance into basic blocks. |
|
ClassicCompleteUnitGraph(Body body)
Constructs the graph from a given Body instance. |
|
CompleteBlockGraph(Body b)
|
|
CompleteUnitGraph(Body b)
|
|
ExceptionalBlockGraph(Body body)
Constructs an ExceptionalBlockGraph for the
blocks found by partitioning the the units of the provided
Body instance into basic blocks. |
|
ExceptionalUnitGraph(Body body,
ThrowAnalysis throwAnalysis,
boolean omitExceptingUnitEdges)
Constructs the graph for a given Body instance, using the ThrowAnalysis and omitExceptingUnitEdges
value that are passed as parameters. |
|
ExceptionalUnitGraph(Body body,
ThrowAnalysis throwAnalysis)
Constructs the graph from a given Body instance using the passed ThrowAnalysis and a default value, provided by
the Options class, for the
omitExceptingUnitEdges parameter. |
|
ExceptionalUnitGraph(Body body)
Constructs the graph from a given Body instance, using the Scene 's default ThrowAnalysis to estimate the
set of exceptions that each Unit might throw and a
default value, provided by the Options class, for the
omitExceptingUnitEdges parameter. |
|
ExceptionalUnitGraph(Body body,
boolean ignoredBogusParameter)
Allocates an ExceptionalUnitGraph object
without initializing it. |
|
TrapUnitGraph(Body body)
Constructs the graph from a given Body instance. |
|
UnitGraph(Body body)
Performs the work that is required to construct any sort of UnitGraph. |
|
ZonedBlockGraph(Body body)
Constructs a ZonedBlockGraph for the Units comprising the passed Body . |
Uses of Body in soot.toolkits.graph.interaction |
Methods in soot.toolkits.graph.interaction with parameters of type Body | |
void |
InteractionHandler.handleNewAnalysis(Transform t,
Body b)
|
void |
InteractionHandler.handleTransformDone(Transform t,
Body b)
|
Uses of Body in soot.toolkits.scalar |
Methods in soot.toolkits.scalar with parameters of type Body | |
static void |
FastColorer.unsplitAssignColorsToLocals(Body unitBody,
Map localToGroup,
Map localToColor,
Map groupToColorCount)
Provides a coloring for the locals of unitBody , attempting to not
split locals assigned the same name in the original Jimple. |
static void |
FastColorer.assignColorsToLocals(Body unitBody,
Map localToGroup,
Map localToColor,
Map groupToColorCount)
Provides an economical coloring for the locals of unitBody . |
protected void |
LocalPacker.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
LocalSplitter.internalTransform(Body body,
String phaseName,
Map options)
|
protected void |
UnusedLocalEliminator.internalTransform(Body body,
String phaseName,
Map options)
|
Constructors in soot.toolkits.scalar with parameters of type Body | |
FastColorer.UnitInterferenceGraph(Body body,
Map localToGroup,
LiveLocals liveLocals)
|
|
SimpleLocalUses(Body body,
LocalDefs localDefs)
Construct the analysis from a method body and a LocalDefs interface. |
Uses of Body in soot.tools |
Methods in soot.tools with parameters of type Body | |
protected void |
CFGViewer.internalTransform(Body b,
String phaseName,
Map options)
|
protected void |
CFGViewer.print_cfg(Body body)
|
Uses of Body in soot.util |
Methods in soot.util with parameters of type Body | |
void |
PhaseDumper.dumpBefore(Body b,
String phaseName)
Tells the PhaseDumper that a Body
transforming phase has started, so that it can dump the
phases's “before” file. |
void |
PhaseDumper.dumpAfter(Body b,
String phaseName)
Tells the PhaseDumper that a Body
transforming phase has ended, so that it can dump the
phases's “after” file. |
void |
PhaseDumper.dumpGraph(DirectedGraph g,
Body b)
Asks the PhaseDumper to dump the passed DirectedGraph if the current phase is being dumped. |
Constructors in soot.util with parameters of type Body | |
UnitMap(Body b)
maps each unit of this body to the result of mapTo .before the mapping the method init is called.the internal hashtable is initialized without any parameter. |
|
UnitMap(Body b,
int initialCapacity)
maps each unit of this body to the result of mapTo .before the mapping the method init is called.the internal hashtable is initialized to initialCapacity . |
|
UnitMap(Body b,
int initialCapacity,
float loadFactor)
maps each unit of this body to the result of mapTo .before the mapping the method init is called.the internal hashtable is initialized to initialCapacity and
loadFactor . |
Uses of Body in soot.util.cfgcmd |
Methods in soot.util.cfgcmd that return Body | |
abstract Body |
CFGIntermediateRep.getBody(JimpleBody b)
Converts a JimpleBody into the
corresponding Body in this intermediate
representation. |
Methods in soot.util.cfgcmd with parameters of type Body | |
abstract DirectedGraph |
CFGGraphType.buildGraph(Body b)
Method that will build a graph of this type. |
abstract DotGraph |
CFGGraphType.drawGraph(CFGToDotGraph drawer,
DirectedGraph g,
Body b)
Method that will draw a DotGraph representation of the
control flow in this type of graph. |
DotGraph |
CFGToDotGraph.drawCFG(DirectedGraph graph,
Body body)
Create a DotGraph whose nodes and edges depict
a control flow graph without distinguished
exceptional edges. |
Uses of Body in soot.xml |
Methods in soot.xml with parameters of type Body | |
void |
TagCollector.collectBodyTags(Body b)
|
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |