Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Class
org.jikesrvm.classloader.TypeReference

Packages that use TypeReference
org.jikesrvm.adaptive.measurements.instrumentation   
org.jikesrvm.classloader   
org.jikesrvm.compilers.baseline   
org.jikesrvm.compilers.baseline.ia32   
org.jikesrvm.compilers.common   
org.jikesrvm.compilers.opt   
org.jikesrvm.compilers.opt.bc2ir   
org.jikesrvm.compilers.opt.driver   
org.jikesrvm.compilers.opt.hir2lir   
org.jikesrvm.compilers.opt.ir   
org.jikesrvm.compilers.opt.ir.operand   
org.jikesrvm.compilers.opt.liveness   
org.jikesrvm.compilers.opt.runtimesupport   
org.jikesrvm.compilers.opt.ssa   
org.jikesrvm.jni.ia32   
org.jikesrvm.mm.mminterface   
org.jikesrvm.tools.oth   
 

Uses of TypeReference in org.jikesrvm.adaptive.measurements.instrumentation
 

Methods in org.jikesrvm.adaptive.measurements.instrumentation with parameters of type TypeReference
(package private) static RegisterOperand CounterArrayManager.InsertALoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, int offset)
          Insert array load off before s in the instruction stream.
 

Uses of TypeReference in org.jikesrvm.classloader
 

Fields in org.jikesrvm.classloader declared as TypeReference
static TypeReference TypeReference.Address
           
static TypeReference TypeReference.AddressArray
           
private  TypeReference[] TypeReferenceVector.array
           
static TypeReference TypeReference.BaselineNoRegisters
           
static TypeReference TypeReference.BaselineSaveLSRegisters
           
(package private) static TypeReference TypeReference.baseReflectionClass
          Abstract base of reflective method invoker classes
static TypeReference TypeReference.Boolean
           
static TypeReference TypeReference.BooleanArray
           
static TypeReference TypeReference.Byte
           
static TypeReference TypeReference.ByteArray
           
static TypeReference TypeReference.Char
           
static TypeReference TypeReference.CharArray
           
static TypeReference TypeReference.Class
           
static TypeReference TypeReference.Code
           
static TypeReference TypeReference.CodeArray
           
private  TypeReference[] RVMClass.declaredClasses
          Declared inner classes, may be null
private  TypeReference RVMMember.declaringClass
          The class that declared this member, available by calling getDeclaringClass once the class is loaded.
private  TypeReference RVMClass.declaringClass
          The outer class, or null if this is not a inner/nested class
static TypeReference TypeReference.Double
           
static TypeReference TypeReference.DoubleArray
           
static TypeReference TypeReference.DynamicBridge
           
private static TypeReference[] TypeReferenceVector.empty
           
private  TypeReference RVMClass.enclosingClass
          The enclosing class if this is a local class
static TypeReference TypeReference.ExceptionTable
           
private  TypeReference[] ExceptionHandlerMap.exceptionTypes
          exception type for which i-th handler is to be invoked - something like "java/lang/IOException".
static TypeReference TypeReference.Extent
           
static TypeReference TypeReference.ExtentArray
           
private  TypeReference FieldReference.fieldContentsType
          The field's type
static TypeReference TypeReference.Float
           
static TypeReference TypeReference.FloatArray
           
static TypeReference TypeReference.FunctionTable
           
static TypeReference TypeReference.IMT
           
static TypeReference TypeReference.Int
           
static TypeReference TypeReference.IntArray
           
static TypeReference TypeReference.Interruptible
           
static TypeReference TypeReference.ITable
           
static TypeReference TypeReference.ITableArray
           
static TypeReference TypeReference.JavaIoSerializable
           
static TypeReference TypeReference.JavaLangArithmeticException
           
static TypeReference TypeReference.JavaLangArrayIndexOutOfBoundsException
           
static TypeReference TypeReference.JavaLangArrayStoreException
           
static TypeReference TypeReference.JavaLangClass
           
static TypeReference TypeReference.JavaLangClassCastException
           
static TypeReference TypeReference.JavaLangCloneable
           
static TypeReference TypeReference.JavaLangError
           
static TypeReference TypeReference.JavaLangIllegalMonitorStateException
           
static TypeReference TypeReference.JavaLangNegativeArraySizeException
           
static TypeReference TypeReference.JavaLangNullPointerException
           
static TypeReference TypeReference.JavaLangObject
           
static TypeReference TypeReference.JavaLangObjectArray
           
static TypeReference TypeReference.JavaLangRefReference
           
static TypeReference TypeReference.JavaLangString
           
static TypeReference TypeReference.JavaLangSystem
           
static TypeReference TypeReference.JavaLangThrowable
           
static TypeReference TypeReference.JNIFunctions
           
static TypeReference TypeReference.LinkageTripletTable
           
static TypeReference TypeReference.LogicallyUninterruptible
           
static TypeReference TypeReference.Long
           
static TypeReference TypeReference.LongArray
           
static TypeReference TypeReference.Magic
           
static TypeReference TypeReference.NativeBridge
           
static TypeReference TypeReference.NoCheckStore
           
static TypeReference TypeReference.NonMoving
           
static TypeReference TypeReference.NonMovingAllocation
           
static TypeReference TypeReference.NULL_TYPE
           
static TypeReference TypeReference.ObjectReference
           
static TypeReference TypeReference.ObjectReferenceArray
           
static TypeReference TypeReference.Offset
           
static TypeReference TypeReference.OffsetArray
           
static TypeReference TypeReference.OptimizationPlanner
           
private  TypeReference[] MethodReference.parameterTypes
          types of parameters (not including "this", if virtual)
static TypeReference TypeReference.Preemptible
           
static TypeReference TypeReference.ReferenceFieldsVary
           
static TypeReference TypeReference.ReferenceMaps
           
private  TypeReference MethodReference.returnType
          type of return value
static TypeReference TypeReference.RVMArray
           
static TypeReference TypeReference.SaveVolatile
           
static TypeReference TypeReference.Short
           
static TypeReference TypeReference.ShortArray
           
static TypeReference TypeReference.SpecializedMethodInvoke
           
static TypeReference TypeReference.SysCall
           
static TypeReference TypeReference.Thread
           
static TypeReference TypeReference.TIB
           
private  TypeReference RVMAnnotation.type
          The type of the annotation.
protected  TypeReference MemberReference.type
          The type reference
static TypeReference TypeReference.Type
           
protected  TypeReference RVMType.typeRef
          Canonical type reference for this RVMType instance
private static TypeReference[][] TypeReference.types
          Dictionary of all TypeReference instances.
static TypeReference TypeReference.Uninterruptible
           
static TypeReference TypeReference.UninterruptibleNoWarn
           
static TypeReference TypeReference.Unpreemptible
           
static TypeReference TypeReference.UnpreemptibleNoWarn
           
static TypeReference TypeReference.Untraced
           
static TypeReference TypeReference.VALIDATION_TYPE
           
static TypeReference TypeReference.Void
           
static TypeReference TypeReference.Word
           
static TypeReference TypeReference.WordArray
           
 

Fields in org.jikesrvm.classloader with type parameters of type TypeReference
private static ImmutableEntryHashSetRVM<TypeReference> TypeReference.dictionary
          Used to canonicalize TypeReferences
 

Methods in org.jikesrvm.classloader that return TypeReference
(package private)  TypeReference RVMAnnotation.annotationType()
          Return the TypeReference of the declared annotation, ie an interface and not the class object of this instance
(package private)  TypeReference TypeReferenceVector.elementAt(int index)
           
static TypeReference TypeReference.findOrCreate(Class<?> klass)
          Convert a java.lang.Class into a type reference the slow way.
static TypeReference TypeReference.findOrCreate(ClassLoader cl, Atom tn)
          Find or create the canonical TypeReference instance for the given pair.
static TypeReference TypeReference.findOrCreate(String tn)
          Shorthand for doing a find or create for a type reference that should be created using the bootstrap classloader.
static TypeReference TypeReference.findOrCreateInternal(ClassLoader cl, Atom tn)
          Find or create the canonical TypeReference instance for the given pair without type descriptor parsing.
 TypeReference[] TypeReferenceVector.finish()
           
 TypeReference TypeReference.getArrayElementType()
          Get the element type of for this array type
 TypeReference TypeReference.getArrayTypeForElementType()
          Get array type corresponding to "this" array element type.
private static TypeReference RVMClassLoader.getClassTypeRef(DataInputStream input, ClassLoader cl)
           
 TypeReference[] RVMClass.getDeclaredClasses()
          Declared inner and static member classes.
 TypeReference RVMClass.getDeclaringClass()
          Class that declared this class, or null if this is not an inner/nested class.
 TypeReference RVMClass.getEnclosingClass()
          Class that immediately encloses this class, or null if this is not an inner/nested class.
 TypeReference ExceptionHandlerMap.getExceptionType(int i)
           
 TypeReference[] ExceptionHandlerMap.getExceptionTypes()
           
 TypeReference[] RVMMethod.getExceptionTypes()
          Exceptions thrown by this method - something like { "java/lang/IOException", "java/lang/EOFException" }
 TypeReference FieldReference.getFieldContentsType()
           
 TypeReference TypeReference.getInnermostElementType()
          Return the innermost element type reference for an array
 TypeReference BytecodeStream.getObjectArrayType()
          Returns the type of the object array (as a RVMType).
 TypeReference[] MethodReference.getParameterTypes()
           
 TypeReference[] RVMMethod.getParameterTypes()
          Type of this method's parameters.
 TypeReference MethodReference.getReturnType()
           
abstract  TypeReference SpecializedMethod.getReturnType()
           
 TypeReference RVMMethod.getReturnType()
          Type of this method's return value.
abstract  TypeReference[] SpecializedMethod.getSignature()
           
 TypeReference RVMField.getType()
          Get type of this field's value.
 TypeReference MemberReference.getType()
           
 TypeReference RVMType.getTypeRef()
          Canonical type reference for this type.
static TypeReference TypeReference.getTypeRef(int id)
          Get the canonical type reference given its id.
 TypeReference RVMClass.getTypeRef(int constantPoolIndex)
          Get contents of a "typeRef" constant pool entry.
(package private) static TypeReference ClassFileReader.getTypeRef(int[] constantPool, int constantPoolIndex)
          Get contents of a "typeRef" constant pool entry.
 TypeReference BytecodeStream.getTypeReference()
          Returns the type reference (as a RVMType).
 TypeReference[] Atom.parseForParameterTypes(ClassLoader cl)
          Parse "this" method descriptor to obtain descriptions of method's parameters.
 TypeReference Atom.parseForReturnType(ClassLoader cl)
          Parse "this" method descriptor to obtain description of method's return type.
 

Methods in org.jikesrvm.classloader with parameters of type TypeReference
(package private)  void TypeReferenceVector.addElement(TypeReference item)
           
 void TypeReferenceVector.addUniqueElement(TypeReference item)
           
protected  CompiledMethod SpecializedMethod.compileSpecializedMethod(RVMMethod template, TypeReference[] specializedParams)
          Compile a specialized version of a template method.
(package private) static RVMField RVMField.createAnnotationField(TypeReference annotationClass, MemberReference memRef)
          Create a field for a synthetic annotation class
(package private) static RVMMethod RVMMethod.createAnnotationInit(TypeReference aClass, int[] constantPool, MemberReference memRef, int objectInitIndex, RVMField[] aFields, RVMMethod[] aMethods, int[] defaultConstants)
          Create a method to initialise the annotation class
(package private) static RVMMethod RVMMethod.createAnnotationMethod(TypeReference annotationClass, int[] constantPool, MemberReference memRef, RVMMethod interfaceMethod, int constantPoolIndex)
          Create a copy of the method that occurs in the annotation interface.
protected static Class<?> RVMType.createClassForType(RVMType type, TypeReference typeRef)
          Utility to create a java.lang.Class for the given type using the given type reference
(package private) static RVMMethod RVMMethod.createDefaultConstructor(TypeReference klass, MemberReference memRef)
          Create a method to act as a default constructor (just return)
(package private) static Primitive Primitive.createPrimitive(TypeReference tr)
          Create an instance of a Primitive
(package private)  RVMMethod RVMMethod.createReflectionMethod(TypeReference reflectionClass, int[] constantPool, MethodReference memRef)
          Create a method for reflectively invoking this method
(package private) static UnboxedType UnboxedType.createUnboxedType(TypeReference tr)
          Create an instance of a UnboxedType
 boolean TypeReference.definitelyDifferent(TypeReference that)
          Do this and that definitely refer to the different types?
 boolean TypeReference.definitelySame(TypeReference that)
          Do this and that definitely refer to the same type?
static MethodReference MethodReference.findOrCreate(TypeReference tRef, Atom mn, Atom md)
          Find or create a method reference
static MemberReference MemberReference.findOrCreate(TypeReference tRef, Atom mn, Atom md)
          Find or create the canonical MemberReference instance for the given tuple.
(package private)  boolean AnnotatedElement.isAnnotationDeclared(TypeReference annotationTypeRef)
          Return true if annotation present.
(package private) static RVMAnnotation.AnnotationMember RVMAnnotation.AnnotationMember.readAnnotationMember(TypeReference type, int[] constantPool, DataInputStream input, ClassLoader classLoader)
          Read the pair from the input stream and create object
(package private) static RVMClass ClassFileReader.readClass(TypeReference typeRef, DataInputStream input)
          Create an instance of a RVMClass.
(package private) static int[] ClassFileReader.readConstantPool(TypeReference typeRef, DataInputStream input)
          Parse and return the constant pool in a class file
(package private) static RVMField[] ClassFileReader.readDeclaredFields(TypeReference typeRef, DataInputStream input, int[] constantPool)
          Read the declared fields of the class being read
(package private) static RVMMethod[] ClassFileReader.readDeclaredMethods(TypeReference typeRef, DataInputStream input, int[] constantPool)
          Read the declared methods of the class being read
(package private) static RVMField RVMField.readField(TypeReference declaringClass, int[] constantPool, MemberReference memRef, short modifiers, DataInputStream input)
          Read and create a field.
(package private) static RVMMethod RVMMethod.readMethod(TypeReference declaringClass, int[] constantPool, MemberReference memRef, short modifiers, DataInputStream input)
          Called from ClassFileReader.readClass(TypeReference,DataInputStream) to create an instance of a RVMMethod by reading the relevant data from the argument bytecode stream.
(package private) static int ClassFileReader.readTypeRef(TypeReference typeRef, DataInputStream input, int[] constantPool)
          Read the class' TypeReference
(package private) static
<T> Object
RVMAnnotation.readValue(TypeReference type, int[] constantPool, DataInputStream input, ClassLoader classLoader)
          Read the element_value field of an annotation
private static
<T> Object
RVMAnnotation.readValue(TypeReference type, int[] constantPool, DataInputStream input, ClassLoader classLoader, byte elementValue_tag)
           
(package private)  void TypeReferenceVector.setElementAt(TypeReference item, int index)
           
private static int RVMMethod.typeRefToReturnBytecode(TypeReference tr)
          What would be the appropriate return bytecode for the given type reference?
 

Constructors in org.jikesrvm.classloader with parameters of type TypeReference
AbstractMethod(TypeReference declaringClass, MemberReference memRef, short modifiers, TypeReference[] exceptionTypes, Atom signature, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object annotationDefault)
          Construct abstract method information
AbstractMethod(TypeReference declaringClass, MemberReference memRef, short modifiers, TypeReference[] exceptionTypes, Atom signature, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object annotationDefault)
          Construct abstract method information
ExceptionHandlerMap(int[] startPCs, int[] endPCs, int[] handlerPCs, TypeReference[] exceptionTypes)
          Construct the exception handler map
FieldReference(TypeReference tr, Atom mn, Atom d, int id)
           
MemberReference(TypeReference tRef, Atom mn, Atom d, int id)
           
MethodReference(TypeReference tr, Atom mn, Atom d, int id)
           
NativeMethod(TypeReference declaringClass, MemberReference memRef, short modifiers, TypeReference[] exceptionTypes, Atom signature, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object annotationDefault)
          Construct native method information
NativeMethod(TypeReference declaringClass, MemberReference memRef, short modifiers, TypeReference[] exceptionTypes, Atom signature, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object annotationDefault)
          Construct native method information
NormalMethod(TypeReference dc, MemberReference mr, short mo, TypeReference[] et, short lw, short ow, byte[] bc, ExceptionHandlerMap eMap, int[] lm, LocalVariableTable lvt, int[] constantPool, Atom sig, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object ad)
          Construct a normal Java bytecode method's information
NormalMethod(TypeReference dc, MemberReference mr, short mo, TypeReference[] et, short lw, short ow, byte[] bc, ExceptionHandlerMap eMap, int[] lm, LocalVariableTable lvt, int[] constantPool, Atom sig, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object ad)
          Construct a normal Java bytecode method's information
Primitive(TypeReference tr, Class<?> classForType, Atom name, int stackWords, int memoryBytes)
          Constructor
RVMAnnotation(TypeReference type, RVMAnnotation.AnnotationMember[] elementValuePairs)
          Construct a read annotation
RVMArray(TypeReference typeRef, RVMType elementType)
          Constructor
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
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
RVMField(TypeReference declaringClass, MemberReference memRef, short modifiers, Atom signature, int constantValueIndex, RVMAnnotation[] annotations)
          Create a field.
RVMMember(TypeReference declaringClass, MemberReference memRef, short modifiers, Atom signature, RVMAnnotation[] annotations)
          NOTE: Only RVMClass is allowed to create an instance of a RVMMember.
RVMMethod(TypeReference declaringClass, MemberReference memRef, short modifiers, TypeReference[] exceptionTypes, Atom signature, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object annotationDefault)
          Construct a read method
RVMMethod(TypeReference declaringClass, MemberReference memRef, short modifiers, TypeReference[] exceptionTypes, Atom signature, RVMAnnotation[] annotations, RVMAnnotation[][] parameterAnnotations, Object annotationDefault)
          Construct a read method
RVMType(TypeReference typeRef, Class<?> classForType, int dimension, RVMAnnotation[] annotations)
          Create an instance of a RVMType
RVMType(TypeReference typeRef, int dimension, RVMAnnotation[] annotations)
          Create an instance of a RVMType
UnboxedType(TypeReference tr, Class<?> classForType, Atom name, int stackWords, int memoryBytes)
          Constructor
 

Uses of TypeReference in org.jikesrvm.compilers.baseline
 

Methods in org.jikesrvm.compilers.baseline with parameters of type TypeReference
protected  CompiledMethod BaselineBootImageCompiler.compileMethod(NormalMethod method, TypeReference[] params)
           
protected abstract  void TemplateCompilerFramework.emit_checkcast(TypeReference typeRef)
          Emit code to implement the checkcast bytecode
protected abstract  void TemplateCompilerFramework.emit_instanceof(TypeReference typeRef)
          Emit code to implement the instanceof bytecode
protected abstract  void TemplateCompilerFramework.emit_multianewarray(TypeReference typeRef, int dimensions)
          Emit code to allocate a multi-dimensional array
protected abstract  void TemplateCompilerFramework.emit_unresolved_new(TypeReference typeRef)
          Emit code to dynamically link and allocate a scalar object
protected abstract  void TemplateCompilerFramework.emit_unresolved_newarray(TypeReference typeRef)
          Emit code to dynamically link the element class and allocate an array
 

Uses of TypeReference in org.jikesrvm.compilers.baseline.ia32
 

Fields in org.jikesrvm.compilers.baseline.ia32 declared as TypeReference
private  TypeReference[] BaselineGCMapIterator.bridgeParameterTypes
          parameter types passed by that method
 

Methods in org.jikesrvm.compilers.baseline.ia32 with parameters of type TypeReference
protected  void BaselineCompilerImpl.emit_checkcast(TypeReference typeRef)
           
protected  void BaselineCompilerImpl.emit_instanceof(TypeReference typeRef)
           
protected  void BaselineCompilerImpl.emit_multianewarray(TypeReference typeRef, int dimensions)
           
protected  void BaselineCompilerImpl.emit_unresolved_new(TypeReference typeRef)
           
protected  void BaselineCompilerImpl.emit_unresolved_newarray(TypeReference tRef)
           
 

Uses of TypeReference in org.jikesrvm.compilers.common
 

Methods in org.jikesrvm.compilers.common with parameters of type TypeReference
static CompiledMethod BootImageCompiler.compile(NormalMethod method, TypeReference[] params)
           
protected abstract  CompiledMethod BootImageCompiler.compileMethod(NormalMethod method, TypeReference[] params)
          Compile a method with bytecodes.
 

Uses of TypeReference in org.jikesrvm.compilers.opt
 

Fields in org.jikesrvm.compilers.opt declared as TypeReference
(package private)  TypeReference FieldDatabase.FieldDatabaseEntry.cachedConcreteType
          cache a copy of the concrete type already determined for this field
(package private)  TypeReference FieldDatabase.FieldWriterInfo.concreteType
           
(package private)  TypeReference OptimizingCompilerException.IllegalUpcast.magicType
          Unboxed type that was attempted to convert to an Object
 

Methods in org.jikesrvm.compilers.opt that return TypeReference
static TypeReference ClassLoaderProxy.findCommonSuperclass(TypeReference t1, TypeReference t2)
          Returns a common superclass of the two types.
(package private)  TypeReference FieldDatabase.FieldDatabaseEntry.getConcreteType()
           
static TypeReference FieldAnalysis.getConcreteType(RVMField f)
          Have we determined a single concrete type for a field?
 TypeReference FieldDatabase.getConcreteType(RVMField f)
          return the concrete type of a field, or null if none determined
static TypeReference StaticFieldReader.getTypeFromStaticField(RVMField field)
          Get the type of an object contained in a static field.
 

Methods in org.jikesrvm.compilers.opt with parameters of type TypeReference
private static ConstantOperand Simplifier.boxConstantObjectAsOperand(Object x, TypeReference t)
          Package up an object as a constant operand
private static Object Simplifier.boxConstantOperand(ConstantOperand op, TypeReference t)
          Package up a constant operand as an object
static TypeReference ClassLoaderProxy.findCommonSuperclass(TypeReference t1, TypeReference t2)
          Returns a common superclass of the two types.
static byte ClassLoaderProxy.includesType(TypeReference parentType, TypeReference childType)
          Return Constants.YES if the parent type is defintely a supertype of the child type.
private static boolean FieldAnalysis.isCandidate(TypeReference tref)
          Is a type a candidate for type analysis?
private static void FieldAnalysis.recordConcreteType(RVMMethod m, RVMField f, TypeReference t)
          Record that a method stores an object of a particular concrete type to a field.
 

Constructors in org.jikesrvm.compilers.opt with parameters of type TypeReference
OptimizingCompilerException.IllegalUpcast(TypeReference type)
           
 

Uses of TypeReference in org.jikesrvm.compilers.opt.bc2ir
 

Methods in org.jikesrvm.compilers.opt.bc2ir that return TypeReference
 TypeReference BC2IR.getArrayTypeOf(Operand op)
          Return the data type of the given operand, assuming that the operand is an array reference.
private  TypeReference BC2IR.getRefTypeOf(Operand op)
          Return the data type of the given operand, assuming that the operand is a reference.
 

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type TypeReference
 Instruction BC2IR._aloadHelper(Operator operator, Operand ref, Operand index, TypeReference type)
           
private  Instruction BC2IR._binaryDualHelper(Operator operator, Operand op1, Operand op2, TypeReference type)
           
private  Instruction BC2IR._binaryHelper(Operator operator, Operand op1, Operand op2, TypeReference type)
           
private  Instruction BC2IR._guardedBinaryDualHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)
           
private  Instruction BC2IR._guardedBinaryHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)
           
private  Instruction BC2IR._moveDualHelper(Operator operator, Operand val, TypeReference type)
           
private  Instruction BC2IR._moveHelper(Operator operator, Operand val, TypeReference type)
           
private  Instruction BC2IR._unaryDualHelper(Operator operator, Operand val, TypeReference type)
           
private  Instruction BC2IR._unaryHelper(Operator operator, Operand val, TypeReference type)
           
private  void BC2IR.assertIsAssignable(TypeReference parentType, TypeReference childType)
          Assert that the given child type is a subclass of the given parent type.
 void BC2IR.assertIsType(Operand op, TypeReference type)
          Assert that the given operand is of the given type, or of a subclass of the given type.
private  boolean BC2IR.couldCauseClassLoading(TypeReference typeRef)
           
private  boolean BC2IR.do_CheckStore(Operand ref, Operand elem, TypeReference elemType)
          Generate a storecheck for the given array and elem
 Instruction BC2IR.generateAnewarray(TypeReference arrayTypeRef, TypeReference elementTypeRef)
           
 int GenerationContext.getLocalNumberFor(Register reg, TypeReference type)
          Get the local number for a given register
private static Operator GenerateMagic.getOperator(TypeReference type, int operatorClass)
           
private  Register[] GenerationContext.getPool(TypeReference type)
           
 boolean GenerationContext.isLocal(Operand op, int i, TypeReference type)
          Is the operand a particular bytecode local?
 Register GenerationContext.localReg(int i, TypeReference type)
          Return the Register used to for local i of TypeReference type
 RegisterOperand GenerationContext.makeLocal(int i, TypeReference type)
          Make a register operand that refers to the given local variable number and has the given type.
private  TypeOperand BC2IR.makeTypeOperand(TypeReference type)
          Make a type operand that refers to the given type.
(package private)  byte HandlerBlockLE.mayCatchException(TypeReference et)
           
(package private)  byte HandlerBlockLE.mustCatchException(TypeReference et)
           
(package private)  Operand BC2IR.pop(TypeReference type)
          Pop an operand of the given type from the stack.
(package private)  void BC2IR.push(Operand r, TypeReference type)
          Push an operand of the specified type on the simulated stack.
 BasicBlock BC2IR.rectifyStateWithExceptionHandler(TypeReference exceptionType)
           
private  BasicBlock BC2IR.rectifyStateWithExceptionHandler(TypeReference exceptionType, boolean linkToExitIfUncaught)
           
private  void BC2IR.replaceLocalsOnStack(int index, TypeReference type)
          Replaces copies of local <#index,type> with newly-generated temporaries, and generates the necessary move instructions.
 

Constructors in org.jikesrvm.compilers.opt.bc2ir with parameters of type TypeReference
GenerationContext(NormalMethod meth, TypeReference[] params, CompiledMethod cm, OptOptions opts, InlineOracle ip)
          Use this constructor to create an outermost (non-inlined) GenerationContext.
 

Uses of TypeReference in org.jikesrvm.compilers.opt.driver
 

Fields in org.jikesrvm.compilers.opt.driver declared as TypeReference
 TypeReference[] CompilationPlan.params
          The specialized parameters to use in place of those defined in method.
 

Methods in org.jikesrvm.compilers.opt.driver with parameters of type TypeReference
protected  CompiledMethod OptimizingBootImageCompiler.compileMethod(NormalMethod method, TypeReference[] params)
           
 

Constructors in org.jikesrvm.compilers.opt.driver with parameters of type TypeReference
CompilationPlan(NormalMethod m, TypeReference[] pms, OptimizationPlanElement[] op, InstrumentationPlan mp, OptOptions opts)
          Construct a compilation plan
 

Uses of TypeReference in org.jikesrvm.compilers.opt.hir2lir
 

Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type TypeReference
private static Instruction DynamicTypeCheckExpansion.convertToBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result)
          Generate wrapper around branching type check to get a value producing type check.
private static Instruction DynamicTypeCheckExpansion.generateBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, BasicBlock trueBlock, BasicBlock falseBlock, RegisterOperand oldGuard, BranchProfileOperand falseProb)
          Generate a branching dynamic type check.
private static Instruction DynamicTypeCheckExpansion.generateValueProducingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result)
          Generate a value-producing dynamic type check.
static RegisterOperand ConvertToLowLevelIR.insertBinary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand o2)
          Insert a binary instruction before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertGuardedUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand guard)
          Insert a guarded unary instruction before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset)
          Insert a load off before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, LocationOperand loc, Operand guard)
          Insert a load off before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, Operand guard)
          Insert a load off before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Operand offset, LocationOperand loc, Operand guard)
          Insert a load off before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Offset offset)
          Insert a load off the JTOC before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Operand offset)
          Insert a load off the JTOC before s in the instruction stream.
(package private) static RegisterOperand ConvertToLowLevelIR.InsertUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1)
          Insert a unary instruction before s in the instruction stream.
 

Uses of TypeReference in org.jikesrvm.compilers.opt.ir
 

Fields in org.jikesrvm.compilers.opt.ir declared as TypeReference
 TypeReference[] IR.params
          The specialized parameters to be used in place of those defined in the NormalMethod.
 

Methods in org.jikesrvm.compilers.opt.ir with parameters of type TypeReference
private  void BasicBlock.addTargets(BasicBlock.ComputedBBEnum e, TypeReference thrownException)
           
static Operator IRTools.getCondMoveOp(TypeReference type)
          Returns the correct operator for a conditional move with the given data type.
static Operand IRTools.getDefaultOperand(TypeReference type)
          Returns a constant operand with a default value for a given type
static Operator IRTools.getLoadOp(TypeReference type, boolean isStatic)
          Returns the correct operator for loading a value of the given type
static Operator IRTools.getMoveOp(TypeReference type)
          Returns the correct operator for moving the given data type.
 Register AbstractRegisterPool.getReg(TypeReference type)
          Get a new register of the appropriate type to hold values of 'type'
static Operator IRTools.getStoreOp(TypeReference type, boolean isStatic)
          Returns the correct operator for storing a value of the given type
 RegisterOperand AbstractRegisterPool.makeTemp(TypeReference type)
          Make a temporary register operand to hold values of the specified type (a new register is allocated).
 byte ExceptionHandlerBasicBlock.mayCatchException(TypeReference cand)
          Return YES/NO/MAYBE values that answer the question is it possible for this handler block to catch an exception of the type et.
static RegisterOperand IRTools.moveIntoRegister(TypeReference type, Operator move_op, ArchitectureSpecificOpt.RegisterPool pool, Instruction s, Operand op)
          Generates an instruction to move the given operand into a register, and inserts it before the given instruction.
 byte ExceptionHandlerBasicBlock.mustCatchException(TypeReference cand)
          Return YES/NO/MAYBE values that answer the question is it guarenteed that this handler block will catch an exception of type cand
 

Uses of TypeReference in org.jikesrvm.compilers.opt.ir.operand
 

Fields in org.jikesrvm.compilers.opt.ir.operand declared as TypeReference
(package private)  TypeReference LocationOperand.arrayElementType
          Array element type that corresponds to the type of the array that contains this location; null if this is not an array access.
 TypeReference RegisterOperand.type
          Inferred data type of the contents of the register.
private  TypeReference TypeOperand.typeRef
          The data type.
 

Methods in org.jikesrvm.compilers.opt.ir.operand that return TypeReference
 TypeReference LocationOperand.getElementType()
           
 TypeReference ObjectConstantOperand.getType()
           
 TypeReference TypeOperand.getType()
           
 TypeReference LocationOperand.getType()
           
 TypeReference ClassConstantOperand.getType()
           
 TypeReference NullConstantOperand.getType()
           
 TypeReference CodeConstantOperand.getType()
           
 TypeReference AddressConstantOperand.getType()
           
 TypeReference StringConstantOperand.getType()
           
 TypeReference TIBConstantOperand.getType()
           
 TypeReference Operand.getType()
          Return the TypeReference of the value represented by the operand.
 TypeReference LongConstantOperand.getType()
           
 TypeReference DoubleConstantOperand.getType()
           
 TypeReference IntConstantOperand.getType()
          Return the TypeReference of the value represented by the operand.
 TypeReference RegisterOperand.getType()
          Return the TypeReference of the value represented by the operand.
 TypeReference TrueGuardOperand.getType()
           
 TypeReference FloatConstantOperand.getType()
           
 TypeReference TypeOperand.getTypeRef()
           
 

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type TypeReference
private static boolean LocationOperand.arrayMayBeAliased(TypeReference t1, TypeReference t2)
           
private static boolean Operand.compatiblePrimitives(TypeReference type1, TypeReference type2)
           
 void RegisterOperand.refine(TypeReference t)
          Refine the type of the register to t if t is a more precise type than the register currently holds
 void RegisterOperand.setPreciseType(TypeReference t)
          Set the TypeReference of the value represented by the operand and make the type precise.
 void RegisterOperand.setType(TypeReference t)
          Set the TypeReference of the value represented by the operand.
 

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type TypeReference
LocationOperand(TypeReference t)
          Constructs a new location operand with the given array element type.
RegisterOperand(Register reg, TypeReference typ)
          Constructs a new register operand with the given register and data type.
RegisterOperand(Register reg, TypeReference typ, byte inFlags, boolean isPrecise, boolean isDeclared)
          Constructs a new register operand with the given register, data type and flags.
TypeOperand(RVMType t, TypeReference tr)
           
TypeOperand(TypeReference tr)
          Create a new type operand with the specified type reference
 

Uses of TypeReference in org.jikesrvm.compilers.opt.liveness
 

Methods in org.jikesrvm.compilers.opt.liveness that return TypeReference
 TypeReference LiveSetElement.getRegisterType()
          Returns the register type associated with this element
 

Uses of TypeReference in org.jikesrvm.compilers.opt.runtimesupport
 

Fields in org.jikesrvm.compilers.opt.runtimesupport declared as TypeReference
private static TypeReference OptMachineCodeMap.TYPE
           
 

Uses of TypeReference in org.jikesrvm.compilers.opt.ssa
 

Methods in org.jikesrvm.compilers.opt.ssa that return TypeReference
private  TypeReference EnterSSA.findParameterType(Register p)
          Find a parameter type.
private static TypeReference EnterSSA.meetPhiType(Instruction s)
          Return the meet of the types on the rhs of a phi instruction SIDE EFFECT: bashes the Instruction scratch field.
 

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type TypeReference
(package private) static Register LoadElimination.findOrCreateRegister(Object heapType, int valueNumber, HashMap<LoadElimination.UseRecord,Register> registers, ArchitectureSpecificOpt.RegisterPool pool, TypeReference type)
          Given a value number, return the temporary register allocated for that value number.
(package private) static Register LoadElimination.findOrCreateRegister(Object heapType, int v1, int v2, HashMap<LoadElimination.UseRecord,Register> registers, ArchitectureSpecificOpt.RegisterPool pool, TypeReference type)
          Given a pair of value numbers, return the temporary register allocated for that pair.
(package private) static Instruction SSA.makeMoveInstruction(IR ir, Register r1, Register r2, TypeReference t)
          Create a move instruction r1 := r2.
private  void SSADictionary.registerDef(Instruction s, BasicBlock b, TypeReference t)
          Register that an instruction writes a heap variable for a given type.
private  void SSADictionary.registerUse(Instruction s, TypeReference t)
          Register that an instruction uses a heap variable of a given type.
 

Method parameters in org.jikesrvm.compilers.opt.ssa with type arguments of type TypeReference
private  void LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)
          Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
private  void LoopVersioning.getRegistersDefinedInLoop(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> definingInstructions)
          Get registers defined in the given loop.
 

Uses of TypeReference in org.jikesrvm.jni.ia32
 

Methods in org.jikesrvm.jni.ia32 with parameters of type TypeReference
static Object JNIHelpers.invokeWithDotDotVarArg(int methodID, TypeReference expectReturnType)
          Common code shared by the JNI functions CallStaticMethod (static method invocation)
static Object JNIHelpers.invokeWithDotDotVarArg(Object obj, int methodID, TypeReference expectReturnType, boolean skip4Args)
          Common code shared by the JNI functions CallMethod (virtual method invocation)
static Object JNIHelpers.invokeWithJValue(int methodID, Address argAddress, TypeReference expectReturnType)
          Common code shared by the JNI functions CallStaticMethodA
static Object JNIHelpers.invokeWithJValue(Object obj, int methodID, Address argAddress, TypeReference expectReturnType, boolean skip4Args)
          Common code shared by the JNI functions CallMethodA
static Object JNIHelpers.invokeWithVarArg(int methodID, Address argAddress, TypeReference expectReturnType)
          Common code shared by the JNI functions CallStaticMethodV
static Object JNIHelpers.invokeWithVarArg(Object obj, int methodID, Address argAddress, TypeReference expectReturnType, boolean skip4Args)
          Common code shared by the JNI functions CallMethodV
(package private) static Object JNIHelpers.packageAndInvoke(Object obj, int methodID, Address argAddress, TypeReference expectReturnType, boolean skip4Args, boolean isVarArg)
          Common code shared by invokeWithJValue, invokeWithVarArg and invokeWithDotDotVarArg
 

Uses of TypeReference in org.jikesrvm.mm.mminterface
 

Fields in org.jikesrvm.mm.mminterface declared as TypeReference
private static TypeReference SpecializedScanMethod.returnType
          The return type of this method: void
private static TypeReference[] SpecializedScanMethod.signature
          This method's signature: the object to be scanned and the trace to use
private static TypeReference SpecializedScanMethod.specializedScanMethodType
          Our type reference
private  TypeReference[] SpecializedScanMethod.specializedSignature
          The specialized signature of the method
 

Methods in org.jikesrvm.mm.mminterface that return TypeReference
 TypeReference SpecializedScanMethod.getReturnType()
           
 TypeReference[] SpecializedScanMethod.getSignature()
           
 

Constructors in org.jikesrvm.mm.mminterface with parameters of type TypeReference
SpecializedScanMethod(int id, TypeReference specializedTrace)
           
 

Uses of TypeReference in org.jikesrvm.tools.oth
 

Methods in org.jikesrvm.tools.oth with parameters of type TypeReference
(package private) static int OptTestHarness.parseMethodArgs(TypeReference[] argDesc, String[] args, int i, Object[] methodArgs)
           
 

Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES