| Modifier and Type | Method and Description |
|---|---|
static void |
VM.sysWriteln(int i,
Address a,
RVMMethod m) |
| Modifier and Type | Field and Description |
|---|---|
private static ImmutableEntryHashMapRVM<RVMMethod,LinkedList<ControllerPlan>> |
ControllerMemory.table
This is a hashtable of controller plans indexed by RVMMethod.
|
| Modifier and Type | Method and Description |
|---|---|
RVMMethod |
HotMethodEvent.getMethod() |
| Modifier and Type | Method and Description |
|---|---|
(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.
|
| Modifier and Type | Field and Description |
|---|---|
private RVMMethod |
CallSite.method
Caller method
|
(package private) RVMMethod[] |
WeightedCallTargets.MultiTarget.methods |
private RVMMethod |
WeightedCallTargets.SingleTarget.target |
| Modifier and Type | Method and Description |
|---|---|
RVMMethod |
CallSite.getMethod() |
| Modifier and Type | Method and Description |
|---|---|
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) |
| Constructor and Description |
|---|
CallSite(RVMMethod m,
int bci) |
SingleTarget(RVMMethod t,
double w) |
| Modifier and Type | Method and Description |
|---|---|
private static RVMMethod |
DynamicCallFileInfoReader.getMethod(MethodReference ref)
Establish the RVMMethod for a given MethodReference gracefully.
|
| Modifier and Type | Method and Description |
|---|---|
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
|
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Field and Description |
|---|---|
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
|
| Modifier and Type | Field and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
(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() |
(package private) static RVMMethod |
ClassFileReader.getClassInitializerMethod(RVMMethod[] declaredMethods)
Returns the class initializer method among the declared methods of the class
|
RVMMethod[] |
RVMClass.getConstructorMethods() |
RVMMethod[] |
RVMClass.getDeclaredMethods() |
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[] |
RVMClass.getStaticMethods() |
abstract RVMMethod[] |
RVMType.getStaticMethods() |
RVMMethod[] |
Primitive.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 |
RVMType.getTIBMethodAtSlot(int slot)
Return the method at the given TIB slot
|
RVMMethod[] |
RVMClass.getVirtualMethods() |
abstract RVMMethod[] |
RVMType.getVirtualMethods() |
RVMMethod[] |
Primitive.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 |
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) |
(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()
Resolves the method reference for an invoke special into a target
method, if that is possible without causing classloading.
|
private RVMMethod |
MethodReference.searchInterfaceMethods(RVMClass c) |
| Modifier and Type | Method and Description |
|---|---|
void |
InterfaceInvocation.IMTDict.addElement(InterfaceMethodSignature sig,
RVMMethod m) |
(package private) void |
MethodVector.addElement(RVMMethod item) |
void |
MethodVector.addUniqueElement(RVMMethod item)
Adds an item if it is not already in the vector.
|
protected CompiledMethod |
SpecializedMethod.compileSpecializedMethod(RVMMethod template,
TypeReference[] specializedParams)
Compile a specialized version of a template method.
|
(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)
Returns 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) |
(package private) static void |
RVMType.updateArrayMethods(RVMMethod m)
Updates the TIB for all array types with the newly (re)compiled method.
|
void |
RVMClass.updateJTOCEntry(RVMMethod m)
Updates 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)
Updates 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.
|
| Constructor and Description |
|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Constructor and Description |
|---|
BaselineCompiledMethod(int id,
RVMMethod m) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
BaselineCompilerImpl.emit_resolved_invokespecial(MethodReference methodRef,
RVMMethod target) |
(package private) static boolean |
BaselineMagic.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd)
Entry point to generating magic
|
(package private) abstract void |
BaselineMagic.MagicGenerator.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.EarlyReferenceCheckDecorator.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LateReferenceCheckDecorator.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Load32.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Load64.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Load32_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Load64_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_LoadWord_MD.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadByte.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadByte_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadUnsignedByte_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadShort.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadShort_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadChar.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadChar_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadLong.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadLong_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store32.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store64.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store32_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store64_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store32.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store64.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store32_MD.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store64_MD.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store8.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store8_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store8.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store8_MD.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store16.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store16_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store16.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Store16_MD.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.StoreLong.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.StoreLong_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_StoreLong.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_StoreLong_MD.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Attempt.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Attempt_Offset.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_Attempt.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Magic_AttemptLong.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Prefetch.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetObjectType.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Nop.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.MFence.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.FreeStackSlot.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.DuplicateStackSlot.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.QuadZeroExtend.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.QuadSignExtend.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.AddressConstant.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.AddressComparison.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.AddressComparison_isZero.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.AddressComparison_isMax.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordPlus.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordPlus32.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordMinus.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordMinus32.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordAnd.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordOr.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordXor.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordLsh.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordRshl.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordRsha.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordNot.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.WordToLong.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.SetRegister.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetRegister.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeMethodReturningObject.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeMethodReturningVoid.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeMethodReturningInt.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeMethodReturningLong.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeMethodReturningFloat.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeMethodReturningDouble.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeEntryPoint.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.DynamicBridgeTo.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.ReturnToNewStack.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.InvokeClassInitializer.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetFramePointer.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetValueAtDisplacement.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.SetValueAtDisplacement.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.CreateArray.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Load32_Array.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Load64_Array.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.LoadByte_Array.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store32_Array.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store64_Array.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Store8_Array.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetReturnAddressLocation.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetTimeBase.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Pause.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Fsqrt.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.Dsqrt.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.GetInlineDepth.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
(package private) void |
BaselineMagic.IsConstantParameter.generateMagic(Assembler asm,
MethodReference m,
RVMMethod cm,
Offset sd) |
| Modifier and Type | Field and Description |
|---|---|
RVMMethod |
CompiledMethod.method
The RVMMethod that was compiled
|
| Modifier and Type | Method and Description |
|---|---|
RVMMethod |
CompiledMethod.getMethod() |
| Modifier and Type | Method and Description |
|---|---|
static CompiledMethod |
CompiledMethods.createCompiledMethod(RVMMethod m,
int compilerType) |
| Constructor and Description |
|---|
CompiledMethod(int id,
RVMMethod m) |
HardwareTrapCompiledMethod(int id,
RVMMethod m) |
| Modifier and Type | Field and Description |
|---|---|
private ImmutableEntryHashMapRVM<RVMMethod,FieldDatabase.FieldWriterInfo> |
FieldDatabase.FieldDatabaseEntry.summaries |
| Modifier and Type | Method and Description |
|---|---|
static RVMMethod |
ClassLoaderProxy.lookupMethod(RVMClass cls,
MethodReference ref)
Find the method of the given class that matches the given descriptor.
|
| Modifier and Type | Method and Description |
|---|---|
(package private) FieldDatabase.FieldWriterInfo |
FieldDatabase.FieldDatabaseEntry.findMethodInfo(RVMMethod m) |
private static void |
FieldAnalysis.recordBottom(RVMMethod m,
RVMField f)
Records 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.
|
| Modifier and Type | Method and Description |
|---|---|
private String |
CFGVisualization.determineFileName(IR ir,
String tag,
RVMMethod method) |
private boolean |
OptimizingBootImageCompiler.match(RVMMethod method) |
| Modifier and Type | Field and Description |
|---|---|
private static ImmutableEntryHashMapRVM<RVMMethod,MethodSummary> |
SummaryDatabase.hash |
| Modifier and Type | Method and Description |
|---|---|
static MethodSummary |
SummaryDatabase.findMethodSummary(RVMMethod m) |
static MethodSummary |
SummaryDatabase.findOrCreateMethodSummary(RVMMethod m) |
private static MethodSummary |
SimpleEscape.getMethodSummaryIfAvailable(RVMMethod m,
OptOptions options)
Returns a method summary if present.
|
private static void |
SimpleEscape.performSimpleEscapeAnalysis(RVMMethod m,
OptOptions options) |
| Constructor and Description |
|---|
MethodSummary(RVMMethod m) |
| Modifier and Type | Method and Description |
|---|---|
(package private) static RegisterOperand |
ConvertToLowLevelIR.getInstanceMethod(Instruction s,
IR ir,
Operand tib,
RVMMethod method) |
private void |
ExpandRuntimeServices.primitiveArrayStoreHelper(RVMMethod target,
Instruction inst,
IR ir)
Helper method to generate call to primitive arrayStore write barrier
|
private void |
ExpandRuntimeServices.primitiveObjectFieldStoreHelper(RVMMethod target,
Instruction inst,
IR ir,
FieldReference fieldRef)
Helper method to generate call to primitive putfield write barrier
|
| Modifier and Type | Field and Description |
|---|---|
private RVMMethod[] |
InlineDecision.targets
The set of methods to inline.
|
| Modifier and Type | Field and Description |
|---|---|
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"
|
| Modifier and Type | Method and Description |
|---|---|
RVMMethod[] |
InlineDecision.getTargets() |
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()
Obtains the target method from the compilation state.
|
| Modifier and Type | Method and Description |
|---|---|
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)
Records 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) |
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)
Deletes a NotOverriddenDependency.
|
static InlineDecision |
InlineDecision.YES(RVMMethod target,
String reason)
Return a decision to inline without a guard.
|
| Constructor and Description |
|---|
InlineDecision(RVMMethod[] targets,
byte[] guards,
InlineDecision.Code code,
String reason) |
| Constructor and Description |
|---|
GenericRegisterPool(RVMMethod meth)
Initializes a new register pool for the method meth.
|
| Constructor and Description |
|---|
RegisterPool(RVMMethod meth)
Initializes a new register pool for the method meth.
|
| Modifier and Type | Field and Description |
|---|---|
(package private) RVMMethod |
MethodOperand.target
Target RVMMethod of invocation.
|
RVMMethod |
CodeConstantOperand.value
The non-
null method for the code represent |
| Modifier and Type | Method and Description |
|---|---|
RVMMethod |
MethodOperand.getTarget() |
| Modifier and Type | Method and Description |
|---|---|
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)
Refines 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
|
| Constructor and Description |
|---|
CodeConstantOperand(RVMMethod v)
Construct a new code constant operand
|
MethodOperand(MemberReference ref,
RVMMethod tar,
byte t) |
| Constructor and Description |
|---|
RegisterPool(RVMMethod meth)
Initializes a new register pool for the method meth.
|
| Modifier and Type | Method and Description |
|---|---|
private static void |
FinalMIRExpansion.expandUnconditionalYieldpoint(Instruction s,
IR ir,
RVMMethod meth) |
private static void |
FinalMIRExpansion.expandYieldpoint(Instruction s,
IR ir,
RVMMethod meth,
IA32ConditionOperand ypCond) |
| Modifier and Type | Method and Description |
|---|---|
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) |
| Constructor and Description |
|---|
OptCompiledMethod(int id,
RVMMethod m) |
| Modifier and Type | Field and Description |
|---|---|
private static ImmutableEntryHashMapRVM<RVMMethod,SpecializationDatabase.MethodSet<RVMMethod>> |
SpecializationDatabase.specialVersionsHash |
private static ImmutableEntryHashMapRVM<RVMMethod,SpecializationDatabase.MethodSet<RVMMethod>> |
SpecializationDatabase.specialVersionsHash |
| Modifier and Type | Method and Description |
|---|---|
(package private) static int |
SpecializationDatabase.getSpecialVersionCount(RVMMethod m) |
(package private) static Iterator<SpecializedMethod> |
SpecializationDatabase.getSpecialVersions(RVMMethod m) |
| Modifier and Type | Method and Description |
|---|---|
static int |
MachineReflection.countParameters(RVMMethod method)
Determines number/type of registers and parameters required to
call specified method.
|
static 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)
Collects parameters into arrays of registers/spills, as required to
call specified method.
|
| Constructor and Description |
|---|
JNICompiledMethod(int id,
RVMMethod m) |
| Modifier and Type | Method and Description |
|---|---|
static void |
JNICompiler.generateEpilogForJNIMethod(Assembler asm,
RVMMethod method)
Handles the C to Java transition: JNI methods in JNIFunctions.java.
|
| Modifier and Type | Method and Description |
|---|---|
static int |
MemoryManager.pickAllocator(RVMType type,
RVMMethod method)
Returns the appropriate allocation scheme/area for the given type
and given method requesting the allocation.
|
| Modifier and Type | Method and Description |
|---|---|
private void |
ScanThread.printMethod(RVMMethod m)
Print out the name of a method
|
| Modifier and Type | Method and Description |
|---|---|
static RVMMethod |
InvokeStatic.targetMethod(int tid) |
| Modifier and Type | Field and Description |
|---|---|
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 |
protected RVMMethod |
StackTrace.Element.method
Stack trace's method, null => invisible or trap
|
| Modifier and Type | Method and Description |
|---|---|
RVMMethod |
StackBrowser.getMethod() |
static RVMMethod |
EntrypointHelper.getMethod(Class<?> klass,
Atom member,
Class<?>... argTypes) |
(package private) static RVMMethod |
DynamicLinker.DL_Helper.resolveMethodRef(DynamicLink dynamicLink)
Resolves a method ref into appropriate RVMMethod.
|
| Modifier and Type | Method and Description |
|---|---|
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 dispatch tables.
|
private StackTrace.Element |
StackTrace.createOptStackTraceElement(RVMMethod m,
int ln,
Offset mcOffset,
int bci) |
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.
|
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.
|
private static Object |
Reflection.outOfLineInvoke(RVMMethod method,
Object thisArg,
Object[] otherArgs,
boolean isNonvirtual) |
void |
StackBrowser.setMethod(RVMMethod method) |
| Constructor and Description |
|---|
Element(RVMMethod method,
int ln)
Constructor for opt compiled methods.
|
InternalStackTraceElement(RVMMethod method,
int ln,
Offset mcOffset,
int bci)
Constructor for opt compiled methods.
|
| Modifier and Type | Field and Description |
|---|---|
private RVMMethod |
MainThread.mainMethod |
| Modifier and Type | Method and Description |
|---|---|
(package private) RVMMethod |
MainThread.getMainMethod() |
| Modifier and Type | Method and Description |
|---|---|
private static void |
RVMThread.showMethod(RVMMethod method,
int lineNumber,
Address fp,
int bci,
Offset mcOffset)
Helper function for
RVMThread.dumpStack(Address,Address). |
| Modifier and Type | Field and Description |
|---|---|
(package private) Vector<RVMMethod> |
OptTestHarness.baselineMethodVector |
(package private) Vector<RVMMethod> |
OptTestHarness.optMethodVector |
(package private) Vector<RVMMethod> |
OptTestHarness.reflectMethodVector |
| Modifier and Type | Method and Description |
|---|---|
(package private) 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.
|
| Modifier and Type | Method and Description |
|---|---|
private Object |
OptTestHarness.attemptToInvokeDefaultConstructor(RVMMethod method) |
(package private) static String |
OptTestHarness.endOfExecutionString(RVMMethod method) |
private void |
OptTestHarness.processMethod(RVMMethod method,
OptOptions opts) |
private void |
OptTestHarness.processMethod(RVMMethod method,
OptOptions opts,
boolean isBaseline) |
(package private) static String |
OptTestHarness.startOfExecutionString(RVMMethod method) |