|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |
DirectedGraph
.
ThrowAnalysis
interface which may be common to multiple concrete
ThrowAnalysis
classes.ClassLoader
that loads specified classes from a
different class path than that given by the value of
java.class.path
in System.getProperties()
.AltClassLoader
for inclusion in Soot's
global variable manager, G
.
Block
instances, and where
Unit
s which include array references start new blocks.ArrayRefBlockGraph
from the given
Body
.
BriefUnitGraph
.
ThrowableSet
which contains
e
in addition to the exceptions in
this ThrowableSet
.
ThrowableSet
which contains
e
and all of its subclasses as well as the
exceptions in this set.
ThrowableSet
which contains
all the exceptions in s
in addition to those in
this ThrowableSet
.
obj
to this
.
this
union obj
into dest
.
t
to this host
unitBody
.
Body
at the basic
block level.BlockGraph
representing at the basic block
level the control flow specified, at the Unit
level,
by a given UnitGraph
.
Body
where the nodes are Block
s and edges are derived from control flow.BriefBlockGraph
from a given Body
.
BriefBlockGraph
representing the
Unit-level control flow represented by the passed
BriefUnitGraph
.
A utility method that does most of the work of constructing basic blocks, once the set of block leaders has been determined, and which designates the heads and tails of the graph.
BlockGraph
provides an implementation of
buildBlocks()
which splits the Unit
s in
unitGraph
so that each Unit
in the
passed set of block leaders is the first unit in a block. It
defines as heads the blocks which begin with
Unit
s which are heads in unitGraph
,
and defines as tails the blocks which end with
Unit
s which are tails in unitGraph
.
Subclasses might override this behavior.
This implementation calls the inherited implementation to split
units into blocks, before adding the distinctions between
exceptional and unexceptional control flow.
UnitGraph
variants which include exceptional control flow.
UnitGraph.buildHeadsAndTails()
with a method which always throws an exception.
UnitGraph
s, to be
called only after the unitToPreds and unitToSuccs maps have
been built.
CFGOptionMatcher
.DotGraph
visualization
of a control flow graph.Block
s and the
edges are derived from control flow.Body
instance into basic blocks.
ClassicCompleteUnitGraph
.
Unit
instances, and where edges are a conservative
indication of unexceptional and exceptional control
flow.Body
instance where the nodes
are Block
instances, and where control flow associated with
exceptions is taken into account.Body
instance where the nodes
are Unit
instances, and where control flow
associated with exceptions is taken into account.catcher
.
Unit
s
of this graph's body to the union of the values stored in the
two argument Map
s, used to combine the maps of
exceptional and unexceptional predecessors and successors into
maps of all predecessors and successors.
this
.
dest
.
Body
, given its UnitGraph
(i.e., the
instructions which begin new basic blocks).
Body
, given its UnitGraph
(i.e., the
instructions which begin new basic blocks).
Body
, given its UnitGraph
(i.e., the
instructions which begin new basic blocks).
obj
.
out
.
source
flow object in dest
.
dg
and the Earliest-computation earliest
.equivRhsMap
is only here to avoid doing these things
again...
dg
and the Earliest-computation earliest
.equivRhsMap
is only here to avoid doing these things
again...other
, putting result into this
.
other
, putting result into dest
.
DotGraph
whose nodes and edges depict
a control flow graph without distinguished
exceptional edges.
DotGraph
whose nodes and edges depict the
control flow in a ExceptionalGraph
, with
distinguished edges for exceptional control flow.
DotGraph
representation of the
control flow in this type of graph.
PhaseDumper
that a Body
transforming phase has ended, so that it can dump the
phases's “after” file.
PhaseDumper
that a Scene
transforming phase has ended, so that it can dump the
phases's “after” files.
PhaseDumper
that a Body
transforming phase has started, so that it can dump the
phases's “before” file.
PhaseDumper
that a Scene
transforming phase has started, so that it can dump the
phases's “before” files.
PhaseDumper
to dump the passed DirectedGraph
if the current phase is being dumped.
PhaseDumper
to dump the passed ExceptionalGraph
if the current phase is being dumped.
ThrowableSet
containing no exception classes.
\\unnnn
) in the
input and de-escapes them.\\unnnn
) in the
input and substitutes their escaped representation.Block
s and the
edges are derived from control flow.ExceptionalBlockGraph
for the
blocks found by partitioning the the units of the provided
Body
instance into basic blocks.
Unit
s in an ExceptionalUnitGraph
.
Trap
will catch some subset of the exceptions
which may be thrown by a given graph node.Body
instance
where the nodes are Unit
instances, and where control flow
associated with exceptions is taken into account.ThrowAnalysis
and omitExceptingUnitEdges
value that are passed as parameters.
ThrowAnalysis
and a default value, provided by
the Options
class, for the
omitExceptingUnitEdges
parameter.
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
object
without initializing it.
((FlowSet)clone()).clear()
target
is legal from
code in container
.
target
is legal from code in container
.
Object
s are
ThrowableSet.Pair
s representing the same set of
caught and uncaught exception types.
v
, using
equals
v
, using
equivTo
DirectedGraph
.
in
sets,
compute the fallOut
and branchOuts
set for s
.
out
sets, compute the in
set for s
(or in to out, depending on direction).
a
follows object b
in the Chain.
someObject
follows object someReferenceObject
in the Chain.
Trap
does not trap any units at all.
Trap.getBeginUnit()
.
Body
this BlockGraph
is derived from.
Body
from which this graph was built.
JimpleBody
into the
corresponding Body
in this intermediate
representation.
op
if it is easy
to find the constant value; else returns null
.
op
if it is easy to
find the constant value; else returns null
.
SootMethod
.
this
.
ThrowAnalysis
to be used by default when
constructing CFGs which include exceptional control flow.
Chain
), unless this Trap
does not trap
any units at all.
Trap.getEndUnit()
.
'\\unnnn'
.
ExceptionDest
objects which represent how exceptions thrown by a specified
node will be handled.
ExceptionDest
objects which represent how exceptions thrown by a specified
unit will be handled.
node
.
node
.
CFGGraphType
identified by the
passed name.
trap().getBeginUnit()
).
CFGIntermediateRep
identified by the
passed name.
point
.
point
.
point
.
point
.
aName
\\unnnn
representation for any escaped characters in the string.
\\unnnn
representation for ch
.
aName
CFGGraphType
s, separated by
'|' characters.
CFGIntermediateRep
s, separated by
'|' characters.
CFGOptionMatcher
, separated by
'|' characters.
ExceptionalUnitGraph
, factored out of the
constructors so that subclasses have the option to delay
creating the graph's edges until after they have performed
some subclass-specific initialization.
inlinee
into the container
at the point toInline
.
toInsert
in the Chain after point
.
toInsert
in the Chain after point
.
toInsert
in the Chain after point
.
toInsert
in the Chain after point
.
toInsert
in the Chain after point
.
toInsert
in the Chain before point
.
toInsert
in the Chain before point
.
toInsert
in the Chain before point
.
toInsert
in the Chain before point
.
toInsert
in the Chain before point
.
toInsert
in the Chain before point
.
NopStmt
s from the passed body (which must be
a JimpleBody
).
other
,
putting result into this
.
other
,
putting result into dest
.
target
is legal from code in container
.
stmt
contains an illegal access to a field or method,
assuming the statement is in method container
SootClass
object declares this SootMethod
object.
val
is an invoke.
val
is a Local.
SootMethod
object is phantom.
head
to
tail
, inclusive.
equivRhsMap
could be calculated on the fly, but it is
very likely that it already exists (as similar maps are used for
calculating Earliestness, Delayed,...newLocal(type)
will be called, the given prefix is
used.
setAltClasses()
, from the
regular system classpath otherwise.
null
if val
is null.
Map
,
which must be instances of List
, with unmodifiable
equivalents.
CFGOptionMatcher
looking for one whose name begins with the passed string
(ignoring the case of letters in the string).
in1
and in2
sets, putting the result into out
.
Throwable
s as the set
of types that the specified unit might throw, regardless of the
unit's identity.
Throwable
types that
the specified unit might throw.
Throwable
types that
the specified throw instruction might throw explicitly, that is,
the possible types for its Throwable
argument.
Throwable
types that
the specified throw statement might throw explicitly, that is,
the possible types for its Throwable
argument.
Throwable
s as the set
of types that a throw
instruction may throw implicitly,
that is, the possible types of errors which might arise in
the course of executing the throw
instruction, rather
than the type of the throw
's operand.
Throwable
s as the set
of types that a throw
statement may throw implicitly,
that is, the possible types of errors which might arise in
the course of executing the throw
statement, rather
than the type of the throw
's operand.
Throwable
types that
the specified throw instruction might throw implicitly, that is,
the possible types of errors which might arise in the course
of executing the throw
instruction, rather than
the type of the throw
's operand.
Throwable
types that
the specified throw statement might throw implicitly, that is,
the possible types of errors which might arise in the course
of executing the throw
statement, rather than
the type of the throw
's operand.
Unit
might throw an exception to a particular Trap
, according to
the information supplied by a particular control flow graph.
dg
using the Latest-computation latest
.equivRhsMap
is only here to avoid doing these things
again...
dg
using the Latest-computation latest
.equivRhsMap
is only here to avoid doing these things
again...null
if val
is null.
null
if val
is null.
ParameterRef
objects are used by Body
objects to refer to the parameter slots on method entry.ThrowAnalysis
that says that every unit can throw every
possible exception type.PedanticThrowAnalysis
for inclusion in
Soot's global variable manager, G
.
key
to value
.
obj
from this
.
this
minus obj
into dest
.
aName
AltClassLoader
should load from the alternate classpath instead of the
regular classpath.
Trap.getBeginUnit()
to
beginUnit
.
ThrowAnalysis
to be used by default when
constructing CFGs which include exceptional control flow.
Trap.getEndUnit()
to
endUnit
.
exception
.
handlerUnit
.
out
in the Chain by in
.
out
in the Chain by in
.
Unit
s might throw.G
and Singletons
classes).ThrowableSet.Manager
for inclusion in
Soot's global variable manager, G
.
ThrowableSet.whichCatchableAs(RefType)
,
consisting of a pair of ThrowableSets.ThrowableSet.Pair
.
BodyTransformer
that shrinks the protected area covered
by each Trap
in the Body
so that it begins at the first of
the Body
's Unit
s which might throw an exception caught by
the Trap
and ends just after the last Unit
which might
throw an exception caught by the Trap
.Body
instance where the nodes are
Unit
instances, and where, in additional to unexceptional
control flow edges, edges are added from every trapped Unit
to the Trap
's handler Unit
, regardless
of whether the trapped Unit
s may actually throw the
exception caught by the Trap
.int
, java.lang.String
.e
.
ThrowableSet
, suitable for human consumption.
ThrowableSet
,
used to identify a set when it appears in a collection.
ThrowableSet
.
entryInitialFlow()
is applied to trap handlers.
Unit
instances and
edges represent unexceptional and (possibly) exceptional control
flow between Units.mapTo
.mapTo
.init
is called.mapTo
.init
is called.mapTo
.init
is called.initialCapacity
.
mapTo
.init
is called.initialCapacity
.
mapTo
.init
is called.initialCapacity
and
loadFactor
.
mapTo
.init
is called.initialCapacity
and
loadFactor
.
ThrowAnalysis
which returns the set of runtime exceptions
and errors that might be thrown by the bytecode instructions
represented by a unit, as indicated by the Java Virtual Machine
specification.UnitThrowAnalysis
for inclusion in
Soot's global variable manager, G
.
other
, putting
result into this
.
other
, putting
result into dest
.
unitBody
, attempting to not
split locals assigned the same name in the original Jimple.
PedanticThrowAnalysis
.
ThrowableSet.Manager
.
UnitThrowAnalysis
.
PhaseDumper
.
AltClassLoader
, which
loads classes from the classpath set by the most recent call to
its AltClassLoader.setAltClassPath(java.lang.String)
.
ThrowableSet
into those which would be caught by a handler with the passed
catch
parameter type and those which would not.
Block
instances, and where
exception boundaries are taken into account when finding the
Blocks for the provided Body.Body
.
BriefUnitGraph
.
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |