Examples with RVMClass org.jikesrvm.classloader.RVMClass used on opensource projects

Example 6 with RVMClass

use of org.jikesrvm.classloader.RVMClass in project JikesRVM by JikesRVM.

the class BulkCompile method compileAllMethods.

/**
 * Compile all methods nominated in the compiler advice,
 * which should have been provided in a .ca advice file.<p>
 *
 * This method will be called at boot time (via notifyStartup())
 * if ENABLE_PRECOMPILE is true.  For replay compilation, this
 * method needs to be called explicitly from within the application
 * or benchmark harness. Typical usage in a benchmarking context
 * would be to call this method at the end of the first iteration
 * of the benchmark so that all/most classes were loaded, and
 * compilation could occur prior to the second iteration.
 */
public static void compileAllMethods() {
    if (!(Controller.options.ENABLE_BULK_COMPILE || Controller.options.ENABLE_PRECOMPILE)) {
        /* should not be here */
        VM.sysFail("Attempt to perform bulk compilation without setting either -X:aos:enable_bulk_compile=true or -X:aos:enable_precompile=true");
    }
    EdgeCounts.loadCountsFromFileIfAvailable(VM.EdgeCounterFile);
    CompilerAdvice.readCompilerAdvice();
    if (Controller.options.BULK_COMPILATION_VERBOSITY >= 1)
        VM.sysWriteln(Controller.options.ENABLE_PRECOMPILE ? "Start precompile" : "Start bulk compile");
    for (CompilerAdviceAttribute value : CompilerAdviceAttribute.values()) {
        if (value.getOptLevel() == -1) {
            if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                VM.sysWriteln("Skipping base method: ", value.toString());
            } else if (Controller.options.BULK_COMPILATION_VERBOSITY == 1) {
                VM.sysWrite(".");
            }
            continue;
        }
        ClassLoader cl = RVMClassLoader.findWorkableClassloader(value.getClassName());
        if (cl == null)
            continue;
        TypeReference tRef = TypeReference.findOrCreate(cl, value.getClassName());
        RVMClass cls = (RVMClass) tRef.peekType();
        if (cls != null) {
            // Ensure the class is properly loaded
            if (!cls.isInstantiated()) {
                if (!cls.isResolved()) {
                    if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                        VM.sysWriteln("Resolving class: ", cls.toString());
                    } else if (Controller.options.BULK_COMPILATION_VERBOSITY == 1) {
                        VM.sysWrite("R");
                    }
                    cls.resolve();
                }
                if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                    VM.sysWriteln("Instantiating class: ", cls.toString());
                } else if (Controller.options.BULK_COMPILATION_VERBOSITY == 1) {
                    VM.sysWrite("I");
                }
                cls.instantiate();
            }
            // Find the method
            RVMMethod method = cls.findDeclaredMethod(value.getMethodName(), value.getMethodSig());
            // If found, compile it
            if ((method != null) && !method.hasNoOptCompileAnnotation() && (method instanceof org.jikesrvm.classloader.NormalMethod)) {
                // if user's requirement is higher than advice
                if (value.getOptLevel() > Controller.options.DERIVED_MAX_OPT_LEVEL) {
                    if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                        VM.sysWrite("Replay advice overriden by default opt levels.  Wanted ");
                        VM.sysWrite(value.getOptLevel());
                        VM.sysWrite(", but Controller.options.DERIVED_MAX_OPT_LEVEL: ");
                        VM.sysWrite(Controller.options.DERIVED_MAX_OPT_LEVEL);
                        VM.sysWrite(" ");
                        VM.sysWriteln(value.toString());
                    } else if (Controller.options.BULK_COMPILATION_VERBOSITY == 1) {
                        VM.sysWrite(value.getOptLevel(), "!");
                    }
                    method.compile();
                } else {
                    CompilationPlan compPlan;
                    if (Controller.options.counters()) {
                        // for invocation counter, we only use one optimization level
                        compPlan = InvocationCounts.createCompilationPlan((NormalMethod) method);
                        AOSLogging.logger.recompilationStarted(compPlan);
                        if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                            VM.sysWrite("Bulk compiling for counters ");
                            VM.sysWriteln(value.toString());
                        }
                        RuntimeCompiler.recompileWithOpt(compPlan);
                        AOSLogging.logger.recompilationCompleted(compPlan);
                    } else if (Controller.options.sampling()) {
                        // Create our set of standard optimization plans.
                        compPlan = Controller.recompilationStrategy.createCompilationPlan((NormalMethod) method, value.getOptLevel(), null);
                        if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                            VM.sysWrite("Bulk compiling for sampling ");
                            VM.sysWriteln(value.toString());
                        }
                        if (Controller.options.BULK_COMPILATION_VERBOSITY == 1) {
                            VM.sysWrite(value.getOptLevel());
                        }
                        AOSLogging.logger.recompilationStarted(compPlan);
                        RuntimeCompiler.recompileWithOpt(compPlan);
                        AOSLogging.logger.recompilationCompleted(compPlan);
                    } else {
                        if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                            VM.sysWrite("Compiler advice file overridden ");
                            VM.sysWriteln(value.toString());
                        }
                        method.compile();
                    }
                }
            } else {
                if (Controller.options.BULK_COMPILATION_VERBOSITY > 1) {
                    VM.sysWrite("Replay failed for ");
                    VM.sysWrite(value.toString());
                    VM.sysWrite(" ");
                    VM.sysWriteln(cl.toString());
                } else if (Controller.options.BULK_COMPILATION_VERBOSITY == 1) {
                    VM.sysWrite("*");
                }
            }
        }
    }
    AOSLogging.logger.compileAllMethodsCompleted();
    if (Controller.options.BULK_COMPILATION_VERBOSITY >= 1)
        VM.sysWriteln();
    if (Controller.options.BULK_COMPILATION_VERBOSITY >= 1)
        VM.sysWriteln("Recompilation complete");
}

Example 7 with RVMClass

use of org.jikesrvm.classloader.RVMClass in project JikesRVM by JikesRVM.

the class BuildJNIFunctionTable method buildTable.

/**
 * Construct the JNIFuntionTable.
 * This is not very efficient, but is done at bootImageWriting time,
 * so we just don't worry about it.
 */
public static FunctionTable buildTable() {
    String[] names = initNames();
    FunctionTable functions = FunctionTable.allocate(JNIFunctions.FUNCTIONCOUNT);
    RVMClass cls = TypeReference.JNIFunctions.peekType().asClass();
    if (VM.VerifyAssertions)
        VM._assert(cls.isInstantiated());
    for (RVMMethod mth : cls.getDeclaredMethods()) {
        String methodName = mth.getName().toString();
        int jniIndex = indexOf(names, methodName);
        if (jniIndex != -1) {
            functions.set(jniIndex, mth.getCurrentEntryCodeArray());
        }
    }
    return functions;
}

Example 8 with RVMClass

use of org.jikesrvm.classloader.RVMClass in project JikesRVM by JikesRVM.

the class JNICompiler method compile.

/**
 * This method creates the stub to link native method.  It will be called
 * from the lazy linker the first time a native method is invoked.  The stub
 * generated will be patched by the lazy linker to link to the native method
 * for all future calls. <p>
 * <pre>
 * The stub performs the following tasks in the prologue:
 * <ol>
 *  <li>Allocate the glue frame
 *  <li>Save the TR and JTOC registers in the JNI Environment for reentering Java later
 *  <li>Shuffle the parameters in the registers to conform to the OS calling convention
 *  <li>Save the nonvolatile registers in a known space in the frame to be used
 *    for the GC stack map
 *  <li>Push a new JREF frame on the JNIRefs stack
 *  <li>Supply the first JNI argument:  the JNI environment pointer
 *  <li>Supply the second JNI argument:  class object if static, "this" if virtual
 * </ol>
 * <p>
 * The stub performs the following tasks in the epilogue:
 * <ol>
 *  <li>Restore TR and JTOC registers saved in JNI Environment
 *  <li>Restore the nonvolatile registers if GC has occurred
 *  <li>Pop the JREF frame off the JNIRefs stack
 *  <li>Check for pending exception and deliver to Java caller if present
 *  <li>Process the return value from native:  push onto caller's Java stack
 * </ol>
 * <p>
 * Within the stackframe, we have two frames.
 * The "main" frame exactly follows the OS native ABI and is therefore
 * different for each ABI.
 * The "mini-frame" is identical on all platforms and is stores RVM-specific fields.
 * The picture below shows the frames for 64-bit PowerPC ELF ABI.
 * <pre>
 *
 *   | fp       | <- native frame
 *   | cr       |
 *   | lr       |
 *   | resv     |
 *   | resv     |
 *   + toc      +
 *   |          |
 *   |          |
 *   |----------| <- Java to C glue frame using native calling conventions
 *   | fp       | saved fp of mini-frame
 *   | cr       |
 *   | lr       | native caller saves return address of native method here
 *   | resv     |
 *   | resv     |
 *   + toc      +
 *   |   0      | spill area (at least 8 words reserved)
 *   |   1      | (also used for saving volatile regs during calls in prolog)
 *   |   2      |
 *   |   3      |
 *   |   4      |
 *   |   5      |
 *   |   6      |
 *   |   7      |
 *   |  ...     |
 *   |----------| <- mini-frame for use by RVM stackwalkers
 *   |  fp      | saved fp of Java caller                 <- JNI_SAVE_AREA_OFFSET
 *   | mid      | cmid of native method
 *   | xxx (lr) | lr slot not used in mini frame
 *   |GC flag   | did GC happen while thread in native?   <- JNI_GC_FLAG_OFFSET
 *   |ENV       | JNIEnvironment                       <- JNI_ENV_OFFSET
 *   |RVM nonvol| save RVM nonvolatile GPRs for updating by GC stack mapper
 *   | ...      |
 *   |RVM nonvol|                                         <- JNI_RVM_NONVOLATILE_OFFSET
 *   |----------|
 *   |  fp      | <- Java caller frame
 *   | mid      |
 *   | xxx      |
 *   |          |
 *   |          |
 *   |          |
 *   |----------|
 *   |          |
 * </pre>
 * <p>
 * Runtime.unwindNativeStackFrame will return a pointer to the mini-frame
 * because none of our stack walkers need to do anything with the main frame.
 */
public static synchronized CompiledMethod compile(NativeMethod method) {
    JNICompiledMethod cm = (JNICompiledMethod) CompiledMethods.createCompiledMethod(method, CompiledMethod.JNI);
    int compiledMethodId = cm.getId();
    Assembler asm = new Assembler(0);
    int frameSize = getFrameSize(method);
    RVMClass klass = method.getDeclaringClass();
    // need 4 gp temps
    if (VM.VerifyAssertions)
        VM._assert(T3.value() <= LAST_VOLATILE_GPR.value());
    // need 4 fp temps
    if (VM.VerifyAssertions)
        VM._assert(F3.value() <= LAST_VOLATILE_FPR.value());
    if (VM.VerifyAssertions)
        VM._assert(S0.value() < S1.value() && // need 2 scratch
        S1.value() <= LAST_SCRATCH_GPR.value());
    Address nativeIP = method.getNativeIP();
    Address nativeTOC = method.getNativeTOC();
    // NOTE:  this must be done before the condition Thread.hasNativeStackFrame() become true
    // so that the first Java to C transition will be allowed to resize the stack
    // (currently, this is true when the JNIRefsTop index has been incremented from 0)
    // add at least 14 for C frame (header + spill)
    asm.emitNativeStackOverflowCheck(frameSize + 14);
    // save return address in caller frame
    asm.emitMFLR(REGISTER_ZERO);
    asm.emitSTAddr(REGISTER_ZERO, STACKFRAME_RETURN_ADDRESS_OFFSET.toInt(), FP);
    // buy mini frame
    asm.emitSTAddrU(FP, -JNI_SAVE_AREA_SIZE, FP);
    // store CMID for native method in mini-frame
    asm.emitLVAL(S0, compiledMethodId);
    asm.emitSTW(S0, STACKFRAME_METHOD_ID_OFFSET.toInt(), FP);
    // buy main frame, the total size equals to frameSize
    asm.emitSTAddrU(FP, -frameSize + JNI_SAVE_AREA_SIZE, FP);
    // establish S0 -> threads JNIEnv structure
    asm.emitLAddrOffset(S0, THREAD_REGISTER, Entrypoints.jniEnvField.getOffset());
    // save the TR register in the JNIEnvironment object for possible calls back into Java
    asm.emitSTAddrOffset(THREAD_REGISTER, S0, Entrypoints.JNIEnvSavedTRField.getOffset());
    // save the JNIEnvironment in the stack frame so we can use it to acquire the TR
    // when we return from native code.
    // save TR in frame
    asm.emitSTAddr(S0, frameSize - JNI_ENV_OFFSET, FP);
    // save mini-frame frame pointer in JNIEnv, JNITopJavaFP, which will be the frame
    // to start scanning this stack during GC, if top of stack is still executing in C
    asm.emitLAddr(THREAD_REGISTER, 0, FP);
    asm.emitSTAddrOffset(THREAD_REGISTER, S0, Entrypoints.JNITopJavaFPField.getOffset());
    // save the RVM nonvolatile GPRs, to be scanned by GC stack mapper
    for (int i = LAST_NONVOLATILE_GPR.value(), offset = JNI_RVM_NONVOLATILE_OFFSET; i >= FIRST_NONVOLATILE_GPR.value(); --i, offset += BYTES_IN_STACKSLOT) {
        asm.emitSTAddr(GPR.lookup(i), frameSize - offset, FP);
    }
    // clear the GC flag on entry to native code
    // use TR as scratch
    asm.emitLVAL(THREAD_REGISTER, 0);
    asm.emitSTW(THREAD_REGISTER, frameSize - JNI_GC_FLAG_OFFSET, FP);
    // generate the code to map the parameters to OS convention and add the
    // second parameter (either the "this" ptr or class if a static method).
    // The JNI Function ptr first parameter is set before making the call
    // by the out of line machine code we invoke below.
    // Opens a new frame in the JNIRefs table to register the references.
    // Assumes S0 set to JNIEnv, kills KLUDGE_TI_REG, S1 & THREAD_REGISTER
    // On return, S0 still contains JNIEnv
    storeParameters(asm, frameSize, method, klass);
    // 
    // Load required JNI function ptr into first parameter reg (GPR3/T0)
    // This pointer is an interior pointer to the JNIEnvironment which is
    // currently in S0.
    // 
    asm.emitADDI(T0, Entrypoints.JNIExternalFunctionsField.getOffset(), S0);
    // 
    // change the status of the thread to IN_JNI
    // 
    asm.emitLAddrOffset(THREAD_REGISTER, S0, Entrypoints.JNIEnvSavedTRField.getOffset());
    asm.emitLVALAddr(S1, Entrypoints.execStatusField.getOffset());
    // get status for thread
    asm.emitLWARX(S0, S1, THREAD_REGISTER);
    // we should be in java code?
    asm.emitCMPI(S0, RVMThread.IN_JAVA + (RVMThread.ALWAYS_LOCK_ON_STATE_TRANSITION ? 100 : 0));
    ForwardReference notInJava = asm.emitForwardBC(NE);
    // S0  <- new state value
    asm.emitLVAL(S0, RVMThread.IN_JNI);
    // attempt to change state to IN_JNI
    asm.emitSTWCXr(S0, S1, THREAD_REGISTER);
    // branch if success over slow path
    ForwardReference enteredJNIRef = asm.emitForwardBC(EQ);
    notInJava.resolve(asm);
    asm.emitLAddrOffset(S0, THREAD_REGISTER, Entrypoints.threadContextRegistersField.getOffset());
    asm.emitLAddrOffset(S1, JTOC, ArchEntrypoints.saveVolatilesInstructionsField.getOffset());
    asm.emitMTLR(S1);
    asm.emitBCLRL();
    // NOTE: THREAD_REGISTER should still have the thread
    // pointer, since up to this point we would have saved it but not
    // overwritten it.
    // call into our friendly slow path function.  note that this should
    // work because:
    // 1) we're not calling from C so we don't care what registers are
    // considered non-volatile in C
    // 2) all Java non-volatiles have been saved
    // 3) the only other registers we need - TR and S0 are taken care
    // of (see above)
    // 4) the prologue and epilogue will take care of the frame pointer
    // accordingly (it will just save it on the stack and then restore
    // it - so we don't even have to know what its value is here)
    // the only thing we have to make sure of is that MMTk ignores the
    // framePointer field in RVMThread and uses the one in the JNI
    // environment instead (see Collection.prepareMutator)...
    // T1 gets address of function
    asm.emitLAddrOffset(S1, JTOC, Entrypoints.enterJNIBlockedFromCallIntoNativeMethod.getOffset());
    asm.emitMTLR(S1);
    // call RVMThread.enterJNIBlocked
    asm.emitBCLRL();
    asm.emitLAddrOffset(S0, THREAD_REGISTER, Entrypoints.threadContextRegistersField.getOffset());
    asm.emitLAddrOffset(S1, JTOC, ArchEntrypoints.restoreVolatilesInstructionsField.getOffset());
    asm.emitMTLR(S1);
    asm.emitBCLRL();
    // come here when we're done
    enteredJNIRef.resolve(asm);
    // set the TOC and IP for branch to out_of_line code
    asm.emitLVALAddr(JTOC, nativeTOC);
    asm.emitLVALAddr(S1, nativeIP);
    // move native code address to CTR reg;
    // do this early so that S1 will be available as a scratch.
    asm.emitMTCTR(S1);
    // 
    // CALL NATIVE METHOD
    // 
    asm.emitBCCTRL();
    // if we have to call sysVirtualProcessorYield because we are locked in native.
    if (VM.BuildFor64Addr) {
        asm.emitSTD(T0, NATIVE_FRAME_HEADER_SIZE, FP);
    } else {
        asm.emitSTW(T0, NATIVE_FRAME_HEADER_SIZE, FP);
        asm.emitSTW(T1, NATIVE_FRAME_HEADER_SIZE + BYTES_IN_ADDRESS, FP);
    }
    // 
    // try to return thread status to IN_JAVA
    // 
    int label1 = asm.getMachineCodeIndex();
    // TODO: we can do this directly from FP because we know framesize at compiletime
    // (the same way we stored the JNI Env above)
    // get mini-frame
    asm.emitLAddr(S0, 0, FP);
    // get Java caller FP
    asm.emitLAddr(S0, 0, S0);
    // load JNIEnvironment into TR
    asm.emitLAddr(THREAD_REGISTER, -JNI_ENV_OFFSET, S0);
    // Restore JTOC and TR
    asm.emitLAddrOffset(JTOC, THREAD_REGISTER, Entrypoints.JNIEnvSavedJTOCField.getOffset());
    asm.emitLAddrOffset(THREAD_REGISTER, THREAD_REGISTER, Entrypoints.JNIEnvSavedTRField.getOffset());
    asm.emitLVALAddr(S1, Entrypoints.execStatusField.getOffset());
    // get status for processor
    asm.emitLWARX(S0, S1, THREAD_REGISTER);
    // are we IN_JNI code?
    asm.emitCMPI(S0, RVMThread.IN_JNI + (RVMThread.ALWAYS_LOCK_ON_STATE_TRANSITION ? 100 : 0));
    ForwardReference blocked = asm.emitForwardBC(NE);
    // S0  <- new state value
    asm.emitLVAL(S0, RVMThread.IN_JAVA);
    // attempt to change state to java
    asm.emitSTWCXr(S0, S1, THREAD_REGISTER);
    // branch over blocked call if state change successful
    ForwardReference fr = asm.emitForwardBC(EQ);
    blocked.resolve(asm);
    // if not IN_JNI call RVMThread.leaveJNIBlockedFromCallIntoNative
    // T1 gets address of function
    asm.emitLAddrOffset(T1, JTOC, Entrypoints.leaveJNIBlockedFromCallIntoNativeMethod.getOffset());
    asm.emitMTLR(T1);
    // call RVMThread.leaveJNIBlockedFromCallIntoNative
    asm.emitBCLRL();
    fr.resolve(asm);
    // check if GC has occurred, If GC did not occur, then
    // VM NON_VOLATILE regs were restored by OS and are valid.  If GC did occur
    // objects referenced by these restored regs may have moved, in this case we
    // restore the nonvolatile registers from our save area,
    // where any object references would have been relocated during GC.
    // use T2 as scratch (not needed any more on return from call)
    // 
    asm.emitLWZ(T2, frameSize - JNI_GC_FLAG_OFFSET, FP);
    asm.emitCMPI(T2, 0);
    ForwardReference fr1 = asm.emitForwardBC(EQ);
    for (int i = LAST_NONVOLATILE_GPR.value(), offset = JNI_RVM_NONVOLATILE_OFFSET; i >= FIRST_NONVOLATILE_GPR.value(); --i, offset += BYTES_IN_STACKSLOT) {
        asm.emitLAddr(GPR.lookup(i), frameSize - offset, FP);
    }
    fr1.resolve(asm);
    // reestablish S0 to hold pointer to JNIEnvironment
    asm.emitLAddrOffset(S0, THREAD_REGISTER, Entrypoints.jniEnvField.getOffset());
    // pop jrefs frame off the JNIRefs stack, "reopen" the previous top jref frame
    // use S1 as scratch, also use T2, T3 for scratch which are no longer needed
    // load base of JNIRefs array
    asm.emitLAddrOffset(S1, S0, Entrypoints.JNIRefsField.getOffset());
    asm.emitLIntOffset(T2, S0, // get saved offset for JNIRefs frame ptr previously pushed onto JNIRefs array
    Entrypoints.JNIRefsSavedFPField.getOffset());
    // compute offset for new TOP
    asm.emitADDI(T3, -BYTES_IN_STACKSLOT, T2);
    // store new offset for TOP into JNIEnv
    asm.emitSTWoffset(T3, S0, Entrypoints.JNIRefsTopField.getOffset());
    // retrieve the previous frame ptr
    asm.emitLIntX(T2, S1, T2);
    asm.emitSTWoffset(T2, S0, // store new offset for JNIRefs frame ptr into JNIEnv
    Entrypoints.JNIRefsSavedFPField.getOffset());
    // Restore the return value R3-R4 saved in the glue frame spill area before the migration
    if (VM.BuildFor64Addr) {
        asm.emitLD(T0, NATIVE_FRAME_HEADER_SIZE, FP);
    } else {
        asm.emitLWZ(T0, NATIVE_FRAME_HEADER_SIZE, FP);
        asm.emitLWZ(T1, NATIVE_FRAME_HEADER_SIZE + BYTES_IN_STACKSLOT, FP);
    }
    // if the the return type is a reference, the native C is returning a jref
    // which is a byte offset from the beginning of the threads JNIRefs stack/array
    // of the corresponding ref.  In this case, emit code to replace the returned
    // offset (in R3) with the ref from the JNIRefs array
    TypeReference returnType = method.getReturnType();
    if (returnType.isReferenceType()) {
        asm.emitCMPI(T0, 0);
        ForwardReference globalRef = asm.emitForwardBC(LT);
        // Local ref - load from JNIRefs
        // S1 is still the base of the JNIRefs array
        asm.emitLAddrX(T0, S1, T0);
        ForwardReference afterGlobalRef = asm.emitForwardB();
        // Deal with global references
        globalRef.resolve(asm);
        asm.emitLVAL(T3, JNIGlobalRefTable.STRONG_REF_BIT);
        asm.emitAND(T1, T0, T3);
        asm.emitLAddrOffset(T2, JTOC, Entrypoints.JNIGlobalRefsField.getOffset());
        asm.emitCMPI(T1, 0);
        ForwardReference weakGlobalRef = asm.emitForwardBC(EQ);
        // Strong global references
        asm.emitNEG(T0, T0);
        // convert index to offset
        asm.emitSLWI(T0, T0, LOG_BYTES_IN_ADDRESS);
        asm.emitLAddrX(T0, T2, T0);
        ForwardReference afterWeakGlobalRef = asm.emitForwardB();
        // Weak global references
        weakGlobalRef.resolve(asm);
        // STRONG_REF_BIT
        asm.emitOR(T0, T0, T3);
        asm.emitNEG(T0, T0);
        // convert index to offset
        asm.emitSLWI(T0, T0, LOG_BYTES_IN_ADDRESS);
        asm.emitLAddrX(T0, T2, T0);
        asm.emitLAddrOffset(T0, T0, Entrypoints.referenceReferentField.getOffset());
        afterWeakGlobalRef.resolve(asm);
        afterGlobalRef.resolve(asm);
    }
    // pop the whole stack frame (main & mini), restore the Java caller frame
    asm.emitADDI(FP, +frameSize, FP);
    // C return value is already where caller expected it (T0/T1 or F0)
    // So, just restore the return address to the link register.
    asm.emitLAddr(REGISTER_ZERO, STACKFRAME_RETURN_ADDRESS_OFFSET.toInt(), FP);
    // restore return address
    asm.emitMTLR(REGISTER_ZERO);
    // CHECK EXCEPTION AND BRANCH TO ATHROW CODE OR RETURN NORMALLY
    asm.emitLIntOffset(T2, S0, Entrypoints.JNIHasPendingExceptionField.getOffset());
    // get a zero value to compare
    asm.emitLVAL(T3, 0);
    asm.emitCMP(T2, T3);
    ForwardReference fr3 = asm.emitForwardBC(NE);
    // if no pending exception, proceed to return to caller
    asm.emitBCLR();
    fr3.resolve(asm);
    // T1 gets address of function
    asm.emitLAddrToc(T1, Entrypoints.jniThrowPendingException.getOffset());
    // point LR to the exception delivery code
    asm.emitMTCTR(T1);
    // then branch to the exception delivery code, does not return
    asm.emitBCCTR();
    cm.compileComplete(asm.getMachineCodes());
    return cm;
}

Example 9 with RVMClass

use of org.jikesrvm.classloader.RVMClass in project JikesRVM by JikesRVM.

the class JNIFunctions method RegisterNatives.

/**
 * RegisterNatives: registers implementation of native methods
 * @param env A JREF index for the JNI environment object
 * @param classJREF a JREF index for the class to register native methods in
 * @param methodsAddress the address of an array of native methods to be registered
 * @param nmethods the number of native methods in the array
 * @return 0 is successful -1 if failed
 * @throws NoSuchMethodError if a specified method cannot be found or is not native
 */
private static int RegisterNatives(JNIEnvironment env, int classJREF, Address methodsAddress, int nmethods) {
    if (traceJNI)
        VM.sysWriteln("JNI called: RegisterNatives");
    RuntimeEntrypoints.checkJNICountDownToGC();
    try {
        // get the target class
        Class<?> jcls = (Class<?>) env.getJNIRef(classJREF);
        RVMType type = java.lang.JikesRVMSupport.getTypeForClass(jcls);
        if (!type.isClassType()) {
            env.recordException(new NoSuchMethodError());
            return 0;
        }
        RVMClass klass = type.asClass();
        if (!klass.isInitialized()) {
            RuntimeEntrypoints.initializeClassForDynamicLink(klass);
        }
        // Create list of methods and verify them to avoid partial success
        NativeMethod[] methods = new NativeMethod[nmethods];
        AddressArray symbols = AddressArray.create(nmethods);
        Address curMethod = methodsAddress;
        for (int i = 0; i < nmethods; i++) {
            String methodString = JNIGenericHelpers.createStringFromC(curMethod.loadAddress());
            Atom methodName = Atom.findOrCreateAsciiAtom(methodString);
            String sigString = JNIGenericHelpers.createStringFromC(curMethod.loadAddress(Offset.fromIntSignExtend(BYTES_IN_ADDRESS)));
            Atom sigName = Atom.findOrCreateAsciiAtom(sigString);
            // Find the target method
            RVMMethod meth = klass.findDeclaredMethod(methodName, sigName);
            if (meth == null || !meth.isNative()) {
                env.recordException(new NoSuchMethodError(klass + ": " + methodName + " " + sigName));
                return -1;
            }
            methods[i] = (NativeMethod) meth;
            symbols.set(i, curMethod.loadAddress(Offset.fromIntSignExtend(BYTES_IN_ADDRESS * 2)));
            curMethod = curMethod.plus(3 * BYTES_IN_ADDRESS);
        }
        // Register methods
        for (int i = 0; i < nmethods; i++) {
            methods[i].registerNativeSymbol(symbols.get(i));
        }
        return 0;
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return -1;
    }
}

Example 10 with RVMClass

use of org.jikesrvm.classloader.RVMClass in project JikesRVM by JikesRVM.

the class JNIFunctions method GetStaticMethodID.

/**
 * GetStaticMethodID:  return the method ID for invocation later
 * @param env A JREF index for the JNI environment object
 * @param classJREF a JREF index for the class object
 * @param methodNameAddress a raw address to a null-terminated string in C for the method name
 * @param methodSigAddress a raw address to a null-terminated string in C for (TODO: document me)
 * @return a method ID or null if it fails
 * @throws NoSuchMethodError if the method is not found
 * @throws ExceptionInInitializerError if the initializer fails
 * @throws OutOfMemoryError if the system runs out of memory
 */
private static int GetStaticMethodID(JNIEnvironment env, int classJREF, Address methodNameAddress, Address methodSigAddress) {
    if (traceJNI)
        VM.sysWriteln("JNI called: GetStaticMethodID");
    RuntimeEntrypoints.checkJNICountDownToGC();
    try {
        // obtain the names as String from the native space
        String methodString = JNIGenericHelpers.createStringFromC(methodNameAddress);
        Atom methodName = Atom.findOrCreateAsciiAtom(methodString);
        String sigString = JNIGenericHelpers.createStringFromC(methodSigAddress);
        Atom sigName = Atom.findOrCreateAsciiAtom(sigString);
        // get the target class
        Class<?> jcls = (Class<?>) env.getJNIRef(classJREF);
        RVMType type = java.lang.JikesRVMSupport.getTypeForClass(jcls);
        if (!type.isClassType()) {
            env.recordException(new NoSuchMethodError());
            return 0;
        }
        RVMClass klass = type.asClass();
        if (!klass.isInitialized()) {
            RuntimeEntrypoints.initializeClassForDynamicLink(klass);
        }
        // Find the target method
        RVMMethod meth = klass.findStaticMethod(methodName, sigName);
        if (meth == null) {
            env.recordException(new NoSuchMethodError());
            return 0;
        }
        if (traceJNI)
            VM.sysWriteln("got method " + meth);
        return meth.getId();
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return 0;
    }
}