org.jikesrvm.jni.ia32

Class JNICompiler

java.lang.Object

org.jikesrvm.jni.ia32.JNICompiler

public abstract class JNICompiler
extends Object

This class compiles the prolog and epilog for all code that makes the transition between Java and Native C for the 2 cases:

• from Java to C: all user-defined native methods
• C to Java: all JNI functions in JNIFunctions

When performing the transitions the values in registers and on the stack need to be treated with care, but also when transitioning into Java we need to do a spin-wait if a GC is underway. Transitioning from Java to C then back:

1. Set up stack frame and save non-volatile registers
2. Move all native method arguments on to stack (NB at this point all non-volatile state is saved)
3. Set up jniEnv
4. Record the frame pointer of the last Java frame (this) in the jniEnv
5. Set up JNI refs, a stack that holds references accessed via JNI
6. Call out to convert reference arguments to IDs
7. Set processor as being "in native"
8. Set up stack frame and registers for transition to C
9. Call out to C
10. Save result to stack
11. Transition back from "in native" to "in Java", take care that the Processor isn't "blocked in native", ie other processors have decided to start a GC and we're not permitted to execute Java code whilst this occurs
12. Convert a reference result (currently a JNI ref) into a true reference
13. Release JNI refs
14. Restore stack and place result in register

Prologue generation from C to Java:

1. Set up stack frame with C arguments in Jikes RVM convention
2. Set up extra stack frame entry that records the previous last top Java FP
3. Transition from "in native" to "in Java" taking care of blocked (in GC) case

Epilogue generation from Java to C:

1. Restore record of the previous last top Java FP in the jniEnv
2. Transition from "in Java" to "in native"
3. Set up result in registers. NB. JNIFunctions don't return references but JNI refs directly, so we don't need to transition these

Field Summary

Fields

Modifier and Type	Field and Description
private static Offset	BP_ON_ENTRY_OFFSET Location of a saved version of the field JNIEnvironment.basePointerOnEntryToNative
(package private) static Offset	EBP_SAVE_OFFSET Location of non-volatile EBP register when saved to stack
(package private) static Offset	EBX_SAVE_OFFSET Location of non-volatile EBX register when saved to stack
(package private) static Offset	EDI_SAVE_OFFSET Location of non-volatile EDI register when saved to stack
private static Offset	JNI_ENV_OFFSET Location of an extra copy of the RVMThread.jniEnv when saved to stack
private static int	jniExternalFunctionsFieldOffset Offset of external functions field in JNIEnvironment
static int	SAVED_GPRS_FOR_JNI The following is used in BaselineCompilerImpl to compute offset to first local.
private static Offset	SAVED_JAVA_FP_OFFSET Stack frame location for saved JNIEnvironment.JNITopJavaFP that will be clobbered by a transition from Java to C.
private JNIExceptionDeliverer	unused Dummy field to force compilation of the exception deliverer

Constructor Summary

Constructors

Constructor and Description
JNICompiler()

Method Summary

Modifier and Type	Method and Description
static CompiledMethod	compile(NativeMethod method) Compiles a method to handle the Java to C transition and back Transitioning from Java to C then back: Set up stack frame and save non-volatile registers Set up jniEnv - set up a register to hold JNIEnv and store the Processor in the JNIEnv for easy access Move all native method arguments on to stack (NB at this point all non-volatile state is saved) Record the frame pointer of the last Java frame (this) in the jniEnv Call out to convert reference arguments to IDs Set processor as being "in native" Set up stack frame and registers for transition to C Call out to C Save result to stack Transition back from "in native" to "in Java", take care that the Processor isn't "blocked in native", ie other processors have decided to start a GC and we're not permitted to execute Java code whilst this occurs Convert a reference result (currently a JNI ref) into a true reference Release JNI refs Restore stack and place result in register
static void	generateEpilogForJNIMethod(Assembler asm, RVMMethod method) Handles the C to Java transition: JNI methods in JNIFunctions.java.
static void	generateGlueCodeForJNIMethod(Assembler asm, NormalMethod method, int methodID) Handles the C to Java transition: JNI methods in JNIFunctions.java.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

unused

private JNIExceptionDeliverer unused

Dummy field to force compilation of the exception deliverer

jniExternalFunctionsFieldOffset

private static final int jniExternalFunctionsFieldOffset

Offset of external functions field in JNIEnvironment

EDI_SAVE_OFFSET

static final Offset EDI_SAVE_OFFSET

Location of non-volatile EDI register when saved to stack

EBX_SAVE_OFFSET

static final Offset EBX_SAVE_OFFSET

Location of non-volatile EBX register when saved to stack

EBP_SAVE_OFFSET

static final Offset EBP_SAVE_OFFSET

Location of non-volatile EBP register when saved to stack

JNI_ENV_OFFSET

private static final Offset JNI_ENV_OFFSET

Location of an extra copy of the RVMThread.jniEnv when saved to stack

BP_ON_ENTRY_OFFSET

private static final Offset BP_ON_ENTRY_OFFSET

Location of a saved version of the field JNIEnvironment.basePointerOnEntryToNative

SAVED_JAVA_FP_OFFSET

private static final Offset SAVED_JAVA_FP_OFFSET

Stack frame location for saved JNIEnvironment.JNITopJavaFP that will be clobbered by a transition from Java to C. Only used in the prologue & epilogue for JNIFunctions.

SAVED_GPRS_FOR_JNI

public static final int SAVED_GPRS_FOR_JNI

The following is used in BaselineCompilerImpl to compute offset to first local. Number of non-volatile GPRs and FPRs and then 1 slot for the SAVED_JAVA_FP.

Constructor Detail

JNICompiler

public JNICompiler()

Method Detail

compile

public static CompiledMethod compile(NativeMethod method)

Compiles a method to handle the Java to C transition and back Transitioning from Java to C then back:

1. Set up stack frame and save non-volatile registers
3. Set up jniEnv - set up a register to hold JNIEnv and store the Processor in the JNIEnv for easy access
4. Move all native method arguments on to stack (NB at this point all non-volatile state is saved)
5. Record the frame pointer of the last Java frame (this) in the jniEnv
6. Call out to convert reference arguments to IDs
7. Set processor as being "in native"
8. Set up stack frame and registers for transition to C
9. Call out to C
10. Save result to stack
11. Transition back from "in native" to "in Java", take care that the Processor isn't "blocked in native", ie other processors have decided to start a GC and we're not permitted to execute Java code whilst this occurs
12. Convert a reference result (currently a JNI ref) into a true reference
13. Release JNI refs
14. Restore stack and place result in register

Parameters:

method - the method to compile

Returns:

the compiled method (always a JNICompiledMethod)

generateGlueCodeForJNIMethod

public static void generateGlueCodeForJNIMethod(Assembler asm,
                                                NormalMethod method,
                                                int methodID)

Handles the C to Java transition: JNI methods in JNIFunctions.java. Creates a prologue for the baseline compiler.

 NOTE:
   -We need THREAD_REGISTER to access Java environment; we can get it from
    the JNIEnv* (which is an interior pointer to the JNIEnvironment)
   -Unlike the powerPC scheme which has a special prolog preceding
    the normal Java prolog, the Intel scheme replaces the Java prolog
    completely with the special prolog

            Stack on entry            Stack at end of prolog after call
             high memory                       high memory
            |            |                   |            |
    EBP ->  |saved FP    |                   |saved FP    |
            |  ...       |                   |  ...       |
            |            |                   |            |
            |arg n-1     |                   |arg n-1     |
 native     |  ...       |                   |  ...       |
 caller     |arg 0       | JNIEnv*           |arg 0       | JNIEnvironment
    ESP ->  |return addr |                   |return addr |
            |            |           EBP ->  |saved FP    | outer most native frame pointer
            |            |                   |methodID    | normal MethodID for JNI function
            |            |                   |saved JavaFP| offset to preceeding java frame
            |            |                   |saved nonvol| to be used for nonvolatile storage
            |            |                   |  ...       |   including ebp on entry
            |            |                   |arg 0       | copied in reverse order (JNIEnvironment)
            |            |                   |  ...       |
            |            |           ESP ->  |arg n-1     |
            |            |                   |            | normally compiled Java code continue
            |            |                   |            |
            |            |                   |            |
            |            |                   |            |
             low memory                        low memory
 

Parameters:

asm - the assembler to use

method - the method that's being compiled (i.e. the method which is a bridge from native).

methodID - the id of the compiled method

generateEpilogForJNIMethod

public static void generateEpilogForJNIMethod(Assembler asm,
                                              RVMMethod method)

Handles the C to Java transition: JNI methods in JNIFunctions.java. Creates an epilogue for the baseline compiler.

Parameters:

asm - the assembler to use

method - the method that's being compiled