Search in sources :

Example 11 with RVMClass

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

the class JNIFunctions method NewObjectV.

/**
 * NewObjectV: create a new object instance
 * @param env A JREF index for the JNI environment object
 * @param classJREF a JREF index for the class object
 * @param methodID id of a MethodReference
 * @param argAddress a raw address to a variable argument list, each element is 1-word or
 *                   2-words of the appropriate type for the constructor invocation
 * @return the new object instance
 * @throws InstantiationException if the class is abstract or is an interface
 * @throws OutOfMemoryError if no more memory to allocate
 */
private static int NewObjectV(JNIEnvironment env, int classJREF, int methodID, Address argAddress) throws Exception {
    if (traceJNI)
        VM.sysWriteln("JNI called: NewObjectV");
    RuntimeEntrypoints.checkJNICountDownToGC();
    try {
        Class<?> cls = (Class<?>) env.getJNIRef(classJREF);
        RVMClass vmcls = java.lang.JikesRVMSupport.getTypeForClass(cls).asClass();
        if (vmcls.isAbstract() || vmcls.isInterface()) {
            env.recordException(new InstantiationException());
            return 0;
        }
        Object newobj = JNIHelpers.invokeInitializer(cls, methodID, argAddress, false, false);
        return env.pushJNIRef(newobj);
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return 0;
    }
}
Also used : RVMClass(org.jikesrvm.classloader.RVMClass) RVMClass(org.jikesrvm.classloader.RVMClass)

Example 12 with RVMClass

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

the class JNIFunctions method GetMethodID.

/**
 * GetMethodID:  get the virtual method ID given the name and the signature
 * @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 the method signature
 * @return id of a MethodReference
 * @throws NoSuchMethodError if the method cannot be found
 * @throws ExceptionInInitializerError if the class or interface static initializer fails
 * @throws OutOfMemoryError if the system runs out of memory
 */
private static int GetMethodID(JNIEnvironment env, int classJREF, Address methodNameAddress, Address methodSigAddress) {
    if (traceJNI)
        VM.sysWriteln("JNI called: GetMethodID");
    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
        final RVMMethod meth;
        if (methodString.equals("<init>")) {
            meth = klass.findInitializerMethod(sigName);
        } else {
            meth = klass.findVirtualMethod(methodName, sigName);
        }
        if (meth == null) {
            env.recordException(new NoSuchMethodError(klass + ": " + methodName + " " + sigName));
            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;
    }
}
Also used : RVMMethod(org.jikesrvm.classloader.RVMMethod) RVMType(org.jikesrvm.classloader.RVMType) RVMClass(org.jikesrvm.classloader.RVMClass) Atom(org.jikesrvm.classloader.Atom) RVMClass(org.jikesrvm.classloader.RVMClass)

Example 13 with RVMClass

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

the class JNIFunctions method UnregisterNatives.

/**
 * UnregisterNatives: unregisters 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
 * @return 0 is successful -1 if failed
 */
private static int UnregisterNatives(JNIEnvironment env, int classJREF) {
    if (traceJNI)
        VM.sysWriteln("JNI called: UnregisterNatives");
    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 NoClassDefFoundError());
            return -1;
        }
        RVMClass klass = type.asClass();
        if (!klass.isInitialized()) {
            return 0;
        }
        klass.unregisterNativeMethods();
        return 0;
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return -1;
    }
}
Also used : RVMType(org.jikesrvm.classloader.RVMType) RVMClass(org.jikesrvm.classloader.RVMClass) RVMClass(org.jikesrvm.classloader.RVMClass)

Example 14 with RVMClass

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

the class JNIFunctions method NewObject.

/**
 * NewObject: create a new object instance
 * NOTE:  the vararg's are not visible in the method signature here;
 *        they are saved in the caller frame and the glue frame
 * <p>
 * <strong>NOTE: This implementation is NOT used for IA32. On IA32, it is overwritten
 * with a C implementation in the bootloader when the VM starts.</strong>
 * @param env A JREF index for the JNI environment object
 * @param classJREF a JREF index for the class object
 * @param methodID id of a MethodReference
 * @return the new object instance
 * @throws InstantiationException if the class is abstract or is an interface
 * @throws OutOfMemoryError if no more memory to allocate
 */
private static int NewObject(JNIEnvironment env, int classJREF, int methodID) throws Exception {
    if (VM.VerifyAssertions) {
        VM._assert(VM.BuildForPowerPC, ERROR_MSG_WRONG_IMPLEMENTATION);
    }
    if (traceJNI)
        VM.sysWriteln("JNI called: NewObject");
    RuntimeEntrypoints.checkJNICountDownToGC();
    try {
        Class<?> cls = (Class<?>) env.getJNIRef(classJREF);
        RVMClass vmcls = java.lang.JikesRVMSupport.getTypeForClass(cls).asClass();
        if (vmcls.isAbstract() || vmcls.isInterface()) {
            env.recordException(new InstantiationException());
            return 0;
        }
        Object newobj = JNIHelpers.invokeInitializer(cls, methodID, Address.zero(), false, true);
        return env.pushJNIRef(newobj);
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return 0;
    }
}
Also used : RVMClass(org.jikesrvm.classloader.RVMClass) RVMClass(org.jikesrvm.classloader.RVMClass)

Example 15 with RVMClass

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

the class TemplateCompilerFramework method genCode.

/**
 * Main code generation loop.
 *
 * @return generated machine code
 */
protected final MachineCode genCode() {
    AbstractAssembler asm = getAssembler();
    AbstractLister lister = getLister();
    emit_prologue();
    while (bcodes.hasMoreBytecodes()) {
        biStart = bcodes.index();
        bytecodeMap[biStart] = asm.getMachineCodeIndex();
        asm.resolveForwardReferences(biStart);
        starting_bytecode();
        int code = bcodes.nextInstruction();
        switch(code) {
            case JBC_nop:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "nop");
                    break;
                }
            case JBC_aconst_null:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aconst_null");
                    emit_aconst_null();
                    break;
                }
            case JBC_iconst_m1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_m1");
                    emit_iconst(-1);
                    break;
                }
            case JBC_iconst_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_0");
                    emit_iconst(0);
                    break;
                }
            case JBC_iconst_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_1");
                    emit_iconst(1);
                    break;
                }
            case JBC_iconst_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_2");
                    emit_iconst(2);
                    break;
                }
            case JBC_iconst_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_3");
                    emit_iconst(3);
                    break;
                }
            case JBC_iconst_4:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_4");
                    emit_iconst(4);
                    break;
                }
            case JBC_iconst_5:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iconst_5");
                    emit_iconst(5);
                    break;
                }
            case JBC_lconst_0:
                {
                    // floating-point 0 is long 0
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lconst_0");
                    emit_lconst(0);
                    break;
                }
            case JBC_lconst_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lconst_1");
                    emit_lconst(1);
                    break;
                }
            case JBC_fconst_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fconst_0");
                    emit_fconst_0();
                    break;
                }
            case JBC_fconst_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fconst_1");
                    emit_fconst_1();
                    break;
                }
            case JBC_fconst_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fconst_2");
                    emit_fconst_2();
                    break;
                }
            case JBC_dconst_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dconst_0");
                    emit_dconst_0();
                    break;
                }
            case JBC_dconst_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dconst_1");
                    emit_dconst_1();
                    break;
                }
            case JBC_bipush:
                {
                    int val = bcodes.getByteValue();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "bipush", val);
                    emit_iconst(val);
                    break;
                }
            case JBC_sipush:
                {
                    int val = bcodes.getShortValue();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "sipush", val);
                    emit_iconst(val);
                    break;
                }
            case JBC_ldc:
                {
                    int index = bcodes.getConstantIndex();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ldc", index);
                    Offset offset = klass.getLiteralOffset(index);
                    byte type = klass.getLiteralDescription(index);
                    emit_ldc(offset, type);
                    break;
                }
            case JBC_ldc_w:
                {
                    int index = bcodes.getWideConstantIndex();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ldc_w", index);
                    Offset offset = klass.getLiteralOffset(index);
                    byte type = klass.getLiteralDescription(index);
                    emit_ldc(offset, type);
                    break;
                }
            case JBC_ldc2_w:
                {
                    int index = bcodes.getWideConstantIndex();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ldc2_w", index);
                    Offset offset = klass.getLiteralOffset(index);
                    byte type = klass.getLiteralDescription(index);
                    emit_ldc2(offset, type);
                    break;
                }
            case JBC_iload:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iload", index);
                    emit_iload(index);
                    break;
                }
            case JBC_lload:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lload", index);
                    emit_lload(index);
                    break;
                }
            case JBC_fload:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fload", index);
                    emit_fload(index);
                    break;
                }
            case JBC_dload:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dload", index);
                    emit_dload(index);
                    break;
                }
            case JBC_aload:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aload", index);
                    emit_aload(index);
                    break;
                }
            case JBC_iload_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iload_0");
                    emit_iload(0);
                    break;
                }
            case JBC_iload_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iload_1");
                    emit_iload(1);
                    break;
                }
            case JBC_iload_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iload_2");
                    emit_iload(2);
                    break;
                }
            case JBC_iload_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iload_3");
                    emit_iload(3);
                    break;
                }
            case JBC_lload_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lload_0");
                    emit_lload(0);
                    break;
                }
            case JBC_lload_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lload_1");
                    emit_lload(1);
                    break;
                }
            case JBC_lload_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lload_2");
                    emit_lload(2);
                    break;
                }
            case JBC_lload_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lload_3");
                    emit_lload(3);
                    break;
                }
            case JBC_fload_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fload_0");
                    emit_fload(0);
                    break;
                }
            case JBC_fload_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fload_1");
                    emit_fload(1);
                    break;
                }
            case JBC_fload_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fload_2");
                    emit_fload(2);
                    break;
                }
            case JBC_fload_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fload_3");
                    emit_fload(3);
                    break;
                }
            case JBC_dload_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dload_0");
                    emit_dload(0);
                    break;
                }
            case JBC_dload_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dload_1");
                    emit_dload(1);
                    break;
                }
            case JBC_dload_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dload_2");
                    emit_dload(2);
                    break;
                }
            case JBC_dload_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dload_3");
                    emit_dload(3);
                    break;
                }
            case JBC_aload_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aload_0");
                    emit_aload(0);
                    break;
                }
            case JBC_aload_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aload_1");
                    emit_aload(1);
                    break;
                }
            case JBC_aload_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aload_2");
                    emit_aload(2);
                    break;
                }
            case JBC_aload_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aload_3");
                    emit_aload(3);
                    break;
                }
            case JBC_iaload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iaload");
                    emit_iaload();
                    break;
                }
            case JBC_laload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "laload");
                    emit_laload();
                    break;
                }
            case JBC_faload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "faload");
                    emit_faload();
                    break;
                }
            case JBC_daload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "daload");
                    emit_daload();
                    break;
                }
            case JBC_aaload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aaload");
                    emit_aaload();
                    break;
                }
            case JBC_baload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "baload");
                    emit_baload();
                    break;
                }
            case JBC_caload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "caload");
                    emit_caload();
                    break;
                }
            case JBC_saload:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "saload");
                    emit_saload();
                    break;
                }
            case JBC_istore:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "istore", index);
                    emit_istore(index);
                    break;
                }
            case JBC_lstore:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lstore", index);
                    emit_lstore(index);
                    break;
                }
            case JBC_fstore:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fstore", index);
                    emit_fstore(index);
                    break;
                }
            case JBC_dstore:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dstore", index);
                    emit_dstore(index);
                    break;
                }
            case JBC_astore:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "astore", index);
                    emit_astore(index);
                    break;
                }
            case JBC_istore_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "istore_0");
                    emit_istore(0);
                    break;
                }
            case JBC_istore_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "istore_1");
                    emit_istore(1);
                    break;
                }
            case JBC_istore_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "istore_2");
                    emit_istore(2);
                    break;
                }
            case JBC_istore_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "istore_3");
                    emit_istore(3);
                    break;
                }
            case JBC_lstore_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lstore_0");
                    emit_lstore(0);
                    break;
                }
            case JBC_lstore_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lstore_1");
                    emit_lstore(1);
                    break;
                }
            case JBC_lstore_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lstore_2");
                    emit_lstore(2);
                    break;
                }
            case JBC_lstore_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lstore_3");
                    emit_lstore(3);
                    break;
                }
            case JBC_fstore_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fstore_0");
                    emit_fstore(0);
                    break;
                }
            case JBC_fstore_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fstore_1");
                    emit_fstore(1);
                    break;
                }
            case JBC_fstore_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fstore_2");
                    emit_fstore(2);
                    break;
                }
            case JBC_fstore_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fstore_3");
                    emit_fstore(3);
                    break;
                }
            case JBC_dstore_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dstore_0");
                    emit_dstore(0);
                    break;
                }
            case JBC_dstore_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dstore_1");
                    emit_dstore(1);
                    break;
                }
            case JBC_dstore_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dstore_2");
                    emit_dstore(2);
                    break;
                }
            case JBC_dstore_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dstore_3");
                    emit_dstore(3);
                    break;
                }
            case JBC_astore_0:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "astore_0");
                    emit_astore(0);
                    break;
                }
            case JBC_astore_1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "astore_1");
                    emit_astore(1);
                    break;
                }
            case JBC_astore_2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "astore_2");
                    emit_astore(2);
                    break;
                }
            case JBC_astore_3:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "astore_3");
                    emit_astore(3);
                    break;
                }
            case JBC_iastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iastore");
                    emit_iastore();
                    break;
                }
            case JBC_lastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lastore");
                    emit_lastore();
                    break;
                }
            case JBC_fastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fastore");
                    emit_fastore();
                    break;
                }
            case JBC_dastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dastore");
                    emit_dastore();
                    break;
                }
            case JBC_aastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "aastore");
                    // ArrayStoreException}
                    if (VM.VerifyUnint && isUninterruptible && doesCheckStore)
                        forbiddenBytecode("aastore", bcodes.index());
                    emit_aastore();
                    break;
                }
            case JBC_bastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "bastore");
                    emit_bastore();
                    break;
                }
            case JBC_castore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "castore");
                    emit_castore();
                    break;
                }
            case JBC_sastore:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "sastore");
                    emit_sastore();
                    break;
                }
            case JBC_pop:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "pop");
                    emit_pop();
                    break;
                }
            case JBC_pop2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "pop2");
                    emit_pop2();
                    break;
                }
            case JBC_dup:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dup");
                    emit_dup();
                    break;
                }
            case JBC_dup_x1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dup_x1");
                    emit_dup_x1();
                    break;
                }
            case JBC_dup_x2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dup_x2");
                    emit_dup_x2();
                    break;
                }
            case JBC_dup2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dup2");
                    emit_dup2();
                    break;
                }
            case JBC_dup2_x1:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dup2_x1");
                    emit_dup2_x1();
                    break;
                }
            case JBC_dup2_x2:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dup2_x2");
                    emit_dup2_x2();
                    break;
                }
            case JBC_swap:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "swap");
                    emit_swap();
                    break;
                }
            case JBC_iadd:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iadd");
                    emit_iadd();
                    break;
                }
            case JBC_ladd:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ladd");
                    emit_ladd();
                    break;
                }
            case JBC_fadd:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fadd");
                    emit_fadd();
                    break;
                }
            case JBC_dadd:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dadd");
                    emit_dadd();
                    break;
                }
            case JBC_isub:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "isub");
                    emit_isub();
                    break;
                }
            case JBC_lsub:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lsub");
                    emit_lsub();
                    break;
                }
            case JBC_fsub:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fsub");
                    emit_fsub();
                    break;
                }
            case JBC_dsub:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dsub");
                    emit_dsub();
                    break;
                }
            case JBC_imul:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "imul");
                    emit_imul();
                    break;
                }
            case JBC_lmul:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lmul");
                    emit_lmul();
                    break;
                }
            case JBC_fmul:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fmul");
                    emit_fmul();
                    break;
                }
            case JBC_dmul:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dmul");
                    emit_dmul();
                    break;
                }
            case JBC_idiv:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "idiv");
                    emit_idiv();
                    break;
                }
            case JBC_ldiv:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ldiv");
                    emit_ldiv();
                    break;
                }
            case JBC_fdiv:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fdiv");
                    emit_fdiv();
                    break;
                }
            case JBC_ddiv:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ddiv");
                    emit_ddiv();
                    break;
                }
            case JBC_irem:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "irem");
                    emit_irem();
                    break;
                }
            case JBC_lrem:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lrem");
                    emit_lrem();
                    break;
                }
            case JBC_frem:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "frem");
                    emit_frem();
                    break;
                }
            case JBC_drem:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "drem");
                    emit_drem();
                    break;
                }
            case JBC_ineg:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ineg");
                    emit_ineg();
                    break;
                }
            case JBC_lneg:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lneg");
                    emit_lneg();
                    break;
                }
            case JBC_fneg:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fneg");
                    emit_fneg();
                    break;
                }
            case JBC_dneg:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dneg");
                    emit_dneg();
                    break;
                }
            case JBC_ishl:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ishl");
                    emit_ishl();
                    break;
                }
            case JBC_lshl:
                {
                    // l >> n
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lshl");
                    emit_lshl();
                    break;
                }
            case JBC_ishr:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ishr");
                    emit_ishr();
                    break;
                }
            case JBC_lshr:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lshr");
                    emit_lshr();
                    break;
                }
            case JBC_iushr:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iushr");
                    emit_iushr();
                    break;
                }
            case JBC_lushr:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lushr");
                    emit_lushr();
                    break;
                }
            case JBC_iand:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iand");
                    emit_iand();
                    break;
                }
            case JBC_land:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "land");
                    emit_land();
                    break;
                }
            case JBC_ior:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ior");
                    emit_ior();
                    break;
                }
            case JBC_lor:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lor");
                    emit_lor();
                    break;
                }
            case JBC_ixor:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ixor");
                    emit_ixor();
                    break;
                }
            case JBC_lxor:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lxor");
                    emit_lxor();
                    break;
                }
            case JBC_iinc:
                {
                    int index = bcodes.getLocalNumber();
                    int val = bcodes.getIncrement();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "iinc", index, val);
                    emit_iinc(index, val);
                    break;
                }
            case JBC_i2l:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "i2l");
                    emit_i2l();
                    break;
                }
            case JBC_i2f:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "i2f");
                    emit_i2f();
                    break;
                }
            case JBC_i2d:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "i2d");
                    emit_i2d();
                    break;
                }
            case JBC_l2i:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "l2i");
                    emit_l2i();
                    break;
                }
            case JBC_l2f:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "l2f");
                    emit_l2f();
                    break;
                }
            case JBC_l2d:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "l2d");
                    emit_l2d();
                    break;
                }
            case JBC_f2i:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "f2i");
                    emit_f2i();
                    break;
                }
            case JBC_f2l:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "f2l");
                    emit_f2l();
                    break;
                }
            case JBC_f2d:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "f2d");
                    emit_f2d();
                    break;
                }
            case JBC_d2i:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "d2i");
                    emit_d2i();
                    break;
                }
            case JBC_d2l:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "d2l");
                    emit_d2l();
                    break;
                }
            case JBC_d2f:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "d2f");
                    emit_d2f();
                    break;
                }
            case JBC_int2byte:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "i2b");
                    emit_i2b();
                    break;
                }
            case JBC_int2char:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "i2c");
                    emit_i2c();
                    break;
                }
            case JBC_int2short:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "i2s");
                    emit_i2s();
                    break;
                }
            case JBC_lcmp:
                {
                    // a ? b
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lcmp");
                    emit_lcmp();
                    break;
                }
            case JBC_fcmpl:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fcmpl");
                    emit_DFcmpGL(true, false);
                    break;
                }
            case JBC_fcmpg:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "fcmpg");
                    emit_DFcmpGL(true, true);
                    break;
                }
            case JBC_dcmpl:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dcmpl");
                    emit_DFcmpGL(false, false);
                    break;
                }
            case JBC_dcmpg:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dcmpg");
                    emit_DFcmpGL(false, true);
                    break;
                }
            case JBC_ifeq:
                {
                    do_if(biStart, BranchCondition.EQ);
                    break;
                }
            case JBC_ifne:
                {
                    do_if(biStart, BranchCondition.NE);
                    break;
                }
            case JBC_iflt:
                {
                    do_if(biStart, BranchCondition.LT);
                    break;
                }
            case JBC_ifge:
                {
                    do_if(biStart, BranchCondition.GE);
                    break;
                }
            case JBC_ifgt:
                {
                    do_if(biStart, BranchCondition.GT);
                    break;
                }
            case JBC_ifle:
                {
                    do_if(biStart, BranchCondition.LE);
                    break;
                }
            case JBC_if_icmpeq:
                {
                    do_if_icmp(biStart, BranchCondition.EQ);
                    break;
                }
            case JBC_if_icmpne:
                {
                    do_if_icmp(biStart, BranchCondition.NE);
                    break;
                }
            case JBC_if_icmplt:
                {
                    do_if_icmp(biStart, BranchCondition.LT);
                    break;
                }
            case JBC_if_icmpge:
                {
                    do_if_icmp(biStart, BranchCondition.GE);
                    break;
                }
            case JBC_if_icmpgt:
                {
                    do_if_icmp(biStart, BranchCondition.GT);
                    break;
                }
            case JBC_if_icmple:
                {
                    do_if_icmp(biStart, BranchCondition.LE);
                    break;
                }
            case JBC_if_acmpeq:
                {
                    int offset = bcodes.getBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "if_acmpeq", offset, bTarget);
                    if (offset <= 0)
                        emit_threadSwitchTest(RVMThread.BACKEDGE);
                    emit_if_acmpeq(bTarget);
                    break;
                }
            case JBC_if_acmpne:
                {
                    int offset = bcodes.getBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "if_acmpne", offset, bTarget);
                    if (offset <= 0)
                        emit_threadSwitchTest(RVMThread.BACKEDGE);
                    emit_if_acmpne(bTarget);
                    break;
                }
            case JBC_goto:
                {
                    int offset = bcodes.getBranchOffset();
                    // bi has been bumped by 3 already
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "goto", offset, bTarget);
                    if (offset <= 0)
                        emit_threadSwitchTest(RVMThread.BACKEDGE);
                    emit_goto(bTarget);
                    break;
                }
            case JBC_jsr:
                {
                    int offset = bcodes.getBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "jsr", offset, bTarget);
                    emit_jsr(bTarget);
                    break;
                }
            case JBC_ret:
                {
                    int index = bcodes.getLocalNumber();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ret ", index);
                    emit_ret(index);
                    break;
                }
            case JBC_tableswitch:
                {
                    bcodes.alignSwitch();
                    int defaultval = bcodes.getDefaultSwitchOffset();
                    int low = bcodes.getLowSwitchValue();
                    int high = bcodes.getHighSwitchValue();
                    if (shouldPrint)
                        lister.noteTableswitchBytecode(biStart, low, high, defaultval);
                    emit_tableswitch(defaultval, low, high);
                    break;
                }
            case JBC_lookupswitch:
                {
                    bcodes.alignSwitch();
                    int defaultval = bcodes.getDefaultSwitchOffset();
                    int npairs = bcodes.getSwitchLength();
                    if (shouldPrint)
                        lister.noteLookupswitchBytecode(biStart, npairs, defaultval);
                    emit_lookupswitch(defaultval, npairs);
                    break;
                }
            case JBC_ireturn:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "ireturn");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    emit_ireturn();
                    break;
                }
            case JBC_lreturn:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "lreturn");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    emit_lreturn();
                    break;
                }
            case JBC_freturn:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "freturn");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    emit_freturn();
                    break;
                }
            case JBC_dreturn:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "dreturn");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    emit_dreturn();
                    break;
                }
            case JBC_areturn:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "areturn");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    emit_areturn();
                    break;
                }
            case JBC_return:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "return");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    emit_return();
                    break;
                }
            case JBC_getstatic:
                {
                    FieldReference fieldRef = bcodes.getFieldReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "getstatic", fieldRef);
                    if (fieldRef.needsDynamicLink(method)) {
                        // interruptions
                        if (VM.VerifyUnint && !isInterruptible)
                            forbiddenBytecode("unresolved getstatic ", fieldRef, bcodes.index());
                        emit_unresolved_getstatic(fieldRef);
                    } else {
                        emit_resolved_getstatic(fieldRef);
                    }
                    break;
                }
            case JBC_putstatic:
                {
                    FieldReference fieldRef = bcodes.getFieldReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "putstatic", fieldRef);
                    if (fieldRef.needsDynamicLink(method)) {
                        // interruptions
                        if (VM.VerifyUnint && !isInterruptible)
                            forbiddenBytecode("unresolved putstatic ", fieldRef, bcodes.index());
                        emit_unresolved_putstatic(fieldRef);
                    } else {
                        emit_resolved_putstatic(fieldRef);
                    }
                    break;
                }
            case JBC_getfield:
                {
                    FieldReference fieldRef = bcodes.getFieldReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "getfield", fieldRef);
                    if (fieldRef.needsDynamicLink(method)) {
                        // interruptions
                        if (VM.VerifyUnint && !isInterruptible)
                            forbiddenBytecode("unresolved getfield ", fieldRef, bcodes.index());
                        emit_unresolved_getfield(fieldRef);
                    } else {
                        emit_resolved_getfield(fieldRef);
                    }
                    break;
                }
            case JBC_putfield:
                {
                    FieldReference fieldRef = bcodes.getFieldReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "putfield", fieldRef);
                    if (fieldRef.needsDynamicLink(method)) {
                        // interruptions
                        if (VM.VerifyUnint && !isInterruptible)
                            forbiddenBytecode("unresolved putfield ", fieldRef, bcodes.index());
                        emit_unresolved_putfield(fieldRef);
                    } else {
                        emit_resolved_putfield(fieldRef);
                    }
                    break;
                }
            case JBC_invokevirtual:
                {
                    ForwardReference xx = null;
                    if (biStart == this.pendingIdx) {
                        // goto X
                        ForwardReference x = emit_pending_goto(0);
                        // pendingIdx:     (target of pending goto in prologue)
                        this.pendingRef.resolve(asm);
                        CompiledMethod cm = CompiledMethods.getCompiledMethod(this.pendingCMID);
                        if (VM.VerifyAssertions)
                            VM._assert(cm.isSpecialForOSR());
                        // invoke_cmid
                        emit_invoke_compiledmethod(cm);
                        // goto XX
                        xx = emit_pending_goto(0);
                        // X:
                        x.resolve(asm);
                    }
                    MethodReference methodRef = bcodes.getMethodReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "invokevirtual", methodRef);
                    if (methodRef.getType().isMagicType()) {
                        if (emit_Magic(methodRef)) {
                            break;
                        }
                    }
                    if (methodRef.isMiranda()) {
                        /* Special case of abstract interface method should generate
             * an invokeinterface, despite the compiler claiming it should
             * be invokevirtual.
             */
                        if (shouldPrint)
                            lister.noteBytecode(biStart, "invokeinterface", methodRef);
                        // causes runtime checks that can be interrupted
                        if (VM.VerifyUnint && !isInterruptible)
                            forbiddenBytecode("invokeinterface ", methodRef, bcodes.index());
                        emit_invokeinterface(methodRef);
                    } else {
                        if (methodRef.needsDynamicLink(method)) {
                            // cause interruptions
                            if (VM.VerifyUnint && !isInterruptible)
                                forbiddenBytecode("unresolved invokevirtual ", methodRef, bcodes.index());
                            emit_unresolved_invokevirtual(methodRef);
                        } else {
                            if (VM.VerifyUnint && !isInterruptible)
                                checkTarget(methodRef.peekResolvedMethod(), bcodes.index());
                            emit_resolved_invokevirtual(methodRef);
                        }
                    }
                    if (xx != null) {
                        // XX:
                        xx.resolve(asm);
                    }
                    break;
                }
            case JBC_invokespecial:
                {
                    ForwardReference xx = null;
                    if (biStart == this.pendingIdx) {
                        // goto X
                        ForwardReference x = emit_pending_goto(0);
                        // pendingIdx:     (target of pending goto in prologue)
                        this.pendingRef.resolve(asm);
                        CompiledMethod cm = CompiledMethods.getCompiledMethod(this.pendingCMID);
                        if (VM.VerifyAssertions)
                            VM._assert(cm.isSpecialForOSR());
                        // invoke_cmid
                        emit_invoke_compiledmethod(cm);
                        // goto XX
                        xx = emit_pending_goto(0);
                        // X:
                        x.resolve(asm);
                    }
                    MethodReference methodRef = bcodes.getMethodReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "invokespecial", methodRef);
                    RVMMethod target = methodRef.resolveInvokeSpecial();
                    if (target != null) {
                        if (VM.VerifyUnint && !isInterruptible)
                            checkTarget(target, bcodes.index());
                        emit_resolved_invokespecial(methodRef, target);
                    } else {
                        emit_unresolved_invokespecial(methodRef);
                    }
                    if (xx != null) {
                        // XX:
                        xx.resolve(asm);
                    }
                    break;
                }
            case JBC_invokestatic:
                {
                    ForwardReference xx = null;
                    if (biStart == this.pendingIdx) {
                        // goto X
                        ForwardReference x = emit_pending_goto(0);
                        // pendingIdx:     (target of pending goto in prologue)
                        this.pendingRef.resolve(asm);
                        CompiledMethod cm = CompiledMethods.getCompiledMethod(this.pendingCMID);
                        if (VM.VerifyAssertions)
                            VM._assert(cm.isSpecialForOSR());
                        // invoke_cmid
                        emit_invoke_compiledmethod(cm);
                        // goto XX
                        xx = emit_pending_goto(0);
                        // X:
                        x.resolve(asm);
                    }
                    MethodReference methodRef = bcodes.getMethodReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "invokestatic", methodRef);
                    if (methodRef.isMagic()) {
                        if (emit_Magic(methodRef)) {
                            break;
                        }
                    }
                    if (methodRef.needsDynamicLink(method)) {
                        // cause interruptions
                        if (VM.VerifyUnint && !isInterruptible)
                            forbiddenBytecode("unresolved invokestatic ", methodRef, bcodes.index());
                        emit_unresolved_invokestatic(methodRef);
                    } else {
                        if (VM.VerifyUnint && !isInterruptible)
                            checkTarget(methodRef.peekResolvedMethod(), bcodes.index());
                        emit_resolved_invokestatic(methodRef);
                    }
                    if (xx != null) {
                        // XX:
                        xx.resolve(asm);
                    }
                    break;
                }
            case JBC_invokeinterface:
                {
                    ForwardReference xx = null;
                    if (biStart == this.pendingIdx) {
                        // goto X
                        ForwardReference x = emit_pending_goto(0);
                        // pendingIdx:     (target of pending goto in prologue)
                        this.pendingRef.resolve(asm);
                        CompiledMethod cm = CompiledMethods.getCompiledMethod(this.pendingCMID);
                        if (VM.VerifyAssertions)
                            VM._assert(cm.isSpecialForOSR());
                        // invoke_cmid
                        emit_invoke_compiledmethod(cm);
                        // goto XX
                        xx = emit_pending_goto(0);
                        // X:
                        x.resolve(asm);
                    }
                    MethodReference methodRef = bcodes.getMethodReference();
                    bcodes.alignInvokeInterface();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "invokeinterface", methodRef);
                    // causes runtime checks that can be interrupted
                    if (VM.VerifyUnint && !isInterruptible)
                        forbiddenBytecode("invokeinterface ", methodRef, bcodes.index());
                    emit_invokeinterface(methodRef);
                    if (xx != null) {
                        // XX:
                        xx.resolve(asm);
                    }
                    break;
                }
            case JBC_invokedynamic:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "unused");
                    if (VM.VerifyAssertions)
                        VM._assert(VM.NOT_REACHED);
                    break;
                }
            case JBC_new:
                {
                    TypeReference typeRef = bcodes.getTypeReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "new", typeRef);
                    // that are interruptible
                    if (VM.VerifyUnint && isUninterruptible)
                        forbiddenBytecode("new ", typeRef, bcodes.index());
                    RVMType type = typeRef.peekType();
                    if (type != null && (type.isInitialized() || type.isInBootImage())) {
                        emit_resolved_new(type.asClass());
                    } else {
                        if (VM.VerifyUnint && isUnpreemptible)
                            forbiddenBytecode("unresolved new ", typeRef, bcodes.index());
                        emit_unresolved_new(typeRef);
                    }
                    break;
                }
            case JBC_newarray:
                {
                    int atype = bcodes.getArrayElementType();
                    RVMArray array = RVMArray.getPrimitiveArrayType(atype);
                    if (VM.VerifyAssertions) {
                        boolean resolved = array.isResolved();
                        if (!resolved) {
                            String msg = "Found reference to unresolved array type " + array + " while compiling newarray bytecode in method " + method;
                            VM._assert(VM.NOT_REACHED, msg);
                        }
                    }
                    // that are interruptible
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "newarray", array.getTypeRef());
                    if (VM.VerifyUnint && isUninterruptible)
                        forbiddenBytecode("newarray ", array, bcodes.index());
                    emit_resolved_newarray(array);
                    break;
                }
            case JBC_anewarray:
                {
                    TypeReference elementTypeRef = bcodes.getTypeReference();
                    TypeReference arrayRef = elementTypeRef.getArrayTypeForElementType();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "anewarray new", arrayRef);
                    // that are interruptible
                    if (VM.VerifyUnint && !isInterruptible)
                        forbiddenBytecode("anewarray ", arrayRef, bcodes.index());
                    if (VM.VerifyAssertions && elementTypeRef.isUnboxedType()) {
                        String msg = "During compilation of " + method + " found an anewarray of " + elementTypeRef + "\n" + "You must use the 'create' function to create an array of this type";
                        VM._assert(VM.NOT_REACHED, msg);
                    }
                    RVMArray array = (RVMArray) arrayRef.peekType();
                    if (RVMType.JavaLangObjectType.isInstantiated()) {
                        // We need Object to be instantiated because we are going to mine it's TIB to get entries for array methods...
                        if (array == null || !(array.isInitialized() || array.isInBootImage())) {
                            RVMType elementType = elementTypeRef.peekType();
                            if (elementType != null && (elementType.isInitialized() || elementType.isInBootImage())) {
                                if (array == null) {
                                    array = (RVMArray) arrayRef.resolve();
                                }
                                array.resolve();
                                array.instantiate();
                            }
                        }
                    }
                    if (array != null && (array.isInitialized() || array.isInBootImage())) {
                        emit_resolved_newarray(array);
                    } else {
                        emit_unresolved_newarray(arrayRef);
                    }
                    break;
                }
            case JBC_arraylength:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "arraylength");
                    emit_arraylength();
                    break;
                }
            case JBC_athrow:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "athrow");
                    if (VM.UseEpilogueYieldPoints)
                        emit_threadSwitchTest(RVMThread.EPILOGUE);
                    // that are interruptible
                    if (VM.VerifyUnint && isUninterruptible)
                        forbiddenBytecode("athrow", bcodes.index());
                    emit_athrow();
                    break;
                }
            case JBC_checkcast:
                {
                    TypeReference typeRef = bcodes.getTypeReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "checkcast", typeRef);
                    RVMType type = typeRef.peekType();
                    if (type != null) {
                        if (type.isClassType()) {
                            RVMClass cType = type.asClass();
                            if (cType.isFinal()) {
                                emit_checkcast_final(cType);
                                break;
                            } else if (cType.isResolved()) {
                                if (cType.isInterface()) {
                                    emit_checkcast_resolvedInterface(cType);
                                } else {
                                    emit_checkcast_resolvedClass(cType);
                                }
                                break;
                            }
                        // else fall through to emit_checkcast
                        } else if (type.isArrayType()) {
                            RVMType elemType = type.asArray().getElementType();
                            if (elemType.isPrimitiveType() || elemType.isUnboxedType() || (elemType.isClassType() && elemType.asClass().isFinal())) {
                                emit_checkcast_final(type);
                                break;
                            }
                        // else fall through to emit_checkcast
                        } else {
                            // checkcast to a primitive. Must be a word type.
                            if (VM.VerifyAssertions)
                                VM._assert(type.getTypeRef().isUnboxedType());
                            break;
                        }
                    }
                    // that executes via interruptible code
                    if (VM.VerifyUnint && !isInterruptible)
                        forbiddenBytecode("checkcast ", typeRef, bcodes.index());
                    emit_checkcast(typeRef);
                    break;
                }
            case JBC_instanceof:
                {
                    TypeReference typeRef = bcodes.getTypeReference();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "instanceof", typeRef);
                    RVMType type = typeRef.peekType();
                    if (type != null) {
                        if (type.isClassType()) {
                            RVMClass cType = type.asClass();
                            if (cType.isFinal()) {
                                emit_instanceof_final(type);
                                break;
                            } else if (cType.isResolved()) {
                                if (cType.isInterface()) {
                                    emit_instanceof_resolvedInterface(cType);
                                } else {
                                    emit_instanceof_resolvedClass(cType);
                                }
                                break;
                            }
                        } else if (type.isArrayType()) {
                            RVMType elemType = type.asArray().getElementType();
                            if (elemType.isPrimitiveType() || elemType.isUnboxedType() || (elemType.isClassType() && elemType.asClass().isFinal())) {
                                emit_instanceof_final(type);
                                break;
                            }
                        }
                    }
                    // for its implementation
                    if (VM.VerifyUnint && !isInterruptible)
                        forbiddenBytecode("instanceof ", typeRef, bcodes.index());
                    emit_instanceof(typeRef);
                    break;
                }
            case JBC_monitorenter:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "monitorenter");
                    // for its implementation
                    if (VM.VerifyUnint && isUninterruptible)
                        forbiddenBytecode("monitorenter", bcodes.index());
                    emit_monitorenter();
                    break;
                }
            case JBC_monitorexit:
                {
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "monitorexit");
                    // for its implementation
                    if (VM.VerifyUnint && isUninterruptible)
                        forbiddenBytecode("monitorexit", bcodes.index());
                    emit_monitorexit();
                    break;
                }
            case JBC_wide:
                {
                    int widecode = bcodes.getWideOpcode();
                    int index = bcodes.getWideLocalNumber();
                    switch(widecode) {
                        case JBC_iload:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide iload", index);
                                emit_iload(index);
                                break;
                            }
                        case JBC_lload:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide lload", index);
                                emit_lload(index);
                                break;
                            }
                        case JBC_fload:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide fload", index);
                                emit_fload(index);
                                break;
                            }
                        case JBC_dload:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide dload", index);
                                emit_dload(index);
                                break;
                            }
                        case JBC_aload:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide aload", index);
                                emit_aload(index);
                                break;
                            }
                        case JBC_istore:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide istore", index);
                                emit_istore(index);
                                break;
                            }
                        case JBC_lstore:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide lstore", index);
                                emit_lstore(index);
                                break;
                            }
                        case JBC_fstore:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide fstore", index);
                                emit_fstore(index);
                                break;
                            }
                        case JBC_dstore:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide dstore", index);
                                emit_dstore(index);
                                break;
                            }
                        case JBC_astore:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide astore", index);
                                emit_astore(index);
                                break;
                            }
                        case JBC_iinc:
                            {
                                int val = bcodes.getWideIncrement();
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide inc", index, val);
                                emit_iinc(index, val);
                                break;
                            }
                        case JBC_ret:
                            {
                                if (shouldPrint)
                                    lister.noteBytecode(biStart, "wide ret", index);
                                emit_ret(index);
                                break;
                            }
                        default:
                            if (VM.VerifyAssertions)
                                VM._assert(VM.NOT_REACHED);
                    }
                    break;
                }
            case JBC_multianewarray:
                {
                    TypeReference typeRef = bcodes.getTypeReference();
                    int dimensions = bcodes.getArrayDimension();
                    if (shouldPrint)
                        lister.noteBytecode(biStart, "multianewarray", typeRef);
                    // that are interruptible
                    if (VM.VerifyUnint && !isInterruptible)
                        forbiddenBytecode("multianewarray", bcodes.index());
                    emit_multianewarray(typeRef, dimensions);
                    break;
                }
            case JBC_ifnull:
                {
                    int offset = bcodes.getBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "ifnull", offset, bTarget);
                    if (offset <= 0)
                        emit_threadSwitchTest(RVMThread.BACKEDGE);
                    emit_ifnull(bTarget);
                    break;
                }
            case JBC_ifnonnull:
                {
                    int offset = bcodes.getBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "ifnonnull", offset, bTarget);
                    if (offset <= 0)
                        emit_threadSwitchTest(RVMThread.BACKEDGE);
                    emit_ifnonnull(bTarget);
                    break;
                }
            case JBC_goto_w:
                {
                    int offset = bcodes.getWideBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "goto_w", offset, bTarget);
                    if (offset <= 0)
                        emit_threadSwitchTest(RVMThread.BACKEDGE);
                    emit_goto(bTarget);
                    break;
                }
            case JBC_jsr_w:
                {
                    int offset = bcodes.getWideBranchOffset();
                    int bTarget = biStart + offset;
                    if (shouldPrint)
                        lister.noteBranchBytecode(biStart, "jsr_w", offset, bTarget);
                    emit_jsr(bTarget);
                    break;
                }
            /* CAUTION: cannot use JBC_impdep1, which is 0xfffffffe (signed),
         * this is not consistent with OPT compiler.
         */
            case JBC_impdep1:
                /* --- pseudo bytecode --- */
                {
                    if (VM.BuildForAdaptiveSystem) {
                        int pseudo_opcode = bcodes.nextPseudoInstruction();
                        // pseudo instruction
                        switch(pseudo_opcode) {
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_LoadIntConst:
                                {
                                    int value = bcodes.readIntConst();
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_load_int", value);
                                    Offset offset = Offset.fromIntSignExtend(Statics.findOrCreateIntSizeLiteral(value));
                                    emit_ldc(offset, CP_INT);
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_LoadLongConst:
                                {
                                    // fetch8BytesUnsigned();
                                    long value = bcodes.readLongConst();
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_load_long", value);
                                    Offset offset = Offset.fromIntSignExtend(Statics.findOrCreateLongSizeLiteral(value));
                                    emit_ldc2(offset, CP_LONG);
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_LoadWordConst:
                                {
                                    if (VM.BuildFor32Addr) {
                                        int value = bcodes.readIntConst();
                                        if (shouldPrint)
                                            lister.noteBytecode(biStart, "pseudo_load_word " + Integer.toHexString(value));
                                        Offset offset = Offset.fromIntSignExtend(Statics.findOrCreateIntSizeLiteral(value));
                                        emit_ldc(offset, CP_INT);
                                    } else {
                                        long value = bcodes.readLongConst();
                                        if (shouldPrint)
                                            lister.noteBytecode(biStart, "pseudo_load_word " + Long.toHexString(value));
                                        Offset offset = Offset.fromIntSignExtend(Statics.findOrCreateLongSizeLiteral(value));
                                        emit_ldc2(offset, CP_LONG);
                                        // dirty hack
                                        emit_l2i();
                                    }
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_LoadFloatConst:
                                {
                                    // fetch4BytesSigned();
                                    int ibits = bcodes.readIntConst();
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_load_float", ibits);
                                    Offset offset = Offset.fromIntSignExtend(Statics.findOrCreateIntSizeLiteral(ibits));
                                    emit_ldc(offset, CP_FLOAT);
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_LoadDoubleConst:
                                {
                                    // fetch8BytesUnsigned();
                                    long lbits = bcodes.readLongConst();
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_load_double", lbits);
                                    Offset offset = Offset.fromIntSignExtend(Statics.findOrCreateLongSizeLiteral(lbits));
                                    emit_ldc2(offset, CP_DOUBLE);
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_LoadRetAddrConst:
                                {
                                    // fetch4BytesSigned();
                                    int bcIndex = bcodes.readIntConst();
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_load_retaddr", bcIndex);
                                    // for bytecode to get future bytecode's address
                                    // we register it and patch it later.
                                    emit_loadretaddrconst(bcIndex);
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_InvokeStatic:
                                {
                                    // fetch4BytesSigned();
                                    int targetidx = bcodes.readIntConst();
                                    RVMMethod methodRef = InvokeStatic.targetMethod(targetidx);
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_invokestatic", methodRef);
                                    emit_resolved_invokestatic(methodRef.getMemberRef().asMethodReference());
                                    break;
                                }
                            /*
                case org.jikesrvm.osr.OSRConstants.PSEUDO_CheckCast: {

                if (shouldPrint) lister.noteBytecode(biStart, "pseudo_checkcast");

                // fetch 4 byte type id
                int tid = bcodes.readIntConst(); // fetch4BytesSigned();
                // do nothing now
                break;
                }
              */
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_InvokeCompiledMethod:
                                {
                                    // fetch4BytesSigned();    // callee's cmid
                                    int cmid = bcodes.readIntConst();
                                    int origIdx = // fetch4BytesSigned(); // orginal bytecode index of this call (for build gc map)
                                    bcodes.readIntConst();
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_invoke_cmid", cmid);
                                    this.pendingCMID = cmid;
                                    this.pendingIdx = origIdx + this.method.getOsrPrologueLength();
                                    this.pendingRef = emit_pending_goto(this.pendingIdx);
                                    /*
                  CompiledMethod cm = CompiledMethods.getCompiledMethod(cmid);
                  if (VM.VerifyAssertions) VM._assert(cm.isSpecialForOSR());
                  emit_invoke_compiledmethod(cm);
                */
                                    break;
                                }
                            case org.jikesrvm.osr.OSRConstants.PSEUDO_ParamInitEnd:
                                {
                                    if (shouldPrint)
                                        lister.noteBytecode(biStart, "pseudo_paraminitend");
                                    // now we can inserted stack overflow check,
                                    emit_deferred_prologue();
                                    break;
                                }
                            default:
                                if (VM.TraceOnStackReplacement) {
                                    VM.sysWriteln("Unexpected PSEUDO code " + Services.intAsHexString(pseudo_opcode));
                                }
                                if (VM.VerifyAssertions)
                                    VM._assert(VM.NOT_REACHED);
                                break;
                        }
                    } else {
                        if (VM.VerifyAssertions)
                            VM._assert(VM.NOT_REACHED);
                    }
                    break;
                }
            default:
                VM.sysWriteln("BaselineCompilerImpl: unexpected bytecode: " + Services.getHexString(code, false));
                if (VM.VerifyAssertions)
                    VM._assert(VM.NOT_REACHED);
        }
        ending_bytecode();
    }
    bytecodeMap[bcodes.length()] = asm.getMachineCodeIndex();
    ending_method();
    return new MachineCode(getAssembler().getMachineCodes(), bytecodeMap);
}
Also used : FieldReference(org.jikesrvm.classloader.FieldReference) RVMType(org.jikesrvm.classloader.RVMType) CompiledMethod(org.jikesrvm.compilers.common.CompiledMethod) Offset(org.vmmagic.unboxed.Offset) RVMClass(org.jikesrvm.classloader.RVMClass) ForwardReference(org.jikesrvm.compilers.common.assembler.ForwardReference) RVMMethod(org.jikesrvm.classloader.RVMMethod) AbstractLister(org.jikesrvm.compilers.common.assembler.AbstractLister) RVMArray(org.jikesrvm.classloader.RVMArray) AbstractAssembler(org.jikesrvm.compilers.common.assembler.AbstractAssembler) MethodReference(org.jikesrvm.classloader.MethodReference) TypeReference(org.jikesrvm.classloader.TypeReference)

Aggregations

RVMClass (org.jikesrvm.classloader.RVMClass)69 RVMMethod (org.jikesrvm.classloader.RVMMethod)28 TypeReference (org.jikesrvm.classloader.TypeReference)22 RVMType (org.jikesrvm.classloader.RVMType)20 Atom (org.jikesrvm.classloader.Atom)14 RVMField (org.jikesrvm.classloader.RVMField)11 RVMArray (org.jikesrvm.classloader.RVMArray)8 Instruction (org.jikesrvm.compilers.opt.ir.Instruction)8 IntConstantOperand (org.jikesrvm.compilers.opt.ir.operand.IntConstantOperand)8 MethodOperand (org.jikesrvm.compilers.opt.ir.operand.MethodOperand)8 Operand (org.jikesrvm.compilers.opt.ir.operand.Operand)8 RegisterOperand (org.jikesrvm.compilers.opt.ir.operand.RegisterOperand)8 BranchProfileOperand (org.jikesrvm.compilers.opt.ir.operand.BranchProfileOperand)7 ConditionOperand (org.jikesrvm.compilers.opt.ir.operand.ConditionOperand)7 LocationOperand (org.jikesrvm.compilers.opt.ir.operand.LocationOperand)7 Address (org.vmmagic.unboxed.Address)7 NormalMethod (org.jikesrvm.classloader.NormalMethod)6 CompiledMethod (org.jikesrvm.compilers.common.CompiledMethod)6 TrapCodeOperand (org.jikesrvm.compilers.opt.ir.operand.TrapCodeOperand)6 BasicBlock (org.jikesrvm.compilers.opt.ir.BasicBlock)5