Examples with Address org.vmmagic.unboxed.Address used on opensource projects

Example 26 with Address

use of org.vmmagic.unboxed.Address in project JikesRVM by JikesRVM.

the class JNIFunctions method GetStringUTFChars.

/**
 * GetStringUTFChars:  return address of buffer containing contents of a String
 * @param env A JREF index for the JNI environment object
 * @param strJREF a JREF index for the String object
 * @param isCopyAddress address of isCopy jboolean (an int)
 * @return address of a copy of the String unicode characters
 *         and *isCopy is set to 1 (TRUE)
 * @throws OutOfMemoryError if the system runs out of memory
 */
private static Address GetStringUTFChars(JNIEnvironment env, int strJREF, Address isCopyAddress) {
    if (traceJNI)
        VM.sysWriteln("JNI called: GetStringUTFChars");
    RuntimeEntrypoints.checkJNICountDownToGC();
    String str = (String) env.getJNIRef(strJREF);
    if (str == null) {
        return Address.zero();
    }
    // Get length of C string
    // for terminating zero
    int len = UTF8Convert.utfLength(str) + 1;
    // alloc non moving buffer in C heap for string
    Address copyBuffer = sysCall.sysMalloc(len);
    if (copyBuffer.isZero()) {
        env.recordException(new OutOfMemoryError());
        return Address.zero();
    }
    try {
        JNIGenericHelpers.createUTFForCFromString(str, copyBuffer, len);
        JNIGenericHelpers.setBoolStar(isCopyAddress, true);
        return copyBuffer;
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return Address.zero();
    }
}

Example 27 with Address

use of org.vmmagic.unboxed.Address in project JikesRVM by JikesRVM.

the class JNIGenericHelpers method packageParametersFromJValuePtr.

/**
 * Repackage the arguments passed as an array of jvalue into an array of Object,
 * used by the JNI functions CallStatic<type>MethodA
 * @param targetMethod the target {@link MethodReference}
 * @param argAddress an address into the C space for the array of jvalue unions
 * @return an Object array holding the arguments wrapped at Objects
 */
protected static Object[] packageParametersFromJValuePtr(MethodReference targetMethod, Address argAddress) {
    TypeReference[] argTypes = targetMethod.getParameterTypes();
    int argCount = argTypes.length;
    Object[] argObjectArray = new Object[argCount];
    // get the JNIEnvironment for this thread in case we need to dereference any object arg
    JNIEnvironment env = RVMThread.getCurrentThread().getJNIEnv();
    Address addr = argAddress;
    for (int i = 0; i < argCount; i++, addr = addr.plus(BYTES_IN_LONG)) {
        // convert and wrap the argument according to the expected type
        if (argTypes[i].isReferenceType()) {
            // Avoid endianness issues by loading the whole slot
            Word wholeSlot = addr.loadWord();
            // for object, the arg is a JREF index, dereference to get the real object
            int JREFindex = wholeSlot.toInt();
            argObjectArray[i] = env.getJNIRef(JREFindex);
        } else if (argTypes[i].isIntType()) {
            argObjectArray[i] = addr.loadInt();
        } else if (argTypes[i].isLongType()) {
            argObjectArray[i] = addr.loadLong();
        } else if (argTypes[i].isBooleanType()) {
            // the 0/1 bit is stored in the high byte
            argObjectArray[i] = addr.loadByte() != 0;
        } else if (argTypes[i].isByteType()) {
            // the target byte is stored in the high byte
            argObjectArray[i] = addr.loadByte();
        } else if (argTypes[i].isCharType()) {
            // char is stored in the high 2 bytes
            argObjectArray[i] = addr.loadChar();
        } else if (argTypes[i].isShortType()) {
            // short is stored in the high 2 bytes
            argObjectArray[i] = addr.loadShort();
        } else if (argTypes[i].isFloatType()) {
            argObjectArray[i] = addr.loadFloat();
        } else {
            if (VM.VerifyAssertions)
                VM._assert(argTypes[i].isDoubleType());
            argObjectArray[i] = addr.loadDouble();
        }
    }
    return argObjectArray;
}

Example 28 with Address

use of org.vmmagic.unboxed.Address in project JikesRVM by JikesRVM.

the class JNICompiler method compile.

/**
 * Compiles a method to handle the Java to C transition and back
 * Transitioning from Java to C then back:
 * <ol>
 * <li>Set up stack frame and save non-volatile registers<li>
 * <li>Set up jniEnv - set up a register to hold JNIEnv and store
 *     the Processor in the JNIEnv for easy access</li>
 * <li>Move all native method arguments on to stack (NB at this point all
 *     non-volatile state is saved)</li>
 * <li>Record the frame pointer of the last Java frame (this) in the jniEnv</li>
 * <li>Call out to convert reference arguments to IDs</li>
 * <li>Set processor as being "in native"</li>
 * <li>Set up stack frame and registers for transition to C</li>
 * <li>Call out to C</li>
 * <li>Save result to stack</li>
 * <li>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</li>
 * <li>Convert a reference result (currently a JNI ref) into a true reference</li>
 * <li>Release JNI refs</li>
 * <li>Restore stack and place result in register</li>
 * </ol>
 *
 * @param method the method to compile
 * @return the compiled method (always a {@link JNICompiledMethod})
 */
public static synchronized CompiledMethod compile(NativeMethod method) {
    // Meaning of constant offset into frame (assuming 4byte word size):
    // Stack frame:
    // on entry          after prolog
    // 
    // high address        high address
    // |          |        |          | Caller frame
    // |          |        |          |
    // +    |arg 0     |        |arg 0     | <- firstParameterOffset
    // +    |arg 1     |        |arg 1     |
    // +    |...       |        |...       |
    // +8   |arg n-1   |        |arg n-1   | <- lastParameterOffset
    // +4   |returnAddr|        |returnAddr|
    // 0   +          +        +saved FP  + <- EBP/FP value in glue frame
    // -4   |          |        |methodID  |
    // -8   |          |        |saved EDI |
    // -C   |          |        |saved EBX |
    // -10  |          |        |saved EBP |
    // -14  |          |        |saved ENV |  (JNIEnvironment)
    // -18  |          |        |arg n-1   |  reordered args to native method
    // -1C  |          |        | ...      |  ...
    // -20  |          |        |arg 1     |  ...
    // -24  |          |        |arg 0     |  ...
    // -28  |          |        |class/obj |  required second arg to native method
    // -2C  |          |        |jni funcs |  required first arg to native method
    // -30  |          |        |          |
    // |          |        |          |
    // |          |        |          |
    // low address         low address
    // Register values:
    // EBP    - after step 1 EBP holds a frame pointer allowing easy
    // access to both this and the proceeding frame
    // ESP    - gradually floats down as the stack frame is initialized
    // S0/ECX - reference to the JNI environment after step 3
    JNICompiledMethod cm = (JNICompiledMethod) CompiledMethods.createCompiledMethod(method, CompiledMethod.JNI);
    // some size for the instruction array
    Assembler asm = new Assembler(100);
    Address nativeIP = method.getNativeIP();
    final Offset lastParameterOffset = Offset.fromIntSignExtend(2 * WORDSIZE);
    // final Offset firstParameterOffset = Offset.fromIntSignExtend(WORDSIZE+(method.getParameterWords() << LG_WORDSIZE));
    final TypeReference[] args = method.getParameterTypes();
    // (1) Set up stack frame and save non-volatile registers
    // TODO:  check and resize stack once on the lowest Java to C transition
    // on the stack.  Not needed if we use the thread original stack
    // set 2nd word of header = return address already pushed by CALL
    asm.emitPUSH_RegDisp(THREAD_REGISTER, ArchEntrypoints.framePointerField.getOffset());
    // establish new frame
    if (VM.BuildFor32Addr) {
        asm.emitMOV_RegDisp_Reg(THREAD_REGISTER, ArchEntrypoints.framePointerField.getOffset(), SP);
    } else {
        asm.emitMOV_RegDisp_Reg_Quad(THREAD_REGISTER, ArchEntrypoints.framePointerField.getOffset(), SP);
    }
    // set first word of header: method ID
    if (VM.VerifyAssertions)
        VM._assert(STACKFRAME_METHOD_ID_OFFSET.toInt() == -WORDSIZE);
    asm.emitPUSH_Imm(cm.getId());
    // save nonvolatile registrs: EDI, EBX, EBP
    if (VM.VerifyAssertions)
        VM._assert(EDI_SAVE_OFFSET.toInt() == -2 * WORDSIZE);
    // save nonvolatile EDI register
    asm.emitPUSH_Reg(EDI);
    if (VM.VerifyAssertions)
        VM._assert(EBX_SAVE_OFFSET.toInt() == -3 * WORDSIZE);
    // save nonvolatile EBX register
    asm.emitPUSH_Reg(EBX);
    if (VM.VerifyAssertions)
        VM._assert(EBP_SAVE_OFFSET.toInt() == -4 * WORDSIZE);
    // save nonvolatile EBP register
    asm.emitPUSH_Reg(EBP);
    // Establish EBP as the framepointer for use in the rest of the glue frame
    if (VM.BuildFor32Addr) {
        asm.emitLEA_Reg_RegDisp(EBP, SP, Offset.fromIntSignExtend(4 * WORDSIZE));
    } else {
        asm.emitLEA_Reg_RegDisp_Quad(EBP, SP, Offset.fromIntSignExtend(4 * WORDSIZE));
    }
    // S0 = RVMThread.jniEnv
    if (VM.BuildFor32Addr) {
        asm.emitMOV_Reg_RegDisp(S0, THREAD_REGISTER, Entrypoints.jniEnvField.getOffset());
    } else {
        asm.emitMOV_Reg_RegDisp_Quad(S0, THREAD_REGISTER, Entrypoints.jniEnvField.getOffset());
    }
    if (VM.VerifyAssertions)
        VM._assert(JNI_ENV_OFFSET.toInt() == -5 * WORDSIZE);
    // save JNI Env for after call
    asm.emitPUSH_Reg(S0);
    if (VM.VerifyAssertions)
        VM._assert(BP_ON_ENTRY_OFFSET.toInt() == -6 * WORDSIZE);
    asm.emitPUSH_RegDisp(S0, Entrypoints.JNIEnvBasePointerOnEntryToNative.getOffset());
    // save BP into JNIEnv
    if (VM.BuildFor32Addr) {
        asm.emitMOV_RegDisp_Reg(S0, Entrypoints.JNIEnvBasePointerOnEntryToNative.getOffset(), EBP);
    } else {
        asm.emitMOV_RegDisp_Reg_Quad(S0, Entrypoints.JNIEnvBasePointerOnEntryToNative.getOffset(), EBP);
    }
    // (3) Move all native method arguments on to stack (NB at this
    // point all non-volatile state is saved)
    // (3.1) Count how many arguments could be passed in either FPRs or GPRs
    int numFprArgs = 0;
    int numGprArgs = 0;
    for (TypeReference arg : args) {
        if (arg.isFloatingPointType()) {
            numFprArgs++;
        } else if (VM.BuildFor32Addr && arg.isLongType()) {
            numGprArgs += 2;
        } else {
            numGprArgs++;
        }
    }
    // (3.2) add stack aligning padding
    if (VM.BuildFor64Addr) {
        int argsInRegisters = Math.min(numFprArgs, NATIVE_PARAMETER_FPRS.length) + Math.min(numGprArgs + 2, NATIVE_PARAMETER_GPRS.length);
        int argsOnStack = numGprArgs + numFprArgs + 2 - argsInRegisters;
        if (VM.VerifyAssertions)
            VM._assert(argsOnStack >= 0);
        if ((argsOnStack & 1) != 0) {
            // need odd alignment prior to pushes
            asm.emitAND_Reg_Imm_Quad(SP, -16);
            asm.emitPUSH_Reg(T0);
        } else {
            // need even alignment prior to pushes
            asm.emitAND_Reg_Imm_Quad(SP, -16);
        }
    }
    // (we always pass a this or a class but we only pop this)
    if (!method.isStatic()) {
        numGprArgs++;
    }
    // (3.3) Walk over arguments backwards pushing either from memory or registers
    Offset currentArg = lastParameterOffset;
    int argFpr = numFprArgs - 1;
    int argGpr = numGprArgs - 1;
    for (int i = args.length - 1; i >= 0; i--) {
        TypeReference arg = args[i];
        if (arg.isFloatType()) {
            if (argFpr < PARAMETER_FPRS.length) {
                // make space
                asm.emitPUSH_Reg(T0);
                if (SSE2_FULL) {
                    asm.emitMOVSS_RegInd_Reg(SP, (XMM) PARAMETER_FPRS[argFpr]);
                } else {
                    asm.emitFSTP_RegInd_Reg(SP, FP0);
                }
            } else {
                asm.emitPUSH_RegDisp(EBP, currentArg);
            }
            argFpr--;
        } else if (arg.isDoubleType()) {
            if (VM.BuildFor32Addr) {
                if (argFpr < PARAMETER_FPRS.length) {
                    // make space
                    asm.emitPUSH_Reg(T0);
                    // need 2 slots with 32bit addresses
                    asm.emitPUSH_Reg(T0);
                    if (SSE2_FULL) {
                        asm.emitMOVSD_RegInd_Reg(SP, (XMM) PARAMETER_FPRS[argFpr]);
                    } else {
                        asm.emitFSTP_RegInd_Reg_Quad(SP, FP0);
                    }
                } else {
                    asm.emitPUSH_RegDisp(EBP, currentArg.plus(WORDSIZE));
                    // need 2 slots with 32bit addresses
                    asm.emitPUSH_RegDisp(EBP, currentArg);
                }
            } else {
                if (argFpr < PARAMETER_FPRS.length) {
                    // make space
                    asm.emitPUSH_Reg(T0);
                    if (SSE2_FULL) {
                        asm.emitMOVSD_RegInd_Reg(SP, (XMM) PARAMETER_FPRS[argFpr]);
                    } else {
                        asm.emitFSTP_RegInd_Reg_Quad(SP, FP0);
                    }
                } else {
                    asm.emitPUSH_RegDisp(EBP, currentArg);
                }
            }
            argFpr--;
            currentArg = currentArg.plus(WORDSIZE);
        } else if (VM.BuildFor32Addr && arg.isLongType()) {
            if (argGpr < PARAMETER_GPRS.length) {
                asm.emitPUSH_Reg(PARAMETER_GPRS[argGpr - 1]);
                asm.emitPUSH_Reg(PARAMETER_GPRS[argGpr]);
            } else if (argGpr - 1 < PARAMETER_GPRS.length) {
                asm.emitPUSH_Reg(PARAMETER_GPRS[argGpr - 1]);
                asm.emitPUSH_RegDisp(EBP, currentArg);
            } else {
                asm.emitPUSH_RegDisp(EBP, currentArg.plus(WORDSIZE));
                asm.emitPUSH_RegDisp(EBP, currentArg);
            }
            argGpr -= 2;
            currentArg = currentArg.plus(WORDSIZE);
        } else {
            if (argGpr < PARAMETER_GPRS.length) {
                asm.emitPUSH_Reg(PARAMETER_GPRS[argGpr]);
            } else {
                asm.emitPUSH_RegDisp(EBP, currentArg);
            }
            argGpr--;
            if (VM.BuildFor64Addr && arg.isLongType()) {
                currentArg = currentArg.plus(WORDSIZE);
            }
        }
        currentArg = currentArg.plus(WORDSIZE);
    }
    // (3.4) push class or object argument
    if (method.isStatic()) {
        // push java.lang.Class object for klass
        Offset klassOffset = Offset.fromIntSignExtend(Statics.findOrCreateObjectLiteral(method.getDeclaringClass().getClassForType()));
        asm.generateJTOCpush(klassOffset);
    } else {
        if (VM.VerifyAssertions)
            VM._assert(argGpr == 0);
        asm.emitPUSH_Reg(PARAMETER_GPRS[0]);
    }
    // (3.5) push a pointer to the JNI functions that will be
    // dereferenced in native code
    asm.emitPUSH_Reg(S0);
    if (jniExternalFunctionsFieldOffset != 0) {
        if (VM.BuildFor32Addr) {
            asm.emitADD_RegInd_Imm(ESP, jniExternalFunctionsFieldOffset);
        } else {
            asm.emitADD_RegInd_Imm_Quad(ESP, jniExternalFunctionsFieldOffset);
        }
    }
    // (4) Call out to convert reference arguments to IDs, set thread as
    // being "in native" and record the frame pointer of the last Java frame
    // (this) in the jniEnv
    // Encode reference arguments into a long
    int encodedReferenceOffsets = 0;
    for (int i = 0, pos = 0; i < args.length; i++, pos++) {
        TypeReference arg = args[i];
        if (arg.isReferenceType()) {
            if (VM.VerifyAssertions)
                VM._assert(pos < 32);
            encodedReferenceOffsets |= 1 << pos;
        } else if (VM.BuildFor32Addr && (arg.isLongType() || arg.isDoubleType())) {
            pos++;
        }
    }
    // Call out to JNI environment JNI entry
    if (VM.BuildFor32Addr) {
        asm.emitMOV_Reg_RegDisp(PARAMETER_GPRS[0], EBP, JNI_ENV_OFFSET);
    } else {
        asm.emitMOV_Reg_RegDisp_Quad(PARAMETER_GPRS[0], EBP, JNI_ENV_OFFSET);
    }
    asm.emitPUSH_Reg(PARAMETER_GPRS[0]);
    asm.emitMOV_Reg_Imm(PARAMETER_GPRS[1], encodedReferenceOffsets);
    asm.emitPUSH_Reg(PARAMETER_GPRS[1]);
    asm.baselineEmitLoadTIB(S0, PARAMETER_GPRS[0]);
    asm.emitCALL_RegDisp(S0, Entrypoints.jniEntry.getOffset());
    // (5) Set up stack frame and registers for transition to C
    int stackholes = 0;
    int position = 0;
    int argsPassedInRegister = 0;
    if (VM.BuildFor64Addr) {
        int gpRegistersInUse = 2;
        int fpRegistersInUse = 0;
        boolean dataOnStack = false;
        // JNI env
        asm.emitPOP_Reg(NATIVE_PARAMETER_GPRS[0]);
        // Object/Class
        asm.emitPOP_Reg(NATIVE_PARAMETER_GPRS[1]);
        argsPassedInRegister += 2;
        for (TypeReference arg : method.getParameterTypes()) {
            if (arg.isFloatType()) {
                if (fpRegistersInUse < NATIVE_PARAMETER_FPRS.length) {
                    asm.emitMOVSS_Reg_RegDisp((XMM) NATIVE_PARAMETER_FPRS[fpRegistersInUse], SP, Offset.fromIntZeroExtend(position << LG_WORDSIZE));
                    if (dataOnStack) {
                        stackholes |= 1 << position;
                    } else {
                        asm.emitPOP_Reg(T0);
                    }
                    fpRegistersInUse++;
                    argsPassedInRegister++;
                } else {
                    // no register available so we have data on the stack
                    dataOnStack = true;
                }
            } else if (arg.isDoubleType()) {
                if (fpRegistersInUse < NATIVE_PARAMETER_FPRS.length) {
                    asm.emitMOVSD_Reg_RegDisp((XMM) NATIVE_PARAMETER_FPRS[fpRegistersInUse], SP, Offset.fromIntZeroExtend(position << LG_WORDSIZE));
                    if (dataOnStack) {
                        stackholes |= 1 << position;
                    } else {
                        asm.emitPOP_Reg(T0);
                    }
                    if (VM.BuildFor32Addr)
                        asm.emitPOP_Reg(T0);
                    fpRegistersInUse++;
                    argsPassedInRegister += VM.BuildFor32Addr ? 2 : 1;
                } else {
                    // no register available so we have data on the stack
                    dataOnStack = true;
                }
            } else {
                if (gpRegistersInUse < NATIVE_PARAMETER_GPRS.length) {
                    // TODO: we can't have holes in the data that is on the stack, we need to shuffle it up
                    asm.emitMOV_Reg_RegDisp_Quad(NATIVE_PARAMETER_GPRS[gpRegistersInUse], SP, Offset.fromIntZeroExtend(position << LG_WORDSIZE));
                    if (dataOnStack) {
                        stackholes |= 1 << position;
                    } else {
                        asm.emitPOP_Reg(T0);
                    }
                    gpRegistersInUse++;
                    argsPassedInRegister++;
                } else {
                    // no register available so we have data on the stack
                    dataOnStack = true;
                }
            }
            if (dataOnStack) {
                position++;
            }
        }
        position--;
        int onStackOffset = position;
        int mask = 0;
        for (int i = position; i >= 0; i--) {
            mask = 1 << i;
            if ((stackholes & mask) != 0) {
                continue;
            }
            if (i < onStackOffset) {
                asm.emitMOV_Reg_RegDisp_Quad(T0, SP, Offset.fromIntZeroExtend(i << LOG_BYTES_IN_WORD));
                asm.emitMOV_RegDisp_Reg_Quad(SP, Offset.fromIntZeroExtend(onStackOffset << LOG_BYTES_IN_WORD), T0);
            }
            onStackOffset--;
        }
        while (onStackOffset >= 0) {
            asm.emitPOP_Reg(T0);
            onStackOffset--;
        }
    }
    // move address of native code to invoke into T0
    if (VM.BuildFor32Addr) {
        asm.emitMOV_Reg_Imm(T0, nativeIP.toInt());
    } else {
        asm.emitMOV_Reg_Imm_Quad(T0, nativeIP.toLong());
    }
    // Trap if stack alignment fails
    if (VM.ExtremeAssertions && VM.BuildFor64Addr) {
        asm.emitBT_Reg_Imm(ESP, 3);
        ForwardReference fr = asm.forwardJcc(LGE);
        asm.emitINT_Imm(3);
        fr.resolve(asm);
    }
    // make the call to native code
    asm.emitCALL_Reg(T0);
    // (7) Discard parameters on stack
    if (VM.BuildFor32Addr) {
        // throw away args, class/this ptr and env
        int argsToThrowAway = method.getParameterWords() + 2 - argsPassedInRegister;
        if (argsToThrowAway != 0) {
            asm.emitLEA_Reg_RegDisp(SP, EBP, BP_ON_ENTRY_OFFSET);
        }
    } else {
        // throw away args, class/this ptr and env (and padding)
        asm.emitLEA_Reg_RegDisp_Quad(SP, EBP, BP_ON_ENTRY_OFFSET);
    }
    // (8) Save result to stack
    final TypeReference returnType = method.getReturnType();
    if (returnType.isVoidType()) {
    // Nothing to save
    } else if (returnType.isFloatType()) {
        // adjust stack
        asm.emitPUSH_Reg(T0);
        if (VM.BuildFor32Addr) {
            asm.emitFSTP_RegInd_Reg(ESP, FP0);
        } else {
            asm.emitMOVSS_RegInd_Reg(ESP, XMM0);
        }
    } else if (returnType.isDoubleType()) {
        // adjust stack
        asm.emitPUSH_Reg(T0);
        // adjust stack
        asm.emitPUSH_Reg(T0);
        if (VM.BuildFor32Addr) {
            asm.emitFSTP_RegInd_Reg_Quad(ESP, FP0);
        } else {
            asm.emitMOVSD_RegInd_Reg(ESP, XMM0);
        }
    } else if (VM.BuildFor32Addr && returnType.isLongType()) {
        asm.emitPUSH_Reg(T0);
        asm.emitPUSH_Reg(T1);
    } else {
        // Ensure sign-extension is correct
        if (returnType.isBooleanType()) {
            asm.emitMOVZX_Reg_Reg_Byte(T0, T0);
        } else if (returnType.isByteType()) {
            asm.emitMOVSX_Reg_Reg_Byte(T0, T0);
        } else if (returnType.isCharType()) {
            asm.emitMOVZX_Reg_Reg_Word(T0, T0);
        } else if (returnType.isShortType()) {
            asm.emitMOVSX_Reg_Reg_Word(T0, T0);
        }
        asm.emitPUSH_Reg(T0);
    }
    // (9.1) reload JNIEnvironment from glue frame
    if (VM.BuildFor32Addr) {
        asm.emitMOV_Reg_RegDisp(S0, EBP, JNICompiler.JNI_ENV_OFFSET);
    } else {
        asm.emitMOV_Reg_RegDisp_Quad(S0, EBP, JNICompiler.JNI_ENV_OFFSET);
    }
    // (9.2) Reload thread register from JNIEnvironment
    if (VM.BuildFor32Addr) {
        asm.emitMOV_Reg_RegDisp(THREAD_REGISTER, S0, Entrypoints.JNIEnvSavedTRField.getOffset());
    } else {
        asm.emitMOV_Reg_RegDisp_Quad(THREAD_REGISTER, S0, Entrypoints.JNIEnvSavedTRField.getOffset());
    }
    // (9.3) Establish frame pointer to this glue method
    if (VM.BuildFor32Addr) {
        asm.emitMOV_RegDisp_Reg(THREAD_REGISTER, ArchEntrypoints.framePointerField.getOffset(), EBP);
    } else {
        asm.emitMOV_RegDisp_Reg_Quad(THREAD_REGISTER, ArchEntrypoints.framePointerField.getOffset(), EBP);
    }
    // result (currently a JNI ref) into a true reference, release JNI refs
    if (VM.BuildFor32Addr) {
        // 1st arg is JNI Env
        asm.emitMOV_Reg_Reg(PARAMETER_GPRS[0], S0);
    } else {
        // 1st arg is JNI Env
        asm.emitMOV_Reg_Reg_Quad(PARAMETER_GPRS[0], S0);
    }
    if (returnType.isReferenceType()) {
        // 2nd arg is ref result
        asm.emitPOP_Reg(PARAMETER_GPRS[1]);
    } else {
        // place dummy (null) operand on stack
        asm.emitXOR_Reg_Reg(PARAMETER_GPRS[1], PARAMETER_GPRS[1]);
    }
    // save JNIEnv
    asm.emitPUSH_Reg(S0);
    // push arg 1
    asm.emitPUSH_Reg(S0);
    // push arg 2
    asm.emitPUSH_Reg(PARAMETER_GPRS[1]);
    // Do the call
    asm.baselineEmitLoadTIB(S0, S0);
    asm.emitCALL_RegDisp(S0, Entrypoints.jniExit.getOffset());
    // restore JNIEnv
    asm.emitPOP_Reg(S0);
    // place result in register
    if (returnType.isVoidType()) {
    // Nothing to save
    } else if (returnType.isReferenceType()) {
    // value already in register
    } else if (returnType.isFloatType()) {
        if (SSE2_FULL) {
            asm.emitMOVSS_Reg_RegInd(XMM0, ESP);
        } else {
            asm.emitFLD_Reg_RegInd(FP0, ESP);
        }
        // adjust stack
        asm.emitPOP_Reg(T0);
    } else if (returnType.isDoubleType()) {
        if (SSE2_FULL) {
            asm.emitMOVSD_Reg_RegInd(XMM0, ESP);
        } else {
            asm.emitFLD_Reg_RegInd_Quad(FP0, ESP);
        }
        // adjust stack
        asm.emitPOP_Reg(T0);
        // adjust stack
        asm.emitPOP_Reg(T0);
    } else if (VM.BuildFor32Addr && returnType.isLongType()) {
        asm.emitPOP_Reg(T0);
        asm.emitPOP_Reg(T1);
    } else {
        asm.emitPOP_Reg(T0);
    }
    // saved previous native BP
    asm.emitPOP_Reg(EBX);
    if (VM.BuildFor32Addr) {
        asm.emitMOV_RegDisp_Reg(S0, Entrypoints.JNIEnvBasePointerOnEntryToNative.getOffset(), EBX);
    } else {
        asm.emitMOV_RegDisp_Reg_Quad(S0, Entrypoints.JNIEnvBasePointerOnEntryToNative.getOffset(), EBX);
    }
    // throw away JNI env
    asm.emitPOP_Reg(EBX);
    // restore non-volatile EBP
    asm.emitPOP_Reg(EBP);
    // restore non-volatile EBX
    asm.emitPOP_Reg(EBX);
    // restore non-volatile EDI
    asm.emitPOP_Reg(EDI);
    // throw away cmid
    asm.emitPOP_Reg(S0);
    asm.emitPOP_RegDisp(THREAD_REGISTER, ArchEntrypoints.framePointerField.getOffset());
    // pop parameters from stack (Note that parameterWords does not include "this")
    if (method.isStatic()) {
        asm.emitRET_Imm(method.getParameterWords() << LG_WORDSIZE);
    } else {
        asm.emitRET_Imm((method.getParameterWords() + 1) << LG_WORDSIZE);
    }
    CodeArray code = asm.getMachineCodes();
    cm.compileComplete(code);
    return cm;
}

Example 29 with Address

use of org.vmmagic.unboxed.Address in project JikesRVM by JikesRVM.

the class MemoryManager method allocateArrayInternal.

/**
 * Allocate an array object.
 *
 * @param numElements The number of element bytes
 * @param size size in bytes of array header
 * @param tib type information block for array object
 * @param allocator int that encodes which allocator should be used
 * @param align the alignment requested; must be a power of 2.
 * @param offset the offset at which the alignment is desired.
 * @param site allocation site.
 * @return array object with header installed and all elements set
 *         to zero/{@code null}
 * See also: bytecode 0xbc ("newarray") and 0xbd ("anewarray")
 */
@Inline
private static Object allocateArrayInternal(int numElements, int size, TIB tib, int allocator, int align, int offset, int site) {
    Selected.Mutator mutator = Selected.Mutator.get();
    allocator = mutator.checkAllocator(org.jikesrvm.runtime.Memory.alignUp(size, MIN_ALIGNMENT), align, allocator);
    Address region = allocateSpace(mutator, size, align, offset, allocator, site);
    Object result = ObjectModel.initializeArray(region, tib, numElements, size);
    mutator.postAlloc(ObjectReference.fromObject(result), ObjectReference.fromObject(tib), size, allocator);
    return result;
}

Example 30 with Address

use of org.vmmagic.unboxed.Address in project JikesRVM by JikesRVM.

the class JavaHeader method moveObject.

/**
 * Copies an object to the given raw storage address.
 *
 * @param toObj the target object. If this is non-{@code null}, the target
 *  address must be {@code Address.zero()}.
 * @param toAddress the target address. If this is not {@code Address.zero()},
 *  the target object must be {@code null}.
 * @param fromObj the object to copy from
 * @param numBytes the number of bytes to copy
 * @return the reference of the object's copy
 */
@Inline
public static Object moveObject(Address toAddress, Object fromObj, Object toObj, int numBytes) {
    if (VM.VerifyAssertions)
        VM._assert(toAddress.isZero() || toObj == null);
    // Default values
    int copyBytes = numBytes;
    int objRefOffset = OBJECT_REF_OFFSET;
    Word statusWord = Word.zero();
    Word hashState = HASH_STATE_UNHASHED;
    if (ADDRESS_BASED_HASHING) {
        // Read the hash state (used below)
        statusWord = Magic.getWordAtOffset(fromObj, STATUS_OFFSET);
        hashState = statusWord.and(HASH_STATE_MASK);
        if (hashState.EQ(HASH_STATE_HASHED)) {
            // We do not copy the hashcode, but we do allocate it
            copyBytes -= HASHCODE_BYTES;
            if (!DYNAMIC_HASH_OFFSET) {
                // The hashcode is the first word, so we copy to object one word higher
                if (toObj == null) {
                    toAddress = toAddress.plus(HASHCODE_BYTES);
                }
            }
        } else if (!DYNAMIC_HASH_OFFSET && hashState.EQ(HASH_STATE_HASHED_AND_MOVED)) {
            // Simple operation (no hash state change), but one word larger header
            objRefOffset += HASHCODE_BYTES;
        }
    }
    if (toObj != null) {
        toAddress = Magic.objectAsAddress(toObj).minus(objRefOffset);
    }
    // Low memory word of source object
    Address fromAddress = Magic.objectAsAddress(fromObj).minus(objRefOffset);
    // Do the copy
    Memory.aligned32Copy(toAddress, fromAddress, copyBytes);
    if (toObj == null) {
        toObj = Magic.addressAsObject(toAddress.plus(objRefOffset));
    } else {
        if (VM.VerifyAssertions)
            VM._assert(toObj == Magic.addressAsObject(toAddress.plus(objRefOffset)));
    }
    // Do we need to copy the hash code?
    if (hashState.EQ(HASH_STATE_HASHED)) {
        int hashCode = Magic.objectAsAddress(fromObj).toWord().rshl(LOG_BYTES_IN_ADDRESS).toInt();
        if (DYNAMIC_HASH_OFFSET) {
            Magic.setIntAtOffset(toObj, Offset.fromIntSignExtend(numBytes - OBJECT_REF_OFFSET - HASHCODE_BYTES), hashCode);
        } else {
            Magic.setIntAtOffset(toObj, HASHCODE_OFFSET, (hashCode << 1) | ALIGNMENT_MASK);
        }
        Magic.setWordAtOffset(toObj, STATUS_OFFSET, statusWord.or(HASH_STATE_HASHED_AND_MOVED));
        if (ObjectModel.HASH_STATS)
            ObjectModel.hashTransition2++;
    }
    return toObj;
}