All Classes and Interfaces
Class
Description
Associated with an AddressStoreStmt is a Subroutine whose address (offset in
the instruction sequence) is to be stored.
ArithExpr represents a binary arithmetic expression.
ArrayLengthExpr represents the arraylength opcode which
gets length of an array.
ArrayRefExpr represents an expression that references an element in an array.
AscendVisitor is the superclass of Type0Visitor and Type1Visitor,
conveniently containing the common code.
Mechanism for making assertions about things in BLOAT.
Classes that implement Assign involve an assignment (definition).
Attribute is an abstract class for an attribute defined for a method, field,
or class.
This class is used to run a benchmark Java program with Perfmon running in
the background.
The BenchmarkSecurityManager allows us to execute a "main" method
multiple times without the virtual machine exiting.
This abstract class is a central repository for all things that are necessary
for a BLOATing sessions.
BloatingClassLoader is a Java class loader that BLOATs a class
before it is loader into a Java Virtual Machine.Block represents a basic block of code used in control flow
graphs.
Does a lot of the same stuff as PersistentBloatContext except that
it manages the chaches of BLOAT objects.
CallExpr is a superclass of expressions that represent the
invocation of a method.
CallMethodExpr represents the invocation of an object's method.
CallStaticExpr represents the invokestatic opcode which invokes a
class (static) method.
CastExpr represents an expression that casts an object to a given type.
Catch stores information about a protected block and an exception handler in
a method.
CatchExpr represents an expression that catches an exception.
CheckExpr is a superclass for classes representing a check on an expression.
A ClassEditor provides finer-grain access to a class than a CLassInfo object
does.
ClassFile basically represents a Java classfile as it is found on disk.
ClassFileLoder provides an interface for loading classes from files.
ClassHierarchy maintains a graph of the subclass relationships of the classes
loaded by the ClassInfoLoader.
ClassInfo allows a class to be accessed and modified at a very low level.
ClassInfoLoader provides an interface for loading classes.
Code is used to store the Code attribute of a method in a class file.
CodeArray converts an array of Instructions into an array of bytes suitable
for saving to a MethodInfo with setCode.
CodeGenerator performs some final optimizations and is used (via a visitor)
to generate bytecode for the contents of a control flow graph.
CompactArrayInitializer optimizes the initialization of arrays by
transforming the initialization code into a loop that loads the array
elements from a string in the class's constant pool.
ComponentVisitor is used to visit the strongly connected components (SSC) of
a control flow graph.
CondExpr is a superclass for conditional expressions.
A Constant is used to represent an item in the constant pool of a class.
ConstantExpr represents a constant expression.
ConstantPool models constants in the constant pool.
The ConstantValue attribute stores an index into the constant pool that
represents constant value.
DeadCodeElimination performs SSA-based dead code elimination as described in
[Cytron, et.
An expression in which a definition occurs.
DefInformation contains information about the definition of a local variable
DecsendVisitor is the superclass of a few private classes of Type0Visitor and
Type1Visitor.
DominanceFrontier is used to calculate the dominance frontier
of each node in a control flow graph.
DominatorTree finds the dominator tree of a FlowGraph.
An EditorContext supplies a means of loading and editing classes.
EditorVisitor "visits" the "nodes" in a class.
Exceptions describes the types of exceptions that a method may throw.
Expr is the superclass for a number of other classes representing expressions
in byte code.
Performs copy and constant propagation on the blocks in a control flow graph.
ExprStmt is a statement consisting of an expression.
Field models a field (member variable) in a class.
FieldEditor provides a means to edit a field of a class.
FieldExpr represents the getfield opcode which fetches a field from
an object.
FieldInfo grants access to a field's name and type (represented as indices
into the constant pool), as well as its modifiers.
FlowGraph constructs and represents a Control Flow Graph (CFG) used for
analyzing a method.
The Java Virtual Machine Specification allows implementors to invent their
own attributes.
Represents an unconditional branch to a basic block.
Graph represents a graph of nodes with directed edges between them.
GraphNode represents a node in a Graph.
Handler represents a try-catch block.
IdentityComparator compares two objects using the result of
System.identityHashCode.
IfCmpStmt consists of a comparison expression (a left-hand expression, a
comparison operator, and a right-hand expression) that is to be evaluated.
IfStmt is a super class of statements in which some expression is evaluated
and one of two branches is taken.
IfZeroStmt evaluates an expression and executes one of its two branches
depending on whether or not the expression evaluated to zero.
ImmutableIterator is simply an iterator whose contents can not be changed.
IncOperand encapsulates the operands to the iinc instruction.
InductionVarAnalyzer traverses a control flow graph and looks for array
element swizzle operations inside loops.
InitStmt groups together the initialization of local variables (LocalExpr).
InstanceOfExpr represnts the instanceof opcode which determine if an
object is of a given type.
Instruction represents a single instruction in the JVM.
This adapter provides a default implementation for every method in
InstructionVisitor.
The visitor pattern allows functionality to be added to a number of classes
(or in this case one class, Instruction, that can vary in
behavior) without modifying the classes themselves.
Does a lot of the same stuff as ClassFileLoader, but classes are
committed to a JAR file instead of regular files.
JsrStmt represents a jsr instruction that jumps to a subroutine.
JumpStmt is the super class for several classes that represent
statements that chang the flow of control in a program.
Label is used to label an instruction.
LabelStmt is a placeholder in a Tree for a Label (the target of a jump).
An expression that can appear as a leaf node in a Tree.
LEGatherer visits a basic block and returns all the LocalExprs in a vector
LineNumberDebugInfo is used to map a range of instructions to a line number
in the original Java source file.
LineNumberTable is an attribute of a code attribute.
Liveness represents the interference graph of the local variables contained
in a control flow graph.
LocalDebugInfo is used to map a local variable index in a range of
instructions to a local in the original Java source file.
LocalExpr represents an expression that accesses a variable in a method's
local variable table.
LocalVariable represents a local variable index operand to various
instructions.
LocalVariableTable represents debugging information that may be used by a
debugger to determine the value of a given local variable during program
execution.
Inserts residency, update, or swizzle checks into the methods of the classes
specified on the command line.
Performs a number of analyses on the methods of some specified classes.
Prints the contents of a Java classfile to the console.
Usage: java EDU.purdue.cs.bloat.optimize.Main [-options] classes dir
where options include: -help print out this message -v -verbose turn on
verbose mode -debug display a hideous amount of debug info -classpath
list directories in which to look for
classes -f optimize files even if up-to-date -closure recursively optimize
referenced classes -relax-loading don't report errors if a class is not found
-skip invalid input: '<'class|package.*> skip the given class or package -only
invalid input: '<'class|package.*> skip all but the given class or package -preserve-debug try
to preserve debug information -[no]anno insert an annotation in the contant
pool -[no]stack-alloc try to push locals onto the operand stack -peel-loops
invalid input: '<'n|all> peel innermost loops to enable code hoisting (n >= 0 is the maximum
loop level to peel) -[no]pre perform partial redundency elimination
-[no]appre perform partial redundency elimination on access paths -[no]dce
perform dead code elimination -diva perform demand-driven induction variable
analysis -[no]prop perform copy and constant propagation
This program just performs array initialization compaction on a class.
This class is a driver program that uses BLOAT to make a Java class file
smaller by removing all non-essential information (such as debugging
information) from it.
MemberRef represents a method or field (as a NameAndType) and the
class (as a Type) in which it is declared.
An expression that accesses a memory location.
MemRefExpr represents an expression that references a memory location as
opposed to a local variable or a variable on the stack.
Method represents a method in a Java classfile.
MethodEditor provides a means to edit a method of a class.
MethodInfo provides methods for accessing and modifying a method.
Modifiers is an interface containing constants used as modifiers of classes,
fields, and methods.
MonitorStmt represents the monitorenter and monitorexit
opcodes, which gain and release ownership of the monitor associated with a
given object.
MultiArrayOperand encapsulates the operands to the
multianewarray instruction.
Methods and fields are described by their name and type descriptor.
NegExpr represents the arithmetic negation of an expression.
NewArrayExpr represents the newarray opcode which creates a new
array of a specified length and element type.
NewExpr represents the new opcode that creates a new object of a
specified type.
NewMultiArrayExpr represents the multianewarray opcode which
creates a new multidimensional array.
Node represents a node in an expression tree.
NodeComparator is a class used to differentiate nodes in an expression tree.
Runs a Java program multiple times without the Virtual Machine exiting.
Opcode is an interface containing constants defining the opcodes of
instructions and related constants.
OperandStack is used to simulate the JVM stack.
Performs some peephole optimizations such as loads and stores and removes
unreachable instructions.
Maintains all BLOAT data structures as if they were meant to reside in a
persistent store.
Attempts to remove residency checks an update checks from a control flow
graph.
A PhiCatchStmt is used to handle variables that are used inside an exception
handler.
PhiJoinStmt represents a phi-function inserted into a control flow
graph during conversion of variables to static single-assignment form.
A PhiStmt is inserted into a CFG in Single Static Assignment for.
PrintVistor traverses a Tree and prints some information about each visited
Node to a stream.
RCExpr represents a residency check.
RegisterAllocator performs analysis on a control flow graph and determines
the minimum amount of local variables needed in a method.
ReplaceTarget replaces the block that is the target of a
JumpStmt, JsrStmt, RetStmt,
GotoStmt, SwitchStmt, or IfStmt with
another Block.
ReplaceVisitor traverses a tree and replaces each occurrence of one Node with
another Node.
ResizableArrayList is the same as ArrayList except that ensureSize not only
increases the size of the array (super.ensureCapacity), but it also fills the
empty space with null.
RetStmt represents the ret opcode which returns from a subroutine.
ReturnAddressExpr represents a return address used with the ret
opcode.
ReturnExprStmt represents the areturn opcode which returns a
reference from a method.
ReturnStmt represents the return opcode which returns
void from a method.
SCStmt represents a swizzle check on an element in an array.
This class computes the serial version UID of a class modeled by a
ClassEditor.This class is used to execute the BLOAT benchmarks while the Shade
performanace monitoring software is running.
ShiftExpr represents a bit shift operation.
SideEffectChecker traverses a tree and determines is a node has
any side effects such as changing the stack, calling a function, or
performing a residency check.
SRStmt represents the swizzle of a range of elements in an array.
Compute the SSA form of the control flow graph and build FUD chains.
SSAConstructionInfo contains information needed to convert a CFG
into SSA form.
The SSA graph (also called the value graph) represents the nesting of
expression in a control flow graph.
Perform partial redundancy elimination of a CFG in SSA form using the
SSA-based algorithm described in:
StackExpr represents an expression that is stored on the stack.
StackManipStmt represents the opcodes that manipulate the stack such as
swap and dup.
StackOptimizer analyzes the relative distances of various uses of the same
definition of a local variable to add dups and swaps to the bytecode and
eliminate loads and stores.
Eliminate partially redundant local variable loads and stores by replacing
them with stack variables and dups.
StaticFieldExpr represents the getstatic opcode which gets a
static (class) field from a class.
Stats is used to run a benchmark using an instrumented Java
Virtual machine that counts the number of each kind of bytecodes executed.
Stmt is a super class used to represent statements in a Java bytecode
program.
StoreExpr represents a store of an expression into a memory location.
Subroutine represents a subroutine (target of a jsr instruction) in
java bytecode.
Switch is used to hold the lookup values and branch targets of a tableswitch
or lookup switch instruction.
SwitchStmt represents a switch statement.
Swizzler represents an induction variable that is used as an index into an
array.
Performs Type-Based Alias Analysis (TBAA) to determine if one expression can
alias another.
ThrowStmt represents the athrow opcode which throws an exception
or error.
This class allows Java to access the information obtained by the UNIX system
call times.
Tree represents the expression tree of a basic Block.
TreeVisitor performs a traversal of a tree.
TryCatch holds the labels for the start and end of a protected block and the
beginning of a catch block and the type of the exception to catch.
Type represents a type descriptor in a classes constant pool.
Type0Visitor searches up the tree, starting at a LocalExpr, looking for an
earlier instance of the same definition of that LocalExpr in a Type 0
relation.
Type1Visitor...
A TypeComparator orders Types such that a subclass
preceededs its superclass.
Typed-based alias analysis requires that we know the types of all entities in
a method.
UPExpr represents an update check opcode which checks the persistent store to
determine if a variable needs to be updated.
Represents the union-find data structure.
UseInformation stores information about a use of a local variable.
ValueFolding uses a ValueFolder to determine which
nodes in an expression tree can be removed or replaced by common expression
elimination and constant propagation.
Performs value numbering analysis on the nodes in a control flow graph.
VarExpr represents an expression that accesses a local variable or a variable
on the stack.
VerifyCFG visits the nodes in a control flow graph and verifies that certain
properties of the graph are true.
ZeroCheckExpr represents a check for a zero value.