CompilerToVM (Graal OpenJDK Project Documentation)

All Known Implementing Classes:

CompilerToVMImpl
```
public interface CompilerToVM
```
Calls from Java into HotSpot.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`int`	`allocateCompileId(long metaspaceMethod, int entryBCI)` Generate a unique id to identify the result of the compile.
`boolean`	`canInlineMethod(long metaspaceMethod)` Determines if a given metaspace Method can be inlined.
`long[]`	`collectCounters()` Collects the current values of all JVMCI benchmark counters, summed up over all threads.
`long`	`constantPoolKlassAt(long metaspaceConstantPool, int cpi)`
`int`	`constantPoolRemapInstructionOperandFromCache(long metaspaceConstantPool, int cpi)`
`String`	`disassembleCodeBlob(long codeBlob)`
`void`	`doNotInlineOrCompile(long metaspaceMethod)`
`int`	`exceptionTableLength(long metaspaceMethod)`
`long`	`exceptionTableStart(long metaspaceMethod)`
`Object`	`executeCompiledMethod(Object arg1, Object arg2, Object arg3, InstalledCode hotspotInstalledCode)`
`Object`	`executeCompiledMethodVarargs(Object[] args, InstalledCode hotspotInstalledCode)`
`long`	`findUniqueConcreteMethod(long actualHolderMetaspaceKlass, long metaspaceMethod)` Used to implement `ResolvedJavaType.findUniqueConcreteMethod(ResolvedJavaMethod)`.
`void`	`flushDebugOutput()`
`byte[]`	`getBytecode(long metaspaceMethod)` Copies the original bytecode of a given method into a new byte array and returns it.
`long`	`getClassInitializer(long metaspaceKlass)`
`String`	`getFileName(HotSpotResolvedJavaType method)`
`String`	`getGPUs()` Gets the names of the supported GPU architectures.
`Class<?>`	`getJavaMirror(long metaspaceKlass)`
`long`	`getKlassImplementor(long metaspaceKlass)` Returns the implementor for the given interface class, if there is a single implementor.
`long[]`	`getLineNumberTable(long metaspaceMethod)`
`int`	`getLocalVariableTableLength(long metaspaceMethod)`
`long`	`getLocalVariableTableStart(long metaspaceMethod)`
`long`	`getMaxCallTargetOffset(long address)`
`long`	`getMetaspaceMethod(Class<?> holder, int slot)` Gets the metaspace Method object corresponding to a given `Class` object and slot number.
`HotSpotStackFrameReference`	`getNextStackFrame(HotSpotStackFrameReference frame, long[] methods, int initialSkip)` Looks for the next Java stack frame with the given method.
`StackTraceElement`	`getStackTraceElement(long metaspaceMethod, int bci)`
`String`	`getSymbol(long metaspaceSymbol)` Gets the value of a metaspace `Symbol` as a String.
`long`	`getTimeStamp()` Fetch the time stamp used for printing inside hotspot.
`int`	`getVtableIndexForInterface(long metaspaceKlass, long metaspaceMethod)`
`boolean`	`hasBalancedMonitors(long metaspaceMethod)` Determines if a given metaspace Method object has balanced monitors.
`boolean`	`hasCompiledCodeForOSR(long metaspaceMethod, int entryBCI, int level)`
`boolean`	`hasFinalizableSubclass(long metaspaceKlass)`
`void`	`initializeConfiguration(HotSpotVMConfig config)`
`int`	`installCode(HotSpotCompiledCode compiledCode, InstalledCode code, SpeculationLog speculationLog)` Installs the result of a compilation into the code cache.
`void`	`invalidateInstalledCode(InstalledCode hotspotInstalledCode)`
`boolean`	`isMature(long metaspaceMethodData)`
`Object`	`lookupAppendixInPool(long metaspaceConstantPool, int cpi)`
`long`	`lookupKlassInPool(long metaspaceConstantPool, int cpi)` Looks up a class entry in a constant pool.
`int`	`lookupKlassRefIndexInPool(long metaspaceConstantPool, int cpi)`
`long`	`lookupMethodInPool(long metaspaceConstantPool, int cpi, byte opcode)` Looks up a method entry in a constant pool.
`int`	`lookupNameAndTypeRefIndexInPool(long metaspaceConstantPool, int cpi)`
`String`	`lookupNameRefInPool(long metaspaceConstantPool, int cpi)`
`String`	`lookupSignatureRefInPool(long metaspaceConstantPool, int cpi)`
`long`	`lookupType(String name, Class<?> accessingClass, boolean resolve)` Converts a name to a metaspace klass.
`void`	`materializeVirtualObjects(HotSpotStackFrameReference stackFrame, boolean invalidate)` Materialized all virtual objects within the given stack frame and update the locals within the given stackFrame object.
`boolean`	`methodIsIgnoredBySecurityStackWalk(long metaspaceMethod)` Determines if a given metaspace method is ignored by security stack walks.
`void`	`notifyCompilationStatistics(int id, HotSpotResolvedJavaMethod method, boolean osr, int processedBytecodes, long time, long timeUnitsPerSecond, InstalledCode installedCode)` Notifies the VM of statistics for a completed compilation.
`Object`	`readUncompressedOop(long address)` Reads an object pointer within a VM data structure.
`long`	`readUnsafeKlassPointer(Object o)`
`void`	`reprofile(long metaspaceMethod)` Invalidates the profiling information and restarts profiling upon the next invocation.
`void`	`resetCompilationStatistics()`
`Object`	`resolveConstantInPool(long metaspaceConstantPool, int cpi)`
`long`	`resolveField(long metaspaceConstantPool, int cpi, byte opcode, long[] info)` Looks up a field entry in a constant pool and attempts to resolve it.
`void`	`resolveInvokeDynamic(long metaspaceConstantPool, int index)`
`void`	`resolveInvokeHandle(long metaspaceConstantPool, int index)`
`long`	`resolveMethod(long metaspaceKlassExactReceiver, long metaspaceMethod, long metaspaceKlassCaller)`
`Object`	`resolvePossiblyCachedConstantInPool(long metaspaceConstantPool, int cpi)`
`boolean`	`shouldDebugNonSafepoints()`
`boolean`	`shouldInlineMethod(long metaspaceMethod)` Determines if a given metaspace Method should be inlined at any cost.
`void`	`writeDebugOutput(byte[] bytes, int offset, int length)`

- Method Detail
  - getBytecode
```
byte[] getBytecode(long metaspaceMethod)
```
    Copies the original bytecode of a given method into a new byte array and returns it.
    
    Parameters:
    
    metaspaceMethod - the metaspace Method object
    
    Returns:
    
    a new byte array containing the original bytecode
  - exceptionTableLength
```
int exceptionTableLength(long metaspaceMethod)
```
  - exceptionTableStart
```
long exceptionTableStart(long metaspaceMethod)
```
  - hasBalancedMonitors
```
boolean hasBalancedMonitors(long metaspaceMethod)
```
    Determines if a given metaspace Method object has balanced monitors.
    
    Parameters:
    
    metaspaceMethod - the metaspace Method object to query
    
    Returns:
    
    true if the method has balanced monitors
  - canInlineMethod
```
boolean canInlineMethod(long metaspaceMethod)
```
    Determines if a given metaspace Method can be inlined. A method may not be inlinable for a number of reasons such as:
    - a CompileOracle directive may prevent inlining or compilation of methods
    - the method may have a bytecode breakpoint set
    - the method may have other bytecode features that require special handling by the VM
    Parameters:
    
    metaspaceMethod - the metaspace Method object to query
    
    Returns:
    
    true if the method can be inlined
  - shouldInlineMethod
```
boolean shouldInlineMethod(long metaspaceMethod)
```
    Determines if a given metaspace Method should be inlined at any cost. This could be because:
    - a CompileOracle directive may forces inlining of this methods
    - an annotation forces inlining of this method
    Parameters:
    
    metaspaceMethod - the metaspace Method object to query
    
    Returns:
    
    true if the method should be inlined
  - findUniqueConcreteMethod
```
long findUniqueConcreteMethod(long actualHolderMetaspaceKlass,
                              long metaspaceMethod)
```
    Used to implement ResolvedJavaType.findUniqueConcreteMethod(ResolvedJavaMethod).
    
    Parameters:
    
    metaspaceMethod - the metaspace Method on which to based the search
    
    actualHolderMetaspaceKlass - the best known type of receiver
    
    Returns:
    
    the metaspace Method result or 0 is there is no unique concrete method for metaspaceMethod
  - getKlassImplementor
```
long getKlassImplementor(long metaspaceKlass)
```
    Returns the implementor for the given interface class, if there is a single implementor.
    
    Parameters:
    
    metaspaceKlass - the metaspace klass to get the implementor for
    
    Returns:
    
    the implementor as metaspace klass pointer if there is a single implementor, null if there is no implementor, or the input metaspace klass pointer (metaspaceKlass ) itself if there is more than one implementor.
  - methodIsIgnoredBySecurityStackWalk
```
boolean methodIsIgnoredBySecurityStackWalk(long metaspaceMethod)
```
    Determines if a given metaspace method is ignored by security stack walks.
    
    Parameters:
    
    metaspaceMethod - the metaspace Method object
    
    Returns:
    
    true if the method is ignored
  - lookupType
```
long lookupType(String name,
                Class<?> accessingClass,
                boolean resolve)
```
    Converts a name to a metaspace klass.
    
    Parameters:
    
    name - a well formed Java type in internal format
    
    accessingClass - the context of resolution (must not be null)
    
    resolve - force resolution to a ResolvedJavaType. If true, this method will either return a ResolvedJavaType or throw an exception
    
    Returns:
    
    a metaspace klass for name
    
    Throws:
    
    LinkageError - if resolve == true and the resolution failed
  - resolveConstantInPool
```
Object resolveConstantInPool(long metaspaceConstantPool,
                             int cpi)
```
  - resolvePossiblyCachedConstantInPool
```
Object resolvePossiblyCachedConstantInPool(long metaspaceConstantPool,
                                           int cpi)
```
  - lookupNameAndTypeRefIndexInPool
```
int lookupNameAndTypeRefIndexInPool(long metaspaceConstantPool,
                                    int cpi)
```
  - lookupNameRefInPool
```
String lookupNameRefInPool(long metaspaceConstantPool,
                           int cpi)
```
  - lookupSignatureRefInPool
```
String lookupSignatureRefInPool(long metaspaceConstantPool,
                                int cpi)
```
  - lookupKlassRefIndexInPool
```
int lookupKlassRefIndexInPool(long metaspaceConstantPool,
                              int cpi)
```
  - constantPoolKlassAt
```
long constantPoolKlassAt(long metaspaceConstantPool,
                         int cpi)
```
  - lookupKlassInPool
```
long lookupKlassInPool(long metaspaceConstantPool,
                       int cpi)
```
    Looks up a class entry in a constant pool.
    
    Parameters:
    
    metaspaceConstantPool - metaspace constant pool pointer
    
    cpi - constant pool index
    
    Returns:
    
    a metaspace Klass for a resolved method entry, a metaspace Symbol otherwise (with tagging)
  - lookupMethodInPool
```
long lookupMethodInPool(long metaspaceConstantPool,
                        int cpi,
                        byte opcode)
```
    Looks up a method entry in a constant pool.
    
    Parameters:
    
    metaspaceConstantPool - metaspace constant pool pointer
    
    cpi - constant pool index
    
    Returns:
    
    a metaspace Method for a resolved method entry, 0 otherwise
  - resolveField
```
long resolveField(long metaspaceConstantPool,
                  int cpi,
                  byte opcode,
                  long[] info)
```
    Looks up a field entry in a constant pool and attempts to resolve it. The values returned in info are:
```
     [(int) flags,   // only valid if field is resolved
      (int) offset]  // only valid if field is resolved
 
```
    Parameters:
    
    metaspaceConstantPool - metaspace constant pool pointer
    
    cpi - constant pool index
    
    info - an array in which the details of the field are returned
    
    Returns:
    
    true if the field is resolved
  - constantPoolRemapInstructionOperandFromCache
```
int constantPoolRemapInstructionOperandFromCache(long metaspaceConstantPool,
                                                 int cpi)
```
  - lookupAppendixInPool
```
Object lookupAppendixInPool(long metaspaceConstantPool,
                            int cpi)
```
  - installCode
```
int installCode(HotSpotCompiledCode compiledCode,
                InstalledCode code,
                SpeculationLog speculationLog)
```
    Installs the result of a compilation into the code cache.
    
    Parameters:
    
    compiledCode - the result of a compilation
    
    code - the details of the installed CodeBlob are written to this object
    
    Returns:
    
    the outcome of the installation which will be one of HotSpotVMConfig.codeInstallResultOk, HotSpotVMConfig.codeInstallResultCacheFull, HotSpotVMConfig.codeInstallResultCodeTooLarge, HotSpotVMConfig.codeInstallResultDependenciesFailed or HotSpotVMConfig.codeInstallResultDependenciesInvalid.
  - notifyCompilationStatistics
```
void notifyCompilationStatistics(int id,
                                 HotSpotResolvedJavaMethod method,
                                 boolean osr,
                                 int processedBytecodes,
                                 long time,
                                 long timeUnitsPerSecond,
                                 InstalledCode installedCode)
```
    Notifies the VM of statistics for a completed compilation.
    
    Parameters:
    
    id - the identifier of the compilation
    
    method - the method compiled
    
    osr - specifies if the compilation was for on-stack-replacement
    
    processedBytecodes - the number of bytecodes processed during the compilation, including the bytecodes of all inlined methods
    
    time - the amount time spent compiling method
    
    timeUnitsPerSecond - the granularity of the units for the time value
    
    installedCode - the nmethod installed as a result of the compilation
  - resetCompilationStatistics
```
void resetCompilationStatistics()
```
  - initializeConfiguration
```
void initializeConfiguration(HotSpotVMConfig config)
```
  - resolveMethod
```
long resolveMethod(long metaspaceKlassExactReceiver,
                   long metaspaceMethod,
                   long metaspaceKlassCaller)
```
  - getClassInitializer
```
long getClassInitializer(long metaspaceKlass)
```
  - hasFinalizableSubclass
```
boolean hasFinalizableSubclass(long metaspaceKlass)
```
  - getMetaspaceMethod
```
long getMetaspaceMethod(Class<?> holder,
                        int slot)
```
    Gets the metaspace Method object corresponding to a given Class object and slot number.
    
    Parameters:
    
    holder - method holder
    
    slot - slot number of the method
    
    Returns:
    
    the metaspace Method
  - getMaxCallTargetOffset
```
long getMaxCallTargetOffset(long address)
```
  - disassembleCodeBlob
```
String disassembleCodeBlob(long codeBlob)
```
  - getStackTraceElement
```
StackTraceElement getStackTraceElement(long metaspaceMethod,
                                       int bci)
```
  - executeCompiledMethod
```
Object executeCompiledMethod(Object arg1,
                             Object arg2,
                             Object arg3,
                             InstalledCode hotspotInstalledCode)
                      throws InvalidInstalledCodeException
```
    Throws:
    
    InvalidInstalledCodeException
  - executeCompiledMethodVarargs
```
Object executeCompiledMethodVarargs(Object[] args,
                                    InstalledCode hotspotInstalledCode)
                             throws InvalidInstalledCodeException
```
    Throws:
    
    InvalidInstalledCodeException
  - getLineNumberTable
```
long[] getLineNumberTable(long metaspaceMethod)
```
  - getLocalVariableTableStart
```
long getLocalVariableTableStart(long metaspaceMethod)
```
  - getLocalVariableTableLength
```
int getLocalVariableTableLength(long metaspaceMethod)
```
  - getFileName
```
String getFileName(HotSpotResolvedJavaType method)
```
  - getJavaMirror
```
Class<?> getJavaMirror(long metaspaceKlass)
```
  - readUnsafeKlassPointer
```
long readUnsafeKlassPointer(Object o)
```
  - readUncompressedOop
```
Object readUncompressedOop(long address)
```
    Reads an object pointer within a VM data structure. That is, any HotSpotVMField whose type is "oop" (e.g., ArrayKlass::_component_mirror, Klass::_java_mirror, JavaThread::_threadObj). Note that Unsafe.getObject(Object, long) cannot be used for this since it does a narrowOop read if the VM is using compressed oops whereas oops within VM data structures are (currently) always uncompressed.
    
    Parameters:
    
    address - address of an oop field within a VM data structure
  - doNotInlineOrCompile
```
void doNotInlineOrCompile(long metaspaceMethod)
```
  - reprofile
```
void reprofile(long metaspaceMethod)
```
    Invalidates the profiling information and restarts profiling upon the next invocation.
    
    Parameters:
    
    metaspaceMethod - the metaspace Method object
  - invalidateInstalledCode
```
void invalidateInstalledCode(InstalledCode hotspotInstalledCode)
```
  - collectCounters
```
long[] collectCounters()
```
    Collects the current values of all JVMCI benchmark counters, summed up over all threads.
  - isMature
```
boolean isMature(long metaspaceMethodData)
```
  - allocateCompileId
```
int allocateCompileId(long metaspaceMethod,
                      int entryBCI)
```
    Generate a unique id to identify the result of the compile.
  - getGPUs
```
String getGPUs()
```
    Gets the names of the supported GPU architectures.
    
    Returns:
    
    a comma separated list of names
  - hasCompiledCodeForOSR
```
boolean hasCompiledCodeForOSR(long metaspaceMethod,
                              int entryBCI,
                              int level)
```
    Parameters:
    
    metaspaceMethod - the method to check
    
    entryBCI -
    
    level - the compilation level
    
    Returns:
    
    true if the metaspaceMethod has code for level
  - getTimeStamp
```
long getTimeStamp()
```
    Fetch the time stamp used for printing inside hotspot. It's relative to VM start to that all events can be ordered.
    
    Returns:
    
    milliseconds since VM start
  - getSymbol
```
String getSymbol(long metaspaceSymbol)
```
    Gets the value of a metaspace Symbol as a String.
    
    Parameters:
    
    metaspaceSymbol -
  - getNextStackFrame
```
HotSpotStackFrameReference getNextStackFrame(HotSpotStackFrameReference frame,
                                             long[] methods,
                                             int initialSkip)
```
    Looks for the next Java stack frame with the given method.
    
    Parameters:
    
    frame - the starting point of the search, where null refers to the topmost frame
    
    methods - the metaspace methods to look for, where null means that any frame is returned
    
    Returns:
    
    the frame, or null if the end of the stack was reached during the search
  - materializeVirtualObjects
```
void materializeVirtualObjects(HotSpotStackFrameReference stackFrame,
                               boolean invalidate)
```
    Materialized all virtual objects within the given stack frame and update the locals within the given stackFrame object.
    
    Parameters:
    
    invalidate - if true, the compiled method for the stack frame will be invalidated.
  - resolveInvokeDynamic
```
void resolveInvokeDynamic(long metaspaceConstantPool,
                          int index)
```
  - resolveInvokeHandle
```
void resolveInvokeHandle(long metaspaceConstantPool,
                         int index)
```
  - getVtableIndexForInterface
```
int getVtableIndexForInterface(long metaspaceKlass,
                               long metaspaceMethod)
```
  - shouldDebugNonSafepoints
```
boolean shouldDebugNonSafepoints()
```
  - writeDebugOutput
```
void writeDebugOutput(byte[] bytes,
                      int offset,
                      int length)
```
  - flushDebugOutput
```
void flushDebugOutput()
```

Interface CompilerToVM

Method Summary

Method Detail

getBytecode

exceptionTableLength

exceptionTableStart

hasBalancedMonitors

canInlineMethod

shouldInlineMethod

findUniqueConcreteMethod

getKlassImplementor

methodIsIgnoredBySecurityStackWalk

lookupType

resolveConstantInPool

resolvePossiblyCachedConstantInPool

lookupNameAndTypeRefIndexInPool

lookupNameRefInPool

lookupSignatureRefInPool

lookupKlassRefIndexInPool

constantPoolKlassAt

lookupKlassInPool

lookupMethodInPool

resolveField

constantPoolRemapInstructionOperandFromCache

lookupAppendixInPool

installCode

notifyCompilationStatistics

resetCompilationStatistics

initializeConfiguration

resolveMethod

getClassInitializer

hasFinalizableSubclass

getMetaspaceMethod

getMaxCallTargetOffset

disassembleCodeBlob

getStackTraceElement

executeCompiledMethod

executeCompiledMethodVarargs

getLineNumberTable

getLocalVariableTableStart

getLocalVariableTableLength

getFileName

getJavaMirror

readUnsafeKlassPointer

readUncompressedOop

doNotInlineOrCompile

reprofile

invalidateInstalledCode

collectCounters

isMature

allocateCompileId

getGPUs

hasCompiledCodeForOSR

getTimeStamp

getSymbol

getNextStackFrame

materializeVirtualObjects

resolveInvokeDynamic

resolveInvokeHandle

getVtableIndexForInterface

shouldDebugNonSafepoints

writeDebugOutput

flushDebugOutput