OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

260
ceptions continue to identify the correct locations within the code stream once a rule
has been applied to it.
Retaining the correct branch and exception semantics is accomplished within the
class file mutator by representing the bytecode stream as an ordered list of instruction
objects rather than a sequence of bytes. When the code stream is translated into a
list, all branch targets are expressed as pointers to other objects in the list rather
than as offsets within the code stream. The multicode substitution is performed
on the list representation. Once the substitution is complete, the bytecode stream
is generated from the list representation by performing two passes. The first pass
determines the program counter value for each of the instructions, including any pad
bytes that need to be introduced within tableswitch and lookupswitch bytecodes.
The bytecode stream is generated during the second pass. At that time, the branch
targets expressed as pointers are replaced with the difference between the program
counter of the current instruction and the instruction that is the target of the branch.
Entries in the exception table are handled in a similar manner. Items in the
exception table are converted from program counter values to pointers into the list
of bytecodes immediately after the list representation is generated. The program
counter representation of the exception table is regenerated immediately after the list
of bytecodes is converted back into a byte stream. Consequently, appropriate changes
will be made to the program counter values specified in the exception table for any
changes made to the bytecode list.
Care is taken to ensure that the pointers to entries in the list of bytecodes remain
valid as the list is manipulated. When despecializations are performed the internal
operations do not deallocate the bytecode object representing the specialized bytecode
and then allocate a new bytecode object to represent its general purpose form.
Instead, the opcode and operand values of the bytecode object are modified so that
the object represents the equivalent general purpose form. If the general purpose
form is a sequence of bytecodes then new bytecode objects are allocated to represent
the bytecodes in the sequence beyond the first. Performing the manipulation in this
manner removes the need to update any pointers in other data structures because the
object that was the specialized bytecode before the transformation is the first (and
possibly only) bytecode in the despecialized form after the despecialization.
A similar strategy is employed for multicode substitution. In this case, the objects
representing the second bytecode in the sequence and beyond are deallocated. It was
determined that none of these bytecodes are targets of any branches or exception
handlers before the substitution process began. Consequently, it is guaranteed that