|Home >> All|
|||Compil3r.BytecodeAnalysis.* (14)||||Compil3r.Dataflow.* (9)|
|||Compil3r.Quad.* (58)||||Compil3r.Quad.AndersenInterface.* (8)|
|||Compil3r.Quad.IPA.* (4)||||Compil3r.Quad.x86.* (2)|
|||Compil3r.Reference.* (3)||||Compil3r.Reference.x86.* (3)|
Compil3r: Javadoc index of package Compil3r.
BasicBlock: Represents a basic block in the quad intermediate representation. Basic blocks are single-entry regions, but not necessarily single-exit regions due to the fact that control flow may exit a basic block early due to a run time exception. That is to say, a potential exception point does not end a basic block. Each basic block contains a list of quads, a list of predecessors, a list of successors, and a list of exception handlers. It also has an id number that is unique within its control flow graph, and some flags. You should never create a basic block directly. You should create one via a ControlFlowGraph ...
BDDPointerAnalysis: This is an implementation of the "Points-to Analysis using BDDs" algorithm described in the PLDI 2003 paper by Berndl, Lhotak, Qian, Hendren and Umanee. This code is based on their original implementation available at: http://www.sable.mcgill.ca/bdd/. This version has been rewritten in Java and requires the open-source JavaBDD library, available at http://javabdd.sf.net. This implementation extends Berndl et al.'s algorithm to support on-the-fly computation of the call graph using BDDs. See the handleVirtualCalls() method.
ExceptionHandler: Exception handler for basic blocks. Each exception handler handles a type of exception. When an exception is raised at run time, a routine looks up the list of exception handlers that guard the location where the exception was raised. It checks each of the exception handlers in order. Control flow branches to the first exception handler whose type matches the type of the raised exception. Note that the type check is a Java "assignable" type check, and therefore inheritance and interface checks may be necessary.
ControlFlowGraph: Control flow graph for the Quad format. The control flow graph is a fundamental part of the quad intermediate representation. The control flow graph organizes the basic blocks for a method. Control flow graphs always include an entry basic block and an exit basic block. These basic blocks are always empty and have id numbers 0 and 1, respectively. A control flow graph includes references to the entry and exit nodes, and the set of exception handlers for the method.
ExceptionHandlerList: Holds a list of exception handlers that protect a basic block. It includes a reference to a parent exception handler list, to handle nesting of exception handlers. These form a tree structure where each node has a pointer to its parent.
BytecodeToQuad: Converts stack-based Java bytecode to Quad intermediate format. This utilizes the ControlFlowGraph in the BytecodeAnalysis package to build up a control flow graph, then iterates over the graph to generate the Quad code.
IterativeSolver: Solves a dataflow problem using a iterative technique. Successively iterates over the locations in the graph in a given order until there are no more changes.
CSPAResults: Records results for context-sensitive pointer analysis. The results can be saved and reloaded. This class also provides methods to query the results.
ProgramLocation: This class combines a jq_Method with a Quad to represent a location in the code. This is useful for interprocedural analysis.
BasicBlockVisitor: Interface for the basic block visitor design pattern. Make your visitor object implement this class in order to visit
CHACallGraph: A simple call graph implementation based on class-hierarchy analysis with optional rapid type analysis.
ExceptionHandlerIterator: Iterator for iterating through exception handlers. Compatible with ListIterator.