RVMClass (Jikes RVM API)

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

All Implemented Interfaces:

AnnotatedElement
```
public final class RVMClass
extends RVMType
```
Description of a java "class" type.
This description is read from a ".class" file as classes/field/methods referenced by the running program need to be bound in to the running image.

See Also:

RVMType, RVMArray, Primitive, UnboxedType

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`acyclic` Reference Count GC: is this type acyclic?
`private int`	`alignment` The desired alignment for instances of this type.
`private Annotation[]`	`annotations` Cached set of inherited and declared annotations.
`private RVMMethod`	`classInitializerMethod` Class initializer method, null if no method or if class is initialized (ie class initializer method has been run)
`private static boolean`	`classLoadingDisabled` Flag for closed world testing
`static ClassLoadingListener`	`classLoadListener`
`private int[]`	`constantPool` The constant pool holds constants used by the class and the Java bytecodes in the methods associated with this class.
`private RVMMethod[]`	`constructorMethods` constructor methods of class
`private TypeReference[]`	`declaredClasses` Declared inner classes, may be null
`private RVMField[]`	`declaredFields` Fields of this class
`private RVMClass[]`	`declaredInterfaces` Interfaces supported by this class
`private RVMMethod[]`	`declaredMethods` Methods of this class
`private TypeReference`	`declaringClass` The outer class, or null if this is not a inner/nested class
`private boolean`	`desiredAssertionStatus` Are assertions enabled on this class?
`private TypeReference`	`enclosingClass` The enclosing class if this is a local class
`private MethodReference`	`enclosingMethod` The enclosing method if this is a local class
`private FieldLayoutContext`	`fieldLayoutContext` A field layout helper - used to keep context regarding field layouts.
`private boolean`	`hasFinalizer` Do objects of this class have a finalizer method?
`private IMT`	`imt` The imt for this class
`private boolean`	`inBootImage` Is this class type in the bootimage?
`private RVMField[]`	`instanceFields` fields distinct for each instance of class
`private int`	`instanceSize` Total size of per-instance data, in bytes
`private static int`	`interfaceCount`
`private static Object`	`interfaceCountLock`
`private int`	`interfaceId`
`private static RVMClass[]`	`interfaces`
`private short`	`modifiers` `ClassLoaderConstants`
`(package private) RVMMethod[]`	`noIMTConflictMap`
`private Object[]`	`objectCache` Set of objects that are cached here to ensure they are not collected by GC
`private Atom`	`signature` The signature is a string representing the generic type for this class declaration, may be null
`private Atom`	`sourceName` Name of file .class file was compiled from, may be null
`private byte`	`state` current class-loading stage (loaded, resolved, instantiated, initializing or initialized)
`private RVMField[]`	`staticFields` fields shared by all instances of class
`private RVMMethod[]`	`staticMethods` static methods of class
`private RVMClass[]`	`subClasses` Non-final list of sub-classes.
`private RVMClass`	`superClass` Super class of this class
`private Offset`	`thinLockOffset` At what offset is the thin lock word to be found in instances of objects of this type?
`private TIB`	`typeInformationBlock` type and virtual method dispatch table for class
`private RVMMethod[]`	`virtualMethods` virtual methods of class

Fields inherited from class org.jikesrvm.classloader.RVMType
AddressArrayType, AddressType, BooleanType, ByteType, CharType, CodeArrayType, CodeType, depth, dimension, doesImplement, DoubleType, emptyVMClass, emptyVMField, emptyVMMethod, ExtentArrayType, ExtentType, FloatType, FunctionTableType, id, IMTType, IntType, ITableArrayType, ITableType, JavaIoSerializableType, JavaLangClassType, JavaLangCloneableType, JavaLangObjectArrayType, JavaLangObjectType, JavaLangRefReferenceReferenceField, JavaLangRefReferenceType, JavaLangStringType, JavaLangThrowableType, LinkageTripletTableType, LongType, MagicType, NOREFS_OFFSET_ARRAY, ObjectReferenceArrayType, ObjectReferenceType, OffsetArrayType, OffsetType, REFARRAY_OFFSET_ARRAY, referenceOffsets, ShortType, superclassIds, tibOffset, TIBType, typeRef, VoidType, WordArrayType, WordType

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

Constructor Summary

Constructors
Constructor and Description
`RVMClass(TypeReference typeRef, int[] constantPool, short modifiers, RVMClass superClass, RVMClass[] declaredInterfaces, RVMField[] declaredFields, RVMMethod[] declaredMethods, TypeReference[] declaredClasses, TypeReference declaringClass, TypeReference enclosingClass, MethodReference enclosingMethod, Atom sourceName, RVMMethod classInitializerMethod, Atom signature, RVMAnnotation[] annotations)` Construct a class from its constituent loaded parts

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCachedObject(Object o)`
`private void`	`addSubClass(RVMClass sub)`
`void`	`allBootImageTypesResolved()` This method is only called by the bootimage writer.
`private void`	`assignInterfaceId()`
`(package private) static Class<?>`	`createReflectionClass(RVMMethod methodToCall)` Create a synthetic class that extends ReflectionBase and invokes the given method
`boolean`	`declaresFinalInstanceField()` Does this class directly define a final instance field (has implications for JMM).
`RVMField`	`findDeclaredField(Atom fieldName)` Find description of a field of this class.
`RVMField`	`findDeclaredField(Atom fieldName, Atom fieldDescriptor)` Find description of a field of this class.
`RVMMethod`	`findDeclaredMethod(Atom methodName)` Find the first description of a method of this class.
`RVMMethod`	`findDeclaredMethod(Atom methodName, Atom methodDescriptor)` Find description of a method of this class.
`RVMMethod`	`findInitializerMethod(Atom memberDescriptor)` Find specified initializer method description.
`RVMMethod`	`findMainMethod()` Find description of "public static void main(String[])" method of this class.
`RVMMethod`	`findStaticMethod(Atom memberName, Atom memberDescriptor)` Find specified static method description.
`int`	`getAlignment()`
`RVMClass[]`	`getAllImplementedInterfaces()`
`(package private) Annotation[]`	`getAnnotationsInternal()`
`static RVMClass`	`getClassFromStackFrame(int skip)` Used for accessibility checks in reflection code.
`RVMMethod`	`getClassInitializerMethod()`
`static ClassLoader`	`getClassLoaderFromStackFrame(int skip)` Support for user-written class loaders: It's required to find the classloader of the class whose method requires another class to be loaded; the initiating loader of the required class is the defining loader of the requiring class.
`RVMMethod[]`	`getConstructorMethods()`
`TypeReference[]`	`getDeclaredClasses()`
`RVMField[]`	`getDeclaredFields()`
`RVMClass[]`	`getDeclaredInterfaces()`
`RVMMethod[]`	`getDeclaredMethods()`
`TypeReference`	`getDeclaringClass()`
`boolean`	`getDesiredAssertionStatus()` Should assertions be enabled on this type?
`int`	`getDimensionality()` Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
`int`	`getDoesImplementBitMask()`
`int`	`getDoesImplementIndex()`
`TypeReference`	`getEnclosingClass()`
`FieldLayoutContext`	`getFieldLayoutContext()`
`FieldReference`	`getFieldRef(int constantPoolIndex)`
`RVMField[]`	`getInstanceFields()`
`int`	`getInstanceSize()`
`int`	`getInstanceSizeInternal()`
`static RVMClass`	`getInterface(int id)`
`int`	`getInterfaceId()` Classes used as Interfaces get assigned an interface id.
`byte`	`getLiteralDescription(int constantPoolIndex)`
`Offset`	`getLiteralOffset(int constantPoolIndex)` Get offset of a literal constant, in bytes.
`int`	`getMemoryBytes()`
`MethodReference`	`getMethodRef(int constantPoolIndex)`
`int`	`getModifiers()` Get the modifiers associated with this class `ClassLoaderConstants`.
`int`	`getNumberOfNonFinalReferences()`
`String`	`getPackageName()` Package name - something like "java.lang".
`Atom`	`getSignature()`
`Atom`	`getSourceName()`
`int`	`getStackWords()` Space required when this type is stored on the stack (or as a field), in words.
`RVMField[]`	`getStaticFields()`
`RVMMethod[]`	`getStaticMethods()`
`RVMClass[]`	`getSubClasses()`
`RVMClass`	`getSuperClass()`
`Offset`	`getThinLockOffset()`
`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
`TIB`	`getTypeInformationBlock()` Runtime type information for this class type.
`TypeReference`	`getTypeRef(int constantPoolIndex)`
`(package private) Atom`	`getUtf(int constantPoolIndex)`
`RVMMethod[]`	`getVirtualMethods()`
`boolean`	`hasBridgeFromNativeAnnotation()` The methods of this class are only called from native code, they are compiled with a special prolog to interface with the native stack frame.
`boolean`	`hasDynamicBridgeAnnotation()` Should the methods of this class be compiled with special register save/restore logic?
`boolean`	`hasFinalizer()`
`boolean`	`hasSaveVolatileAnnotation()` Should the methods of this class save incoming registers ?
`void`	`initialize()` Cause initialization to take place.
`void`	`instantiate()` Cause instantiation to take place.
`boolean`	`isAbstract()`
`boolean`	`isAcyclicReference()` Reference Count GC: Is a reference of this type contained in another object inherently acyclic (without cycles)?
`boolean`	`isAnnotation()`
`boolean`	`isAnonymousClass()`
`boolean`	`isArrayType()` Is this an instance of RVMArray?
`static boolean`	`isClassLoadingDisabled()`
`boolean`	`isClassType()` Is this is an instance of RVMClass?
`boolean`	`isEnum()`
`boolean`	`isFinal()`
`boolean`	`isInBootImage()` Is this class part of the virtual machine's boot image?
`boolean`	`isInitialized()` Initialization status.
`boolean`	`isInstantiated()` Instantiation status.
`boolean`	`isInterface()`
`boolean`	`isLocalClass()`
`boolean`	`isMemberClass()`
`boolean`	`isPrimitiveType()` Is this a primitive type?
`boolean`	`isPublic()`
`boolean`	`isReferenceType()` Is this a reference type?
`boolean`	`isResolved()` Resolution status.
`boolean`	`isSpecial()`
`boolean`	`isSynthetic()`
`boolean`	`isThrowable()`
`boolean`	`isUnboxedType()` Is this an unboxed type?
`void`	`makeFieldTraced(RVMField field)` Make the passed field a traced field by garbage collection.
`void`	`markAsBootImageClass()` Only intended to be used by the BootImageWriter
`private void`	`markFinalFieldsAsLiterals()` Mark final fields as being available as literals
`private void`	`publishResolved(TIB allocatedTib, short[] superclassIds, int[] doesImplement)` Atomically initialize the important parts of the TIB and let the world know this type is resolved.
`void`	`resolve()` Cause resolution to take place.
`(package private) void`	`resolveNativeMethods()`
`private void`	`resolveNativeMethodsInternal(RVMMethod[] methods)`
`void`	`setAlignment(int align)`
`void`	`setAllFinalStaticJTOCEntries()` Copy the values of all static final fields into the JTOC.
`static void`	`setClassLoadingDisabled(boolean classLoadingDisabled)` Provides a way to disable and re-enable classloading for testing purposes.
`void`	`setFieldLayoutContext(FieldLayoutContext newLayout)`
`private void`	`setFinalStaticJTOCEntry(RVMField field, Offset fieldOffset)` Inserts the value of a final static field into the JTOC.
`void`	`setIMT(IMT imt)`
`void`	`setInstanceSizeInternal(int size)` Set the size of the instance.
`(package private) void`	`setResolvedMembers()` Sets the resolvedMember in all declared members.
`void`	`setThinLockOffset(Offset offset)` Sets the thin lock offset for instances of this type.
`String`	`toString()` Name - something like "java.lang.String".
`void`	`unregisterNativeMethods()` Unregisters all native methods declared by "this".
`void`	`updateJTOCEntry(RVMMethod m)` Updates the JTOC slot for the given static method to point to the current compiled code for the given method.
`void`	`updateMethod(RVMMethod m)` Given a method declared by this class, update all dispatching tables to refer to the current compiled code for the method.
`void`	`updateTIBEntry(RVMMethod m)` Updates this class's TIB entry for the given method to point to the current compiled code for the given method.
`void`	`updateVirtualMethod(RVMMethod m)` Update the TIB entry's for all classes that inherit the given method to point to the current compiled code for the given method.

Methods inherited from class org.jikesrvm.classloader.AnnotatedElement
getAnnotation, getAnnotations, 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, wait, wait, wait

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

- Field Detail
  - classLoadingDisabled
```
private static boolean classLoadingDisabled
```
    Flag for closed world testing
  - constantPool
```
private final int[] constantPool
```
    The constant pool holds constants used by the class and the Java bytecodes in the methods associated with this class. This constant pool isn't that from the class file, instead it has been processed during class loading (see ClassFileReader.readClass(org.jikesrvm.classloader.TypeReference, java.io.DataInputStream)). The loaded class' constant pool has 3 bits of type information (such as (see ClassLoaderConstants.CP_INT)), the rest of the int holds data as follows:
    - utf: value is a UTF atom identifier
    - int, long, float, double, string: value is an offset in the JTOC
    - member: value is a member reference identifier
    - class: value is a type reference identifier. NB this means that class literal bytecodes must first convert the identifier in to a JTOC offset.
  - modifiers
```
private final short modifiers
```
    ClassLoaderConstants
  - superClass
```
private final RVMClass superClass
```
    Super class of this class
  - subClasses
```
private RVMClass[] subClasses
```
    Non-final list of sub-classes. Classes added as sub-classes are loaded.
  - declaredInterfaces
```
private final RVMClass[] declaredInterfaces
```
    Interfaces supported by this class
  - declaredFields
```
private final RVMField[] declaredFields
```
    Fields of this class
  - declaredMethods
```
private final RVMMethod[] declaredMethods
```
    Methods of this class
  - declaredClasses
```
private final TypeReference[] declaredClasses
```
    Declared inner classes, may be null
  - declaringClass
```
private final TypeReference declaringClass
```
    The outer class, or null if this is not a inner/nested class
  - enclosingClass
```
private final TypeReference enclosingClass
```
    The enclosing class if this is a local class
  - enclosingMethod
```
private final MethodReference enclosingMethod
```
    The enclosing method if this is a local class
  - sourceName
```
private final Atom sourceName
```
    Name of file .class file was compiled from, may be null
  - signature
```
private final Atom signature
```
    The signature is a string representing the generic type for this class declaration, may be null
  - classInitializerMethod
```
private RVMMethod classInitializerMethod
```
    Class initializer method, null if no method or if class is initialized (ie class initializer method has been run)
  - state
```
private byte state
```
    current class-loading stage (loaded, resolved, instantiated, initializing or initialized)
  - staticFields
```
private RVMField[] staticFields
```
    fields shared by all instances of class
  - instanceFields
```
private RVMField[] instanceFields
```
    fields distinct for each instance of class
  - instanceSize
```
private int instanceSize
```
    Total size of per-instance data, in bytes
  - alignment
```
private int alignment
```
    The desired alignment for instances of this type.
  - fieldLayoutContext
```
private FieldLayoutContext fieldLayoutContext
```
    A field layout helper - used to keep context regarding field layouts. Managed by the field layout objects in the ObjectModel.
  - staticMethods
```
private RVMMethod[] staticMethods
```
    static methods of class
  - constructorMethods
```
private RVMMethod[] constructorMethods
```
    constructor methods of class
  - virtualMethods
```
private RVMMethod[] virtualMethods
```
    virtual methods of class
  - hasFinalizer
```
private boolean hasFinalizer
```
    Do objects of this class have a finalizer method?
  - typeInformationBlock
```
private TIB typeInformationBlock
```
    type and virtual method dispatch table for class
  - inBootImage
```
private boolean inBootImage
```
    Is this class type in the bootimage? Types in the boot image can be initialized prior to execution (therefore removing runtime resolution).
  - thinLockOffset
```
private Offset thinLockOffset
```
    At what offset is the thin lock word to be found in instances of objects of this type? A value of -1 indicates that the instances of this type do not have inline thin locks.
  - acyclic
```
private boolean acyclic
```
    Reference Count GC: is this type acyclic?
  - annotations
```
private Annotation[] annotations
```
    Cached set of inherited and declared annotations.
  - objectCache
```
private Object[] objectCache
```
    Set of objects that are cached here to ensure they are not collected by GC
  - imt
```
private IMT imt
```
    The imt for this class
  - desiredAssertionStatus
```
private final boolean desiredAssertionStatus
```
    Are assertions enabled on this class?
  - classLoadListener
```
public static final ClassLoadingListener classLoadListener
```
  - interfaceCountLock
```
private static final Object interfaceCountLock
```
  - interfaceCount
```
private static int interfaceCount
```
  - interfaces
```
private static RVMClass[] interfaces
```
  - interfaceId
```
private int interfaceId
```
  - noIMTConflictMap
```
RVMMethod[] noIMTConflictMap
```
- Constructor Detail
  - RVMClass
```
RVMClass(TypeReference typeRef,
         int[] constantPool,
         short modifiers,
         RVMClass superClass,
         RVMClass[] declaredInterfaces,
         RVMField[] declaredFields,
         RVMMethod[] declaredMethods,
         TypeReference[] declaredClasses,
         TypeReference declaringClass,
         TypeReference enclosingClass,
         MethodReference enclosingMethod,
         Atom sourceName,
         RVMMethod classInitializerMethod,
         Atom signature,
         RVMAnnotation[] annotations)
```
    Construct a class from its constituent loaded parts
    
    Parameters:
    
    typeRef - the type reference that was resolved to this class
    
    constantPool - array of ints encoding constant value
    
    modifiers - ClassLoaderConstants
    
    superClass - parent of this class
    
    declaredInterfaces - array of interfaces this class implements
    
    declaredFields - fields of the class
    
    declaredMethods - methods of the class
    
    declaredClasses - declared inner classes
    
    enclosingClass - the class that this class is declared in (for inner classes)
    
    enclosingMethod - the method that this class is declared in (for anonymous classes)
    
    declaringClass - outer class if an inner class
    
    sourceName - source file name
    
    classInitializerMethod - handle to class initializer method
    
    signature - the generic type name for this class
    
    annotations - array of runtime visible annotations
- Method Detail
  - toString
```
public String toString()
```
    Name - something like "java.lang.String".
    
    Overrides:
    
    toString in class Object
  - getPackageName
```
public String getPackageName()
```
    Package name - something like "java.lang".
    
    Returns:
    
    package name or the empty string if the class is a member of the unnamed package
  - getStackWords
```
public int getStackWords()
```
    Description copied from class: RVMType
    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
    Specified by:
    
    getStackWords in class RVMType
    
    Returns:
    
    1
  - getMemoryBytes
```
public int getMemoryBytes()
```
    Specified by:
    
    getMemoryBytes in class RVMType
    
    Returns:
    
    number of bytes in memory required to represent the type
  - isInterface
```
public boolean isInterface()
```
    Returns:
    
    true if "this" is an "interface" description rather than a "class" description
  - isPublic
```
public boolean isPublic()
```
    Returns:
    
    whether "this" is usable from other packages
  - isFinal
```
public boolean isFinal()
```
    Returns:
    
    true if "this" is non-subclassable
  - isAbstract
```
public boolean isAbstract()
```
    Returns:
    
    true if "this" is non-instantiable
  - isSpecial
```
public boolean isSpecial()
```
    Returns:
    
    true if "this" uses new-style "invokespecial" semantics for method calls in this class
  - isSynthetic
```
public boolean isSynthetic()
```
    Returns:
    
    true if "this" is not present in source code file
  - isEnum
```
public boolean isEnum()
```
    Returns:
    
    true if "this" is an enumeration
  - isAnnotation
```
public boolean isAnnotation()
```
    Returns:
    
    true if "this" is an annotation type
  - isAnonymousClass
```
public boolean isAnonymousClass()
```
    Returns:
    
    true if this is a representation of an anonymous class
  - isLocalClass
```
public boolean isLocalClass()
```
    Returns:
    
    true if this is a representation of a local class, ie local to a block of code.
  - isMemberClass
```
public boolean isMemberClass()
```
    Returns:
    
    true if this is a representation of a member class
  - isThrowable
```
public boolean isThrowable()
```
    Returns:
    
    true if this an object of this class could be assigned to Throwable
  - getModifiers
```
public int getModifiers()
```
    Get the modifiers associated with this class ClassLoaderConstants.
    
    Returns:
    
    the modifiers of "this"
  - getSignature
```
public Atom getSignature()
```
    Returns:
    
    generic type information for class
  - getSourceName
```
public Atom getSourceName()
```
    Returns:
    
    Name of source file from which class was compiled - something like "c:\java\src\java\lang\Object.java". (null --> "unknown - wasn't recorded by compiler").
  - getSuperClass
```
public RVMClass getSuperClass()
```
    Returns:
    
    superclass of this class (null means "no superclass", i.e. class is "java/lang/Object").
  - getSubClasses
```
public RVMClass[] getSubClasses()
```
    Returns:
    
    currently loaded classes that "extend" this class.
  - getDeclaredInterfaces
```
public RVMClass[] getDeclaredInterfaces()
```
    Returns:
    
    interfaces implemented directly by this class (ie. not including superclasses).
  - getDeclaredFields
```
public RVMField[] getDeclaredFields()
```
    Returns:
    
    fields defined directly by this class (i.e. not including superclasses).
  - declaresFinalInstanceField
```
public boolean declaresFinalInstanceField()
```
    Does this class directly define a final instance field (has implications for JMM).
    
    Returns:
    
    true if this class declares a final instance field
  - getDeclaredMethods
```
public RVMMethod[] getDeclaredMethods()
```
    Returns:
    
    methods defined directly by this class (i.e. not including superclasses).
  - getDeclaredClasses
```
public TypeReference[] getDeclaredClasses()
```
    Returns:
    
    declared inner and static member classes
  - getDeclaringClass
```
public TypeReference getDeclaringClass()
```
    Returns:
    
    class that declared this class, or null if this is not an inner/nested class.
  - getEnclosingClass
```
public TypeReference getEnclosingClass()
```
    Returns:
    
    class that immediately encloses this class, or null if this is not an inner/nested class.
  - setResolvedMembers
```
void setResolvedMembers()
```
    Sets the resolvedMember in all declared members.
  - getClassInitializerMethod
```
public RVMMethod getClassInitializerMethod()
```
    Returns:
    
    static initializer method for this class (null -> no static initializer or initializer already been run).
  - getAnnotationsInternal
```
Annotation[] getAnnotationsInternal()
```
    Overrides:
    
    getAnnotationsInternal in class AnnotatedElement
  - findDeclaredField
```
public RVMField findDeclaredField(Atom fieldName,
                                  Atom fieldDescriptor)
```
    Find description of a field of this class.
    
    Parameters:
    
    fieldName - field name - something like "foo"
    
    fieldDescriptor - field descriptor - something like "I"
    
    Returns:
    
    description (null --> not found)
  - findDeclaredField
```
public RVMField findDeclaredField(Atom fieldName)
```
    Find description of a field of this class. NB. ignores descriptor.
    
    Parameters:
    
    fieldName - field name - something like "foo"
    
    Returns:
    
    description (null --> not found)
  - findDeclaredMethod
```
public RVMMethod findDeclaredMethod(Atom methodName,
                                    Atom methodDescriptor)
```
    Find description of a method of this class.
    
    Parameters:
    
    methodName - method name - something like "foo"
    
    methodDescriptor - method descriptor - something like "()I"
    
    Returns:
    
    description (null --> not found)
  - findDeclaredMethod
```
public RVMMethod findDeclaredMethod(Atom methodName)
```
    Find the first description of a method of this class.
    
    Parameters:
    
    methodName - method name - something like "foo"
    
    Returns:
    
    description (null --> not found)
  - findMainMethod
```
public RVMMethod findMainMethod()
```
    Find description of "public static void main(String[])" method of this class.
    
    Returns:
    
    description (null --> not found)
  - addCachedObject
```
public void addCachedObject(Object o)
```
  - setIMT
```
public void setIMT(IMT imt)
```
  - getLiteralOffset
```
public Offset getLiteralOffset(int constantPoolIndex)
```
    Get offset of a literal constant, in bytes. Offset is with respect to virtual machine's "table of contents" JTOC).
    
    Parameters:
    
    constantPoolIndex - index into the constant pool
    
    Returns:
    
    offset of the literal constant to the JTOC, in bytes
  - getLiteralDescription
```
public byte getLiteralDescription(int constantPoolIndex)
```
  - getTypeRef
```
public TypeReference getTypeRef(int constantPoolIndex)
```
  - getMethodRef
```
public MethodReference getMethodRef(int constantPoolIndex)
```
  - getFieldRef
```
public FieldReference getFieldRef(int constantPoolIndex)
```
  - getUtf
```
Atom getUtf(int constantPoolIndex)
```
  - hasDynamicBridgeAnnotation
```
public boolean hasDynamicBridgeAnnotation()
```
    Should the methods of this class be compiled with special register save/restore logic?
    
    Returns:
    
    true if the methods needs special logic for register saves and restores
    
    See Also:
    
    DynamicBridge
  - hasBridgeFromNativeAnnotation
```
public boolean hasBridgeFromNativeAnnotation()
```
    The methods of this class are only called from native code, they are compiled with a special prolog to interface with the native stack frame.
    
    Returns:
    
    true if the methods of this class can only be called from native code
  - hasSaveVolatileAnnotation
```
public boolean hasSaveVolatileAnnotation()
```
    Should the methods of this class save incoming registers ?
    
    Returns:
    
    true if all volatile registers need to be saved when methods of this class are called
    
    See Also:
    
    SaveVolatile
  - hasFinalizer
```
public boolean hasFinalizer()
```
    Specified by:
    
    hasFinalizer in class RVMType
    
    Returns:
    
    true if this class overrides java.lang.Object.finalize()
  - getStaticFields
```
public RVMField[] getStaticFields()
```
    Specified by:
    
    getStaticFields in class RVMType
  - getInstanceFields
```
public RVMField[] getInstanceFields()
```
    Specified by:
    
    getInstanceFields in class RVMType
    
    Returns:
    
    non-static fields of this class (composed with supertypes, if any). Values in these fields are distinct for each class instance.
  - getStaticMethods
```
public RVMMethod[] getStaticMethods()
```
    Specified by:
    
    getStaticMethods in class RVMType
  - getConstructorMethods
```
public RVMMethod[] getConstructorMethods()
```
    Returns:
    
    constructors (<init>) methods of this class.
  - getVirtualMethods
```
public RVMMethod[] getVirtualMethods()
```
    Specified by:
    
    getVirtualMethods in class RVMType
    
    Returns:
    
    virtually dispatched methods of this class (composed with supertypes, if any).
  - getAllImplementedInterfaces
```
public RVMClass[] getAllImplementedInterfaces()
```
    Returns:
    
    All of the interfaces implemented by this class either directly or by inheritance from superclass and superinterfaces recursively.
  - getInstanceSize
```
public int getInstanceSize()
```
    Returns:
    
    total size, in bytes, of an instance of this class (including object header). Note that the class must be resolved for this information to be available.
  - getInstanceSizeInternal
```
public int getInstanceSizeInternal()
```
    Returns:
    
    total size, in bytes, of an instance of this class (including object header). Doesn't perform any verification.
  - setInstanceSizeInternal
```
public void setInstanceSizeInternal(int size)
```
    Set the size of the instance. Only meant to be called from ObjectModel et al. must be called when lock on class object is already held (ie from resolve).
    
    Parameters:
    
    size - computed size for instances of this class
  - getNumberOfNonFinalReferences
```
public int getNumberOfNonFinalReferences()
```
    Returns:
    
    number of fields that are non-final
  - getFieldLayoutContext
```
public FieldLayoutContext getFieldLayoutContext()
```
  - setFieldLayoutContext
```
public void setFieldLayoutContext(FieldLayoutContext newLayout)
```
  - getAlignment
```
public int getAlignment()
```
    Returns:
    
    alignment for instances of this class type, in bytes
  - setAlignment
```
public void setAlignment(int align)
```
  - findStaticMethod
```
public RVMMethod findStaticMethod(Atom memberName,
                                  Atom memberDescriptor)
```
    Find specified static method description.
    
    Parameters:
    
    memberName - method name - something like "foo"
    
    memberDescriptor - method descriptor - something like "I" or "()I"
    
    Returns:
    
    method description (null --> not found)
  - findInitializerMethod
```
public RVMMethod findInitializerMethod(Atom memberDescriptor)
```
    Find specified initializer method description.
    
    Parameters:
    
    memberDescriptor - init method descriptor - something like "(I)V"
    
    Returns:
    
    method description (null --> not found)
  - getTypeInformationBlock
```
public TIB getTypeInformationBlock()
```
    Runtime type information for this class type.
    
    Specified by:
    
    getTypeInformationBlock in class RVMType
    
    Returns:
    
    runtime type information for this class/array type.
  - getClassLoaderFromStackFrame
```
public static ClassLoader getClassLoaderFromStackFrame(int skip)
```
    Support for user-written class loaders: It's required to find the classloader of the class whose method requires another class to be loaded; the initiating loader of the required class is the defining loader of the requiring class.
    
    Parameters:
    
    skip - specifies the number of frames back from the caller to the method whose class's loader is required
    
    Returns:
    
    the class loader
  - getClassFromStackFrame
```
public static RVMClass getClassFromStackFrame(int skip)
```
    Used for accessibility checks in reflection code. Find the class of the method that corresponds to the requested frame.
    
    Parameters:
    
    skip - Specifies the number of frames back from the caller to the method whose class is required
    
    Returns:
    
    the class that declares the method at the desired frame
  - getDesiredAssertionStatus
```
public boolean getDesiredAssertionStatus()
```
    Description copied from class: RVMType
    
    Should assertions be enabled on this type?
    
    Overrides:
    
    getDesiredAssertionStatus in class RVMType
    
    Returns:
    
    whether or not assertions should be enabled
  - resolve
```
public void resolve()
```
    Cause resolution to take place. This will cause slots to be allocated in the JTOC. Space in the JTOC is allocated for static fields, static methods and constructors. Moreover, this method generates size and offset information for members of this class.
    Side effects: superclasses and superinterfaces are resolved.
    
    Specified by:
    
    resolve in class RVMType
  - publishResolved
```
private void publishResolved(TIB allocatedTib,
                             short[] superclassIds,
                             int[] doesImplement)
```
    Atomically initialize the important parts of the TIB and let the world know this type is resolved.
    
    Parameters:
    
    allocatedTib - The TIB that has been allocated for this type
    
    superclassIds - The calculated superclass ids array
    
    doesImplement - The calculated does implement array
  - allBootImageTypesResolved
```
public void allBootImageTypesResolved()
```
    Description copied from class: RVMType
    
    This method is only called by the bootimage writer. It is called after RVMType.resolve() has been called on all bootimage types but before RVMType.instantiate() has been called on any bootimage type. This provides a hook to compute various summaries that cannot be computed before types are resolved.
    
    Specified by:
    
    allBootImageTypesResolved in class RVMType
  - isAcyclicReference
```
public boolean isAcyclicReference()
```
    Description copied from class: RVMType
    
    Reference Count GC: Is a reference of this type contained in another object inherently acyclic (without cycles)?
    
    Specified by:
    
    isAcyclicReference in class RVMType
    
    Returns:
    
    true if the class is acyclic and final (otherwise the reference could be to a subsequently loaded cyclic subclass)
  - setFinalStaticJTOCEntry
```
private void setFinalStaticJTOCEntry(RVMField field,
                                     Offset fieldOffset)
```
    Inserts the value of a final static field into the JTOC.
    
    Parameters:
    
    field - the field whose value we want to insert
    
    fieldOffset - the field's offset in the JTOC
  - instantiate
```
public 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. The TIB will also be built.
    Side effects: superclasses are instantiated.
    
    Specified by:
    
    instantiate in class RVMType
  - makeFieldTraced
```
public void makeFieldTraced(RVMField field)
```
    Make the passed field a traced field by garbage collection. Also affects all subclasses.
    
    Parameters:
    
    field - the field that we want to make traced
  - initialize
```
public void initialize()
                throws ExceptionInInitializerError
```
    Cause initialization to take place. This will cause the class's <clinit> method to be executed.
    Side effects: superclasses are initialized, static fields receive initial values.
    
    Specified by:
    
    initialize in class RVMType
    
    Throws:
    
    ExceptionInInitializerError
  - markFinalFieldsAsLiterals
```
private void markFinalFieldsAsLiterals()
```
    Mark final fields as being available as literals
  - setAllFinalStaticJTOCEntries
```
public void setAllFinalStaticJTOCEntries()
```
    Copy the values of all static final fields into the JTOC. Note: This method should only be run AFTER the class initializer has run.
  - resolveNativeMethods
```
void resolveNativeMethods()
```
  - resolveNativeMethodsInternal
```
private void resolveNativeMethodsInternal(RVMMethod[] methods)
```
  - unregisterNativeMethods
```
public void unregisterNativeMethods()
```
    Unregisters all native methods declared by "this".
  - addSubClass
```
private void addSubClass(RVMClass sub)
```
  - updateMethod
```
public void updateMethod(RVMMethod m)
```
    Given a method declared by this class, update all dispatching tables to refer to the current compiled code for the method.
    
    Parameters:
    
    m - the method whose tables need to be updated
  - updateJTOCEntry
```
public void updateJTOCEntry(RVMMethod m)
```
    Updates the JTOC slot for the given static method to point to the current compiled code for the given method. NOTE: This method is intentionally not synchronized to avoid deadlocks. We instead rely on the fact that we are always updating the JTOC with the most recent instructions for the method.
    
    Parameters:
    
    m - the method whose JTOC entry will be updated
  - updateTIBEntry
```
public void updateTIBEntry(RVMMethod m)
```
    Updates this class's TIB entry for the given method to point to the current compiled code for the given method.
    NOTE: This method is intentionally not synchronized to avoid deadlocks. We instead rely on the fact that we are always updating the JTOC with the most recent instructions for the method.
    
    Parameters:
    
    m - the method whose class' TIB entry will be updated
  - updateVirtualMethod
```
public void updateVirtualMethod(RVMMethod m)
```
    Update the TIB entry's for all classes that inherit the given method to point to the current compiled code for the given method.
    NOTE: This method is intentionally not synchronized to avoid deadlocks. We instead rely on the fact that we are always updating the JTOC with the most recent instructions for the method.
    
    Parameters:
    
    m - the method
  - getInterfaceId
```
public int getInterfaceId()
```
    Classes used as Interfaces get assigned an interface id. If the class is not an interface, attempting to use this id will cause an IncompatibleClassChangeError to be thrown
    
    Returns:
    
    interface id (a non-negative number)
  - getDoesImplementIndex
```
public int getDoesImplementIndex()
```
  - getDoesImplementBitMask
```
public int getDoesImplementBitMask()
```
  - getInterface
```
public static RVMClass getInterface(int id)
```
  - assignInterfaceId
```
private void assignInterfaceId()
```
  - getDimensionality
```
public int getDimensionality()
```
    Number of [ in descriptor for arrays; -1 for primitives; 0 for classes
    
    Specified by:
    
    getDimensionality in class RVMType
    
    Returns:
    
    0
  - isResolved
```
public boolean isResolved()
```
    Description copied from class: RVMType
    
    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".
    
    Specified by:
    
    isResolved in class RVMType
    
    Returns:
    
    true when the class has been resolved
  - isInstantiated
```
public boolean isInstantiated()
```
    Description copied from class: RVMType
    
    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".
    
    Specified by:
    
    isInstantiated in class RVMType
    
    Returns:
    
    true when the class has been instantiated
  - isInitialized
```
public boolean isInitialized()
```
    Description copied from class: RVMType
    
    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".
    
    Specified by:
    
    isInitialized in class RVMType
    
    Returns:
    
    true when the class has been initialized
  - markAsBootImageClass
```
public void markAsBootImageClass()
```
    Description copied from class: RVMType
    
    Only intended to be used by the BootImageWriter
    
    Specified by:
    
    markAsBootImageClass in class RVMType
  - isInBootImage
```
public boolean isInBootImage()
```
    Description copied from class: RVMType
    
    Is this class part of the virtual machine's boot image?
    
    Specified by:
    
    isInBootImage in class RVMType
    
    Returns:
    
    true if the class is in the bootimage
  - getThinLockOffset
```
public Offset getThinLockOffset()
```
    Specified by:
    
    getThinLockOffset in class RVMType
    
    Returns:
    
    the offset in instances of this type assigned to the thin lock word. Is only known after class has been resolved.
  - setThinLockOffset
```
public void setThinLockOffset(Offset offset)
```
    Sets the thin lock offset for instances of this type. Can be called at most once. and is invoked from ObjectModel.allocateThinLock (in object models which do not allocate thin locks for all scalar object types).
    
    Parameters:
    
    offset - the offset for the thin lock
  - getTypeDepth
```
public int getTypeDepth()
```
    Description copied from class: RVMType
    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
    Specified by:
    
    getTypeDepth in class RVMType
    
    Returns:
    
    number of superclasses to Object
  - isClassType
```
public boolean isClassType()
```
    Description copied from class: RVMType
    
    Is this is an instance of RVMClass?
    
    Specified by:
    
    isClassType in class RVMType
    
    Returns:
    
    true
  - isArrayType
```
public boolean isArrayType()
```
    Description copied from class: RVMType
    
    Is this an instance of RVMArray?
    
    Specified by:
    
    isArrayType in class RVMType
    
    Returns:
    
    false
  - isPrimitiveType
```
public boolean isPrimitiveType()
```
    Description copied from class: RVMType
    
    Is this a primitive type?
    
    Specified by:
    
    isPrimitiveType in class RVMType
    
    Returns:
    
    false
  - isReferenceType
```
public boolean isReferenceType()
```
    Description copied from class: RVMType
    
    Is this a reference type?
    
    Specified by:
    
    isReferenceType in class RVMType
    
    Returns:
    
    true
  - isUnboxedType
```
public boolean isUnboxedType()
```
    Description copied from class: RVMType
    
    Is this an unboxed type?
    
    Specified by:
    
    isUnboxedType in class RVMType
    
    Returns:
    
    false
  - isClassLoadingDisabled
```
public static boolean isClassLoadingDisabled()
```
  - setClassLoadingDisabled
```
public static void setClassLoadingDisabled(boolean classLoadingDisabled)
```
    Provides a way to disable and re-enable classloading for testing purposes.
    Note: General clients must not call this method.
    
    Parameters:
    
    classLoadingDisabled - true if classloading is to be disabled, false if it is to be enabled
  - createReflectionClass
```
static Class<?> createReflectionClass(RVMMethod methodToCall)
```
    Create a synthetic class that extends ReflectionBase and invokes the given method
    
    Parameters:
    
    methodToCall - the method we wish to call reflectively
    
    Returns:
    
    the synthetic class

Class RVMClass

Field Summary

Fields inherited from class org.jikesrvm.classloader.RVMType

Fields inherited from class org.jikesrvm.classloader.AnnotatedElement

Constructor Summary

Method Summary

Methods inherited from class org.jikesrvm.classloader.RVMType

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

classLoadingDisabled

constantPool

modifiers

superClass

subClasses

declaredInterfaces

declaredFields

declaredMethods

declaredClasses

declaringClass

enclosingClass

enclosingMethod

sourceName

signature

classInitializerMethod

state

staticFields

instanceFields

instanceSize

alignment

fieldLayoutContext

staticMethods

constructorMethods

virtualMethods

hasFinalizer

typeInformationBlock

inBootImage

thinLockOffset

acyclic

annotations

objectCache

imt

desiredAssertionStatus

classLoadListener

interfaceCountLock

interfaceCount

interfaces

interfaceId

noIMTConflictMap

Constructor Detail

RVMClass

Method Detail

toString

getPackageName

getStackWords

getMemoryBytes

isInterface

isPublic

isFinal

isAbstract

isSpecial

isSynthetic

isEnum

isAnnotation

isAnonymousClass

isLocalClass

isMemberClass

isThrowable

getModifiers

getSignature

getSourceName

getSuperClass

getSubClasses

getDeclaredInterfaces

getDeclaredFields

declaresFinalInstanceField

getDeclaredMethods

getDeclaredClasses

getDeclaringClass