RVMType (Jikes RVM API)

java.lang.Object
- org.jikesrvm.classloader.AnnotatedElement
- - org.jikesrvm.classloader.RVMType

All Implemented Interfaces:

AnnotatedElement

Direct Known Subclasses:

Primitive, RVMArray, RVMClass, UnboxedType
```
public abstract class RVMType
extends AnnotatedElement
```
A description of a java type.
This class is the base of the java type system. To the three kinds of java objects (class-instances, array-instances, primitive-instances) there are three corresponding subclasses of RVMType: RVMClass, RVMArray, Primitive.
A RVMClass is constructed in four phases:
- A "load" phase reads the ".class" file but does not attempt to examine any of the symbolic references present there. This is done by the RVMClass constructor as a result of a TypeReference being resolved.
- A "resolve" phase follows symbolic references as needed to discover ancestry, to measure field sizes, and to allocate space in the JTOC for the class's static fields and methods.
- An "instantiate" phase initializes and installs the type information block and static methods.
- An "initialize" phase runs the class's static initializer.
RVMArray's are constructed in a similar fashion. Primitive's are constructed ab initio. Their "resolution", "instantiation", and "initialization" phases are no-ops.

Field Summary

Fields
Modifier and Type	Field and Description
`static RVMArray`	`AddressArrayType`
`static UnboxedType`	`AddressType`
`static Primitive`	`BooleanType`
`static Primitive`	`ByteType`
`private RVMArray`	`cachedElementType` cached RVMArray that corresponds to arrays of this type.
`static Primitive`	`CharType`
`private Class<?>`	`classForType` instance of java.lang.Class corresponding to this type
`static RVMArray`	`CodeArrayType`
`static UnboxedType`	`CodeType`
`protected int`	`depth` Number of superclasses to Object.
`protected int`	`dimension` Number of [ in descriptor for arrays; -1 for primitives; 0 for classes.
`protected int[]`	`doesImplement` The interface implementation array for this type.
`static Primitive`	`DoubleType`
`protected static RVMClass[]`	`emptyVMClass` Canonical representation of no VM classes
`protected static RVMField[]`	`emptyVMField` Canonical representation of no fields
`protected static RVMMethod[]`	`emptyVMMethod` Canonical representation of no methods
`static RVMArray`	`ExtentArrayType`
`static UnboxedType`	`ExtentType`
`static Primitive`	`FloatType`
`static RVMClass`	`FunctionTableType`
`protected int`	`id` Type id -- used to index into typechecking datastructures
`static RVMClass`	`IMTType`
`static Primitive`	`IntType`
`static RVMClass`	`ITableArrayType`
`static RVMClass`	`ITableType`
`static RVMClass`	`JavaIoSerializableType`
`static RVMClass`	`JavaLangClassType`
`static RVMClass`	`JavaLangCloneableType`
`static RVMArray`	`JavaLangObjectArrayType`
`static RVMClass`	`JavaLangObjectType`
`static RVMField`	`JavaLangRefReferenceReferenceField`
`static RVMClass`	`JavaLangRefReferenceType`
`static RVMClass`	`JavaLangStringType`
`static RVMClass`	`JavaLangThrowableType`
`static RVMClass`	`LinkageTripletTableType`
`private static int`	`LOG_ROW_SIZE` 2^LOG_ROW_SIZE is the number of elements per row
`static Primitive`	`LongType`
`static RVMClass`	`MagicType`
`private int`	`mmAllocator` The memory manager's allocator id for this type.
`private static int`	`nextId` Next space in the the type array
`protected static int[]`	`NOREFS_OFFSET_ARRAY` A zero-length array, used as GC metadata for primitive arrays.
`static RVMArray`	`ObjectReferenceArrayType`
`static RVMClass`	`ObjectReferenceType`
`static RVMArray`	`OffsetArrayType`
`static UnboxedType`	`OffsetType`
`static int[]`	`REFARRAY_OFFSET_ARRAY` Alias `null` for clarity
`protected int[]`	`referenceOffsets` GC metadata for this type.
`private static int`	`ROW_MASK` Mask to ascertain row from id number
`static Primitive`	`ShortType`
`protected short[]`	`superclassIds` The superclass ids for this type.
`protected int`	`tibOffset` index of JTOC slot that has type information block for this RVMType
`static RVMClass`	`TIBType`
`protected TypeReference`	`typeRef` Canonical type reference for this RVMType instance
`private static RVMType[][]`	`types` All types
`static Primitive`	`VoidType`
`static RVMArray`	`WordArrayType`
`static UnboxedType`	`WordType`

Fields inherited from class org.jikesrvm.classloader.AnnotatedElement
declaredAnnotationDatas

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`RVMType(TypeReference typeRef, Class<?> classForType, int dimension, RVMAnnotation[] annotations)` Create an instance of a `RVMType`
`protected`	`RVMType(TypeReference typeRef, int dimension, RVMAnnotation[] annotations)` Create an instance of a `RVMType`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract void`	`allBootImageTypesResolved()` This method is only called by the bootimage writer.
`RVMArray`	`asArray()`
`RVMClass`	`asClass()`
`Primitive`	`asPrimitive()`
`UnboxedType`	`asUnboxedType()`
`protected static Class<?>`	`createClassForType(RVMType type, TypeReference typeRef)`
`RVMMethod`	`findVirtualMethod(Atom memberName, Atom memberDescriptor)` Find specified virtual method description.
`RVMArray`	`getArrayTypeForElementType()`
`Class<?>`	`getClassForType()`
`ClassLoader`	`getClassLoader()`
`Atom`	`getDescriptor()` Descriptor for this type.
`boolean`	`getDesiredAssertionStatus()` Should assertions be enabled on this type?
`abstract int`	`getDimensionality()` Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
`int[]`	`getDoesImplement()`
`int`	`getId()`
`abstract RVMField[]`	`getInstanceFields()`
`abstract int`	`getMemoryBytes()`
`int`	`getMMAllocator()` This returns the allocator id as supplied by the memory manager.
`int[]`	`getReferenceOffsets()`
`Class<?>`	`getResolvedClassForType()` Gets the resolved class for a type.
`abstract int`	`getStackWords()` Space required when this type is stored on the stack (or as a field), in words.
`abstract RVMField[]`	`getStaticFields()`
`abstract RVMMethod[]`	`getStaticMethods()`
`short[]`	`getSuperclassIds()`
`abstract Offset`	`getThinLockOffset()`
`RVMMethod`	`getTIBMethodAtSlot(int slot)` Return the method at the given TIB slot
`Offset`	`getTibOffset()`
`static RVMType`	`getType(int id)`
`abstract int`	`getTypeDepth()` get number of superclasses to Object 0 java.lang.Object, Primitive, and Classes that are interfaces 1 for RVMArrays and classes that extend Object directly
`abstract TIB`	`getTypeInformationBlock()`
`TypeReference`	`getTypeRef()`
`abstract RVMMethod[]`	`getVirtualMethods()`
`abstract boolean`	`hasFinalizer()`
`int`	`hashCode()` Define hashCode(), to allow use of consistent hash codes during bootImage writing and run-time
`abstract void`	`initialize()` Cause initialization to take place.
`abstract void`	`instantiate()` Cause instantiation to take place.
`abstract boolean`	`isAcyclicReference()` Reference Count GC: Is a reference of this type contained in another object inherently acyclic (without cycles)?
`abstract boolean`	`isArrayType()` Is this an instance of RVMArray?
`boolean`	`isAssignableFrom(RVMType type)`
`boolean`	`isBooleanType()`
`boolean`	`isByteType()`
`boolean`	`isCharType()`
`abstract boolean`	`isClassType()` Is this is an instance of RVMClass?
`boolean`	`isDoubleType()`
`boolean`	`isFloatType()`
`abstract boolean`	`isInBootImage()` Is this class part of the virtual machine's boot image?
`abstract boolean`	`isInitialized()` Initialization status.
`abstract boolean`	`isInstantiated()` Instantiation status.
`boolean`	`isIntLikeType()`
`boolean`	`isIntType()`
`boolean`	`isJavaLangObjectType()`
`boolean`	`isJavaLangStringType()`
`boolean`	`isJavaLangThrowableType()`
`boolean`	`isLongType()`
`boolean`	`isNonMoving()`
`abstract boolean`	`isPrimitiveType()` Is this a primitive type?
`abstract boolean`	`isReferenceType()` Is this a reference type?
`abstract boolean`	`isResolved()` Resolution status.
`boolean`	`isShortType()`
`abstract boolean`	`isUnboxedType()` Is this an unboxed type?
`boolean`	`isVoidType()`
`abstract void`	`markAsBootImageClass()` Only intended to be used by the BootImageWriter
`private static int`	`nextId(RVMType it)` Allocate entry in types array and add it (NB resize array if it's not long enough).
`static int`	`numTypes()` How many types have been created?
`abstract void`	`resolve()` Cause resolution to take place.
`void`	`setMMAllocator(int allocator)` Records the allocator information the memory manager holds about this type.
`void`	`setSpecializedMethod(int id, CodeArray code)`
`(package private) static void`	`updateArrayMethods(RVMMethod m)` Updates the TIB for all array types with the newly (re)compiled method.

Methods inherited from class org.jikesrvm.classloader.AnnotatedElement
getAnnotation, getAnnotations, getAnnotationsInternal, getDeclaredAnnotations, getDeclaredAnnotationsInternal, hasAnnotations, hasBaselineNoRegistersAnnotation, hasBaselineSaveLSRegistersAnnotation, hasInlineAnnotation, hasInterruptibleAnnotation, hasLogicallyUninterruptibleAnnotation, hasNoBoundsCheckAnnotation, hasNoCheckStoreAnnotation, hasNoEscapesAnnotation, hasNoInlineAnnotation, hasNonMovingAllocationAnnotation, hasNonMovingAnnotation, hasNoNullCheckAnnotation, hasNoOptCompileAnnotation, hasPreemptibleAnnotation, hasPureAnnotation, hasRuntimeFinalAnnotation, hasRuntimePureAnnotation, hasUninterruptibleAnnotation, hasUninterruptibleNoWarnAnnotation, hasUnpreemptibleAnnotation, hasUnpreemptibleNoWarnAnnotation, hasUntracedAnnotation, isAnnotationDeclared, isAnnotationPresent, readAnnotations, toAnnotations

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

Methods inherited from interface java.lang.reflect.AnnotatedElement
getAnnotationsByType, getDeclaredAnnotation, getDeclaredAnnotationsByType

- Field Detail
  - NOREFS_OFFSET_ARRAY
```
protected static final int[] NOREFS_OFFSET_ARRAY
```
    A zero-length array, used as GC metadata for primitive arrays.
  - REFARRAY_OFFSET_ARRAY
```
public static final int[] REFARRAY_OFFSET_ARRAY
```
    Alias null for clarity
  - nextId
```
private static int nextId
```
    Next space in the the type array
  - LOG_ROW_SIZE
```
private static final int LOG_ROW_SIZE
```
    2^LOG_ROW_SIZE is the number of elements per row
    
    See Also:
    
    Constant Field Values
  - ROW_MASK
```
private static final int ROW_MASK
```
    Mask to ascertain row from id number
    
    See Also:
    
    Constant Field Values
  - types
```
private static RVMType[][] types
```
    All types
  - emptyVMField
```
protected static final RVMField[] emptyVMField
```
    Canonical representation of no fields
  - emptyVMMethod
```
protected static final RVMMethod[] emptyVMMethod
```
    Canonical representation of no methods
  - emptyVMClass
```
protected static final RVMClass[] emptyVMClass
```
    Canonical representation of no VM classes
  - VoidType
```
public static final Primitive VoidType
```
  - BooleanType
```
public static final Primitive BooleanType
```
  - ByteType
```
public static final Primitive ByteType
```
  - ShortType
```
public static final Primitive ShortType
```
  - IntType
```
public static final Primitive IntType
```
  - LongType
```
public static final Primitive LongType
```
  - FloatType
```
public static final Primitive FloatType
```
  - DoubleType
```
public static final Primitive DoubleType
```
  - CharType
```
public static final Primitive CharType
```
  - JavaLangObjectType
```
public static final RVMClass JavaLangObjectType
```
  - JavaLangObjectArrayType
```
public static final RVMArray JavaLangObjectArrayType
```
  - JavaLangClassType
```
public static final RVMClass JavaLangClassType
```
  - JavaLangThrowableType
```
public static final RVMClass JavaLangThrowableType
```
  - JavaLangStringType
```
public static final RVMClass JavaLangStringType
```
  - JavaLangCloneableType
```
public static final RVMClass JavaLangCloneableType
```
  - JavaIoSerializableType
```
public static final RVMClass JavaIoSerializableType
```
  - JavaLangRefReferenceType
```
public static final RVMClass JavaLangRefReferenceType
```
  - JavaLangRefReferenceReferenceField
```
public static final RVMField JavaLangRefReferenceReferenceField
```
  - MagicType
```
public static final RVMClass MagicType
```
  - WordType
```
public static final UnboxedType WordType
```
  - WordArrayType
```
public static final RVMArray WordArrayType
```
  - AddressType
```
public static final UnboxedType AddressType
```
  - AddressArrayType
```
public static final RVMArray AddressArrayType
```
  - ObjectReferenceType
```
public static final RVMClass ObjectReferenceType
```
  - ObjectReferenceArrayType
```
public static final RVMArray ObjectReferenceArrayType
```
  - OffsetType
```
public static final UnboxedType OffsetType
```
  - OffsetArrayType
```
public static final RVMArray OffsetArrayType
```
  - ExtentType
```
public static final UnboxedType ExtentType
```
  - ExtentArrayType
```
public static final RVMArray ExtentArrayType
```
  - CodeType
```
public static final UnboxedType CodeType
```
  - CodeArrayType
```
public static final RVMArray CodeArrayType
```
  - TIBType
```
public static final RVMClass TIBType
```
  - ITableType
```
public static final RVMClass ITableType
```
  - ITableArrayType
```
public static final RVMClass ITableArrayType
```
  - IMTType
```
public static final RVMClass IMTType
```
  - FunctionTableType
```
public static final RVMClass FunctionTableType
```
  - LinkageTripletTableType
```
public static final RVMClass LinkageTripletTableType
```
  - typeRef
```
protected final TypeReference typeRef
```
    Canonical type reference for this RVMType instance
  - id
```
protected final int id
```
    Type id -- used to index into typechecking datastructures
  - tibOffset
```
protected final int tibOffset
```
    index of JTOC slot that has type information block for this RVMType
  - classForType
```
private final Class<?> classForType
```
    instance of java.lang.Class corresponding to this type
  - dimension
```
protected final int dimension
```
    Number of [ in descriptor for arrays; -1 for primitives; 0 for classes. NB this field must appear in all Types for fast type checks (See transformation from HIR to LIR for details).
  - depth
```
protected int depth
```
    Number of superclasses to Object. Known immediately for primitives and arrays, but only after resolving for classes. NB this field must appear in all Types for fast object array store checks (See transformation from HIR to LIR for details).
  - cachedElementType
```
private RVMArray cachedElementType
```
    cached RVMArray that corresponds to arrays of this type. (null --> not created yet).
  - superclassIds
```
protected short[] superclassIds
```
    The superclass ids for this type.
  - doesImplement
```
protected int[] doesImplement
```
    The interface implementation array for this type.
  - mmAllocator
```
private int mmAllocator
```
    The memory manager's allocator id for this type.
  - referenceOffsets
```
protected int[] referenceOffsets
```
    GC metadata for this type. In a primitive array this field points to a zero-length array. In a reference array this field is null. In a class with pointers, it contains the offsets of reference-containing instance fields
- Constructor Detail
  - RVMType
```
protected RVMType(TypeReference typeRef,
                  Class<?> classForType,
                  int dimension,
                  RVMAnnotation[] annotations)
```
    Create an instance of a RVMType
    
    Parameters:
    
    typeRef - The canonical type reference for this type.
    
    classForType - The java.lang.Class representation
    
    dimension - The dimensionality
    
    annotations - array of runtime visible annotations
  - RVMType
```
protected RVMType(TypeReference typeRef,
                  int dimension,
                  RVMAnnotation[] annotations)
```
    Create an instance of a RVMType
    
    Parameters:
    
    typeRef - The canonical type reference for this type.
    
    dimension - The dimensionality
    
    annotations - array of runtime visible annotations
- Method Detail
  - getTypeRef
```
public final TypeReference getTypeRef()
```
    Returns:
    
    canonical type reference for this type.
  - getId
```
public final int getId()
```
    Returns:
    
    the numeric identifier for this type
  - getClassForType
```
public final Class<?> getClassForType()
```
    Returns:
    
    instance of java.lang.Class corresponding to this type. This is commonly used for reflection. NB: this method will cause resolution to take place if necessary.
  - getResolvedClassForType
```
public final Class<?> getResolvedClassForType()
```
    Gets the resolved class for a type.
    Note that this method may only be called when it's clear that the class has already been resolved. If that is not guaranteed, use getClassForType().
    
    Returns:
    
    instance of java.lang.Class corresponding to this type.
  - getTibOffset
```
public final Offset getTibOffset()
```
    Returns:
    
    offset of TIB slot from start of JTOC, in bytes.
  - getClassLoader
```
public final ClassLoader getClassLoader()
```
    Returns:
    
    the class loader for this type
  - getDesiredAssertionStatus
```
public boolean getDesiredAssertionStatus()
```
    Should assertions be enabled on this type?
    
    Returns:
    
    false
  - getDescriptor
```
public final Atom getDescriptor()
```
    Descriptor for this type.
    - For a class, something like "Ljava/lang/String;".
    - For an array, something like "[I" or "[Ljava/lang/String;".
    - For a primitive, something like "I".
    Returns:
    
    descriptor as described above
  - hashCode
```
public final int hashCode()
```
    Define hashCode(), to allow use of consistent hash codes during bootImage writing and run-time
    
    Overrides:
    
    hashCode in class Object
  - getTypeDepth
```
public abstract int getTypeDepth()
```
    get number of superclasses to Object
    - 0 java.lang.Object, Primitive, and Classes that are interfaces
    - 1 for RVMArrays and classes that extend Object directly
    Returns:
    
    number of superclasses between this type and object
  - isAcyclicReference
```
public abstract boolean isAcyclicReference()
```
    Reference Count GC: Is a reference of this type contained in another object inherently acyclic (without cycles)?
    
    Returns:
    
    true if the reference is acyclic
  - getDimensionality
```
public abstract int getDimensionality()
```
    Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
    
    Returns:
    
    dimensionality of the type (see above)
  - asClass
```
public final RVMClass asClass()
```
    Returns:
    
    this cast to a RVMClass
  - asArray
```
public final RVMArray asArray()
```
    Returns:
    
    this cast to a RVMArray
  - asPrimitive
```
public final Primitive asPrimitive()
```
    Returns:
    
    this cast to a Primitive
  - asUnboxedType
```
public final UnboxedType asUnboxedType()
```
    Returns:
    
    this cast to a UnboxedType
  - isVoidType
```
public final boolean isVoidType()
```
    Returns:
    
    is this type void?
  - isBooleanType
```
public final boolean isBooleanType()
```
    Returns:
    
    is this type the primitive boolean?
  - isByteType
```
public final boolean isByteType()
```
    Returns:
    
    is this type the primitive byte?
  - isShortType
```
public final boolean isShortType()
```
    Returns:
    
    is this type the primitive short?
  - isIntType
```
public final boolean isIntType()
```
    Returns:
    
    is this type the primitive int?
  - isLongType
```
public final boolean isLongType()
```
    Returns:
    
    is this type the primitive long?
  - isFloatType
```
public final boolean isFloatType()
```
    Returns:
    
    is this type the primitive float?
  - isDoubleType
```
public final boolean isDoubleType()
```
    Returns:
    
    is this type the primitive double?
  - isCharType
```
public final boolean isCharType()
```
    Returns:
    
    is this type the primitive char?
  - isIntLikeType
```
public final boolean isIntLikeType()
```
    Returns:
    
    is this type the primitive int like? ie is it held as an int on the JVM stack
  - isJavaLangObjectType
```
public final boolean isJavaLangObjectType()
```
    Returns:
    
    is this type the class Object?
  - isJavaLangThrowableType
```
public final boolean isJavaLangThrowableType()
```
    Returns:
    
    is this type the class Throwable?
  - isJavaLangStringType
```
public final boolean isJavaLangStringType()
```
    Returns:
    
    is this type the class String?
  - getArrayTypeForElementType
```
public final RVMArray getArrayTypeForElementType()
```
    Returns:
    
    array type corresponding to "this" array element type.
  - getSuperclassIds
```
public final short[] getSuperclassIds()
```
    Returns:
    
    superclass id vector (@see DynamicTypeCheck)
  - getDoesImplement
```
public final int[] getDoesImplement()
```
    Returns:
    
    doesImplement vector (@see DynamicTypeCheck)
  - nextId
```
private static int nextId(RVMType it)
```
    Allocate entry in types array and add it (NB resize array if it's not long enough).
    
    Parameters:
    
    it - the type to add
    
    Returns:
    
    the id of the tpye in the types array
  - numTypes
```
public static int numTypes()
```
    How many types have been created? Only intended to be used by the bootimage writer or members of this class!
    
    Returns:
    
    number of types that have been created
  - getType
```
public static RVMType getType(int id)
```
  - createClassForType
```
protected static Class<?> createClassForType(RVMType type,
                                             TypeReference typeRef)
```
  - findVirtualMethod
```
public final RVMMethod findVirtualMethod(Atom memberName,
                                         Atom memberDescriptor)
```
    Find specified virtual method description.
    
    Parameters:
    
    memberName - method name - something like "foo"
    
    memberDescriptor - method descriptor - something like "I" or "()I"
    
    Returns:
    
    method description (null --> not found)
  - getTIBMethodAtSlot
```
public final RVMMethod getTIBMethodAtSlot(int slot)
```
    Return the method at the given TIB slot
    
    Parameters:
    
    slot - the slot that contains the method
    
    Returns:
    
    the method at that slot
  - isResolved
```
public abstract boolean isResolved()
```
    Resolution status.
    If the class/array has been "resolved", then size and offset information is available by which the compiler can generate code to access this class/array's fields/methods via direct loads/stores/calls (rather than generating code to access fields/methods symbolically, via dynamic linking stubs).
    Primitives are always treated as "resolved".
    
    Returns:
    
    true when the class has been resolved
  - isInstantiated
```
public abstract boolean isInstantiated()
```
    Instantiation status.
    If the class/array has been "instantiated", then all its methods have been compiled and its type information block has been placed in the JTOC.
    Primitives are always treated as "instantiated".
    
    Returns:
    
    true when the class has been instantiated
  - isInitialized
```
public abstract boolean isInitialized()
```
    Initialization status.
    If the class has been "initialized", then its <clinit> method has been executed. Arrays have no <clinit> methods so they become "initialized" immediately upon "instantiation".
    Primitives are always treated as "initialized".
    
    Returns:
    
    true when the class has been initialized
  - markAsBootImageClass
```
public abstract void markAsBootImageClass()
```
    Only intended to be used by the BootImageWriter
  - isInBootImage
```
public abstract boolean isInBootImage()
```
    Is this class part of the virtual machine's boot image?
    
    Returns:
    
    true if the class is in the bootimage
  - getThinLockOffset
```
public abstract Offset getThinLockOffset()
```
    Returns:
    
    the offset in instances of this type assigned to the thin lock word. Offset.max() if instances of this type do not have thin lock words.
  - isClassType
```
public abstract boolean isClassType()
```
    Is this is an instance of RVMClass?
    
    Returns:
    
    whether or not this is an instance of RVMClass?
  - isArrayType
```
public abstract boolean isArrayType()
```
    Is this an instance of RVMArray?
    
    Returns:
    
    whether or not this is an instance of RVMArray?
  - isPrimitiveType
```
public abstract boolean isPrimitiveType()
```
    Is this a primitive type?
    
    Returns:
    
    whether or not this is a primitive type
  - isUnboxedType
```
public abstract boolean isUnboxedType()
```
    Is this an unboxed type?
    
    Returns:
    
    whether or not this is an unboxed type
  - isReferenceType
```
public abstract boolean isReferenceType()
```
    Is this a reference type?
    
    Returns:
    
    whether or not this is a reference (ie non-primitive) type.
  - isAssignableFrom
```
public boolean isAssignableFrom(RVMType type)
```
    Parameters:
    
    type - type to checj
    
    Returns:
    
    whether type can be assigned to things of this RVMType
  - getStackWords
```
public abstract int getStackWords()
```
    Space required when this type is stored on the stack (or as a field), in words. Ie. 0, 1, or 2 words:
    - reference types (classes and arrays) require 1 word
    - void types require 0 words
    - long and double types require 2 words
    - all other primitive types require 1 word
    Returns:
    
    space in words on the stack
  - getMemoryBytes
```
public abstract int getMemoryBytes()
```
    Returns:
    
    number of bytes in memory required to represent the type
  - resolve
```
public abstract void resolve()
```
    Cause resolution to take place. This will cause slots to be allocated in the JTOC.
  - allBootImageTypesResolved
```
public abstract void allBootImageTypesResolved()
```
    This method is only called by the bootimage writer. It is called after resolve() has been called on all bootimage types but before instantiate() has been called on any bootimage type. This provides a hook to compute various summaries that cannot be computed before types are resolved.
  - instantiate
```
public abstract void instantiate()
```
    Cause instantiation to take place. This will cause the class's methods to be compiled and slots in the JTOC to be filled-in.
  - initialize
```
public abstract void initialize()
```
    Cause initialization to take place. This will cause the class's <clinit> method to be executed.
  - hasFinalizer
```
public abstract boolean hasFinalizer()
```
    Returns:
    
    true if this type overrides java.lang.Object.finalize()
  - getStaticFields
```
public abstract RVMField[] getStaticFields()
```
  - getInstanceFields
```
public abstract RVMField[] getInstanceFields()
```
    Returns:
    
    non-static fields of this class/array type (composed with supertypes, if any).
  - getStaticMethods
```
public abstract RVMMethod[] getStaticMethods()
```
  - getVirtualMethods
```
public abstract RVMMethod[] getVirtualMethods()
```
    Returns:
    
    virtually dispatched methods of this class/array type (composed with supertypes, if any).
  - getTypeInformationBlock
```
public abstract TIB getTypeInformationBlock()
```
    Returns:
    
    runtime type information for this class/array type.
  - setSpecializedMethod
```
public final void setSpecializedMethod(int id,
                                       CodeArray code)
```
  - updateArrayMethods
```
static void updateArrayMethods(RVMMethod m)
```
    Updates the TIB for all array types with the newly (re)compiled method.
    
    Parameters:
    
    m - the method that was recompiled. Must be a virtual method declared by java.lang.Object.
  - setMMAllocator
```
public final void setMMAllocator(int allocator)
```
    Records the allocator information the memory manager holds about this type.
    
    Parameters:
    
    allocator - the allocator to record
  - getMMAllocator
```
public final int getMMAllocator()
```
    This returns the allocator id as supplied by the memory manager. The method is located here as this is the only common superclass of RVMArray and RVMClass, and due to performance reasons this needs to be a non-abstract method. For Primitive this field is unused.
    
    Returns:
    
    the allocator id previously recorded.
  - isNonMoving
```
public boolean isNonMoving()
```
    Returns:
    
    is this a type that must never move
  - getReferenceOffsets
```
public int[] getReferenceOffsets()
```
    Returns:
    
    offsets of reference-containing instance fields of this class type. Offsets are with respect to object pointer -- see RVMField.getOffset().

Class RVMType

Field Summary

Fields inherited from class org.jikesrvm.classloader.AnnotatedElement

Constructor Summary

Method Summary

Methods inherited from class org.jikesrvm.classloader.AnnotatedElement

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.reflect.AnnotatedElement

Field Detail

NOREFS_OFFSET_ARRAY

REFARRAY_OFFSET_ARRAY

nextId

LOG_ROW_SIZE

ROW_MASK

types

emptyVMField

emptyVMMethod

emptyVMClass

VoidType

BooleanType

ByteType

ShortType

IntType

LongType

FloatType

DoubleType

CharType

JavaLangObjectType

JavaLangObjectArrayType

JavaLangClassType

JavaLangThrowableType

JavaLangStringType

JavaLangCloneableType

JavaIoSerializableType

JavaLangRefReferenceType

JavaLangRefReferenceReferenceField

MagicType

WordType

WordArrayType

AddressType

AddressArrayType

ObjectReferenceType

ObjectReferenceArrayType

OffsetType

OffsetArrayType

ExtentType

ExtentArrayType

CodeType

CodeArrayType

TIBType

ITableType

ITableArrayType

IMTType

FunctionTableType

LinkageTripletTableType

typeRef

id

tibOffset

classForType

dimension

depth

cachedElementType

superclassIds

doesImplement

mmAllocator

referenceOffsets

Constructor Detail

RVMType

RVMType

Method Detail

getTypeRef

getId

getClassForType

getResolvedClassForType

getTibOffset

getClassLoader

getDesiredAssertionStatus

getDescriptor

hashCode

getTypeDepth