|
|||||||||||
| 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
Units 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 Blocks 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 Units 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
Units which are heads in unitGraph,
and defines as tails the blocks which end with
Units 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.
UnitGraphs, to be
called only after the unitToPreds and unitToSuccs maps have
been built.
CFGOptionMatcher.DotGraph visualization
of a control flow graph.Blocks 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.
Units
of this graph's body to the union of the values stored in the
two argument Maps, 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.Blocks 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.
Units 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.
Objects are
ThrowableSet.Pairs 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
CFGGraphTypes, separated by
'|' characters.
CFGIntermediateReps, 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 before point.
toInsert in the Chain before point.
toInsert in the Chain before point.
toInsert in the Chain before point.
NopStmts 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.
Throwables 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.
Throwables 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.
Throwables 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.
Units 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 Units 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 Units 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 | ||||||||||