ObjectModel (Jikes RVM API)

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

```
public class ObjectModel
extends Object
```
The interface to the object model definition accessible to the virtual machine.
Conceptually each Java object is composed of the following pieces:
- The JavaHeader defined by JavaHeader. This portion of the object supports language-level functions such as locking, hashcodes, dynamic type checking, virtual function invocation, and array length.
- The GCHeader defined by MemoryManager. This portion of the object supports allocator-specific requirements such as mark/barrier bits, reference counts, etc.
- The MiscHeader defined by MiscHeader. This portion supports various other clients that want to add bits/words to all objects. Typical uses are profiling and instrumentation (basically this is a way to add an instance field to java.lang.Object).
- The instance fields. Currently defined by various classloader classes. Factoring this code out and making it possible to lay out the instance fields in different ways is a todo item.
Every object's header contains the three portions outlined above.
```
 |<- lo memory                                        hi memory ->|

   SCALAR LAYOUT:
 |<---------- scalar header --------->|
 +----------+------------+------------+------+------+------+--------+
 | GCHeader | MiscHeader | JavaHeader | fldO | fld1 | fldx | fldN-1 |
 +----------+------------+------------+------+------+------+--------+
                         ^ JHOFF             ^objref
                                             .
    ARRAY LAYOUT:                            .
 |<---------- array header ----------------->|
 +----------+------------+------------+------+------+------+------+------+
 | GCHeader | MiscHeader | JavaHeader | len  | elt0 | elt1 | ...  |eltN-1|
 +----------+------------+------------+------+------+------+------+------+
                         ^ JHOFF             ^objref
 
```
Assumptions:
- Each portion of the header (JavaHeader, GCHeader, MiscHeader) is some multiple of 4 bytes (possibly 0). This simplifies access, since we can access each portion independently without having to worry about word tearing.
- The JavaHeader exports k (>=0) unused contiguous bits that can be used by the GCHeader and MiscHeader. The GCHeader gets first dibs on these bits. The GCHeader should use bits 0..i, MiscHeader should use bits i..k.
- JHOFF is a constant for a given configuration.
This model allows efficient array access: the array pointer can be used directly in the base+offset subscript calculation, with no additional constant required.
This model allows free null pointer checking for most reads: a small offset from that reference will wrap around to either very high or very low unmapped memory in the case of a null pointer. As long as these segments of memory are not mapped to the current process, loads/stores through such a pointer will cause a trap that we can catch with a unix signal handler.
Note the key invariant that all elements of the header are available at the same offset from an objref for both arrays and scalar objects.
Note that this model allows for arbitrary growth of the GC header to the left of the object. A possible TODO item is to modify the necessary interfaces within this class and JavaHeader to allow moveObject, bytesUsed, bytesRequiredWhenCopied, etc. to tell this class how many GC header bytes have been allocated. As these calls would be constant within the constant of the call the optimising compiler should be able to allow this at minimal cost.
Another possible TODO item is to include support for linear scanning, where it is possible to move from one object to the next under contiguous allocation. At the moment this is in conflict with object alignment code for objects with long/double fields. We could possibly include the code anyway but require that the alignment code is switched off, or that all objects are aligned. Linear scanning is used in several GC algorithms including card-marking and compaction.
See Also:

JavaHeader, MiscHeader, MemoryManager

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`HASH_STATS` Should we gather stats on hash code state transitions for address-based hashing?
`static int`	`hashRequests` count number of Object.hashCode() operations
`static int`	`hashTransition1` count transitions from UNHASHED to HASHED
`static int`	`hashTransition2` count transitions from HASHED to HASHED_AND_MOVED
`private static FieldLayout`	`layout` Layout widget
`private static boolean`	`PACKED` Whether to pack bytes and shorts into 32bit fields

Constructor Summary

Constructors
Constructor and Description

ObjectModel()

Constructors
Constructor and Description
`ObjectModel()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Address`	`allocateArray(BootImageInterface bootImage, RVMArray array, int numElements, boolean needsIdentityHash, int identityHashValue, int alignCode)` Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array.
`static Address`	`allocateArray(BootImageInterface bootImage, RVMArray array, int numElements, boolean needsIdentityHash, int identityHashValue, int align, int alignCode)` Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array.
`static Address`	`allocateCode(BootImageInterface bootImage, RVMArray array, int numElements)` Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array.
`static Address`	`allocateScalar(BootImageInterface bootImage, RVMClass klass, boolean needsIdentityHash, int identityHashValue)` Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (scalar) type specified by klass.
`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 obj)`
`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)` how many bytes are needed when the scalar object is copied by GC?
`static int`	`bytesUsed(Object obj)`
`static int`	`bytesUsed(Object obj, RVMArray type, int numElements)` how many bytes are used by the array?
`static int`	`bytesUsed(Object obj, RVMClass type)` how many bytes are used by the scalar?
`static int`	`computeArrayHeaderSize(RVMArray type)` Computes the header size of an instance of the given type.
`static int`	`computeHeaderSize(Object ref)` Computes the header size of an object.
`static int`	`computeHeaderSize(Object[] tib)` Given a TIB, compute the header size of an instance of the TIB's class.
`static int`	`computeHeaderSize(RVMType 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`	`describeObject(ObjectReference addr)` For debugging: dumps descriptor of an object.
`static void`	`dumpHeader(Object ref)` For low level debugging of GC subsystem.
`static void`	`dumpHeader(ObjectReference ptr)` For low level debugging of GC subsystem.
`static void`	`fillAlignmentGap(BootImageInterface bootImage, Address address, Extent size)` Fills an alignment gap with the alignment value
`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`	`getArrayLength(Object o)`
`static Offset`	`getArrayLengthOffset()`
`static int`	`getHeaderEndOffset()` For a reference to an object, what is the offset in bytes to the last word of the header from an out-to-in perspective for the object?
`static Lock`	`getHeavyLock(Object o, boolean create)` Obtains the heavy-weight lock, if there is one, associated with the indicated object.
`static ObjectReference`	`getNextObject(ObjectReference obj)`
`static ObjectReference`	`getNextObject(ObjectReference obj, RVMArray type, int numElements)` Get the next object after this array under contiguous allocation.
`static ObjectReference`	`getNextObject(ObjectReference obj, RVMClass type)` Gets the next object after this scalar under contiguous allocation.
`static Address`	`getObjectEndAddress(Object obj)` Get the pointer just past an object.
`static Address`	`getObjectEndAddress(Object object, RVMArray type, int elements)` Gets the pointer just past an object.
`static Address`	`getObjectEndAddress(Object object, RVMClass type)` Gets the pointer just past an object.
`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 RVMType`	`getObjectType(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.
`static Object`	`getReferenceWhenCopiedTo(Object obj, Address to)` Gets the reference of an object after copying to a specified region.
`static Object`	`getReferenceWhenCopiedTo(Object obj, Address region, RVMArray type)` Get the reference of an object after copying to a specified region.
`static Object`	`getReferenceWhenCopiedTo(Object obj, Address region, RVMClass type)` Get the reference of an object after copying to a 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 TIB`	`getTIB(ObjectReference ptr)`
`static boolean`	`holdsLock(Object obj, RVMThread thread)`
`static Object`	`initializeArray(Address ptr, TIB tib, int numElems, int size)` Initialize raw storage with low memory word ptr of size bytes to be an uninitialized instance of the array type specific by tib with numElems elements.
`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`	`initializeScalar(Address ptr, TIB tib, int size)` Initialize raw storage with low memory word ptr of size bytes to be an uninitialized instance of the (scalar) type specified by tib.
`static void`	`layoutInstanceFields(RVMClass klass)` Layout the instance fields declared in this class.
`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 Object`	`moveObject(Address toAddress, Object fromObj, int numBytes, RVMArray type)` Copy an array object to the given raw storage address
`static Object`	`moveObject(Address toAddress, Object fromObj, int numBytes, RVMClass type)` Copy a scalar object to the given raw storage address.
`static Object`	`moveObject(Object fromObj, Object toObj, int numBytes, RVMArray type)` Copy an array object to the given raw storage address.
`static Object`	`moveObject(Object fromObj, Object toObj, int numBytes, RVMClass type)` Copies a scalar object to the given raw storage address.
`static int`	`objectStartOffset(RVMClass t)` For a reference to an object, what is the offset in bytes to the bottom word of the object?
`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`	`setArrayLength(Object o, int len)` Sets the length of an array.
`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 refAddress, Address tibAddr, RVMType type)` Sets the TIB for an object during bootimage writing.
`static void`	`setTIB(ObjectReference ptr, TIB tib)`
`static void`	`setTIB(Object ref, TIB tib)`
`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(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
  - HASH_STATS
```
public static final boolean HASH_STATS
```
    Should we gather stats on hash code state transitions for address-based hashing?
    
    See Also:
    
    Constant Field Values
  - hashRequests
```
public static int hashRequests
```
    count number of Object.hashCode() operations
  - hashTransition1
```
public static int hashTransition1
```
    count transitions from UNHASHED to HASHED
  - hashTransition2
```
public static int hashTransition2
```
    count transitions from HASHED to HASHED_AND_MOVED
  - PACKED
```
private static final boolean PACKED
```
    Whether to pack bytes and shorts into 32bit fields
    
    See Also:
    
    Constant Field Values
  - layout
```
private static final FieldLayout layout
```
    Layout widget
- Constructor Detail
  - ObjectModel
```
public ObjectModel()
```
- Method Detail
  - layoutInstanceFields
```
public static void layoutInstanceFields(RVMClass klass)
```
    Layout the instance fields declared in this class.
    
    Parameters:
    
    klass - the class to layout
  - 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
    
    Returns:
    
    an address that's inside the memory region allocated to the object
  - getArrayLengthOffset
```
public static Offset getArrayLengthOffset()
```
    Returns:
    
    the offset of the array length field from an object reference (in bytes)
  - getTIB
```
public static TIB getTIB(ObjectReference ptr)
```
  - getTIB
```
public static TIB getTIB(Object o)
```
  - setTIB
```
public static void setTIB(ObjectReference ptr,
                          TIB tib)
```
  - setTIB
```
public static void setTIB(Object ref,
                          TIB tib)
```
  - setTIB
```
public static void setTIB(BootImageInterface bootImage,
                          Address refAddress,
                          Address tibAddr,
                          RVMType type)
```
    Sets the TIB for an object during bootimage writing.
    
    Parameters:
    
    bootImage - the bootimage
    
    refAddress - the object's address
    
    tibAddr - the TIB's address
    
    type - the object's type
  - getObjectEndAddress
```
public static Address getObjectEndAddress(Object obj)
```
    Get the pointer just past an object.
    
    Parameters:
    
    obj - the object in question
    
    Returns:
    
    first word after the object
  - getObjectEndAddress
```
public static Address getObjectEndAddress(Object object,
                                          RVMClass type)
```
    Gets the pointer just past an object.
    
    Parameters:
    
    object - the object in question
    
    type - the object's class
    
    Returns:
    
    first word after the scalar object
  - getObjectEndAddress
```
public static Address getObjectEndAddress(Object object,
                                          RVMArray type,
                                          int elements)
```
    Gets the pointer just past an object.
    
    Parameters:
    
    object - the object in question
    
    type - the object's class
    
    elements - the array's length
    
    Returns:
    
    the first word after the array
  - getObjectFromStartAddress
```
public static ObjectReference getObjectFromStartAddress(Address start)
```
    Get 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
  - 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
```
public static ObjectReference getNextObject(ObjectReference obj)
```
    Parameters:
    
    obj - an object
    
    Returns:
    
    the next object in the heap under contiguous allocation
  - getNextObject
```
public static ObjectReference getNextObject(ObjectReference obj,
                                            RVMClass type)
```
    Gets the next object after this scalar under contiguous allocation.
    
    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 object after this array under contiguous allocation.
    
    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)
```
    Gets the reference of an object after copying to a specified region.
    
    Parameters:
    
    obj - the object to copy
    
    to - the target address for the copy
    
    Returns:
    
    the reference of the copy
  - bytesUsed
```
public static int bytesUsed(Object obj)
```
    Parameters:
    
    obj - an object
    
    Returns:
    
    the number of bytes used by the object
  - bytesUsed
```
public static int bytesUsed(Object obj,
                            RVMClass type)
```
    how many bytes are used by the scalar?
    
    Parameters:
    
    obj - an object
    
    type - the object's type
    
    Returns:
    
    the number of bytes used by the object
  - bytesUsed
```
public static int bytesUsed(Object obj,
                            RVMArray type,
                            int numElements)
```
    how many bytes are used by the array?
    
    Parameters:
    
    obj - an object
    
    type - the object's type
    
    numElements - the array's length
    
    Returns:
    
    the number of bytes used by the object
  - bytesRequiredWhenCopied
```
public static int bytesRequiredWhenCopied(Object obj)
```
    Parameters:
    
    obj - the object
    
    Returns:
    
    number of bytes that are required when the object is copied by GC
  - bytesRequiredWhenCopied
```
public static int bytesRequiredWhenCopied(Object fromObj,
                                          RVMClass type)
```
    how many bytes are needed when the scalar object is copied by GC?
    
    Parameters:
    
    fromObj - the object to copy
    
    type - the object's type
    
    Returns:
    
    number of needed bytes when the scalar object is copied by GC
  - 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 number of elements in the array
    
    Returns:
    
    the number of bytes that are required for the copy
  - 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
  - getReferenceWhenCopiedTo
```
public static Object getReferenceWhenCopiedTo(Object obj,
                                              Address region,
                                              RVMClass type)
```
    Get the reference of an object after copying to a specified region.
    
    Parameters:
    
    obj - the object to copy
    
    region - the target address for the copy
    
    type - the scalar's type
    
    Returns:
    
    the reference of the copy
  - getReferenceWhenCopiedTo
```
public static Object getReferenceWhenCopiedTo(Object obj,
                                              Address region,
                                              RVMArray type)
```
    Get the reference of an object after copying to a specified region.
    
    Parameters:
    
    obj - the object to copy
    
    region - the target address for the copy
    
    type - the array's type
    
    Returns:
    
    the reference of the copy
  - moveObject
```
public static Object moveObject(Object fromObj,
                                Object toObj,
                                int numBytes,
                                RVMClass type)
```
    Copies a scalar object to the given raw storage address.
    
    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(Object fromObj,
                                Object toObj,
                                int numBytes,
                                RVMArray type)
```
    Copy an array object to the given raw storage address.
    
    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,
                                int numBytes,
                                RVMClass type)
```
    Copy a scalar object 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(Address toAddress,
                                Object fromObj,
                                int numBytes,
                                RVMArray type)
```
    Copy an array object 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
  - getObjectType
```
public static RVMType getObjectType(Object o)
```
    Parameters:
    
    o - an object
    
    Returns:
    
    the type of an object
  - getArrayLength
```
public static int getArrayLength(Object o)
```
    Parameters:
    
    o - an array
    
    Returns:
    
    the length of an array
  - setArrayLength
```
public static void setArrayLength(Object o,
                                  int len)
```
    Sets the length of an array.
    
    Parameters:
    
    o - an array
    
    len - the length of the array
  - getObjectHashCode
```
public static int getObjectHashCode(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(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
  - computeHeaderSize
```
public static int computeHeaderSize(RVMType 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
  - computeHeaderSize
```
public static int computeHeaderSize(Object ref)
```
    Computes the header size of an object.
    
    Parameters:
    
    ref - the object whose header size is of interest
    
    Returns:
    
    the object's header size
  - 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
  - computeHeaderSize
```
public static int computeHeaderSize(Object[] tib)
```
    Given a TIB, compute the header size of an instance of the TIB's class.
    
    Parameters:
    
    tib - a TIB
    
    Returns:
    
    the header size of an object from the class given by the TIB
  - getHeaderEndOffset
```
public static int getHeaderEndOffset()
```
    For a reference to an object, what is the offset in bytes to the last word of the header from an out-to-in perspective for the object?
    
    Returns:
    
    offset of the last word of the header from an out-to-in perspective
  - objectStartOffset
```
public static int objectStartOffset(RVMClass t)
```
    For a reference to an object, what is the offset in bytes to the bottom word of the object?
    
    Parameters:
    
    t - the class of the object
    
    Returns:
    
    offset of the first word of the class from the object reference
  - 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. IIs 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.
  - initializeScalar
```
public static Object initializeScalar(Address ptr,
                                      TIB tib,
                                      int size)
```
    Initialize raw storage with low memory word ptr of size bytes to be an uninitialized instance of the (scalar) type specified by tib.
    
    Parameters:
    
    ptr - address of raw storage
    
    tib - the type information block
    
    size - number of bytes of raw storage allocated.
    
    Returns:
    
    the object whose storage was initialized
  - allocateScalar
```
public static Address allocateScalar(BootImageInterface bootImage,
                                     RVMClass klass,
                                     boolean needsIdentityHash,
                                     int identityHashValue)
```
    Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (scalar) type specified by klass. NOTE: TIB is set by BootImageWriter2
    
    Parameters:
    
    bootImage - the bootimage to put the object in
    
    klass - the RVMClass object of the instance to create.
    
    needsIdentityHash - needs an identity hash value
    
    identityHashValue - the value for the identity hash
    
    Returns:
    
    the offset of object in bootimage (in bytes)
  - fillAlignmentGap
```
public static void fillAlignmentGap(BootImageInterface bootImage,
                                    Address address,
                                    Extent size)
```
    Fills an alignment gap with the alignment value
    
    Parameters:
    
    bootImage - the bootimage being compiled
    
    address - the start address for the gap that needs to be filled
    
    size - the size of the gap to be filled
  - initializeArray
```
public static Object initializeArray(Address ptr,
                                     TIB tib,
                                     int numElems,
                                     int size)
```
    Initialize raw storage with low memory word ptr of size bytes to be an uninitialized instance of the array type specific by tib with numElems elements.
    
    Parameters:
    
    ptr - address of raw storage
    
    tib - the type information block
    
    numElems - number of elements in the array
    
    size - number of bytes of raw storage allocated.
    
    Returns:
    
    the array whose header was initialized
  - allocateArray
```
public static Address allocateArray(BootImageInterface bootImage,
                                    RVMArray array,
                                    int numElements,
                                    boolean needsIdentityHash,
                                    int identityHashValue,
                                    int alignCode)
```
    Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array. NOTE: TIB is set by BootimageWriter2
    
    Parameters:
    
    bootImage - the bootimage to put the object in
    
    array - RVMArray object of array being allocated.
    
    numElements - number of elements
    
    needsIdentityHash - needs an identity hash value
    
    identityHashValue - the value for the identity hash
    
    alignCode - TODO
    
    Returns:
    
    Address of object in bootimage (in bytes)
  - allocateArray
```
public static Address allocateArray(BootImageInterface bootImage,
                                    RVMArray array,
                                    int numElements,
                                    boolean needsIdentityHash,
                                    int identityHashValue,
                                    int align,
                                    int alignCode)
```
    Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array. NOTE: TIB is set by BootimageWriter2
    
    Parameters:
    
    bootImage - the bootimage to put the object in
    
    array - RVMArray object of array being allocated.
    
    numElements - number of elements
    
    needsIdentityHash - needs an identity hash value
    
    identityHashValue - the value for the identity hash
    
    align - special alignment value
    
    alignCode - the alignment-encoded value
    
    Returns:
    
    Address of object in bootimage (in bytes)
  - allocateCode
```
public static Address allocateCode(BootImageInterface bootImage,
                                   RVMArray array,
                                   int numElements)
```
    Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array. NOTE: TIB is set by BootimageWriter2
    
    Parameters:
    
    bootImage - the bootimage to put the object in
    
    array - RVMArray object of array being allocated.
    
    numElements - number of elements
    
    Returns:
    
    Address of object in bootimage
  - dumpHeader
```
public static void dumpHeader(ObjectReference ptr)
```
    For low level debugging of GC subsystem. Dump the header word(s) of the given object reference.
    
    Parameters:
    
    ptr - the object reference whose header should be dumped
  - 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
  - describeObject
```
public static void describeObject(ObjectReference addr)
```
    For debugging: dumps descriptor of an object.
    
    Parameters:
    
    addr - the object to dump

Class ObjectModel

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

HASH_STATS

hashRequests

hashTransition1

hashTransition2

PACKED

layout

Constructor Detail

ObjectModel

Method Detail

layoutInstanceFields

getPointerInMemoryRegion

getArrayLengthOffset

getTIB

getTIB

setTIB

setTIB

setTIB

getObjectEndAddress

getObjectEndAddress

getObjectEndAddress

getObjectFromStartAddress

getScalarFromStartAddress

getArrayFromStartAddress

getNextObject

getNextObject

getNextObject

getReferenceWhenCopiedTo

bytesUsed

bytesUsed

bytesUsed

bytesRequiredWhenCopied

bytesRequiredWhenCopied

bytesRequiredWhenCopied

objectStartRef

getReferenceWhenCopiedTo

getReferenceWhenCopiedTo

moveObject

moveObject

moveObject

moveObject

getObjectType

getArrayLength

setArrayLength

getObjectHashCode

getThinLockOffset

defaultThinLockOffset

allocateThinLock

genericLock

genericUnlock

holdsLock

getHeavyLock

readAvailableBitsWord

readAvailableByte

writeAvailableBitsWord

writeAvailableByte

testAvailableBit

setAvailableBit

initializeAvailableByte

prepareAvailableBits

attemptAvailableBits

minimumObjectRef

maximumObjectRef

computeHeaderSize

computeHeaderSize

computeScalarHeaderSize

computeArrayHeaderSize

computeHeaderSize

getHeaderEndOffset

objectStartOffset

getAlignment

getAlignment

getAlignment

getAlignment

getOffsetForAlignment