All Classes and Interfaces
Class
Description
The AbstractCallGraphAlgorithm class is the super class of all call graph algorithm.
Abstract class represents a class/module lives in
View.AbstractClassSource represents a Compilation Unit (Interpretation Unit for interpreted
languages).
An abstract class providing a meta-framework for carrying out dataflow analysis.
Abstract base class for
DexNullTransformerPartial default StmtPrinter implementation.
Abstract class for view.
Basic interface used for visited objects in the Visitor design pattern.
Represents an allocation site node in the pointer assignment graph.
Public interface to an input location.
This class models Annotations
Represents an array element.
A class that numbers objects, so they can be placed in bitsets.
Represents the type of an array, e.g.
A
ClassProvider capable of handling Java bytecodeA
BodySource that can read Java bytecodeThis class is responsible for creating the Abstract Syntax Tree (AST) property graph for a given
Soot method.
This type is intermediate type and used for determining the ancestor of an integer type
This type is intermediate type and used for determining the ancestor of an integer type.
This type is intermediate type and used for determining the ancestor of an integer type
Same as
JimpleBasedInterproceduralCFG but based on inverted Stmt graphs.A fast enumerator for sparse bit sets.
This is the Soot internal implementation of java.util.BitSet with Felix and Jerome's clever
efficient iterator.
Original Graph Node(sparkNode) expanded bidirectinally
Class that models the Jimple body (code attribute) of a method.
The BodyBuilder helps to create a new Body in a fluent way (see Builder Pattern)
A class which holds the information of a methods body and knows how to produce a Body for a
SootMethod.
Implement this interface if you want to provide your own body Validator
BooleanConstant didn't exist in old soot, because in Java byte code boolean values are
represented as integer values 1 or 0.
This type is an imaginary/intermediate type which is used to calculate Type Inference
Interface for Stmts at which the execution does not necessarily continue with the following Stmt
in the List
StmtPrinter implementation for normal Jimple
Represents a build error.
Built-in sets of
BodyInterceptors for the bytecode frontendThe interface of all implemented call graph data structures
The interface of a implemented call graph algorithms
callsite based context element in the points to analysis.
Transformers that inlines returns that cast and return an object.
For a given body, type hierarchy and typing, this class calculates all statements that are
necessary for the body to become use-valid.
This class is responsible for creating the Control Dependence Graph (CDG) property graph for a
given Soot method.
This class is responsible for creating the Control Flow Graph (CFG) property graph for a given
Soot method.
Augmented data type guaranteeing O(1) insertion and removal from a set of ordered, unique
elements.
This validator checks whether local variables are defined before they are used.
A queue of Object's.
Interface for different caching strategies of resolved classes.
Interface for cache providers.
Represents an allocation site node the represents a known java.lang.Class object.
This class implements the Class Hierarchy Analysis call graph algorithm.
An Enum that provides static methods and constants to represent and work with with Java modifiers
(ie public, final,...) Represents Java modifiers that can be packed and combined via EnumSet and
methods to query these.
Validator that checks for impossible combinations of class modifiers
Responsible for creating
AbstractClassSourcees based on the handled file type (.class,
.jimple, .java, .dex, etc).Represents the signature of a Class
Implement this interface if you want to provide your own class validator
Features class signatures for commonly used standard classes from the JDK
This marker interface is used for JFieldRef's and ArrayRef's
Statically evaluates the conditional expression of Jimple if statements.
Does constant propagation and folding.
A context in a context-sensitive all graph.
Compute the contexts of each heap object via OAG.
The CopyPropagator performs cascaded copy propagation.
This class is responsible for creating the Code Property Graph (CPG) for a given Soot method.
This class is responsible for creating the Data Dependence Graph (DDG) property graph for a given
Soot method.
This interceptor eliminates assignment statements to locals whose values are not subsequently
used, unless evaluating the right-hand side of the assignment may cause side-effects.
AnalysisInputLocation that points to the shipped Java Runtime of the current JVM execution
DexFileProvider.DexContainer<T extends org.jf.dexlib2.iface.DexFile>
This class represents a wrapper around dexlib instruction.
DexlibWrapper provides an entry point to the dexlib library from the smali project.
BodyTransformer to find and change IntConstant(0) to NullConstant where locals are used as
objects.
Exports a StmtGraph into a Dot representation (see https://graphviz.org) to visualize the Graph
Floating point constant with double precision.
Implementation of points-to set that holds two sets: one for new elements that have not yet been
propagated, and the other for elements that have already been propagated.
This class is added so that examples/target/site/jacoco-ut directory can be created.
stores (already loaded) ClassType -> ClassSource associations for retrieval
Represents a single edge in a call graph.
Removes empty switch statements which always take the default action from a method body, i.e.
An alternate equivalence relation between objects, not necessarily compliant with the contract
defined by
Object.equals(Object).A FilterWriter which catches to-be-escaped characters (
\\unnnn) in the input and
substitutes their escaped representation.Evaluates, whether a value is constant and computes its constant value, if possible.
simple dataflow fact for interprocedural dataflow analysis adaptable with a state enum *
as an equivalent to BranchingStmt
a wrapper of normal field.
Interface for field.
An Enum that provides static methods and constants to represent and work with with Java modifiers
(ie public, final,...) Represents Java modifiers that can be packed and combined via EnumSet and
methods to query these.
Validator that checks for impossible combinations of field modifiers
Represents a field reference node in the pointer assignment graph.
Represents the fully qualified signature of a field.
Defines a sub-signature of a field, containing the field name and the type signature.
An enumeration of common file types used for class loading/writing and other purposes.
Floating point constant with single precision.
An abstract class providing a framework for carrying out dataflow analysis.
forwarding implementation for encapsulating a StmtGraph.
Cache that stores any class that has been resolved.
Provides a new
FullCache object.This class represents Position Information i.e.
This class stores position information stored for a statement.
Represents a simple variable node in the pointer assignment graph that is not associated with any
particular method invocation.
This class implements a mutable call graph as a graph.
This internal class is used to describe a vertex in the graph.
Interface to mark Soot code objects that may contain annotations.
Interface to mark Soot code objects that may contain code location information.
Comparator to sort ClassTypes which are ideally connected in a Hierarchy.
refer to "Hybrid Context-Sensitivity for Points-To Analysis" (PLDI'13)
Hybrid implementation of points-to set, which uses an explicit array for small sets, and a bit
vector for large sets.
refer to "Hybrid Context-Sensitivity for Points-To Analysis" (PLDI'13)
local nodes
A factory used for creating language-specific objects representing entities of the language, for
instance
PackageName, MethodSignature and others.This validator checks whether each ParameterRef and ThisRef is used exactly once.
Immediate is a local or a constant.
This class converts wala instruction to jimple statement.
A 32-bit integer constant.
A class implementing this interface can be invalidated.
Interface for Stmts that could invoke a different method which will be executed before the next
statement is executed
A basic validator that checks whether the length of the invoke statement's argument list matches
the length of the target methods's parameter type list.
A numberer which also supports an iterator on newly-added objects.
An expression that adds two numbers.
An expression that computes a binary AND of two operands.
Represents the assignment of one value to another
An implementation of the
AnalysisInputLocation interface for the Java class path.Represents the unique fully-qualified name of a Class (aka its signature).
The Java-specific implementation of
IdentifierFactory.JavaJimple implements the Java specific terms for
JimpleAn implementation of the
AnalysisInputLocation interface for the Java modulepath.The JavaModuleView manages the Java classes of the application being analyzed for >=Java9
Defines a
JavaSootField.JavaSootFieldBuilder to provide a fluent API.Defines a
JavaSootField.JavaSootFieldBuilder to provide a fluent API.An implementation of the
AnalysisInputLocation interface for the Java source code path.The Class JavaView manages the Java classes of the application being analyzed.
An expression that casts a value to a certain type.
An expression that divides a number by another.
A statement that enters a JVM monitor, thereby synchronizing its following statements.
An expression that checks whether two value are equal.
A statement that exits a JVM monitor, thereby ending synchronization.
An expression that checks whether operand 1 >= operand 2.
Unconditionally jumps to a target Stmt
An expression that checks whether operand 1 > operand 2.
If the condition is true, jumps to the target, otherwise continues to the next stmt.
The Jimple class contains all the constructors for the components of the Jimple grammar for the
Jimple body.
Default implementation for the
InterproceduralCFG interface.This class provides an empty implementation of
JimpleListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
JimpleVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This class contains the equivalence implementations for the individual
EquivTo.equivTo(Object) methods of the Jimple IR.This Utility class provides common used methods in context with parsing Jimple.
This interface defines a complete listener for a parse tree produced by
JimpleParser.Prints out a class and all its methods.
Options to control..
This Interceptor executes validations on Jimple semantics
This AnalysisInputLocation encapsulates and represents a single Jimple "file" - the contents of
the Class are given via String.
This validator checks whether the jimple traps are correct.
The Class JimpleView manages the Sootclasses of the application being analyzed.
This interface defines a complete generic visitor for a parse tree produced
by
JimpleParser.An expression that checks whether a value is of a certain type.
An expression that invokes an interface method.
A method call
An expression that checks whether operand 1 <= operand 2.
An expression that returns the length of an array.
An expression that checks whether operand 1 < operand 2.
An expression that multiplies two numbers.
The opposite of
JEqExprAn expression that negates its operand (-).
An expression that creates a new array of a certain type and a certain size.
An expression that creates a new instance of a class.
Like
JNewArrayExpr, but for multi-dimensional arrays.A no-operation statement.
An expression that computes a binary OR of two operands.
ParameterRef objects are used by Body objects to refer to the parameter
slots on method entry.An expression that computes a % b.
Represents the deprecated JVM
ret statement (< java 1.6) - which is used in JSR
Context - which is deprecated as well.A statement that ends the method, returning a value.
A statement that ends the method, returning no value.
Base class for
AnalysisInputLocations that can be located by a Path object.An expression that shifts its operand to the left (<<).
An expression that shifts its operand to the left (>>).
An expression that invokes a special method (e.g.
An expression that invokes a static method.
An expression that subtracts operand 2 from operand 1.
A statement that throws an Exception
Similar to
JShrExpr, but shifts zero into the leftmost position.An expression that invokes a virtual method.
An expression that computes a binary XOR of two operands.
Enumeration type representing the kind of a call graph edge.
locals
StmtPrinter implementation for normal (full) Jimple for OldSoot
Local variable in
Body.Generates locals for Body.
A BodyInterceptor that attempts to identify and separate uses of a local variable (definition)
that are independent of each other.
A Constant that supports
LogicalConstant.and(LogicalConstant), LogicalConstant.or(LogicalConstant) and LogicalConstant.xor(LogicalConstant)A 64-bit integer constant
Cache that implements a least recently used strategy.
Provides a new
LRUCache object.Marker interface for Values that can be on the left side of an Assignment
Interface for method.
Validates classes to make sure that all method signatures are valid and does not contain
impossible method modifier combinations
An Enum that provides static methods and constants to represent and work with with Java modifiers
(ie public, final,...) Represents Java modifiers that can be packed and combined via EnumSet and
methods to query these.
Part of a pointer assignment graph for a single method.
Represents the fully qualified signature of a method.
Defines a method sub-signature, containing the method name, the parameter type signatures, and
the return type signature.
Discovers all modules in a given module path.
This AnalysisInputLocation models MultiRelease Jars or Directories if path points to a directory
that is not packed into a jar see https://openjdk.org/jeps/238#Modular_multi-release_JAR_files
Represents the signature of a Java 9 package, referencing its module.
Represents a Java 9 module.
If the user wants to analyze a Multi-Release Jar, they have to specify the language level to
analyze explicitly.
This interface defines a mutable call graph.
Interface for caches which are mutable and allow classes to be removed from.
Mutable version of the
FullCache that additionally allows for a removal of cached
classes.Provides a new
MutableFullCache object.This view, in contrast to other views, can be modified.
For internal use only.
This interface has to be implemented to create a mutable view.
Represents every node in the pointer assignment graph.
a modified ArrayList which grows instead of throwing IndexOutOfBounds and behaves more like a
(growing) array.
This convenience class represents the case when there is no position information available.
StmtPrinter implementation for normal (full) Jimple
Represents a signature for a
null-reference.A class that numbers objects, so they can be placed in bitsets.
A class that assigns integers to java.lang.Strings.
A numberer converts objects to unique non-negative integers, and vice-versa.
Implementation of Object Allocation Graph (OAG).
Represents the edges in a call graph.
This class resembles the stack which the bytecode fills.
e.g.
Validates classes to make sure that the outer class chain is not recursive
Allows for replacing specific parts of a method or, resolve methods where all information is
already existing.
Allows for replacing specific parts of a class, such as fields and methods or, allows to resolve
classes that are batchparsed like .java files using wala java source frontend or in tests where
all information is already existing.
Allows for replacing specific parts of a class, such as fields and methods or, allows to resolve
classes that are batchparsed like .java files using wala java source frontend or in tests where
all information is already existing.
Abstract base class for points-to set visitors used to enumerate points-to sets.
Represents a Java Package.
Pointer assignment graph.
Represents a method parameter.
Base class for
PathBasedAnalysisInputLocations that can be located by a Path
object.Common functionality useful to cope with
Paths.A generic interface to any type of pointer analysis.
A generic interface to some set of runtime objects computed by a pointer analysis.
Abstract base class for implementations of points-to sets.
For each object o, this class compute the set of methods which o could potentially be their
context element.
Represents Java's primitive types.
Abstract base class for a propagator that propagates points-to sets along pointer assignment
graph.
Utility class to convert a property graph to DOT format for visualization.
Gather stats on the performance and precision of a PTA run.
A queue of Object's.
This class implements the Rapid Type Analysis call graph algorithm.
Base type for floating point constants.
Represents the signature of a Java type, e.g., a class, an array type, or null.
Replace old use of an expr with a new use
Replace old use of a Ref with a new use
Replace old use(Value) of a Stmt with a new use(Value)
Context selector of BEAN.
This class stores position information (the line number + first/last column) stored for a
statement.
Soot's counterpart of the source languages class concept.
Provides methods common to Soot objects belonging to classes, namely SootField and SootMethod.
Abstract class for the signature of a
SootClassMemberDefines the base class for class member sub signatures.
Basic class for retrieving information that is needed to build a
SootClass.Soot's counterpart of the source language's field concept.
Defines a
SootField builder to provide a fluent API.Soot's counterpart of the source language's method concept.
Defines a
SootMethod builder that provides a fluent API.Represents a field.
In Static Single Assignment Form, each variable be assigned exactly once, and every variable be
defined before it is used.
Interface for control flow graphs on Jimple Stmts.
Iterates over a given StmtGraph (which is connected, so all Stmt nodes are reached - except
traphandler) so the returned Jimple Stmts are returned as valid, linearized code blocks that are
intuitive to navigate.
This class stores position information stored for a statement.
Interface for different methods of printing out a Stmt.
Represents an allocation site node the represents a constant string.
A class that numbers strings, so they can be placed in bitsets.
Utility methods for string manipulations commonly used in sootup.
This reflection model handles reflection according to the dynamic traces recorded through
Tamiflex.
The top type is a superclass of all other types.
Represents a try-catch construct.
Represents the signature of a Java type, e.g., a class, a primitive type, void, or null.
This transformer assigns types to local variables.
Type based context element in the points to analysis.
Represents a type hierarchy.
Checks whether the types used for locals, method parameters, and method return values are allowed
in final Jimple code.
TLDR: this class implements sorting a priorityquueue based on the order of items in a List (i.e.
Represents a signature for an unknown type.
A BodyInterceptor that removes all unreachable stmts from the given Body.
The UnusedLocalEliminator removes any unused locals from the method.
Represents a simple of pointer node in the pointer assignment graph.
Data used as, for instance, arguments to instructions; typical implementations are constants or
expressions.
Represents a simple variable node in the pointer assignment graph.
A View is essentially a collection of code.
Interface that defines notifications that are triggered when a mutable view is modified.
Full documentation is in the wiki.
Holds a vertex for each
ClassType encountered during the scan.Resolves virtual calls.
Holds relevant information about a particular virtual call site.
Basic interface used in the implementation of the Visitor design pattern.
Represents Java's 'void' type as methods return's type.
Converter which converts WALA IR to jimple.
A
ClassProvider that can read Java source codeThis type is used for Type Inference.
Main class of Zipper, which computes precision-critical methods in the program being analyzed.