JavaHeader (Jikes RVM API)

java.lang.Object
- org.jikesrvm.objectmodel.JavaHeader

```
public class JavaHeader
extends Object
```
Defines the JavaHeader portion of the object header for the default JikesRVM object model. The default object model uses a two word header.
One word holds a TIB pointer.
The other word ("status word") contains an inline thin lock, either the hash code or hash code state, and a few unallocated bits that can be used for other purposes. If JavaHeaderConstants.ADDRESS_BASED_HASHING is false, then to implement default hashcodes, Jikes RVM uses a 10 bit hash code that is completely stored in the status word, which is laid out as shown below:
```
      TTTT TTTT TTTT TTTT TTTT HHHH HHHH HHAA
 T = thin lock bits
 H = hash code
 A = available for use by GCHeader and/or MiscHeader.
 
```
If ADDRESS_BASED_HASHING is true, then Jikes RVM uses two bits of the status word to record the hash code state in a typical three state scheme (JavaHeaderConstants.HASH_STATE_UNHASHED, JavaHeaderConstants.HASH_STATE_HASHED, and JavaHeaderConstants.HASH_STATE_HASHED_AND_MOVED). In this case, the status word is laid out as shown below:
```
      TTTT TTTT TTTT TTTT TTTT TTHH AAAA AAAA
 T = thin lock bits
 H = hash code state bits
 A = available for use by GCHeader and/or MiscHeader.
 
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALIGNMENT_VALUE` The alignment value
`protected static int`	`ARRAY_HEADER_SIZE`
`protected static Offset`	`AVAILABLE_BITS_OFFSET`
`protected static Word`	`HASH_CODE_MASK`
`protected static int`	`HASH_CODE_SHIFT`
`protected static Word`	`hashCodeGenerator`
`static int`	`LOG_MIN_ALIGNMENT`
`static int`	`NUM_THIN_LOCK_BITS` How many bits are allocated to a thin lock?
`static int`	`OBJECT_REF_OFFSET` offset of object reference from the lowest memory word
`protected static int`	`SCALAR_HEADER_SIZE`
`protected static Offset`	`STATUS_OFFSET`
`static int`	`THIN_LOCK_DEDICATED_U16_OFFSET` How many bytes do we have to offset to get to the high locking bits
`static int`	`THIN_LOCK_DEDICATED_U16_SHIFT` How many bits do we have to shift to only hold the high locking bits
`static int`	`THIN_LOCK_SHIFT` How many bits to shift to get the thin lock?
`protected static Offset`	`TIB_OFFSET`

Constructor Summary

Constructors
Constructor and Description

JavaHeader()

Constructors
Constructor and Description
`JavaHeader()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`allocateThinLock(RVMType t)` Allocates a thin lock word for instances of the type (if they already have one, then has no effect).
`static boolean`	`attemptAvailableBits(Object o, Word oldVal, Word newVal)` An attempt on the word containing the available bits.
`static int`	`bytesRequiredWhenCopied(Object fromObj, RVMArray type, int numElements)` how many bytes are needed when the array object is copied by GC?
`static int`	`bytesRequiredWhenCopied(Object fromObj, RVMClass type)`
`static int`	`bytesUsed(Object obj, RVMArray type, int numElements)` how many bytes are used by the array object?
`static int`	`bytesUsed(Object obj, RVMClass type)`
`static int`	`computeArrayHeaderSize(RVMArray type)` Computes the header size of an instance of the given type.
`static int`	`computeScalarHeaderSize(RVMClass type)` Computes the header size of an instance of the given type.
`static Offset`	`defaultThinLockOffset()`
`static void`	`dumpHeader(Object ref)` For low level debugging of GC subsystem.
`static void`	`genericLock(Object o)`
`static void`	`genericUnlock(Object o)`
`static int`	`getAlignment(RVMArray t)`
`static int`	`getAlignment(RVMArray t, Object obj)`
`static int`	`getAlignment(RVMClass t)`
`static int`	`getAlignment(RVMClass t, Object obj)`
`static ObjectReference`	`getArrayFromStartAddress(Address start)` Gets an object reference from the address the lowest word of the object was allocated.
`static int`	`getHeaderEndOffset()`
`static Lock`	`getHeavyLock(Object o, boolean create)` Obtains the heavy-weight lock, if there is one, associated with the indicated object.
`protected static ObjectReference`	`getNextObject(ObjectReference obj, int size)` Get the next object in the heap under contiguous allocation.
`static ObjectReference`	`getNextObject(ObjectReference obj, RVMArray type, int numElements)` Get the next array in the heap under contiguous allocation.
`static ObjectReference`	`getNextObject(ObjectReference obj, RVMClass type)` Get the next object in the heap under contiguous allocation.
`static Address`	`getObjectEndAddress(Object obj, RVMArray type, int numElements)` What is the first word after the array?
`static Address`	`getObjectEndAddress(Object obj, RVMClass type)` What is the first word after the class?
`static ObjectReference`	`getObjectFromStartAddress(Address start)` Get an object reference from the address the lowest word of the object was allocated.
`static int`	`getObjectHashCode(Object o)`
`static int`	`getOffsetForAlignment(RVMArray t, boolean needsIdentityHash)`
`static int`	`getOffsetForAlignment(RVMArray t, ObjectReference obj)`
`static int`	`getOffsetForAlignment(RVMClass t, boolean needsIdentityHash)`
`static int`	`getOffsetForAlignment(RVMClass t, ObjectReference obj)`
`static Address`	`getPointerInMemoryRegion(ObjectReference ref)` Given a reference, return an address which is guaranteed to be inside the memory region allocated to the object.
`protected static Object`	`getReferenceWhenCopiedTo(Object obj, Address to)`
`static Object`	`getReferenceWhenCopiedTo(Object obj, Address to, RVMArray type)` Gets the reference of an array when copied to the specified region.
`static Object`	`getReferenceWhenCopiedTo(Object obj, Address to, RVMClass type)` Get the reference of a scalar when copied to the specified region.
`static ObjectReference`	`getScalarFromStartAddress(Address start)` Gets an object reference from the address the lowest word of the object was allocated.
`static Offset`	`getThinLockOffset(Object o)`
`static TIB`	`getTIB(Object o)`
`static Offset`	`getTibOffset()`
`static boolean`	`holdsLock(Object obj, RVMThread thread)`
`static Object`	`initializeArrayHeader(Address ptr, TIB tib, int size)` Perform any required initialization of the JAVA portion of the header.
`static Address`	`initializeArrayHeader(BootImageInterface bootImage, Address ptr, TIB tib, int size, int numElements, boolean needsIdentityHash, int identityHashValue)` Perform any required initialization of the JAVA portion of the header.
`static void`	`initializeAvailableByte(Object o)` Freezes the other bits in the byte containing the available bits so that it is safe to update them using setAvailableBits.
`static Object`	`initializeScalarHeader(Address ptr, TIB tib, int size)` Perform any required initialization of the JAVA portion of the header.
`static Address`	`initializeScalarHeader(BootImageInterface bootImage, Address ptr, TIB tib, int size, boolean needsIdentityHash, int identityHashValue)` Perform any required initialization of the JAVA portion of the header.
`protected static int`	`installHashCode(Object o)`
`static Address`	`maximumObjectRef(Address regionHighAddr)` Given the largest base address in a region, return the largest object reference that could refer to an object in the region.
`static Address`	`minimumObjectRef(Address regionBaseAddr)` Given the smallest base address in a region, return the smallest object reference that could refer to an object in the region.
`static int`	`minimumObjectSize()` How small is the minimum object header size?
`static Object`	`moveObject(Address toAddress, Object fromObj, int numBytes, RVMArray type)` Copies an array to the given raw storage address.
`static Object`	`moveObject(Address toAddress, Object fromObj, int numBytes, RVMClass type)` Copy a scalar to the given raw storage address.
`static Object`	`moveObject(Address toAddress, Object fromObj, Object toObj, int numBytes)` Copies an object to the given raw storage address.
`static Object`	`moveObject(Object fromObj, Object toObj, int numBytes, RVMArray type)` Copies an array to the given location.
`static Object`	`moveObject(Object fromObj, Object toObj, int numBytes, RVMClass type)` Copies a scalar to the given location.
`static int`	`objectStartOffset(RVMClass klass)` What is the offset of the first word of the class?
`static Address`	`objectStartRef(ObjectReference obj)` Maps from the object ref to the lowest address of the storage associated with the object.
`static Word`	`prepareAvailableBits(Object o)` A prepare on the word containing the available bits.
`static Word`	`readAvailableBitsWord(Object o)` Non-atomic read of word containing available bits
`static byte`	`readAvailableByte(Object o)` Non-atomic read of byte containing available bits
`static void`	`setAvailableBit(Object o, int idx, boolean flag)` Sets argument bit to 1 if value is true, 0 if value is false
`static void`	`setTIB(BootImageInterface bootImage, Address refOffset, Address tibAddr, RVMType type)` Sets the TIB for an object during bootimage writing.
`static void`	`setTIB(Object ref, TIB tib)` Sets the TIB for an object.
`static boolean`	`testAvailableBit(Object o, int idx)`
`static void`	`writeAvailableBitsWord(Object o, Word val)` Non-atomic write of word containing available bits.
`static void`	`writeAvailableByte(BootImageInterface bootImage, Address ref, byte val)` Non-atomic write of word containing available bits
`static void`	`writeAvailableByte(Object o, byte val)` Non-atomic write of byte containing available bits

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - SCALAR_HEADER_SIZE
```
protected static final int SCALAR_HEADER_SIZE
```
  - ARRAY_HEADER_SIZE
```
protected static final int ARRAY_HEADER_SIZE
```
  - OBJECT_REF_OFFSET
```
public static final int OBJECT_REF_OFFSET
```
    offset of object reference from the lowest memory word
  - TIB_OFFSET
```
protected static final Offset TIB_OFFSET
```
  - STATUS_OFFSET
```
protected static final Offset STATUS_OFFSET
```
  - AVAILABLE_BITS_OFFSET
```
protected static final Offset AVAILABLE_BITS_OFFSET
```
  - HASH_CODE_SHIFT
```
protected static final int HASH_CODE_SHIFT
```
    See Also:
    
    Constant Field Values
  - HASH_CODE_MASK
```
protected static final Word HASH_CODE_MASK
```
  - hashCodeGenerator
```
protected static Word hashCodeGenerator
```
  - NUM_THIN_LOCK_BITS
```
public static final int NUM_THIN_LOCK_BITS
```
    How many bits are allocated to a thin lock?
  - THIN_LOCK_SHIFT
```
public static final int THIN_LOCK_SHIFT
```
    How many bits to shift to get the thin lock?
  - THIN_LOCK_DEDICATED_U16_OFFSET
```
public static final int THIN_LOCK_DEDICATED_U16_OFFSET
```
    How many bytes do we have to offset to get to the high locking bits
    
    See Also:
    
    Constant Field Values
  - THIN_LOCK_DEDICATED_U16_SHIFT
```
public static final int THIN_LOCK_DEDICATED_U16_SHIFT
```
    How many bits do we have to shift to only hold the high locking bits
    
    See Also:
    
    Constant Field Values
  - ALIGNMENT_VALUE
```
public static final int ALIGNMENT_VALUE
```
    The alignment value
    
    See Also:
    
    Constant Field Values
  - LOG_MIN_ALIGNMENT
```
public static final int LOG_MIN_ALIGNMENT
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - JavaHeader
```
public JavaHeader()
```
- Method Detail
  - getTibOffset
```
public static Offset getTibOffset()
```
    Returns:
    
    the TIB offset.
  - getObjectEndAddress
```
public static Address getObjectEndAddress(Object obj,
                                          RVMClass type)
```
    What is the first word after the class?
    
    Parameters:
    
    obj - the object in question
    
    type - the object's class
    
    Returns:
    
    first word after the scalar object
  - getObjectEndAddress
```
public static Address getObjectEndAddress(Object obj,
                                          RVMArray type,
                                          int numElements)
```
    What is the first word after the array?
    
    Parameters:
    
    obj - the object in question
    
    type - the object's class
    
    numElements - the number of elements in the array
    
    Returns:
    
    the first word after the array
  - objectStartOffset
```
public static int objectStartOffset(RVMClass klass)
```
    What is the offset of the first word of the class?
    
    Parameters:
    
    klass - unused
    
    Returns:
    
    offset of the first word of the class from the object reference
  - getHeaderEndOffset
```
public static int getHeaderEndOffset()
```
    Returns:
    
    offset of the last word of the header from an out-to-in perspective
  - minimumObjectSize
```
public static int minimumObjectSize()
```
    How small is the minimum object header size? Can be used to pick chunk sizes for allocators.
    
    Returns:
    
    the minimum object size
  - getPointerInMemoryRegion
```
public static Address getPointerInMemoryRegion(ObjectReference ref)
```
    Given a reference, return an address which is guaranteed to be inside the memory region allocated to the object.
    
    Parameters:
    
    ref - an object reference
    
    Returns:
    
    an address inside the object's memory
  - getTIB
```
public static TIB getTIB(Object o)
```
    Parameters:
    
    o - an object
    
    Returns:
    
    the TIB for an object.
  - setTIB
```
public static void setTIB(Object ref,
                          TIB tib)
```
    Sets the TIB for an object.
    
    Parameters:
    
    ref - the object
    
    tib - the TIB to set for the object
  - setTIB
```
public static void setTIB(BootImageInterface bootImage,
                          Address refOffset,
                          Address tibAddr,
                          RVMType type)
```
    Sets the TIB for an object during bootimage writing.
    
    Parameters:
    
    bootImage - the bootimage
    
    refOffset - the object's address in the bootimage
    
    tibAddr - the TIB's address in the bootimage
    
    type - the object's type
  - bytesRequiredWhenCopied
```
public static int bytesRequiredWhenCopied(Object fromObj,
                                          RVMClass type)
```
    Parameters:
    
    fromObj - the object to copy
    
    type - the object's type
    
    Returns:
    
    number of needed bytes when the scalar object is copied by GC
  - bytesUsed
```
public static int bytesUsed(Object obj,
                            RVMClass type)
```
    Parameters:
    
    obj - the object
    
    type - the object's type
    
    Returns:
    
    number of bytes are used by the scalar object
  - bytesRequiredWhenCopied
```
public static int bytesRequiredWhenCopied(Object fromObj,
                                          RVMArray type,
                                          int numElements)
```
    how many bytes are needed when the array object is copied by GC?
    
    Parameters:
    
    fromObj - the object to copy
    
    type - the object's type
    
    numElements - the array length
    
    Returns:
    
    the number of bytes that are required for the copy
  - bytesUsed
```
public static int bytesUsed(Object obj,
                            RVMArray type,
                            int numElements)
```
    how many bytes are used by the array object?
    
    Parameters:
    
    obj - the object to copy
    
    type - the object's type
    
    numElements - the array length
    
    Returns:
    
    the number of bytes that the array uses
  - objectStartRef
```
public static Address objectStartRef(ObjectReference obj)
```
    Maps from the object ref to the lowest address of the storage associated with the object.
    
    Parameters:
    
    obj - the object reference
    
    Returns:
    
    the lowest address in the object's memory region
  - getObjectFromStartAddress
```
public static ObjectReference getObjectFromStartAddress(Address start)
```
    Get an object reference from the address the lowest word of the object was allocated. In general this required that we are using a dynamic hash offset or not using address based hashing. However, the GC algorithm could safely do this in the nursery so we can't assert DYNAMIC_HASH_OFFSET.
    
    Parameters:
    
    start - the lowest word in the storage of an allocated object
    
    Returns:
    
    the object reference for the object
  - getScalarFromStartAddress
```
public static ObjectReference getScalarFromStartAddress(Address start)
```
    Gets an object reference from the address the lowest word of the object was allocated.
    
    Parameters:
    
    start - the lowest word in the storage of an allocated object
    
    Returns:
    
    the object reference for the object
  - getArrayFromStartAddress
```
public static ObjectReference getArrayFromStartAddress(Address start)
```
    Gets an object reference from the address the lowest word of the object was allocated.
    
    Parameters:
    
    start - the lowest word in the storage of an allocated object
    
    Returns:
    
    the object reference for the object
  - getNextObject
```
protected static ObjectReference getNextObject(ObjectReference obj,
                                               int size)
```
    Get the next object in the heap under contiguous allocation. Handles alignment issues only when there are no GC or Misc header words. In the case there are we probably have to ask MemoryManager to distinguish this for us.
    
    Parameters:
    
    obj - the present object
    
    size - the object's size
    
    Returns:
    
    the next object, provided that the constraints from above are met
  - getNextObject
```
public static ObjectReference getNextObject(ObjectReference obj,
                                            RVMClass type)
```
    Get the next object in the heap under contiguous allocation. Handles alignment issues.
    
    Parameters:
    
    obj - the current object, which must be a scalar
    
    type - the object's type
    
    Returns:
    
    the next scalar object in the heap
  - getNextObject
```
public static ObjectReference getNextObject(ObjectReference obj,
                                            RVMArray type,
                                            int numElements)
```
    Get the next array in the heap under contiguous allocation. Handles alignment issues.
    
    Parameters:
    
    obj - the current object, which must be an array
    
    type - the object's type
    
    numElements - the length of the array
    
    Returns:
    
    the next scalar object in the heap
  - getReferenceWhenCopiedTo
```
public static Object getReferenceWhenCopiedTo(Object obj,
                                              Address to,
                                              RVMArray type)
```
    Gets the reference of an array when copied to the specified region.
    
    Parameters:
    
    obj - the object to copy
    
    to - the target address for the copy
    
    type - the array's type
    
    Returns:
    
    the reference of the copy
  - getReferenceWhenCopiedTo
```
public static Object getReferenceWhenCopiedTo(Object obj,
                                              Address to,
                                              RVMClass type)
```
    Get the reference of a scalar when copied to the specified region.
    
    Parameters:
    
    obj - the object to copy
    
    to - the target address for the copy
    
    type - the scalar's type
    
    Returns:
    
    the reference of the copy
  - getReferenceWhenCopiedTo
```
protected static Object getReferenceWhenCopiedTo(Object obj,
                                                 Address to)
```
  - moveObject
```
public static Object moveObject(Address toAddress,
                                Object fromObj,
                                int numBytes,
                                RVMClass type)
```
    Copy a scalar to the given raw storage address.
    
    Parameters:
    
    toAddress - the target address
    
    fromObj - the object to copy
    
    numBytes - how many bytes to copy
    
    type - the scalar's type
    
    Returns:
    
    the reference for the object's copy
  - moveObject
```
public static Object moveObject(Object fromObj,
                                Object toObj,
                                int numBytes,
                                RVMClass type)
```
    Copies a scalar to the given location.
    
    Parameters:
    
    fromObj - the scalar to copy
    
    toObj - target address for copy
    
    numBytes - how many bytes to copy
    
    type - the scalar's type
    
    Returns:
    
    the reference for the object's copy
  - moveObject
```
public static Object moveObject(Address toAddress,
                                Object fromObj,
                                int numBytes,
                                RVMArray type)
```
    Copies an array to the given raw storage address.
    
    Parameters:
    
    toAddress - the target address
    
    fromObj - the object to copy
    
    numBytes - how many bytes to copy
    
    type - the array's type
    
    Returns:
    
    the reference for the object's copy
  - moveObject
```
public static Object moveObject(Object fromObj,
                                Object toObj,
                                int numBytes,
                                RVMArray type)
```
    Copies an array to the given location.
    
    Parameters:
    
    fromObj - the object to copy
    
    toObj - the target object
    
    numBytes - the number of bytes to copy
    
    type - the array's type
    
    Returns:
    
    the reference for the array's copy
  - moveObject
```
public static Object moveObject(Address toAddress,
                                Object fromObj,
                                Object toObj,
                                int numBytes)
```
    Copies an object to the given raw storage address.
    
    Parameters:
    
    toObj - the target object. If this is non-null, the target address must be Address.zero().
    
    toAddress - the target address. If this is not Address.zero(), the target object must be null.
    
    fromObj - the object to copy from
    
    numBytes - the number of bytes to copy
    
    Returns:
    
    the reference of the object's copy
  - getObjectHashCode
```
public static int getObjectHashCode(Object o)
```
  - installHashCode
```
protected static int installHashCode(Object o)
```
  - getThinLockOffset
```
public static Offset getThinLockOffset(Object o)
```
  - defaultThinLockOffset
```
public static Offset defaultThinLockOffset()
```
  - allocateThinLock
```
public static void allocateThinLock(RVMType t)
```
    Allocates a thin lock word for instances of the type (if they already have one, then has no effect).
    
    Parameters:
    
    t - the type that is supposed to receive a thin lock word
  - genericLock
```
public static void genericLock(Object o)
```
  - genericUnlock
```
public static void genericUnlock(Object o)
```
  - holdsLock
```
public static boolean holdsLock(Object obj,
                                RVMThread thread)
```
    Parameters:
    
    obj - an object
    
    thread - a thread
    
    Returns:
    
    true if the lock on obj is currently owned by thread false if it is not.
  - getHeavyLock
```
public static Lock getHeavyLock(Object o,
                                boolean create)
```
    Obtains the heavy-weight lock, if there is one, associated with the indicated object. Returns null, if there is no heavy-weight lock associated with the object.
    
    Parameters:
    
    o - the object from which a lock is desired
    
    create - if true, create heavy lock if none found
    
    Returns:
    
    the heavy-weight lock on the object (if any)
  - readAvailableBitsWord
```
public static Word readAvailableBitsWord(Object o)
```
    Non-atomic read of word containing available bits
    
    Parameters:
    
    o - the object to read
    
    Returns:
    
    the available bits word
  - readAvailableByte
```
public static byte readAvailableByte(Object o)
```
    Non-atomic read of byte containing available bits
    
    Parameters:
    
    o - the object to read
    
    Returns:
    
    the available bits bytes
  - writeAvailableBitsWord
```
public static void writeAvailableBitsWord(Object o,
                                          Word val)
```
    Non-atomic write of word containing available bits.
    
    Parameters:
    
    o - the object whose word will be written
    
    val - the available bits word
  - writeAvailableByte
```
public static void writeAvailableByte(BootImageInterface bootImage,
                                      Address ref,
                                      byte val)
```
    Non-atomic write of word containing available bits
    
    Parameters:
    
    bootImage - the bootimage
    
    ref - an object reference whose word will be written
    
    val - the available bits word
  - writeAvailableByte
```
public static void writeAvailableByte(Object o,
                                      byte val)
```
    Non-atomic write of byte containing available bits
    
    Parameters:
    
    o - the object whose available byte will be written
    
    val - the value to write to the available byte
  - testAvailableBit
```
public static boolean testAvailableBit(Object o,
                                       int idx)
```
    Parameters:
    
    o - the object whose bit will be tested
    
    idx - the index in the bits
    
    Returns:
    
    true if argument bit is 1, false if it is 0
  - setAvailableBit
```
public static void setAvailableBit(Object o,
                                   int idx,
                                   boolean flag)
```
    Sets argument bit to 1 if value is true, 0 if value is false
    
    Parameters:
    
    o - the object whose bit will be set
    
    idx - the index in the bits
    
    flag - true for 1, false for 0
  - initializeAvailableByte
```
public static void initializeAvailableByte(Object o)
```
    Freezes the other bits in the byte containing the available bits so that it is safe to update them using setAvailableBits.
    
    Parameters:
    
    o - the object whose available bytes will be initialized
  - prepareAvailableBits
```
public static Word prepareAvailableBits(Object o)
```
    A prepare on the word containing the available bits.
    Note: this method is intended to be used in conjunction with the attempt method.
    
    Parameters:
    
    o - the object which has the available bits
    
    Returns:
    
    the current value of the word
    
    See Also:
    
    attemptAvailableBits(Object, Word, Word)
  - attemptAvailableBits
```
public static boolean attemptAvailableBits(Object o,
                                           Word oldVal,
                                           Word newVal)
```
    An attempt on the word containing the available bits.
    Note: this method is intended to be used in conjunction with the prepare method. If the method returns false, callers must update their information about the old value of the available bits word before retrying again.
    
    Parameters:
    
    o - the object which has the available bits
    
    oldVal - the old value that the word is expected to have
    
    newVal - the new value that will be written, if possible
    
    Returns:
    
    whether the write occurred
  - minimumObjectRef
```
public static Address minimumObjectRef(Address regionBaseAddr)
```
    Given the smallest base address in a region, return the smallest object reference that could refer to an object in the region.
    
    Parameters:
    
    regionBaseAddr - the smallest base address in the region
    
    Returns:
    
    the smallest address in the region that could possibly refer to an object in the region
  - maximumObjectRef
```
public static Address maximumObjectRef(Address regionHighAddr)
```
    Given the largest base address in a region, return the largest object reference that could refer to an object in the region.
    
    Parameters:
    
    regionHighAddr - the highest base address in the region
    
    Returns:
    
    the largest address in the region that could possibly refer to an object in the region
  - computeScalarHeaderSize
```
public static int computeScalarHeaderSize(RVMClass type)
```
    Computes the header size of an instance of the given type.
    
    Parameters:
    
    type - the instance's type
    
    Returns:
    
    size of the head in bytes
  - computeArrayHeaderSize
```
public static int computeArrayHeaderSize(RVMArray type)
```
    Computes the header size of an instance of the given type.
    
    Parameters:
    
    type - the instance's type
    
    Returns:
    
    size of the head in bytes
  - getAlignment
```
public static int getAlignment(RVMClass t)
```
    Parameters:
    
    t - RVMClass instance being created
    
    Returns:
    
    the desired alignment of the alignment point returned by getOffsetForAlignment in instances of the argument RVMClass.
  - getAlignment
```
public static int getAlignment(RVMClass t,
                               Object obj)
```
    Parameters:
    
    t - RVMClass instance being copied
    
    obj - the object being copied
    
    Returns:
    
    the desired alignment of the alignment point returned by getOffsetForAlignment in instances of the argument RVMClass.
  - getAlignment
```
public static int getAlignment(RVMArray t)
```
    Parameters:
    
    t - RVMArray instance being created
    
    Returns:
    
    the desired alignment of the alignment point returned by getOffsetForAlignment in instances of the argument RVMArray.
  - getAlignment
```
public static int getAlignment(RVMArray t,
                               Object obj)
```
    Parameters:
    
    t - RVMArray instance being copied
    
    obj - the object being copied
    
    Returns:
    
    the desired alignment of the alignment point returned by getOffsetForAlignment in instances of the argument RVMArray.
  - getOffsetForAlignment
```
public static int getOffsetForAlignment(RVMClass t,
                                        boolean needsIdentityHash)
```
    Parameters:
    
    t - RVMClass instance being created
    
    needsIdentityHash - TODO document this parameter. Is it still needed? It's never set to true.
    
    Returns:
    
    the offset relative to physical beginning of object that must be aligned.
  - getOffsetForAlignment
```
public static int getOffsetForAlignment(RVMClass t,
                                        ObjectReference obj)
```
    Parameters:
    
    t - RVMClass instance being copied
    
    obj - the object being copied
    
    Returns:
    
    the offset relative to physical beginning of object that must be aligned.
  - getOffsetForAlignment
```
public static int getOffsetForAlignment(RVMArray t,
                                        boolean needsIdentityHash)
```
    Parameters:
    
    t - RVMArray instance being created
    
    needsIdentityHash - TODO document this parameter. Is it still needed? It's never set to true.
    
    Returns:
    
    the offset relative to physical beginning of object that must be aligned.
  - getOffsetForAlignment
```
public static int getOffsetForAlignment(RVMArray t,
                                        ObjectReference obj)
```
    Parameters:
    
    t - RVMArray instance being copied
    
    obj - the object being copied
    
    Returns:
    
    the offset relative to physical beginning of object that must be aligned.
  - initializeScalarHeader
```
public static Object initializeScalarHeader(Address ptr,
                                            TIB tib,
                                            int size)
```
    Perform any required initialization of the JAVA portion of the header.
    
    Parameters:
    
    ptr - the raw storage to be initialized
    
    tib - the TIB of the instance being created
    
    size - the number of bytes allocated by the GC system for this object.
    
    Returns:
    
    the object whose header was initialized
  - initializeScalarHeader
```
public static Address initializeScalarHeader(BootImageInterface bootImage,
                                             Address ptr,
                                             TIB tib,
                                             int size,
                                             boolean needsIdentityHash,
                                             int identityHashValue)
```
    Perform any required initialization of the JAVA portion of the header.
    
    Parameters:
    
    bootImage - The bootimage being written
    
    ptr - The object ref to the storage to be initialized
    
    tib - The TIB of the instance being created
    
    size - The number of bytes allocated by the GC system for this object.
    
    needsIdentityHash - needs an identity hash value
    
    identityHashValue - the value for the identity hash
    
    Returns:
    
    the address used for a reference to this object
  - initializeArrayHeader
```
public static Object initializeArrayHeader(Address ptr,
                                           TIB tib,
                                           int size)
```
    Perform any required initialization of the JAVA portion of the header.
    
    Parameters:
    
    ptr - the raw storage to be initialized
    
    tib - the TIB of the instance being created
    
    size - the number of bytes allocated by the GC system for this object.
    
    Returns:
    
    the array whose header was initialized
  - initializeArrayHeader
```
public static Address initializeArrayHeader(BootImageInterface bootImage,
                                            Address ptr,
                                            TIB tib,
                                            int size,
                                            int numElements,
                                            boolean needsIdentityHash,
                                            int identityHashValue)
```
    Perform any required initialization of the JAVA portion of the header.
    
    Parameters:
    
    bootImage - the bootimage being written
    
    ptr - the object ref to the storage to be initialized
    
    tib - the TIB of the instance being created
    
    size - the number of bytes allocated by the GC system for this object.
    
    numElements - the number of elements in the array
    
    needsIdentityHash - needs an identity hash value
    
    identityHashValue - the value for the identity hash
    
    Returns:
    
    the address used for a reference to this object
  - dumpHeader
```
public static void dumpHeader(Object ref)
```
    For low level debugging of GC subsystem. Dump the header word(s) of the given object reference.
    
    Parameters:
    
    ref - the object reference whose header should be dumped

Class JavaHeader

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SCALAR_HEADER_SIZE

ARRAY_HEADER_SIZE

OBJECT_REF_OFFSET

TIB_OFFSET

STATUS_OFFSET

AVAILABLE_BITS_OFFSET

HASH_CODE_SHIFT

HASH_CODE_MASK

hashCodeGenerator

NUM_THIN_LOCK_BITS

THIN_LOCK_SHIFT

THIN_LOCK_DEDICATED_U16_OFFSET

THIN_LOCK_DEDICATED_U16_SHIFT

ALIGNMENT_VALUE

LOG_MIN_ALIGNMENT

Constructor Detail

JavaHeader

Method Detail

getTibOffset

getObjectEndAddress

getObjectEndAddress

objectStartOffset

getHeaderEndOffset

minimumObjectSize

getPointerInMemoryRegion

getTIB

setTIB

setTIB

bytesRequiredWhenCopied

bytesUsed

bytesRequiredWhenCopied

bytesUsed

objectStartRef

getObjectFromStartAddress

getScalarFromStartAddress

getArrayFromStartAddress

getNextObject

getNextObject

getNextObject

getReferenceWhenCopiedTo

getReferenceWhenCopiedTo

getReferenceWhenCopiedTo

moveObject

moveObject

moveObject

moveObject

moveObject

getObjectHashCode

installHashCode

getThinLockOffset

defaultThinLockOffset

allocateThinLock

genericLock

genericUnlock

holdsLock

getHeavyLock

readAvailableBitsWord

readAvailableByte

writeAvailableBitsWord

writeAvailableByte

writeAvailableByte

testAvailableBit

setAvailableBit

initializeAvailableByte

prepareAvailableBits

attemptAvailableBits

minimumObjectRef

maximumObjectRef

computeScalarHeaderSize

computeArrayHeaderSize

getAlignment

getAlignment

getAlignment

getAlignment