org.jikesrvm.osr
Class BytecodeTraverser

java.lang.Object
  org.jikesrvm.osr.BytecodeTraverser

All Implemented Interfaces:

BytecodeConstants, ClassLoaderConstants, OSRConstants, SizeConstants

public class BytecodeTraverser
extends Object
implements BytecodeConstants, ClassLoaderConstants, OSRConstants

BytecodeTraverser does depth first search on a bytecode array, determines the type information of locals and stacks at Interesting point.

This class only intends to provide type information for on-stack replacement, which needs to know the type of a value. This class can only tells basic type information such as : REFERENCE, LONG, DOUBLE, FLOAT, INT, and ReturnAddress. Not like GCMap which tells GC a value is REFERENCE or NON-REFERENCE we also want to know it is INT or DOUBLE, and takes two words value or one word.

The produced type information has to be adjusted by consulting GC maps because two different types may merge at one program point (REF and non-REF types). Bytecode verifier will make the type info undefined in that case. But this class won't know. So the caller should check the GC map to validate a REF type variable.

More or less, this class needs to do the same work as a bytecode verifier, which tells the type and size of each locals and stacks. The JSR/RET instructions pose the difficulty to our case. However, we can assume the bytecode is verified. We use following assumptions:

1. After JSR, the stack was not changed, only local variable type needs to merge with FINALLY clause.
2. We need program-point specific stack type, but only need the summary of local types. Thus, after analysis, local types are same for all PCs.

retaddr

private int[] retaddr

addr

private int addr

visitedpc

private byte[] visitedpc

TRACE

private boolean TRACE

ignoreGotos

private boolean ignoreGotos

bytecodes

private BytecodeStream bytecodes

ltypes

private byte[] ltypes

stypes

private byte[] stypes

BytecodeTraverser

public BytecodeTraverser()

computeLocalStackTypes

public boolean computeLocalStackTypes(NormalMethod method,
                                      int bcpoint)

Computes types of local variable and stack slots at an interesting point for future querying. Computing type info and retrieval should not be reentered. The type info of local variable is not accurate about reference types, see JVM SPEC (2nd edition) p 146. The caller can consult GC map to verify if a local is a reference or not.

Parameters:

method - whose bytecode to be queried

bcpoint - the bytecode index which is the interesting point at the mean time, we only support one PC.

Returns:

whether the pc is a valid program point of the method

getLocalTypes

public byte[] getLocalTypes()

Returns an array of type information of locals at the registered program point. The size of array is fixed by MAX_LOCALS, the type descriptor can be found in "ClassLoadConstants.java".

Returns:

an array of type information, or null

getStackTypes

public byte[] getStackTypes()

Returns an array of type information of stacks at a program point. The size of array is fixed by MAX_STACKS, the type descriptor can be found in "ClassLoadConstants.java".

Returns:

an array of type information, or null

computeStackHeights

public void computeStackHeights(NormalMethod method,
                                BytecodeStream bcodes,
                                int[] stackHeights,
                                boolean adjustExptable)

prologueStackHeights

public void prologueStackHeights(NormalMethod method,
                                 BytecodeStream bcodes,
                                 int[] stackHeights)

Compute stack heights of bytecode stream (used for osr prologue)

getReturnCodeFromSignature

private byte getReturnCodeFromSignature(String sig)

scanBlocks

private boolean scanBlocks(NormalMethod method,
                           BytecodeStream bytecodes,
                           boolean doDFS,
                           int pcs,
                           byte[] ltypes,
                           byte[] stypes,
                           int startpc,
                           TypeStack S,
                           int[] stackHeights)