|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||
| Uses of RVMMethod in org.jikesrvm |
|---|
| Methods in org.jikesrvm with parameters of type RVMMethod | |
|---|---|
static void |
Callbacks.notifyMethodCompile(RVMMethod method,
int compiler)
Notify the callback manager that a method is about to be compiled. |
void |
Callbacks.MethodCompileMonitor.notifyMethodCompile(RVMMethod method,
int compiler)
Notify the monitor that a method is about to be compiled. |
static void |
Callbacks.notifyMethodOverride(RVMMethod method,
RVMMethod parent)
Notify the callback manager that a method has been overridden. |
void |
Callbacks.MethodOverrideMonitor.notifyMethodOverride(RVMMethod method,
RVMMethod parent)
Notify the monitor that a method has been overridden. |
static void |
VM.sysWriteln(int i,
Address a,
RVMMethod m)
|
| Constructors in org.jikesrvm with parameters of type RVMMethod | |
|---|---|
ArchitectureSpecificOpt.RegisterPool(RVMMethod meth)
|
|
| Uses of RVMMethod in org.jikesrvm.adaptive.controller |
|---|
| Fields in org.jikesrvm.adaptive.controller with type parameters of type RVMMethod | |
|---|---|
private static ImmutableEntryHashMapRVM<RVMMethod,LinkedList<ControllerPlan>> |
ControllerMemory.table
This is a hashtable of controller plans indexed by RVMMethod. |
| Methods in org.jikesrvm.adaptive.controller that return RVMMethod | |
|---|---|
RVMMethod |
HotMethodEvent.getMethod()
|
| Methods in org.jikesrvm.adaptive.controller with parameters of type RVMMethod | |
|---|---|
(package private) static boolean |
ControllerMemory.completedPlanWithOptLevel(RVMMethod method,
int optLevel)
Return true if there is a completed plan with the given opt level for
the given method |
(package private) ControllerPlan |
RecompilationStrategy.createControllerPlan(RVMMethod method,
int optLevel,
InstrumentationPlan instPlan,
int prevCMID,
double expectedSpeedup,
double expectedCompilationTime,
double priority)
This helper method creates a ControllerPlan, which contains a CompilationPlan, for the passed method using the passed optimization level and instrumentation plan. |
static ControllerPlan |
ControllerMemory.findLatestPlan(RVMMethod method)
Looks for the last controller plan for the passed method |
private static LinkedList<ControllerPlan> |
ControllerMemory.findPlan(RVMMethod method)
Looks for a controller plan for the passed method |
(package private) static boolean |
ControllerMemory.planWithStatus(RVMMethod method,
byte status)
Return true if there is a plan with the given status for the given method |
(package private) boolean |
RecompilationStrategy.previousRecompilationAttempted(RVMMethod method)
This method returns true if we've already tried to recompile the
passed method. |
(package private) static boolean |
ControllerMemory.shouldConsiderForInitialRecompilation(RVMMethod method)
Determine if the passed method should be considered as a candidate for _initial_ AOS recompilation. |
| Uses of RVMMethod in org.jikesrvm.adaptive.database.callgraph |
|---|
| Fields in org.jikesrvm.adaptive.database.callgraph declared as RVMMethod | |
|---|---|
private RVMMethod |
CallSite.method
Caller method |
(package private) RVMMethod[] |
WeightedCallTargets.MultiTarget.methods
|
private RVMMethod |
WeightedCallTargets.SingleTarget.target
|
| Methods in org.jikesrvm.adaptive.database.callgraph that return RVMMethod | |
|---|---|
RVMMethod |
CallSite.getMethod()
|
| Methods in org.jikesrvm.adaptive.database.callgraph with parameters of type RVMMethod | |
|---|---|
abstract WeightedCallTargets |
WeightedCallTargets.augmentCount(RVMMethod target,
double amount)
Augment the weight associated with the argument method by the argument amount. |
WeightedCallTargets |
WeightedCallTargets.SingleTarget.augmentCount(RVMMethod t,
double v)
|
WeightedCallTargets |
WeightedCallTargets.MultiTarget.augmentCount(RVMMethod t,
double v)
|
private void |
PartialCallGraph.augmentEdge(RVMMethod caller,
int bcIndex,
RVMMethod callee,
double weight)
Increment the edge represented by the input parameters, creating it if it is not already in the call graph. |
static WeightedCallTargets |
WeightedCallTargets.create(RVMMethod target,
double weight)
|
abstract WeightedCallTargets |
WeightedCallTargets.filter(RVMMethod goal,
boolean isPrecise)
|
WeightedCallTargets |
WeightedCallTargets.SingleTarget.filter(RVMMethod goal,
boolean isPrecise)
|
WeightedCallTargets |
WeightedCallTargets.MultiTarget.filter(RVMMethod goal,
boolean isPrecise)
|
WeightedCallTargets |
PartialCallGraph.getCallTargets(RVMMethod caller,
int bcIndex)
|
WeightedCallTargets |
WeightedCallTargets.incrementCount(RVMMethod target)
Augment the weight associated with the argument method by 1. |
void |
PartialCallGraph.incrementEdge(RVMMethod caller,
int bcIndex,
RVMMethod callee)
Increment the edge represented by the input parameters, creating it if it is not already in the call graph. |
void |
PartialCallGraph.incrementEdge(RVMMethod caller,
int bcIndex,
RVMMethod callee,
float weight)
Increment the edge represented by the input parameters, creating it if it is not already in the call graph. |
void |
WeightedCallTargets.Visitor.visit(RVMMethod target,
double weight)
|
| Constructors in org.jikesrvm.adaptive.database.callgraph with parameters of type RVMMethod | |
|---|---|
CallSite(RVMMethod m,
int bci)
|
|
WeightedCallTargets.SingleTarget(RVMMethod t,
double w)
|
|
| Uses of RVMMethod in org.jikesrvm.adaptive.util |
|---|
| Methods in org.jikesrvm.adaptive.util that return RVMMethod | |
|---|---|
private static RVMMethod |
DynamicCallFileInfoReader.getMethod(MethodReference ref)
Establish the RVMMethod for a given MethodReference gracefully. |
| Methods in org.jikesrvm.adaptive.util with parameters of type RVMMethod | |
|---|---|
static CompilerAdviceAttribute |
CompilerAdviceAttribute.getCompilerAdviceInfo(RVMMethod method)
Given a method and bytecode offset, return an compiler advice attribute or null if none is found for that method and offset. |
void |
AOSLogging.recordControllerEstimateCostDoNothing(RVMMethod method,
int optLevel,
double cost)
This method logs a controller cost estimate for doing nothing. |
void |
AOSLogging.recordControllerEstimateCostOpt(RVMMethod method,
String choiceDesc,
double compilationTime,
double futureTime)
This method logs a controller cost estimate. |
void |
AOSLogging.recordUpdatedCompilationRates(byte compiler,
RVMMethod method,
int BCLength,
int totalBCLength,
int MCLength,
int totalMCLength,
double compTime,
double totalCompTime,
double totalLogOfRates,
int totalLogValueMethods,
int totalMethods)
Records lots of details about the online computation of a compilation rate |
| Uses of RVMMethod in org.jikesrvm.classloader |
|---|
| Subclasses of RVMMethod in org.jikesrvm.classloader | |
|---|---|
class |
AbstractMethod
An abstract method of a java class. |
class |
NativeMethod
A native method of a java class. |
class |
NormalMethod
A method of a java class that has bytecodes. |
| Fields in org.jikesrvm.classloader declared as RVMMethod | |
|---|---|
private RVMMethod[] |
MethodVector.array
|
private RVMMethod |
RVMClass.classInitializerMethod
Class initializer method, null if no method or if class is initialized (ie class initializer method has been run) |
private RVMMethod[] |
RVMClass.constructorMethods
constructor methods of class |
private RVMMethod[] |
RVMClass.declaredMethods
Methods of this class |
private static RVMMethod[] |
MethodVector.empty
|
protected static RVMMethod[] |
RVMType.emptyVMMethod
Canonical representation of no methods |
(package private) RVMMethod |
InterfaceInvocation.IMTDict.Link.method
|
(package private) RVMMethod[] |
RVMClass.noIMTConflictMap
|
private RVMMethod |
MethodReference.resolvedMember
The RVMMethod that this method reference resolved to (null if not yet resolved). |
private RVMMethod[] |
RVMClass.staticMethods
static methods of class |
private RVMMethod[] |
RVMClass.virtualMethods
virtual methods of class |
| Fields in org.jikesrvm.classloader with type parameters of type RVMMethod | |
|---|---|
private static HashMapRVM<RVMMethod,Object> |
RVMMethod.annotationDefaults
A table mapping to values present in the method info tables of annotation types. |
private static ImmutableEntryHashMapRVM<RVMMethod,Annotation[][]> |
RVMMethod.declaredParameterAnnotations
Cache of arrays of declared parameter annotations. |
private static ImmutableEntryHashMapRVM<RVMMethod,TypeReference[]> |
RVMMethod.exceptionTypes
exceptions this method might throw (null --> none) |
private static ImmutableEntryHashMapRVM<RVMMethod,ReflectionBase> |
RVMMethod.invokeMethods
Map from a method to a reflective method capable of invoking it |
private static ImmutableEntryHashMapRVM<RVMMethod,Integer> |
RVMMethod.jtocOffsets
The offsets of virtual methods in the JTOC, if it's been placed there by constant propagation. |
private static ImmutableEntryHashMapRVM<RVMMethod,RVMAnnotation[][]> |
RVMMethod.parameterAnnotations
Method parameter annotations from the class file that are described as runtime visible. |
| Methods in org.jikesrvm.classloader that return RVMMethod | |
|---|---|
(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. |
(package private) static RVMMethod |
RVMMethod.createDefaultConstructor(TypeReference klass,
MemberReference memRef)
Create a method to act as a default constructor (just return) |
(package private) RVMMethod |
RVMMethod.createReflectionMethod(TypeReference reflectionClass,
int[] constantPool,
MethodReference memRef)
Create a method for reflectively invoking this method |
(package private) RVMMethod |
MethodVector.elementAt(int index)
|
RVMMethod |
RVMClass.findDeclaredMethod(Atom methodName)
Find the first description of a method of this class. |
RVMMethod |
RVMClass.findDeclaredMethod(Atom methodName,
Atom methodDescriptor)
Find description of a method of this class. |
RVMMethod |
RVMClass.findInitializerMethod(Atom memberDescriptor)
Find specified initializer method description. |
RVMMethod |
RVMClass.findMainMethod()
Find description of "public static void main(String[])" method of this class. |
RVMMethod |
RVMClass.findStaticMethod(Atom memberName,
Atom memberDescriptor)
Find specified static method description. |
RVMMethod |
RVMType.findVirtualMethod(Atom memberName,
Atom memberDescriptor)
Find specified virtual method description. |
RVMMethod[] |
MethodVector.finish()
|
RVMMethod |
RVMClass.getClassInitializerMethod()
Static initializer method for this class ( null -> no static initializer
or initializer already been run). |
(package private) static RVMMethod |
ClassFileReader.getClassInitializerMethod(RVMMethod[] declaredMethods)
Return the class initializer method among the declared methods of the class |
RVMMethod[] |
RVMClass.getConstructorMethods()
Constructors ( |
RVMMethod[] |
RVMClass.getDeclaredMethods()
Methods defined directly by this class (i.e. not including superclasses). |
RVMMethod |
MethodReference.getResolvedMember()
Get the member this reference has been resolved to, if it has already been resolved. |
private RVMMethod |
InterfaceInvocation.IMTDict.getSoleTarget(int index)
|
RVMMethod[] |
Primitive.getStaticMethods()
Statically dispatched methods of this class/array type. |
abstract RVMMethod[] |
RVMType.getStaticMethods()
Statically dispatched methods of this class/array type. |
RVMMethod[] |
UnboxedType.getStaticMethods()
Statically dispatched methods of this class/array type. |
RVMMethod[] |
RVMArray.getStaticMethods()
Statically dispatched methods of this array type. |
RVMMethod[] |
RVMClass.getStaticMethods()
Statically dispatched methods of this class. |
RVMMethod |
RVMType.getTIBMethodAtSlot(int slot)
Return the method at the given TIB slot |
RVMMethod[] |
Primitive.getVirtualMethods()
Virtually dispatched methods of this class/array type (composed with supertypes, if any). |
abstract RVMMethod[] |
RVMType.getVirtualMethods()
Virtually dispatched methods of this class/array type (composed with supertypes, if any). |
RVMMethod[] |
UnboxedType.getVirtualMethods()
Virtually dispatched methods of this class/array type (composed with supertypes, if any). |
RVMMethod[] |
RVMArray.getVirtualMethods()
Virtually dispatched methods of this array type. |
RVMMethod[] |
RVMClass.getVirtualMethods()
Virtually dispatched methods of this class (composed with supertypes, if any). |
RVMMethod |
MethodReference.peekInterfaceMethod()
Find the RVMMethod that this member reference refers to using the search order specified in JVM spec 5.4.3.4. |
RVMMethod |
MethodReference.peekResolvedMethod()
Find the RVMMethod that this method reference refers to using the search order specified in JVM spec 5.4.3.3. |
(package private) static RVMMethod[] |
ClassFileReader.readDeclaredMethods(TypeReference typeRef,
DataInputStream input,
int[] constantPool)
Read the declared methods of the class being read |
(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. |
RVMMethod |
MethodReference.resolve()
Find the RVMMethod that this field reference refers to using the search order specified in JVM specification 5.4.3.3. |
RVMMethod |
MethodReference.resolveInterfaceMethod()
Find the RVMMethod that this member reference refers to using the search order specified in JVM spec 5.4.3.4. |
private RVMMethod |
MethodReference.resolveInterfaceMethodInternal(RVMClass declaringClass)
Find the RVMMethod that this member reference refers to using the search order specified in JVM spec 5.4.3.4. |
private RVMMethod |
MethodReference.resolveInternal(RVMClass declaringClass)
Find the RVMMethod that this member reference refers to using the search order specified in JVM spec 5.4.3.3. |
RVMMethod |
MethodReference.resolveInvokeSpecial()
Resolve the method reference for an invoke special into a target method, if that is possible without causing classloading. |
private RVMMethod |
MethodReference.searchInterfaceMethods(RVMClass c)
|
| Methods in org.jikesrvm.classloader with parameters of type RVMMethod | |
|---|---|
void |
InterfaceInvocation.IMTDict.addElement(InterfaceMethodSignature sig,
RVMMethod m)
|
(package private) void |
MethodVector.addElement(RVMMethod item)
|
void |
MethodVector.addUniqueElement(RVMMethod item)
|
protected CompiledMethod |
SpecializedMethod.compileSpecializedMethod(RVMMethod template,
TypeReference[] specializedParams)
Compile a specialized version of a template method. |
(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. |
(package private) static Class<?> |
RVMClass.createReflectionClass(RVMMethod methodToCall)
Create a synthetic class that extends ReflectionBase and invokes the given method |
(package private) static RVMMethod |
ClassFileReader.getClassInitializerMethod(RVMMethod[] declaredMethods)
Return the class initializer method among the declared methods of the class |
boolean |
MemberReference.needsDynamicLink(RVMMethod that)
Is dynamic linking code required to access "this" member when referenced from "that" method? |
private void |
RVMClass.resolveNativeMethodsInternal(RVMMethod[] methods)
|
(package private) void |
MethodVector.setElementAt(RVMMethod item,
int index)
|
(package private) void |
MethodReference.setResolvedMember(RVMMethod it)
For use by RVMMethod constructor |
void |
RVMClass.updateJTOCEntry(RVMMethod m)
Update the JTOC slot for the given static method to point to the current compiled code for the given method. |
void |
RVMClass.updateMethod(RVMMethod m)
Given a method declared by this class, update all dispatching tables to refer to the current compiled code for the method. |
static void |
InterfaceInvocation.updateTIBEntry(RVMClass klass,
RVMMethod m)
If there is an an IMT or ITable entry that contains compiled code for the argument method, then update it to contain the current compiled code for the method. |
void |
RVMClass.updateTIBEntry(RVMMethod m)
Update this class's TIB entry for the given method to point to the current compiled code for the given method. |
void |
RVMClass.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. |
| Constructors in org.jikesrvm.classloader with parameters of type RVMMethod | |
|---|---|
InterfaceInvocation.IMTDict.Link(InterfaceMethodSignature sig,
RVMMethod m,
InterfaceInvocation.IMTDict.Link n)
|
|
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 |
|
| Uses of RVMMethod in org.jikesrvm.compilers.baseline |
|---|
| Methods in org.jikesrvm.compilers.baseline with parameters of type RVMMethod | |
|---|---|
protected void |
TemplateCompilerFramework.checkTarget(RVMMethod target,
int bci)
Ensure that the callee method is safe to invoke from uninterruptible code |
protected abstract void |
TemplateCompilerFramework.emit_resolved_invokespecial(MethodReference methodRef,
RVMMethod target)
Emit code to implement a dynamically linked invokespecial |
boolean |
ReferenceMaps.isLocalRefType(RVMMethod method,
Offset mcoff,
int lidx)
Query if a local variable has a reference type value |
int |
ReferenceMaps.locateGCPoint(Offset machCodeOffset,
RVMMethod method)
Given a machine code instruction offset, return an index to identify the stack map closest to the offset ( but not beyond). |
protected void |
TemplateCompilerFramework.printEndHeader(RVMMethod method)
Print a message to mark the end of machine code printing for a method |
protected void |
TemplateCompilerFramework.printStartHeader(RVMMethod method)
Print a message to mark the start of machine code printing for a method |
int |
ReferenceMaps.showReferenceMapStatistics(RVMMethod method)
|
| Constructors in org.jikesrvm.compilers.baseline with parameters of type RVMMethod | |
|---|---|
BaselineCompiledMethod(int id,
RVMMethod m)
Constructor |
|
| Uses of RVMMethod in org.jikesrvm.compilers.baseline.ia32 |
|---|
| Methods in org.jikesrvm.compilers.baseline.ia32 with parameters of type RVMMethod | |
|---|---|
protected void |
BaselineCompilerImpl.emit_resolved_invokespecial(MethodReference methodRef,
RVMMethod target)
|
(package private) static boolean |
BaselineMagic.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
Entry point to generating magic |
(package private) abstract void |
BaselineMagic.MagicGenerator.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.EarlyReferenceCheckDecorator.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LateReferenceCheckDecorator.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Load32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Load32_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Load32_MD.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadByte.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadByte_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadUnsignedByte_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadShort.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadShort_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadChar.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadChar_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Load64.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Load64_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store32_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store32_MD.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store8.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store8_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store8.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store8_MD.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store16.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store16_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store16.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store16_MD.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store64.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store64_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store64.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Store64_MD.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Attempt32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Attempt32_Offset.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Attempt32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Magic_Attempt64.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Prefetch.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetObjectType.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Nop.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.MFence.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.FreeStackSlot.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.DuplicateStackSlot.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.QuadZeroExtend.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.QuadSignExtend.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.AddressConstant.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.AddressComparison.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.AddressComparison_isZero.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.AddressComparison_isMax.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordPlus.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordPlus32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordMinus.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordMinus32.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordAnd.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordOr.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordXor.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordLsh.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordRshl.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordRsha.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordNot.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.WordToLong.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.SetRegister.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetRegister.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeMethodReturningObject.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeMethodReturningVoid.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeMethodReturningInt.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeMethodReturningLong.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeMethodReturningFloat.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeMethodReturningDouble.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeEntryPoint.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.DynamicBridgeTo.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.ReturnToNewStack.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.InvokeClassInitializer.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetFramePointer.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetValueAtDisplacement.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.SetValueAtDisplacement.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.CreateArray.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Load32_Array.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Load64_Array.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.LoadByte_Array.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store32_Array.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store64_Array.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Store8_Array.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetReturnAddressLocation.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetTimeBase.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Pause.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Fsqrt.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.Dsqrt.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.GetInlineDepth.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
(package private) void |
BaselineMagic.IsConstantParameter.generateMagic(ArchitectureSpecific.Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
|
| Uses of RVMMethod in org.jikesrvm.compilers.common |
|---|
| Fields in org.jikesrvm.compilers.common declared as RVMMethod | |
|---|---|
RVMMethod |
CompiledMethod.method
The RVMMethod that was compiled |
| Methods in org.jikesrvm.compilers.common that return RVMMethod | |
|---|---|
RVMMethod |
CompiledMethod.getMethod()
Return the RVMMethod associated with this compiled method |
| Methods in org.jikesrvm.compilers.common with parameters of type RVMMethod | |
|---|---|
static CompiledMethod |
CompiledMethods.createCompiledMethod(RVMMethod m,
int compilerType)
Create a CompiledMethod appropriate for the given compilerType |
| Constructors in org.jikesrvm.compilers.common with parameters of type RVMMethod | |
|---|---|
CompiledMethod(int id,
RVMMethod m)
Set the cmid and method fields |
|
HardwareTrapCompiledMethod(int id,
RVMMethod m)
|
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt |
|---|
| Fields in org.jikesrvm.compilers.opt with type parameters of type RVMMethod | |
|---|---|
private ImmutableEntryHashMapRVM<RVMMethod,FieldDatabase.FieldWriterInfo> |
FieldDatabase.FieldDatabaseEntry.summaries
|
| Methods in org.jikesrvm.compilers.opt that return RVMMethod | |
|---|---|
static RVMMethod |
ClassLoaderProxy.lookupMethod(RVMClass cls,
MethodReference ref)
Find the method of the given class that matches the given descriptor. |
| Methods in org.jikesrvm.compilers.opt with parameters of type RVMMethod | |
|---|---|
(package private) FieldDatabase.FieldWriterInfo |
FieldDatabase.FieldDatabaseEntry.findMethodInfo(RVMMethod m)
|
private static void |
FieldAnalysis.recordBottom(RVMMethod m,
RVMField f)
Record that a method writes an unknown concrete type to a field. |
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. |
| Uses of RVMMethod in org.jikesrvm.compilers.opt.driver |
|---|
| Methods in org.jikesrvm.compilers.opt.driver with parameters of type RVMMethod | |
|---|---|
private boolean |
OptimizingBootImageCompiler.match(RVMMethod method)
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.escape |
|---|
| Fields in org.jikesrvm.compilers.opt.escape with type parameters of type RVMMethod | |
|---|---|
private static ImmutableEntryHashMapRVM<RVMMethod,MethodSummary> |
SummaryDatabase.hash
|
| Methods in org.jikesrvm.compilers.opt.escape with parameters of type RVMMethod | |
|---|---|
static MethodSummary |
SummaryDatabase.findMethodSummary(RVMMethod m)
Lookup a given method in the database |
static MethodSummary |
SummaryDatabase.findOrCreateMethodSummary(RVMMethod m)
|
private static MethodSummary |
SimpleEscape.findOrCreateMethodSummary(RVMMethod m,
OptOptions options)
If a method summary exists for a method, get it. |
private static void |
SimpleEscape.performSimpleEscapeAnalysis(RVMMethod m,
OptOptions options)
Perform the simple escape analysis for a method. |
| Constructors in org.jikesrvm.compilers.opt.escape with parameters of type RVMMethod | |
|---|---|
MethodSummary(RVMMethod m)
|
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.hir2lir |
|---|
| Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type RVMMethod | |
|---|---|
(package private) static RegisterOperand |
ConvertToLowLevelIR.getInstanceMethod(Instruction s,
IR ir,
Operand tib,
RVMMethod method)
Get an instance method from a TIB |
private void |
ExpandRuntimeServices.primitiveArrayStoreHelper(RVMMethod target,
Instruction inst,
Instruction next,
IR ir)
Helper method to generate call to primitive arrayStore write barrier |
private void |
ExpandRuntimeServices.primitiveObjectFieldStoreHelper(RVMMethod target,
Instruction inst,
Instruction next,
IR ir,
FieldReference fieldRef)
Helper method to generate call to primitive putfield write barrier |
| Uses of RVMMethod in org.jikesrvm.compilers.opt.inlining |
|---|
| Fields in org.jikesrvm.compilers.opt.inlining declared as RVMMethod | |
|---|---|
private RVMMethod[] |
InlineDecision.targets
The set of methods to inline. |
| Fields in org.jikesrvm.compilers.opt.inlining with type parameters of type RVMMethod | |
|---|---|
private HashMapRVM<RVMMethod,InvalidationDatabase.MethodSet> |
InvalidationDatabase.nonOverriddenHash
A mapping from RVMMethod to MethodSet: holds the set of methods which depend on a particular method being "final" |
| Methods in org.jikesrvm.compilers.opt.inlining that return RVMMethod | |
|---|---|
RVMMethod[] |
InlineDecision.getTargets()
Return the methods to inline according to this decision. |
static RVMMethod |
InterfaceHierarchy.getUniqueImplementation(RVMMethod foo)
If, in the current class hierarchy, there is exactly one method that defines the interface method foo, then return the unique implementation. |
RVMMethod |
CompilationState.obtainTarget()
Obtain the target method from the compilation state. |
| Methods in org.jikesrvm.compilers.opt.inlining with parameters of type RVMMethod | |
|---|---|
void |
ClassLoadingDependencyManager.addNotOverriddenDependency(RVMMethod source,
CompiledMethod cm)
Record that the code currently being compiled (cm) must be invalidated if source is overridden. |
void |
InvalidationDatabase.addNotOverriddenDependency(RVMMethod source,
int dependent_cmid)
Record that if a particular RVMMethod method is ever overridden, then the CompiledMethod encoded by the cmid must be invalidated. |
private byte |
DefaultInlineOracle.chooseGuard(RVMMethod caller,
RVMMethod singleImpl,
RVMMethod callee,
CompilationState state,
boolean codePatchSupported)
Logic to select the appropriate guarding mechanism for the edge from caller to callee according to the controlling OptOptions. |
boolean |
InlineSequence.containsMethod(RVMMethod m)
Does this inline sequence contain a given method? |
static RVMMethod |
InterfaceHierarchy.getUniqueImplementation(RVMMethod foo)
If, in the current class hierarchy, there is exactly one method that defines the interface method foo, then return the unique implementation. |
static InlineDecision |
InlineDecision.guardedYES(RVMMethod[] targets,
byte[] guards,
String reason)
Return a decision YES to do a guarded inline. |
static InlineDecision |
InlineDecision.guardedYES(RVMMethod target,
byte guard,
String reason)
Return a decision YES to do a guarded inline. |
static boolean |
InlineTools.hasBody(RVMMethod callee)
Does the callee method have a body? |
static boolean |
InlineTools.hasInlinePragma(RVMMethod callee,
CompilationState state)
Should the callee method always be inlined? |
static boolean |
InlineTools.hasNoInlinePragma(RVMMethod callee,
CompilationState state)
Should the callee method be barred from ever being considered for inlining? |
Iterator<Integer> |
InvalidationDatabase.invalidatedByOverriddenMethod(RVMMethod m)
Returns an iteration of CMID's (compiled method ids) that are dependent on the argument RVMMethod not being overridden. |
static boolean |
InlineTools.isCurrentlyFinal(RVMMethod callee,
boolean searchSubclasses)
Is the method CURRENTLY final (not overridden by any subclass)? |
static boolean |
InlineTools.isForbiddenSpeculation(RVMMethod caller,
RVMMethod callee)
Is it safe to speculatively inline the callee into the caller? |
static boolean |
InlineTools.needsGuard(RVMMethod callee)
Does an inlined call to callee need a guard, to protect against a mispredicted dynamic dispatch? |
static InlineDecision |
InlineDecision.NO(RVMMethod target,
String reason)
Return a decision NOT to inline. |
private void |
ClassLoadingDependencyManager.processOverride(RVMMethod overridden)
|
void |
InvalidationDatabase.removeNotOverriddenDependency(RVMMethod source)
Delete all NotOverridden dependencies on the argument RVMMethod |
void |
InvalidationDatabase.removeNotOverriddenDependency(RVMMethod source,
int dependent_cmid)
Delete a NotOverriddenDependency. |
static InlineDecision |
InlineDecision.YES(RVMMethod target,
String reason)
Return a decision to inline without a guard. |
| Constructors in org.jikesrvm.compilers.opt.inlining with parameters of type RVMMethod | |
|---|---|
InlineDecision(RVMMethod[] targets,
byte[] guards,
InlineDecision.Code code,
String reason)
|
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.ir |
|---|
| Constructors in org.jikesrvm.compilers.opt.ir with parameters of type RVMMethod | |
|---|---|
GenericRegisterPool(RVMMethod meth)
Initializes a new register pool for the method meth. |
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.ir.ia32 |
|---|
| Constructors in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type RVMMethod | |
|---|---|
RegisterPool(RVMMethod meth)
Initializes a new register pool for the method meth. |
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.ir.operand |
|---|
| Fields in org.jikesrvm.compilers.opt.ir.operand declared as RVMMethod | |
|---|---|
(package private) RVMMethod |
MethodOperand.target
Target RVMMethod of invocation. |
RVMMethod |
CodeConstantOperand.value
The non- null method for the code represent |
| Methods in org.jikesrvm.compilers.opt.ir.operand that return RVMMethod | |
|---|---|
RVMMethod |
MethodOperand.getTarget()
|
| Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type RVMMethod | |
|---|---|
static MethodOperand |
MethodOperand.COMPILED(RVMMethod callee,
Offset offset)
Returns a method operand representing a compiled method with designated JTOC offset. |
static MethodOperand |
MethodOperand.INTERFACE(MethodReference ref,
RVMMethod target)
create a method operand for an INVOKE_INTERFACE bytecode |
void |
MethodOperand.refine(RVMMethod target)
Refine the target information. |
void |
MethodOperand.refine(RVMMethod target,
boolean isPreciseTarget)
Refine the target information. |
static MethodOperand |
MethodOperand.SPECIAL(MethodReference ref,
RVMMethod target)
create a method operand for an INVOKE_SPECIAL bytecode |
static MethodOperand |
MethodOperand.STATIC(MethodReference ref,
RVMMethod target)
create a method operand for an INVOKE_STATIC bytecode |
static MethodOperand |
MethodOperand.STATIC(RVMMethod target)
create a method operand for an INVOKE_STATIC bytecode where the target method is known at compile time. |
static MethodOperand |
MethodOperand.VIRTUAL(MethodReference ref,
RVMMethod target)
create a method operand for an INVOKE_VIRTUAL bytecode |
| Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type RVMMethod | |
|---|---|
CodeConstantOperand(RVMMethod v)
Construct a new code constant operand |
|
MethodOperand(MemberReference ref,
RVMMethod tar,
byte t)
|
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.mir2mc.ia32 |
|---|
| Methods in org.jikesrvm.compilers.opt.mir2mc.ia32 with parameters of type RVMMethod | |
|---|---|
private static void |
FinalMIRExpansion.expandUnconditionalYieldpoint(Instruction s,
IR ir,
RVMMethod meth)
|
private static void |
FinalMIRExpansion.expandYieldpoint(Instruction s,
IR ir,
RVMMethod meth,
IA32ConditionOperand ypCond)
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.runtimesupport |
|---|
| Methods in org.jikesrvm.compilers.opt.runtimesupport with parameters of type RVMMethod | |
|---|---|
boolean |
OptMachineCodeMap.hasInlinedEdge(RVMMethod caller,
int bcIndex,
RVMMethod callee)
This method searches the machine code maps and determines if the given call edge is definitely inlined into the method. |
private void |
OptMachineCodeMap.recordStats(RVMMethod method,
int mapSize,
int machineCodeSize,
boolean DUMP_MAP_SIZES)
Gather cumulative stats about the space consumed by maps. |
| Constructors in org.jikesrvm.compilers.opt.runtimesupport with parameters of type RVMMethod | |
|---|---|
OptCompiledMethod(int id,
RVMMethod m)
|
|
| Uses of RVMMethod in org.jikesrvm.compilers.opt.specialization |
|---|
| Fields in org.jikesrvm.compilers.opt.specialization with type parameters of type RVMMethod | |
|---|---|
private static ImmutableEntryHashMapRVM<RVMMethod,SpecializationDatabase.MethodSet<RVMMethod>> |
SpecializationDatabase.specialVersionsHash
|
private static ImmutableEntryHashMapRVM<RVMMethod,SpecializationDatabase.MethodSet<RVMMethod>> |
SpecializationDatabase.specialVersionsHash
|
| Methods in org.jikesrvm.compilers.opt.specialization with parameters of type RVMMethod | |
|---|---|
(package private) static int |
SpecializationDatabase.getSpecialVersionCount(RVMMethod m)
|
(package private) static Iterator<SpecializedMethod> |
SpecializationDatabase.getSpecialVersions(RVMMethod m)
Return an iteration of SpecializedMethods that represents specialized compiled versions of the method pointed by RVMMethod |
| Uses of RVMMethod in org.jikesrvm.ia32 |
|---|
| Methods in org.jikesrvm.ia32 with parameters of type RVMMethod | |
|---|---|
static int |
MachineReflection.countParameters(RVMMethod method)
Determine number/type of registers and parameters required to call specified method. |
static ArchitectureSpecific.CodeArray |
InterfaceMethodConflictResolver.createStub(int[] sigIds,
RVMMethod[] targets)
|
private static void |
InterfaceMethodConflictResolver.insertStubCase(Assembler asm,
int[] sigIds,
RVMMethod[] targets,
int[] bcIndices,
int low,
int high)
|
static void |
MachineReflection.packageParameters(RVMMethod method,
Object thisArg,
Object[] otherArgs,
WordArray GPRs,
double[] FPRs,
byte[] FPRmeta,
WordArray Parameters)
Collect parameters into arrays of registers/spills, as required to call specified method. |
| Uses of RVMMethod in org.jikesrvm.jni |
|---|
| Constructors in org.jikesrvm.jni with parameters of type RVMMethod | |
|---|---|
JNICompiledMethod(int id,
RVMMethod m)
|
|
| Uses of RVMMethod in org.jikesrvm.jni.ia32 |
|---|
| Methods in org.jikesrvm.jni.ia32 with parameters of type RVMMethod | |
|---|---|
static void |
JNICompiler.generateEpilogForJNIMethod(Assembler asm,
RVMMethod method)
Handle the C to Java transition: JNI methods in JNIFunctions.java. |
(package private) static Object[] |
JNIHelpers.packageParameterFromJValue(RVMMethod targetMethod,
Address argAddress)
Repackage the arguments passed as an array of jvalue into an array of Object, used by the JNI functions CallStatic |
(package private) static Object[] |
JNIHelpers.packageParameterFromVarArg(RVMMethod targetMethod,
Address argAddress)
Repackage the arguments passed as a variable argument list into an array of Object, used by the JNI functions CallStatic |
| Uses of RVMMethod in org.jikesrvm.mm.mminterface |
|---|
| Methods in org.jikesrvm.mm.mminterface with parameters of type RVMMethod | |
|---|---|
static int |
MemoryManager.pickAllocator(RVMType type,
RVMMethod method)
Returns the appropriate allocation scheme/area for the given type and given method requesting the allocation. |
| Uses of RVMMethod in org.jikesrvm.mm.mmtk |
|---|
| Methods in org.jikesrvm.mm.mmtk with parameters of type RVMMethod | |
|---|---|
private void |
ScanThread.printMethod(RVMMethod m)
Print out the name of a method |
| Uses of RVMMethod in org.jikesrvm.osr.bytecodes |
|---|
| Methods in org.jikesrvm.osr.bytecodes that return RVMMethod | |
|---|---|
static RVMMethod |
InvokeStatic.targetMethod(int tid)
|
| Uses of RVMMethod in org.jikesrvm.runtime |
|---|
| Fields in org.jikesrvm.runtime declared as RVMMethod | |
|---|---|
private RVMMethod |
StackBrowser.currentMethod
Method associated with current stack location |
static RVMMethod |
Entrypoints.getClassFromStackFrame
|
static RVMMethod |
Entrypoints.getClassLoaderFromStackFrame
|
static RVMMethod |
Entrypoints.java_lang_reflect_Method_invokeMethod
|
static RVMMethod |
Entrypoints.jniEntry
|
static RVMMethod |
Entrypoints.jniExit
|
static RVMMethod |
Entrypoints.jniThrowPendingException
|
private RVMMethod |
StackTrace.Element.method
Stack trace's method, null => invisible or trap |
| Methods in org.jikesrvm.runtime that return RVMMethod | |
|---|---|
RVMMethod |
StackBrowser.getMethod()
The method associated with the current stack frame |
static RVMMethod |
EntrypointHelper.getMethod(Class<?> klass,
Atom member,
Class<?>... argTypes)
|
(package private) static RVMMethod |
DynamicLinker.DL_Helper.resolveMethodRef(DynamicLink dynamicLink)
Resolve method ref into appropriate RVMMethod Taken: DynamicLink that describes call site. |
| Methods in org.jikesrvm.runtime with parameters of type RVMMethod | |
|---|---|
static Object |
RuntimeEntrypoints.buildMDAHelper(RVMMethod method,
int[] numElements,
int dimIndex,
RVMArray arrayType)
|
(package private) static void |
DynamicLinker.DL_Helper.compileMethod(DynamicLink dynamicLink,
RVMMethod targetMethod)
Compile (if necessary) targetMethod and patch the appropriate disaptch tables |
Object |
ReflectionBase.invoke(RVMMethod method,
Object obj,
Object[] args)
Invoke reflective method being wrapped by this object |
static Object |
Reflection.invoke(RVMMethod method,
ReflectionBase invoker,
Object thisArg,
Object[] otherArgs,
boolean isNonvirtual)
Call a method. |
private static Object |
Reflection.outOfLineInvoke(RVMMethod method,
Object thisArg,
Object[] otherArgs,
boolean isNonvirtual)
|
void |
StackBrowser.setMethod(RVMMethod method)
Set the current method, called only by the appropriate compiled method code |
| Constructors in org.jikesrvm.runtime with parameters of type RVMMethod | |
|---|---|
StackTrace.Element(RVMMethod method,
int ln)
Constructor for opt compiled methods |
|
| Uses of RVMMethod in org.jikesrvm.scheduler |
|---|
| Fields in org.jikesrvm.scheduler declared as RVMMethod | |
|---|---|
private RVMMethod |
MainThread.mainMethod
|
| Methods in org.jikesrvm.scheduler that return RVMMethod | |
|---|---|
(package private) RVMMethod |
MainThread.getMainMethod()
|
| Methods in org.jikesrvm.scheduler with parameters of type RVMMethod | |
|---|---|
private static void |
RVMThread.showMethod(RVMMethod method,
int lineNumber,
Address fp)
Helper function for RVMThread.dumpStack(Address,Address). |
| Uses of RVMMethod in org.jikesrvm.tools.oth |
|---|
| Fields in org.jikesrvm.tools.oth with type parameters of type RVMMethod | |
|---|---|
(package private) static Vector<RVMMethod> |
OptTestHarness.baselineMethodVector
|
(package private) static Vector<RVMMethod> |
OptTestHarness.optMethodVector
|
(package private) static Vector<RVMMethod> |
OptTestHarness.reflectMethodVector
|
| Methods in org.jikesrvm.tools.oth that return RVMMethod | |
|---|---|
(package private) static RVMMethod |
OptTestHarness.findDeclaredOrFirstMethod(RVMClass klass,
String methname,
String methdesc)
Finds a method, either one with a given descriptor or the first matching one in in the given class. |
| Methods in org.jikesrvm.tools.oth with parameters of type RVMMethod | |
|---|---|
private static void |
OptTestHarness.processMethod(RVMMethod method,
OptOptions opts)
|
private static void |
OptTestHarness.processMethod(RVMMethod method,
OptOptions opts,
boolean isBaseline)
|
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||