CompiledMethod (Jikes RVM API)

java.lang.Object
- org.jikesrvm.compilers.common.CompiledMethod

Direct Known Subclasses:

BaselineCompiledMethod, HardwareTrapCompiledMethod, JNICompiledMethod, OptCompiledMethod
```
public abstract class CompiledMethod
extends Object
```
A method that has been compiled into machine code by one of our compilers.

Field Summary

Fields
Modifier and Type	Field and Description
`private static byte`	`ACTIVE_ON_STACK`
`static int`	`BASELINE`
`private static byte`	`BRIDGE_FROM_NATIVE` Has bridge from native annotation, NB this makes the flags byte negative
`protected int`	`cmid` The compiled method id of this compiled method (index into CompiledMethods)
`protected float`	`compilationTime` The time in milliseconds taken to compile the method.
`private static byte`	`COMPILED`
`private byte`	`flags` Flags bit field
`protected CodeArray`	`instructions` The compiled machine code for said method.
`private static byte`	`INVALID`
`static int`	`JNI`
`RVMMethod`	`method` The RVMMethod that was compiled
`static int`	`NATIVE_METHOD_LINE_NUMBER` Line number for native methods defined by the constructor of java.lang.StackTraceElement
`static int`	`NUM_COMPILER_TYPES`
`private static byte`	`OBSOLETE`
`static int`	`OPT`
`protected int`	`osrJTOCoffset` the offset of instructions in JTOC, for osr-special compiled method only. all osr-ed method is treated like static.
`private static byte`	`OUTDATED` flags the compiled method as outdated, needs OSR
`private static byte`	`SAMPLES_RESET` Has the method sample data for this compiled method been reset?
`private static byte`	`SPECIAL_FOR_OSR`
`static int`	`TRAP`

Constructor Summary

Constructors
Constructor and Description

CompiledMethod(int id, RVMMethod m)

Constructors
Constructor and Description
`CompiledMethod(int id, RVMMethod m)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clearActiveOnStack()`
`CodeArray`	`codeArrayForOffset(Offset offset)` Return the code array for this method that contains the given offset.
`void`	`compileComplete(CodeArray code)` Records that the compilation is complete.
`static String`	`compilerTypeToString(int compilerType)`
`boolean`	`containsReturnAddress(Address ip)` Does the code for the compiled method contain the given return address?
`abstract int`	`findCatchBlockForInstruction(Offset instructionOffset, RVMType exceptionType)` Find "catch" block for a machine instruction of this method that might be guarded against specified class of exceptions by a "try" block.
`int`	`findLineNumberForInstruction(Offset instructionOffset)` Find source line number corresponding to one of this method's machine instructions.
`double`	`getCompilationTime()`
`abstract String`	`getCompilerName()`
`abstract int`	`getCompilerType()` Identify the compiler that produced this compiled method.
`abstract void`	`getDynamicLink(DynamicLink dynamicLink, Offset instructionOffset)` Fetch symbolic reference to a method that's called by one of this method's instructions.
`CodeArray`	`getEntryCodeArray()`
`abstract ExceptionDeliverer`	`getExceptionDeliverer()`
`int`	`getId()`
`Address`	`getInstructionAddress(Offset offset)` Return the address of the instruction at offset offset in the method's instruction stream.
`Offset`	`getInstructionOffset(Address ip)` Return the offset in bytes of the given Address from the start of the machine code array.
`Offset`	`getInstructionOffset(Address ip, boolean dieOnFailure)` Return the offset in bytes of the given Address from the start of the machine code array.
`RVMMethod`	`getMethod()`
`Offset`	`getOsrJTOCoffset()`
`boolean`	`getSamplesReset()`
`boolean`	`hasBridgeFromNativeAnnotation()`
`boolean`	`isActiveOnStack()`
`boolean`	`isCompiled()`
`boolean`	`isInvalid()`
`boolean`	`isObsolete()`
`boolean`	`isOutdated()`
`boolean`	`isSpecialForOSR()`
`abstract boolean`	`isWithinUninterruptibleCode(Offset instructionOffset)` Return whether or not the given address (which is purported to be inside of the compiled method's code array) corresponds to an uninterruptible context.
`int`	`numberOfInstructions()`
`abstract void`	`printStackTrace(Offset instructionOffset, PrintLN out)` Print this compiled method's portion of a stack trace
`abstract void`	`set(StackBrowser browser, Offset instr)` Set the stack browser to the innermost logical stack frame of this method.
`void`	`setActiveOnStack()`
`void`	`setCompilationTime(double ct)`
`void`	`setInvalid()` Mark the compiled method as invalid
`void`	`setObsolete()` Mark the compiled method as obsolete (ie a candidate for eventual GC)
`void`	`setOutdated()` Mark the compiled method as outdated (i.e. requires OSR), the flag is set in AnalyticModel
`void`	`setSamplesReset()`
`void`	`setSpecialForOSR()`
`int`	`size()`
`boolean`	`up(StackBrowser browser)` Advance the StackBrowser up one internal stack frame, if possible

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

- Field Detail
  - TRAP
```
public static final int TRAP
```
    See Also:
    
    Constant Field Values
  - BASELINE
```
public static final int BASELINE
```
    See Also:
    
    Constant Field Values
  - OPT
```
public static final int OPT
```
    See Also:
    
    Constant Field Values
  - JNI
```
public static final int JNI
```
    See Also:
    
    Constant Field Values
  - NUM_COMPILER_TYPES
```
public static final int NUM_COMPILER_TYPES
```
    See Also:
    
    Constant Field Values
  - NATIVE_METHOD_LINE_NUMBER
```
public static final int NATIVE_METHOD_LINE_NUMBER
```
    Line number for native methods defined by the constructor of java.lang.StackTraceElement
    
    See Also:
    
    Constant Field Values
  - COMPILED
```
private static final byte COMPILED
```
    See Also:
    
    Constant Field Values
  - INVALID
```
private static final byte INVALID
```
    See Also:
    
    Constant Field Values
  - OBSOLETE
```
private static final byte OBSOLETE
```
    See Also:
    
    Constant Field Values
  - ACTIVE_ON_STACK
```
private static final byte ACTIVE_ON_STACK
```
    See Also:
    
    Constant Field Values
  - OUTDATED
```
private static final byte OUTDATED
```
    flags the compiled method as outdated, needs OSR
    
    See Also:
    
    Constant Field Values
  - SAMPLES_RESET
```
private static final byte SAMPLES_RESET
```
    Has the method sample data for this compiled method been reset?
    
    See Also:
    
    Constant Field Values
  - SPECIAL_FOR_OSR
```
private static final byte SPECIAL_FOR_OSR
```
    See Also:
    
    Constant Field Values
  - BRIDGE_FROM_NATIVE
```
private static final byte BRIDGE_FROM_NATIVE
```
    Has bridge from native annotation, NB this makes the flags byte negative
    
    See Also:
    
    Constant Field Values
  - flags
```
private byte flags
```
    Flags bit field
  - cmid
```
protected final int cmid
```
    The compiled method id of this compiled method (index into CompiledMethods)
  - method
```
public final RVMMethod method
```
    The RVMMethod that was compiled
  - instructions
```
protected CodeArray instructions
```
    The compiled machine code for said method.
  - osrJTOCoffset
```
protected int osrJTOCoffset
```
    the offset of instructions in JTOC, for osr-special compiled method only. all osr-ed method is treated like static. TODO: OSR redesign: put in subclass? Stick somewhere else? Don't want to waste space for this on every compiled method.
  - compilationTime
```
protected float compilationTime
```
    The time in milliseconds taken to compile the method.
- Constructor Detail
  - CompiledMethod
```
public CompiledMethod(int id,
                      RVMMethod m)
```
    Parameters:
    
    id - the compiled method id
    
    m - the method that this compiled method belongs to
- Method Detail
  - setSamplesReset
```
public void setSamplesReset()
```
  - getSamplesReset
```
public boolean getSamplesReset()
```
  - setSpecialForOSR
```
public void setSpecialForOSR()
```
  - isSpecialForOSR
```
public boolean isSpecialForOSR()
```
  - getOsrJTOCoffset
```
public final Offset getOsrJTOCoffset()
```
  - getId
```
public final int getId()
```
    Returns:
    
    the compiled method id for this compiled method
  - getMethod
```
public final RVMMethod getMethod()
```
    Returns:
    
    the RVMMethod associated with this compiled method
  - hasBridgeFromNativeAnnotation
```
public final boolean hasBridgeFromNativeAnnotation()
```
    Returns:
    
    whether this method has a bridge from native annotation (important when walking the stack)
  - getEntryCodeArray
```
public final CodeArray getEntryCodeArray()
```
    Returns:
    
    the CodeArray to jump to to invoke this method (ie, code_array[0] contains the first instruction of the method's prologue).
  - numberOfInstructions
```
public final int numberOfInstructions()
```
    Returns:
    
    the number of machine instructions for compiled method; may be an overestimate if we have adding padding to machine code.
  - getInstructionOffset
```
public final Offset getInstructionOffset(Address ip)
```
    Return the offset in bytes of the given Address from the start of the machine code array.
    
    Parameters:
    
    ip - a Address (should be an interior pointer to instructions)
    
    Returns:
    
    offset of addr from start of instructions in bytes
  - getInstructionOffset
```
public final Offset getInstructionOffset(Address ip,
                                         boolean dieOnFailure)
```
    Return the offset in bytes of the given Address from the start of the machine code array.
    
    Parameters:
    
    ip - a Address (should be an interior pointer to instructions)
    
    dieOnFailure - if ip is invalid should we kill the VM (we don't want to if already in the process of killing the VM)
    
    Returns:
    
    offset of addr from start of instructions in bytes
  - getInstructionAddress
```
public final Address getInstructionAddress(Offset offset)
```
    Return the address of the instruction at offset offset in the method's instruction stream.
    
    Parameters:
    
    offset - the offset of the desired instruction (as returned by getInstructionOffset)
    
    Returns:
    
    Address of the specified instruction
  - codeArrayForOffset
```
public final CodeArray codeArrayForOffset(Offset offset)
```
    Return the code array for this method that contains the given offset.
    
    Parameters:
    
    offset - the offset of the desired instruction (as returned by getInstructionOffset)
    
    Returns:
    
    CodeArray that contains the specified instruction
  - containsReturnAddress
```
public final boolean containsReturnAddress(Address ip)
```
    Does the code for the compiled method contain the given return address?
    
    Parameters:
    
    ip - a return address
    
    Returns:
    
    true if it belongs to this method's code, false otherwise.
  - compileComplete
```
public final void compileComplete(CodeArray code)
```
    Records that the compilation is complete.
    
    Parameters:
    
    code - the method's code
  - setInvalid
```
public final void setInvalid()
```
    Mark the compiled method as invalid
  - setObsolete
```
public final void setObsolete()
```
    Mark the compiled method as obsolete (ie a candidate for eventual GC)
  - setActiveOnStack
```
public final void setActiveOnStack()
```
  - clearActiveOnStack
```
public final void clearActiveOnStack()
```
  - setOutdated
```
public final void setOutdated()
```
    Mark the compiled method as outdated (i.e. requires OSR), the flag is set in AnalyticModel
  - isOutdated
```
public final boolean isOutdated()
```
    Returns:
    
    true if the compiled method is marked as outdated
  - isCompiled
```
public final boolean isCompiled()
```
    Returns:
    
    true if compilation has completed
  - isInvalid
```
public final boolean isInvalid()
```
    Returns:
    
    true if the compiled code is invalid
  - isObsolete
```
public final boolean isObsolete()
```
    Returns:
    
    true if the compiled code is obsolete
  - isActiveOnStack
```
public final boolean isActiveOnStack()
```
  - getCompilationTime
```
public final double getCompilationTime()
```
  - setCompilationTime
```
public final void setCompilationTime(double ct)
```
  - getCompilerType
```
public abstract int getCompilerType()
```
    Identify the compiler that produced this compiled method.
    
    Returns:
    
    one of TRAP, BASELINE, OPT, or JNI. Note: use this instead of "instanceof" when GC is disabled (i.e. during GC)
  - compilerTypeToString
```
public static String compilerTypeToString(int compilerType)
```
  - getCompilerName
```
public abstract String getCompilerName()
```
    Returns:
    
    Name of the compiler that produced this compiled method.
  - getExceptionDeliverer
```
public abstract ExceptionDeliverer getExceptionDeliverer()
```
    Returns:
    
    a handler to deal with stack unwinding and exception delivery for this compiled method's stackframes.
  - findCatchBlockForInstruction
```
public abstract int findCatchBlockForInstruction(Offset instructionOffset,
                                                 RVMType exceptionType)
```
    Find "catch" block for a machine instruction of this method that might be guarded against specified class of exceptions by a "try" block.
    Notes:
    - The "instructionOffset" must point to the instruction following the actual instruction whose catch block is sought. This allows us to properly handle the case where the only address we have to work with is a return address (i.e. from a stackframe) or an exception address (i.e. from a null pointer dereference, array bounds check, or divide by zero) on a machine architecture with variable length instructions. In such situations we'd have no idea how far to back up the instruction pointer to point to the "call site" or "exception site".
    - This method must not cause any allocations, because it executes with GC disabled when called by RuntimeEntrypoints.deliverException().
    Parameters:
    
    instructionOffset - offset of machine instruction from start of this method, in bytes
    
    exceptionType - type of exception being thrown - something like "NullPointerException"
    
    Returns:
    
    offset of machine instruction for catch block (-1 --> no catch block)
  - getDynamicLink
```
public abstract void getDynamicLink(DynamicLink dynamicLink,
                                    Offset instructionOffset)
```
    Fetch symbolic reference to a method that's called by one of this method's instructions.
    Notes:
    - The "instructionOffset" must point to the instruction i following the call instruction whose target method is sought. This allows us to properly handle the case where the only address we have to work with is a return address (i.e. from a stackframe) on a machine architecture with variable length instructions. In such situations we'd have no idea how far to back up the instruction pointer to point to the "call site".
    - The implementation must not cause any allocations, because it executes with GC disabled when called by GCMapIterator.
    Parameters:
    
    dynamicLink - place to put return information
    
    instructionOffset - offset of machine instruction from start of this method, in bytes
  - findLineNumberForInstruction
```
public int findLineNumberForInstruction(Offset instructionOffset)
```
    Find source line number corresponding to one of this method's machine instructions.
    Usage note: "instructionOffset" must point to the instruction following the actual instruction whose line number is sought. This allows us to properly handle the case where the only address we have to work with is a return address (ie. from a stackframe) or an exception address (ie. from a null pointer dereference, array bounds check, or divide by zero) on a machine architecture with variable length instructions. In such situations we'd have no idea how far to back up the instruction pointer to point to the "call site" or "exception site".
    
    Parameters:
    
    instructionOffset - of machine instruction from start of this method, in bytes
    
    Returns:
    
    source line number (0 == no line info available, 1 == first line of source file, -2 == native method))
  - isWithinUninterruptibleCode
```
public abstract boolean isWithinUninterruptibleCode(Offset instructionOffset)
```
    Return whether or not the given address (which is purported to be inside of the compiled method's code array) corresponds to an uninterruptible context.
    
    Parameters:
    
    instructionOffset - of addr from start of instructions in bytes
    
    Returns:
    
    true if the IP is within an Uninterruptible method, false otherwise.
  - printStackTrace
```
public abstract void printStackTrace(Offset instructionOffset,
                                     PrintLN out)
```
    Print this compiled method's portion of a stack trace
    
    Parameters:
    
    instructionOffset - offset of machine instruction from start of method
    
    out - the PrintLN to print the stack trace to.
  - set
```
public abstract void set(StackBrowser browser,
                         Offset instr)
```
    Set the stack browser to the innermost logical stack frame of this method.
    
    Parameters:
    
    browser - the browser
    
    instr - the offset of the instruction
  - up
```
public boolean up(StackBrowser browser)
```
    Advance the StackBrowser up one internal stack frame, if possible
    
    Parameters:
    
    browser - the browser to advance
    
    Returns:
    
    whether the browser advanced a frame
  - size
```
public int size()
```
    Returns:
    
    the number of bytes used to encode the compiler-specific mapping information for this compiled method. Used to gather statistics on the space costs of mapping schemes.

Class CompiledMethod

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TRAP

BASELINE

OPT

JNI

NUM_COMPILER_TYPES

NATIVE_METHOD_LINE_NUMBER

COMPILED

INVALID

OBSOLETE

ACTIVE_ON_STACK

OUTDATED

SAMPLES_RESET

SPECIAL_FOR_OSR

BRIDGE_FROM_NATIVE

flags

cmid

method

instructions

osrJTOCoffset

compilationTime

Constructor Detail

CompiledMethod

Method Detail

setSamplesReset

getSamplesReset

setSpecialForOSR

isSpecialForOSR

getOsrJTOCoffset

getId

getMethod

hasBridgeFromNativeAnnotation

getEntryCodeArray

numberOfInstructions

getInstructionOffset

getInstructionOffset

getInstructionAddress

codeArrayForOffset

containsReturnAddress

compileComplete

setInvalid

setObsolete

setActiveOnStack

clearActiveOnStack

setOutdated

isOutdated

isCompiled

isInvalid

isObsolete

isActiveOnStack

getCompilationTime

setCompilationTime

getCompilerType

compilerTypeToString

getCompilerName

getExceptionDeliverer

findCatchBlockForInstruction

getDynamicLink

findLineNumberForInstruction

isWithinUninterruptibleCode

printStackTrace

set

up

size