db4o 6.4

Contains classes that are used to run benchmarks that measure the performance of BLOATed code. These classes allow us to do things like run a program several times in the same virtual machine invocation.

Classes to represent a Java method as a control flow graph of basic blocks. A basic block is a sequence of code that is entered only in once place (e.g. the target of a branch statement) and is exited at only one place (e.g. a branch statement). Each basic block consists of an expression tree. There are also classes to represent try-catch blocks, Java subroutines (finally blocks), certain properties of the control flow graph such as its dominator tree, and to visualize a control flow graph.

Generates Java bytecodes from the contents of a control flow graph. It also performs "register" allocation of the local variables inside the virtual machine.

Repositories for important BLOAT objects such as the Editor, ClassHierarchy, and FlowGraphs. In order to avoid build dependencies with other packages we took the novel approach of having a "context" interface in several packages that the classes in this package then implement.

The reason we implement all of the methods in one class is so that if the user wants to have different contexts with different attributes (for instance, caching policies), all one has to do is subclass BloatContext instead of subclassing other contextes which may become ackward.

Contains a program that decorates a Java classfile with opcodes used in a persistent Java virtual machine.

Performs demand-driven induction variable analysis on a Java classfile.

Contains a program that prints the contents of a Java classfile to the console.

Allows classes, methods, and fields to be edited. In addition, the representation of bytecodes (JVM instructions) is refined. Types, opcodes, local variables, and special instrcution operands are introduced.

Allows access to Java classes stored in files on disk. Many of these classes implement the interfaces found in the EDU.purdue.cs.bloat.reflect package. Classes are loaded from a file and things such as constant values, methods, code, debugging information, and exceptions are modeled.

Classes for performing method inlining. The first step in method ininling is to create the call graph for a Java "program". Rapid Type Analysis [Bacon 1997] is used to keep the size of the call graph managable. RTA uses the class hierarchy to determine all possible methods that may be invoked at a given call site. Methods are only considered to be live if their class is instantiated somewhere in the program.

Call sites are specialized using the resolves-to information supplied by the call graph. Each virtual method call is transformed into a "switch" statement on the possible receiver types. The receiver is cast to a given type and a static method is invoked in place of the virtual method.

Contains a program that optimizes Java classes.

Provides an abstract API for working with Java classfiles. In this package, names and types are represent by indices into the constant pool. Modifier flags, the constant pool, exception handlers, and debugging information are also modeled directly in this package. The classes and interfaces in this package exist to give an opaque and abstract view of the underlying representation of the Java class.

Contains a program that performs array initialization compaction on a Java classfile in attempts to make it smaller.

Converts a control flow graph into static single assignment (SSA) form. In SSA form, each variable in the method has a number associated with it. Each target of an assignment statement is assigned a new number. Subsequent uses of that variable are assigned the same number. Thus, we have a compact form of definition-use information. Many of the optimiations we do take advantage of SSA form.

Contains a program that removes non-vital information (such as debugging information) from a Java classfile in an attempt to make it smaller.

Performs type-base alias analysis (TBAA) on a control flow graph. Type-based alias analysis considers the types of variables when deciding whether or not two variable can refer to the same object. Before TBAA can occur, the types of variables are inferred. Type inference requires information about the class hierarchy of classes being BLOATed.

Performs transformations (optimizations) on a control flow graph. There are several optimizations performed by classes in this package. Older Java compilers produced poor code for initializing arrays. BLOAT can replace this poor code with more efficient code by loading the array from the constant pool. Dead code elimination removes code from a method that does not contribute to the final output of the program.

Value numbering associates a number with each expression such that if two expressions have the same number, they have the same value. A value folder is then used to eliminate redundent nodes from and to propagate constants through the control flow graph.

Constant propagation removes unnecessary assignments by replacing variables that are assigned constant values with those values. Copy propagation removes unnecessary assignments to varibles to other variables.

BLOAT was designed to optimize classes that were to be run inside a persistent system that required special opcodes to perform operation such as checking an object cache for a certain resident object. The analysis that BLOAT does can eliminate some of these checks.

SSA-based partial redundency elimination (PRE) of expressions and access paths can also be performed on a control flow graph. If a calculation is redundent along one control flow path leading to a merge point, PRE computes it once along all paths, assigns the result to a variable, and replaces further occurrences of the calculation with that variable. This way, the expression is only computed once along any given control flow path.

Finally, peephole optimizations are performed on Java bytecode. For instance, a push instruction followed by a pop instruction is useless and can be removed. Additionally, unreachable code is removed from the method.

This package also contains several auxiliary classes that perform operations like determining whether or not an expression has side effects and comparing two nodes.

The classes necessary to create and represent a Java method as an expression tree. The nodes of the tree model various operations (arithmetic operations, method calls, exceptions being thrown, etc.) performed by a method. There are also classes that let you visit and operate on the tree.

Contains a number of utility classes used by BLOAT. BLOAT uses several utility classes such as a directed graph and an immutatable iterator to get its work done.