All Classes

Common functionality for ControlFlowGraph implementations.

An object to track performance of an analysis engine

Common implementation for InstanceFieldPointerKey implementations.

A graph whose edges are labeled with IFlowLabels.

Interprocedural control-flow graph, constructed lazily.

This gives some basic facilities for shoving things around on the stack.

A Meeter object provides the dataflow logic needed to meet the abstract machine state for a dataflow meet.

This gives some basic facilities for shoving things around on the stack.

A Meeter object provides the dataflow logic needed to meet the abstract machine state for a dataflow meet.

A PointerKey representing a local variable must carry at least a CGNode.

A Jar file nested in a parent jar file

Abstract superclass for PointerAnalysis implementations.

Abstract base class for solver for pointer analysis.

An abstract superclass of various SSAContextInterpreters that deal with reflection methods.

A warning when we expect excessive pollution from a factory method

This abstract class represents field (a.k.a property) reads in which the field name is not a constant, but rather a computed value.

A synthetic method from the FakeRootClass

Abstract core of traditional SSA conversion (Cytron et al.).

Abstract base class for InstanceKey which represents at least some IClass in some CGNode.

Represents a single variable in a fixed-point system.

This is a demo class.

This class implements a stream that just discards everything written to it.

An InstanceKey which represents a NewSiteReference in some IMethod.

A factory which tries by default to create InstanceKeys which are AllocationSiteInNodes.

A policy that always refines the call graph.

A place to hold onto caches of various analysis artifacts.

Basic interface for options that control call graph generation.

Base class that represents a set of files to analyze.

Utility class for the exception pruning analysis.

This exception is thrown by verify() when it fails.

Fetches an android/content/Context.

The ExecutionOrder is used to partially order EntryPoints.

Implement this interface to put entitys into the AndroidModel.

A definition of an Entrypoint functions o the App are matched against.

Used to control the search mechanisms of AndroidEntryPointLocator.

Read in an extracted AndroidManifest.xml.

Encapsulates synthetic methods for modeling Androids lifecycle.

Does optional checks before building the CallGraph.

Generate a Settings-Object from a String-Representation.

Grab and set data of AndroidClasses.

Representation of an annotation attribute.

represents an annotation argument that itself is an array of arguments

Marker interface for possible element values in an annotation attribute.

A node pattern that matches any AST node.

Keeps a given CGNode if it stems from application code

An entrypoint which chooses some valid (non-interface) concrete type for each argument, if one is available.

Implementation of IClass for array classes.

Pseudo-field modelling the contents of an array of reference type.

A PointerKey that represents an array length location

Iterator that only returns non-null elements of the array hasNext() return true when there is a non-null element, false otherwise next() returns the current element and advances the counter up to the next non-null element or beyond the limit of the array

A simple assignment statement.

A read of a global variable denoted by a FieldReference

IR instruction to check whether a field is defined on some object.

A single lexical access.

A set of lexical writes.

Parents of this method with respect to lexical scoping, that is, methods containing state possibly referenced lexically in this method

Common code to translate CAst to IR.

data structure for the final CFG for a method, based on the information in an AstTranslator.IncipientCFG

a scope in the symbol table built during AST traversal

interface for name information stored in a symbol table.

An utf8-encoded byte string.

A "reversed" supergraph for backwards analysis.

A helper class to make the ipcfg work correctly with context-sensitive call graphs.

Basic implementation of HeapGraph

A relation between non-negative integers This implementation uses n IntVectors, to hold the first n y's associated with each x, and then 1 extra vector of SparseIntSet to hold the remaining ys.

An implementation of NullaryStep that carries its operator explicitly

TODO: refactor to eliminate more redundancy with SSACallGraphBuilder

An implementation of UnaryStatement that carries its operator explicitly

This is a demo class.

This class searches breadth-first for node that matches some criteria.

An implementation of MutableIntSet that delegates to either a MutableSparseIntSet or a BitVectorIntSet

Module representing a directory of .class files

utilities for manipulating values at the bit-level.

Operator OUT = IN - filterSet

Operator OUT = IN

A BitVector implementation of MutableIntSet.

Just kills everything

Operator OUT = IN / v

A repository for shared bit vectors as described by Heintze

Operator U(n) = U(n) U U(j)

Operator lhs = lhs U rhs U v

Operator OUT = IN

Operator U(n) = U(n) U U(j)

This class implements breadth-first search over a Graph, returning an Iterator of the nodes of the graph in order of discovery.

A TabulationSolver that gives up after a finite bound.

Exception thrown when a demand-driven points-to query exceeds its allocated budget.

"Non-standard" bypass rules to use during call graph construction.

This class represents class loaders that introduce classes that do not exist in the actual application being analyzed.

A class representing which originates in some form of bytecode.

A factory for References ...

This is a Context which is defined by a pair consisting of .

This is a context which is defined by a pair consisting of .

Basic interface for a call graph, which is a graph of CGNode

An exception to throw when call graph construction is canceled.

Collect basic call graph statistics

Utility class for computing an analysis result for call graph nodes and their transitive callees, given the results for individual nodes.

A utility class consisting of a pair CallSiteReference x CGNode

Representation for a calling context.

An exception for when work is canceled in eclipse.

The main interface for creating CAPA Abstract Syntax Trees.

abstract class loader that performs CAst and IR generation for relevant entities in a list of Modules.

key indicating that no duplication is being performed

An implementation of a CAstControlFlowMap that is designed to be used by producers of CAPA asts.

Various operators that are built in to many languages, and hence perhaps deserve special notice in WALA CAst interface.

Abstract superclass for types performing a rewrite operation on a CAst.

represents a rewritten CAst

This interface encapsulates the source position of an ast node in its source file.

Utility class to remove exceptional edges to exit() from a CFG

A context-insensitive SDG.

This class provides Instance Key call backs where each instance is in the same equivalence class as all other instances of the same concrete type.

An SSAContextInterpreter specialized to interpret reflective class factories (e.g.

Simple implementation of a class hierarchy.

A ClassTargetSelector that simply looks up the declared type of a NewSiteReference in the appropriate class hierarchy.

A MethodTargetSelector that simply looks up the declared type, name and descriptor of a CallSiteReference in the appropriate class hierarchy.

Statistics about a class hierarchy.

Utilities for querying a class hierarchy

This class provides a convenient way to instrument every method in a class.

A class loader that reads class definitions from a set of Modules.

Class is not in scope.

This class prints the contents of a class file.

AttrIterator provides access to attributes in the class file.

Under construction.

Under construction.

A RawElement is an Element that is already available as some chunk of a byte buffer.

A context interpreter for java.lang.Object.clone TODO: The current implementation does not model CloneNotSupportedExceptions

Simple utilities to scan IMethods to gather information without building an IR.

This class helps emit Code elements.

utilities for parsing a command line

This class generates Java bytecode from ShrikeBT Instructions.

This class represents the union of two sets of Entrypoints.

An Iterator which provides a concatenation of two IntIterators.

An instance key which represents a unique set for each concrete type.

Represents a type and its subtypes.

An instance key which represents a unique, constant object.

This interface defines a bunch of constants from the JVM spec.

This class reads ConstantValue attributes.

This context selector returns a context customized for the InstanceKey of the receiver if receiver is a container, or was allocated in a node whose context was a ReceiverInstanceContext, and the type is interesting according to a delegate ZeroXInstanceKeys Additionally, we add one level of call string context to a few well-known static factory methods from the standard libraries.

Utilities for container class analysis

A basic context selector that ignores context.

A placeholder for strong typing.

This just exists to enforce strong typing.

An interface to an object which helps control context-sensitivity.

handles method recursion by only collapsing cycles of recursive calls observed during analysis

Control Dependence Graph

This class represents instructions that convert from one primitive type to another.

A CallGraph implementation adapted to work for graphs that contain code entities from multiple languages, and hence multiple specialized forms of IR.

A ClassTargetSelector implementation that delegates to one of several child selectors based on the language of the type being allocated.

An InstanceKeyFactory implementation that is designed to support multiple languages.

This class represents the CharacterRangeTable attribute.

This class represents the flags which a entry in the CharacterRangeTable can have.

This class decodes Java bytecodes into ShrikeBT code using a ShrikeCT class reader.

Iterative solver for a Killdall dataflow framework

A debugging factory that creates debugging bitsets that are implemented as two bitsets that perform consistency checks for every operation.

This exception is thrown when the Decoder detects invalid incoming bytecode (code that would not pass the Java verifier).

An entrypoint whose parameter types are the declared types.

Default implementation of a dataflow graph

Default implementation of IRFactory.

Basic analysis; context-insensitive except for newInstance and clone

A context selector that first checks with A, then defaults to B.

A call graph implementation where some edges are delegated to other call sites, since they are guaranteed to be the same.

A field refine policy that first checks with A, then delegates to B

An object that delegates edge management to the nodes, INodeWithNumberedEdges

Basic implementation of a numbered graph -- this implementation relies on nodes that carry numbers and edges.

An SSAContextInterpreter that first checks with A, then defaults to B.

Demand-driven refinement-based points-to analysis.

A flow graph including both pointer and primitive values.

Create AnalysisScope from java & dalvik file.

A module which is a wrapper around .dex and .apk file.

A wrapper around a EncodedMethod object (from dexlib) that represents a method.

utilities related to depth-first search.

This class implements depth-first search over a NumberedGraph, return an enumeration of the nodes of the graph in order of increasing discover time.

This class searches depth-first search for node that matches some criteria.

This is a very simple component to disassemble a ShrikeBT method.

Calculate dominators using Langauer and Tarjan's fastest algorithm.

utilities for interfacing with DOT

A dummy state machine with a single, non-error state.

This class represents dup instructions.

This instruction represents iterating through the properties of its receiver object.

View of a NumberedGraph in which some edges have been filtered out

A singleton instance of an empty iterator; this is better than Collections.EMPTY_SET.iterator(), which allocates an iterator object;

A singleton instance of an empty iterator; this is better than Collections.EMPTY_SET.iterator(), which allocates an iterator object;

A representation of an entrypoint in the call graph.

A Statement representing the exceptional return value in a callee, immediately before returning to the caller.

An ExceptionHandler represents a single handler covering a single instruction.

This abstract class is used as interface for analysis that remove impossible control flow from a CFG.

Utility class to help deal with analysis of exceptions.

This class reads Exceptions attributes.

A call graph which explicitly holds the target for each call site in each node.

A view of a control flow graph where each basic block corresponds to exactly one SSA instruction index.

discovers which names declared by an entity are exposed, i.e., accessed by nested functions.

Factorial utilities

Logic to interpret "factory" methods in context.

A synthetic method that models the fake root node.

This ContextInterpreter can be used when using another WALA frontend than the shrike frontend.

A class to represent the reference in a class file to a field.

Interface for specifying a policy for refinement of field access handling.

FIFO work queue management of Objects that prevents an Object from being added to the queue if it was ever previously enqueued.

An object which represents a set of classes read from a text file.

Some simple utilities used to manipulate Strings

A simple liveness analysis based on flow-insensitive pointer analysis.

This abstract instruction extends the abstract invoke with functionality to support invocations with a fixed number of arguments---the only case in some languages and a common case even in scripting languages.

Floyd-Warshall algorithm to compute all-pairs shortest path in graph with no negative cycles.

Hardcoded EntryPoint-specifications for an Android-Activity.

Represents a single step in an iterative solver

Generic dataflow framework to accumulate reachable gen'ned values in a graph.

SSAContextInterpreter specialized to interpret Object.getClass() in a JavaTypeContext

A context which may be used if the method to be interpreted is either Class.getMethod(String, Class...) or Class.getDeclaredMethod(String, Class...), the type of the "this" argument is known and the value of the first argument (the method name) is a constant. In the special case described above, GetMethodContextInterpreter and GetMethodContextSelector should be preferred over JavaLangClassContextInterpreter and JavaLangClassContextSelector, as GetMethodContextInterpreter and GetMethodContextSelector drastically reduce the number of methods returned increasing the precision of the analysis.

Produces GetMethodContext if appropriate.

Basic interface for a directed graph.

Simple graph printing utility

Utilities related to simple graph subset operations.

A comparator based on hash codes

A debugging aid.

Simple Heap data structure.

A Graph view of a pointer analysis solution.

A HeapModel embodies how a pointer analysis abstracts heap locations.

An interface for a basic block in a control flow graph.

A method which originated in bytecode, decoded by Shrike

Basic interface for an object that represents a single Java class for analysis purposes, including array classes.

Something that lives in a class hierarchy

Basic interface for a demand-driven points-to analysis.

A silly debugging aid that always returns the identity flow function

The general form of a statement definition in an iterative solver is: x >= term, where term can be any complex expression whose free variables are among the IVariables of the constraint system this IFixedPointStatementis part of (x represents the left-hand side of the constraint).

A flow function corresponding to an edge in the supergraph.

The handling for a variable occurring in the AndroidModel.

Basic interface for liveness analysis of heap-allocated objects.

Basic interface for an object that represents a single Java member (method or field) for analysis purposes.

Special case: if supportsMerge(), then the problem is not really IFDS anymore.

BEGIN Custom change: precise positions

A read-only byte array.

A ControlFlowGraph computed from a set of SSAInstruction instructions.

This class reads InnerClasses attributes.

Basic interface from which to execute and get the results of escape analysis.

Basic interface for a node which lives in one graph ...

An instance key which has an associated CGNode.

This class represents instanceof instructions.

Add code to create an instance of a type in a synthetic method.

Instructions are immutable objects.

Collection of Instruction wich allow to get an instruction from its table index id or from its bytecode index.

An implementation of Tarjan's union-find, using path compression and balancing, for non-negative integers

An SSAContextInterpreter that redirects functions that start Android-Components.

Like MicroModel but includes CallBacks.

The flags influence the later model.

Interprocedural control-flow graph.

An IntMapIterator maps an Iterator contents to produce a new Iterator

State machine that only allows intraprocedural paths.

Intraprocedural dataflow analysis to detect impossible NullPointerExceptions.

A variable for dataflow analysis, representing a set of integers.

interface for array of integer

An InvalidSourceInfoException is thrown if SourceInfo could not be initialized.

A graph view that reverses the edges in a graph

An edge manager that reverses the edges in a graph

This class represents method invocation instructions.

An operator in pointer analysis constraints.

A Map that gives the names of the local variables corresponding to SSA value numbers at particular IR instruction indices, if such information is available from source code mapping.

A flow function corresponding to an edge in the supergraph.

Interface for an SDG (loosely defined here as a graph of Statements.

A supergraph as defined by Reps, Horwitz, and Sagiv POPL95

Converts an Iterator to a Collection.

A utility to efficiently compose an iterator and a singleton

utilities dealing with Iterators

simple interface for a vector.

An entry in a Jar file.

Read in a jar file from an input stream.

The implementation of Language which defines Java semantics.

A Java process launcher

Note that classes from JVML have some features that are not present in all "bytecode" languages currently supported.

An object which tracks labeled edges in a graph.

Main interface for language-specific information.

Abstract base class for a process launcher

This class helps emit LineNumberTable attributes.

Behavior loaded from a file.

This class represents local variable load instructions.

Intraprocedural SSA-based live range analysis.

A pointer key which provides a unique set for each local in each call graph node.

A set of summary edges for a particular procedure.

This class helps emit LocalVariableTable attributes.

A stop watch that prints log messages.

a more efficient iterator for sets of longs

Builds an Android Model incorporating three loops.

A call graph refinement policy with manual annotations for which virtual call sites to refine.

A refinement policy specified manually with annotations.

An MapIterator maps an Iterator contents to produce a new Iterator

Abstract superclass of MethodReference and FieldReference

This class is a container for a bunch of information that we might know about a method.

The MethodEditor is the core of the ShrikeBT code rewriting mechanism.

This class is subclassed for each kind of patch that you want to apply.

A statement representing method entry, used for managing control dependence.

A class to represent the reference in a class file to a method.

Provides a way for the nullpointer analysis to decide whether or not a called method may throw an exception.

This interface represents policies for selecting a method to call at a given invocation site.

UNDER CONSTRUCTION.

Models all classes derived from the given AndroidComponent.

Mod-ref analysis for heap locations.

A Module represents a set of files to analyze.

Simple utilities for Eclipse progress monitors

An InstanceKey which represents a multinewarray allocation site in a CGNode.

A modifiable control flow graph.

An object that creates some flavor of mutable int set.

An object that creates some flavor of mutable int set.

The shared bit vector implementation described by [Heintze 1999] TODO: much optimization possible.

A sparse ordered, mutable duplicate-free, fully-encapsulated set of integers.

A sparse ordered, mutable duplicate-free, fully-encapsulated set of longs.

nCFA Call graph builder.

An EdgeFilter that ignores all edges contained in a given graph.

Represents a textual allocation site Note that the identity of a NewSiteReference depends on two things: the program counter, and the containing IR.

A key which represents a set corresponding to a call graph node.

A node pattern that matches an AST node of a certain kind; additionally, the node's children have to match the pattern's child patterns.

A node which carries it's own number; which identifies it in a NumberedGraph implementation.

A singleton iterator for an object which is guaranteed to be not-null.

A Statement representing the normal return value in a callee, immediately before returning to the caller.

A statement that has a corresponding index in the SSA IR

Represents a single step, restricted to a nullary operator.

States for the ssa variables.

Dummy MonitorUtil.IProgressMonitor

This class implements depth-first search over a NumberedGraph, return an enumeration of the nodes of the graph in order of increasing discover time.

Calculate dominators using Langauer and Tarjan's fastest algorithm.

A numbered graph is a Graph where each node has a unique persistent non-negative integer id.

Class files are taken as input arguments (or if there are none, from standard input).

This class provides functionality for performing offline instrumentation.

Adds one-level of ArgumentInstanceContext on the function argument for functions that perform lexical accesses (i.e., those functions represented by a ScopeMappingInstanceKeys.ScopeMappingInstanceKey).

An object that implements a bijection between whole numbers and objects.

Context Free overrides for the startComponent-Methods.

A MemoryAccessMap that makes use of a pre-computed PointerAnalysis to reduce the number of considered accesses.

A Statement representing an actual parameter

The Constructor used to create ParameterAccessor influences the parameter-offset.

The representation of a Parameter handled using a ParameterAccessor.

Encapsulates the state of all parameters of an invoked method

a debugging aid.

a view of a portion of a call graph.

Utilities for dealing with tabulation with partially balanced parentheses.

an individual edge ->

Program dependence graph for a single call graph node

identifier of a phi instruction

identifier of a Pi instruction

Abstract definition of pointer analysis

Iterates over the value numbers of the pointer parameters of a method.

Representation of a points-to set during an andersen-style analysis.

PopInstructions pop one or two elements off the working stack.

Interface for defining an arbitrary predicate on Objects.

Simple object that represents a program counter value (i.e., an instruction in the bytecode)

A dataflow graph implementation specialized for propagation-based pointer analysis

Hardcoded EntryPoint-specifications for an Android-ContentProvider.

A pruned view of a ControlFlowGraph.

Misc SQL-like support for queries on tables

This is a context which is customized for the InstanceKey of the receiver.

For some reason (either a bug in our code that defeats soft references, or a bad policy in the GC), leaving soft reference caches to clear themselves out doesn't work.

SSAContextInterpreter to handle all reflection procession.

A helper class which can modify a PropagationCallGraphBuilder to deal with reflective factory methods.

An SSAContextInterpreter specialized to interpret reflective invocations such as Constructor.newInstance and Method.invoke on an IMethod constant.

This instruction represents all return instructions.

A key which represents the return value for a node.

Helper for building the Descriptor of a model.

An iterator that reverses an input iterator.

This RTA implementation tracks a single set of Classes for each Selector

An InstanceKeyFactory that returns ScopeMappingInstanceKeys.ScopeMappingInstanceKeys as necessary to handle interprocedural lexical scoping (specifically, to handle closure creation when a function escapes its allocating scope)

System dependence graph.

A method selector; something like: foo(Ljava/lang/String;)Ljava/lang/Class; TODO: Canonicalize these?

Hardcoded EntryPoint-specifications for an Android-Service.

Abstraction of a set of PointType.

ShiftInstructions are distinguished from BinaryOpInstructions because most binary operations in the JVM require both parameters to be the same type, but shifts always take one int parameter.

A class read from Shrike

A wrapper around a Shrike object that represents a method

In Shrike, the only "source" level entities which have names relevant to indirect pointer operations are bytecode locals.

Utilities to interface with the Shrike CT library.

This class reads Signature attributes.

Purely field-based, context-insensitive demand-driven points-to analysis with very simple implementation.

Abstract ClassLoaderFactory for languages modeled as having a single class loader.

A flow function which has only the edge 0 -> dest

A demand-driven context-sensitive slicer.

options to control data dependence edges in the SDG

This class implements depth-first search over a Graph, return an enumeration of the nodes of the graph in order of increasing finishing time.

A graph of numbered nodes, expected to have a fairly sparse edge structure.

A simple implementation of Map; intended for Maps with few elements.

This class provides instance keys where for a given type T in a CGNode N, there is one "abstract allocation site" instance for all T allocations in node N.

A Module which is a wrapper around a source file

This class builds serializable SourceFile attributes.

A sparse ordered, duplicate-free, fully-encapsulated set of integers; not necessary mutable

an int vector implementation designed for low occupancy.

An object which tracks edges for nodes that have numbers.

An IVector implementation designed for low occupancy.

An instruction which unconditionally throws an exception

An SSAAddressOfInstruction represents storing the address of some "source" level entity (@see SSAIndirectionData.Name) into an SSA value number.

SSA instruction representing an array load.

SSA instruction representing an array store.

This class constructs an SSA IR from a backing ShrikeBT instruction stream.

A control-flow graph for ssa form.

A checkcast (dynamic type test) instruction.

A conditional branch instruction, which tests two values according to some IConditionalBranchInstruction.IOperator.

Abstract base class for SSAGetInstruction and SSAPutInstruction.

SSA instruction that reads a field (i.e.

A mapping that tells, for a given instruction s, what "names" does s def and use indirectly.

This class performs intra-procedural propagation over an SSA form.

An instruction in SSA form.

A base visitor implementation that does nothing.

A load from a pointer.

An instruction representing a monitorenter or monitorexit operation.

Options that govern SSA construction

A phi instruction in SSA form.

The SSABuilder consults this as an oracle to decide how to insert SSAPiInstructions

A visitor that generates constraints based on statements in SSA form.

sets bingo to true when it visits an interesting instruction

A return instruction.

SSA instruction representing a switch statement.

An SSA instruction for some unary operator.

Identify variables by a string and type.

A key that cannot be recreated.

This NamedKey also equals to TypeKeys.

standard fixed-point iterative solver for pointer analysis

Identifier of a statement in an SDG.

A Statement which carries an instruction index, representing the index of an SSAInstruction in the IR instruction array.

An pointer key which represents a unique set for each static field.

Basic class to time events

This class represents instructions that store to local variables.

An InstanceKey which represents the constant char[] contents of a string constant object.

An entrypoint whose parameter types are cones based on declared types.

A SummarizedMethod (for synthetic functions) with variable names.

An IClass that exists nowhere in bytecode.

An implementation of IMethod, usually for a synthesized method that is not read directly from any source Module.

This is generates a dummy for the call to an external Activity.

A CancelException thrown during tabulation; holds a pointer to a partial TabulationSolver.Result.

Representation of a Dyck-language graph reachability problem for the tabulation solver.

A precise interprocedural tabulation solver.

This context selector selects a context based on whether the receiver type dispatches to a given method.

A cheap, context-insensitive thin slicer based on reachability over a custom SDG.

A synthetic model of single-threaded behavior

This class represents the athrow instruction.

A comparator based on lexicographical ordering of toString()

Trivial method-level escape analysis.

A refinement policy that iteratively adds more types to refine, based on which type was encountered first in each analysis pass.

a simple implementation of int vector that can be tuned to control space usage

An IVector implementation which delegates to pages of int vectors.

UNDER CONSTRUCTION TypeArgument: WildcardIndicator? FieldTypeSignature * WildcardIndicator: + -

A trivial field-based pointer analysis solution, which only uses the information of which types (classes) are live.

An operator which initializes a type to a declared type.

We've introduced this class to canonicalize Atoms that represent package names.

Intended for SyntheticMethods, uses JavaInstructionFactory.

A type variable in the dataflow system for type inference.

Operator U(n) = U(n) U U(j)

This class represents unary operators where the result is the same type as the operand.

A SideEffect is a constraint which carries a points-to-set which is def'fed or used in created constraints.

Something that's not implemented yet.

This Model is used to start an Android-Component of unknown Target.

Abstract class that contains conversion routines to/from utf8 and/or pseudo-utf8.

Convenience methods for navigating a ControlFlowGraph.

This class contains miscellaneous useful functions.

Representation of a particular value which appears in an SSA IR.

A function which gens a vector of outgoing dataflow facts.

An optional interface for data structures that provide a verbose option for debugging purposes.

An exception to raise for some WALA failure

Runtime exception for some WALA failure.

A warning message.

ClassLoader for Java & Dalvik.

Worklist for fixed-point solver implementation

Represents an array with length zero.

0-X-CFA Call graph builder which analyzes calls to "container methods" in a context which is defined by the receiver instance.