org.jikesrvm.compilers.baseline
Class ReferenceMaps

java.lang.Object
  org.jikesrvm.compilers.baseline.ReferenceMaps

All Implemented Interfaces:

ArchitectureSpecific.BaselineConstants, Constants, HeapLayoutConstants, ArchConstants, BaselineConstants, RegisterConstants, StackframeLayoutConstants, TrapConstants, ThinLockConstants, TIBLayoutConstants, SizeConstants

public final class ReferenceMaps
extends Object
implements ArchitectureSpecific.BaselineConstants

class that provides stack (and local var) map for a baseline compiled method GC uses the methods provided here

JSR_MASK

public static final byte JSR_MASK

See Also:

Constant Field Values

JSR_INDEX_MASK

public static final byte JSR_INDEX_MASK

See Also:

Constant Field Values

STARTINDEX

public static final int STARTINDEX

See Also:

Constant Field Values

NOMORE

public static final int NOMORE

See Also:

Constant Field Values

jsrLock

public static final SpinLock jsrLock

Serializes JSR processing

BITS_PER_MAP_ELEMENT

private static final int BITS_PER_MAP_ELEMENT

Number of bits in each map element

See Also:

Constant Field Values

referenceMaps

private byte[] referenceMaps

MCSites

private int[] MCSites

bitsPerMap

private final int bitsPerMap

Number of bits in each map

mapCount

private int mapCount

Number of maps

jsrInfo

private JSRInfo jsrInfo

ReferenceMaps

ReferenceMaps(BaselineCompiledMethod cm,
              int[] stackHeights,
              byte[] localTypes)

bytesPerMap

private int bytesPerMap()

size of individul maps

locateGCPoint

public int locateGCPoint(Offset machCodeOffset,
                         RVMMethod method)

Given a machine code instruction offset, return an index to identify the stack map closest to the offset ( but not beyond) Usage note: "machCodeOffset" must point to the instruction *following* the actual instruction whose stack map is sought. This allows us to properly handle the case where the only address we have to work with is a return address (ie. from a stackframe) or an exception address (ie. from a null pointer dereference, array bounds check, or divide by zero) on a machine architecture with variable length instructions. In such situations we'd have no idea how far to back up the instruction pointer to point to the "call site" or "exception site". If the located site is within the scope of a jsr subroutine the index value returned is a negative number

getNextRefIndex

public int getNextRefIndex(int index,
                           int siteindex)

Parameters:

index - offset in the reference stack frame,

siteindex - index that indicates the callsite (siteindex),

Returns:

return the offset where the next reference can be found.

getNextJSRRefIndex

public int getNextJSRRefIndex(int index)

Parameters:

index - offset in the JSR reference map,

Returns:

The offset where the next reference can be found.

getNextJSRReturnAddrIndex

public int getNextJSRReturnAddrIndex(int index)

Given an offset in the jsr returnAddress map, return the offset where the next returnAddress can be found. NOTE: there is only one jsr returnAddress map for the entire method because it has to be be constructed a GC time and would normally require additional storage. To avoid this, the space for one map is pre-allocated and the map is built in that space. When multiple threads exist and if GC runs in multiple threads concurrently, then the MethodMap must be locked when a jsr map is being scanned. This shoulkd be a low probability event. NOTE: return addresses are handled separately from references because they point inside an object ( internal pointers) Return NOMORE when no more pointers can be found

getStackDepth

public int getStackDepth(int mapid)

For debugging (used with CheckRefMaps) Note: all maps are the same size

size

public int size()

startNewMaps

public void startNewMaps(int gcPointCount,
                         int jsrCount,
                         int parameterWords)

start setting up the reference maps for this method.

recordStkMap

public void recordStkMap(int byteindex,
                         byte[] byteMap,
                         int BBLastPtr,
                         boolean replacemap)

Given the information about a GC point, record the information in the proper tables The information is the following the index in the bytecode of this site, a byte array that describes the contents of the local variables and the java stack, the last offset of a byte that contains information about the map, a boolean to indicate that this map is a replacement for a currently existing map.

recordJSRSubroutineMap

public void recordJSRSubroutineMap(int byteindex,
                                   byte[] currReferenceMap,
                                   int BBLastPtr,
                                   int returnAddrIndex,
                                   boolean replacemap)

Record a map for a point within a JSR Subroutine. This requires setting up one of the unusual maps.

Parameters:

byteindex - index into the byte code array of the point for the map

currReferenceMap - map of references and return addresses that were set within the JSR Subroutine

BBLastPtr - map runs from -1 to BBLastPtr inclusively

returnAddrIndex - Index in the stack where the return address for the jsr routine (in which this gcpoint is located) can be found

replacemap - False if this is the first time this map point has been recorded.

addUnusualMap

private int addUnusualMap(UnusualMaps jsrSiteMap)

Add an UnusualMap to the array of unusual maps, expand the array and referencemap array if necessary

Parameters:

jsrSiteMap - unusualMap to be added to array

setupJSRSubroutineMap

public int setupJSRSubroutineMap(int mapid)

Setup a map within a JSR Subroutine. This requires using up one of the unusual maps. This routine is called when the caller gets a negative mapindex value return from locateGCPoint(org.vmmagic.unboxed.Offset, org.jikesrvm.classloader.RVMMethod). This routine searches the map tables and uses its stack frameAddress input to build reference and returnAddress maps. The caller uses the getNext... routines to scan these maps for offsets in the frame of the related references.

Parameters:

mapid - Index of map of instruction where map is required ( this value was returned by locateGCpoint) steps for this routine use the mapid to get index of the Unusual Map from the unusual map and the frame - get the location of the jsr invoker from the invoker address and the code base address - get the machine code offset from the machine code offset locate the map for that instruction if the invoker was itself in a jsr- merge the delta maps of each jsr and compute the new total delta maps else the invoker was not already in a jsr merge the unusual map differences with the invoker map

getNextJSRAddressIndex

public int getNextJSRAddressIndex(Offset nextMachineCodeOffset,
                                  NormalMethod m)

recordingComplete

public void recordingComplete()

Called when all the recording for this map is complete. Can now sort or perform other cleanups

translateByte2Machine

public void translateByte2Machine(int[] b2m)

After code is generated, translate the bytecode indices recorded in MCSites array into real machine code offsets.

convertMapElement

private byte convertMapElement(byte[] curBBMap,
                               int offset,
                               int len,
                               byte reftype)

convert a portion of an array word of Bytes into a bitmap of references ie given a byte array, a starting offset in the array, the length to scan, and the type of byte to scan for ... convert the area in the array to a word of bits ... max length is 31 ie BITS_PER_MAP_ELEMENT

getNextMapElement

private int getNextMapElement()

get Next free word in referencemaps for gc call sites

scanForNextRef

private int scanForNextRef(int bitnum,
                           int wordnum,
                           int remaining,
                           byte[] map)

given a starting bitnumber in a map, the index of the corresponding byte, and the remaining number of bits in the map, this routine scans forward to find the next ref in the map (inclusive search ie include bitnum)

scanByte

private int scanByte(int bitnum,
                     int bytenum,
                     int toscan,
                     byte[] map)

given a bitnumber in a map, the index of the corresponding map byte, and the remaining number of bits in the byte, this routine scans forward to find the next ref in the byte or return zero if not found

scanByteArray

int scanByteArray(byte[] byteMap,
                  int BBLastPtr,
                  byte refType,
                  int mapslot,
                  boolean skipOneBit)

given a bytearray where each byte describes the corresponding word on a stack, the length of the byte array, and the type of information that is desired to be scanned this subroutine scans the byte array looking for the type of information requested and builds a bit array in the stack maps with the information Skip one bits in the bitarray if skipOnBit is true - we need to skip one bit for setRef and setNonRef maps so they are properly merged with jsr base maps. However, we leave the retAddrMap alone. it returns the index of the map in the reference map

unusualMapcopy

private void unusualMapcopy(UnusualMaps from)

subroutine to deep copy an UnusualMap into the jsrInfo.extraUnusualMap

copyBitMap

private void copyBitMap(int extramapindex,
                        int index)

subroutine to copy a bitmap into the extra unusualmap inputs the index of the map in the jsrInfo.extraUnusualMap ie the "to" map the index of the map to copy ie the "from" map mapid is used to get the length of the map output is in the extraunusual map

combineDeltaMaps

private UnusualMaps combineDeltaMaps(int jsrUnusualMapid)

merge unusual maps- occurs in nested jsr conditions merge each nested delta map ( as represented by the jsrMapid of the location site) into the jsrInfo.extraUnusualMap where the deltas are accumulated NOTE: while the routine is written to combine 2 jsrInfo.unusualMaps in general in reality the target map is always the same ( the jsrInfo.extraUnusualMap)

mergeMap

private void mergeMap(int targetindex,
                      int deltaindex,
                      ReferenceMaps.MergeOperation Op)

Merge a delta map (as represented by its index in the referencemap table) into a target map (similarly represented) and use the operation indicated ( OR or NAND or COPY)

finalMergeMaps

private void finalMergeMaps(int jsrBaseMapIndex,
                            UnusualMaps deltaMap)

This method will merge the jsr invoker's base map with changes due to *all* nested jsr subroutines.

The nested jsr subroutine maps were merged into a single delta map prior to the calling of this method. We therefore know that the base map can never be due to a subroutine (since all subroutines have been merged), and therefore that there are no return address maps due to the invoker (since return addresses are only due to the subroutine maps).

Parameters:

jsrBaseMapIndex - The map index for the invoker

deltaMap - The map for the invoked subroutine/s (all nested subroutine maps are guaranteed to have been combined prior to calling this)

cleanupPointers

public void cleanupPointers()

This routine is used to clean out the MethodMap of structures that were allocated from temporary storage. Temporary storage is freed up between stack frames as the GC scans the stack.

findUnusualMap

int findUnusualMap(int mapid)

This routine is used to find an Unusual map with an index greater than 127 it returns the index by doing a sequential scan and looking for the mapid in the normal map directory

showInfo

public void showInfo()

show the basic information for each of the maps this is for testing use

showAMap

public void showAMap(int MCSiteIndex)

Show the basic information for a single map. This is for testing use.

showOffsets

public void showOffsets()

Show the offsets for all the maps. This is for test use.

showReferenceMapStatistics

public int showReferenceMapStatistics(RVMMethod method)

isLocalRefType

public boolean isLocalRefType(RVMMethod method,
                              Offset mcoff,
                              int lidx)

Query if a local variable has a reference type value

Parameters:

method - The method we're asking about.

mcoff - The machine code offset of the instruction *following* the actual instruction.

lidx - the local index

Returns:

true, if it is a reference type false, otherwise