Search in sources :

Example 1 with RVMArray

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

the class JNIFunctions method NewObjectArray.

/**
 * NewObjectArray: create a new Object array
 * @param env A JREF index for the JNI environment object
 * @param length the size of the new array
 * @param classJREF a JREF index for the class of the element
 * @param initElementJREF a JREF index for the value to initialize the array elements
 * @return the new Object array initialized
 * @throws OutOfMemoryError if the system runs out of memory
 */
private static int NewObjectArray(JNIEnvironment env, int length, int classJREF, int initElementJREF) {
    if (traceJNI)
        VM.sysWriteln("JNI called: NewObjectArray");
    RuntimeEntrypoints.checkJNICountDownToGC();
    try {
        Object initElement = env.getJNIRef(initElementJREF);
        Class<?> cls = (Class<?>) env.getJNIRef(classJREF);
        if (cls == null) {
            throw new NullPointerException();
        }
        if (length < 0) {
            throw new NegativeArraySizeException();
        }
        RVMArray arrayType = java.lang.JikesRVMSupport.getTypeForClass(cls).getArrayTypeForElementType();
        if (!arrayType.isInitialized()) {
            arrayType.resolve();
            arrayType.instantiate();
            arrayType.initialize();
        }
        Object[] newArray = (Object[]) RuntimeEntrypoints.resolvedNewArray(length, arrayType);
        if (initElement != null) {
            for (int i = 0; i < length; i++) {
                newArray[i] = initElement;
            }
        }
        return env.pushJNIRef(newArray);
    } catch (Throwable unexpected) {
        if (traceJNI)
            unexpected.printStackTrace(System.err);
        env.recordException(unexpected);
        return 0;
    }
}
Also used : RVMArray(org.jikesrvm.classloader.RVMArray) RVMClass(org.jikesrvm.classloader.RVMClass)

Example 2 with RVMArray

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

the class MemoryManager method newRuntimeTable.

/**
 * Allocates a new runtime table (at runtime).
 *
 * @param size The size of the table
 * @param type the type for the table
 * @return the newly allocated table
 */
@NoInline
@Interruptible
public static Object newRuntimeTable(int size, RVMType type) {
    if (VM.VerifyAssertions)
        VM._assert(VM.runningVM);
    TIB realTib = type.getTypeInformationBlock();
    RVMArray fakeType = RVMType.WordArrayType;
    TIB fakeTib = fakeType.getTypeInformationBlock();
    int headerSize = ObjectModel.computeArrayHeaderSize(fakeType);
    int align = ObjectModel.getAlignment(fakeType);
    int offset = ObjectModel.getOffsetForAlignment(fakeType, false);
    int width = fakeType.getLogElementSize();
    /* Allocate a word array */
    Object array = allocateArray(size, width, headerSize, fakeTib, type.getMMAllocator(), align, offset, Plan.DEFAULT_SITE);
    /* Now we replace the TIB */
    ObjectModel.setTIB(array, realTib);
    return array;
}
Also used : RVMArray(org.jikesrvm.classloader.RVMArray) TIB(org.jikesrvm.objectmodel.TIB) Entrypoint(org.vmmagic.pragma.Entrypoint) Interruptible(org.vmmagic.pragma.Interruptible) NoInline(org.vmmagic.pragma.NoInline)

Example 3 with RVMArray

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

the class MemoryManager method newTIB.

/**
 * Allocates a new type information block (TIB).
 *
 * @param numVirtualMethods the number of virtual method slots in the TIB
 * @param alignCode alignment encoding for the TIB
 * @return the new TIB
 * @see AlignmentEncoding
 */
@NoInline
@Interruptible
public static TIB newTIB(int numVirtualMethods, int alignCode) {
    int elements = TIB.computeSize(numVirtualMethods);
    if (!VM.runningVM) {
        return TIB.allocate(elements, alignCode);
    }
    if (alignCode == AlignmentEncoding.ALIGN_CODE_NONE) {
        return (TIB) newRuntimeTable(elements, RVMType.TIBType);
    }
    RVMType type = RVMType.TIBType;
    if (VM.VerifyAssertions)
        VM._assert(VM.runningVM);
    TIB realTib = type.getTypeInformationBlock();
    RVMArray fakeType = RVMType.WordArrayType;
    TIB fakeTib = fakeType.getTypeInformationBlock();
    int headerSize = ObjectModel.computeArrayHeaderSize(fakeType);
    int align = ObjectModel.getAlignment(fakeType);
    int offset = ObjectModel.getOffsetForAlignment(fakeType, false);
    int width = fakeType.getLogElementSize();
    int elemBytes = elements << width;
    if (elemBytes < 0 || (elemBytes >>> width) != elements) {
        /* asked to allocate more than Integer.MAX_VALUE bytes */
        throwLargeArrayOutOfMemoryError();
    }
    int size = elemBytes + headerSize + AlignmentEncoding.padding(alignCode);
    Selected.Mutator mutator = Selected.Mutator.get();
    Address region = allocateSpace(mutator, size, align, offset, type.getMMAllocator(), Plan.DEFAULT_SITE);
    region = AlignmentEncoding.adjustRegion(alignCode, region);
    Object result = ObjectModel.initializeArray(region, fakeTib, elements, size);
    mutator.postAlloc(ObjectReference.fromObject(result), ObjectReference.fromObject(fakeTib), size, type.getMMAllocator());
    /* Now we replace the TIB */
    ObjectModel.setTIB(result, realTib);
    return (TIB) result;
}
Also used : Address(org.vmmagic.unboxed.Address) RVMArray(org.jikesrvm.classloader.RVMArray) RVMType(org.jikesrvm.classloader.RVMType) TIB(org.jikesrvm.objectmodel.TIB) Entrypoint(org.vmmagic.pragma.Entrypoint) Interruptible(org.vmmagic.pragma.Interruptible) NoInline(org.vmmagic.pragma.NoInline)

Example 4 with RVMArray

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

the class MemoryManager method newStack.

/**
 * Allocate a stack
 * @param bytes the number of bytes to allocate. Must be greater than
 *  0.
 * @return The stack
 */
@NoInline
@Unpreemptible
public static byte[] newStack(int bytes) {
    if (bytes <= 0) {
        if (VM.VerifyAssertions) {
            VM.sysWrite("Invalid stack size: ");
            VM.sysWrite(bytes);
            VM.sysWriteln("!");
            VM._assert(VM.NOT_REACHED, "Attempted to create stack with size (in bytes) of 0 or smaller!");
        } else {
            bytes = StackFrameLayout.getStackSizeNormal();
        }
    }
    if (!VM.runningVM) {
        return new byte[bytes];
    } else {
        RVMArray stackType = RVMArray.ByteArray;
        int headerSize = ObjectModel.computeArrayHeaderSize(stackType);
        int align = ObjectModel.getAlignment(stackType);
        int offset = ObjectModel.getOffsetForAlignment(stackType, false);
        int width = stackType.getLogElementSize();
        TIB stackTib = stackType.getTypeInformationBlock();
        return (byte[]) allocateArray(bytes, width, headerSize, stackTib, Plan.ALLOC_STACK, align, offset, Plan.DEFAULT_SITE);
    }
}
Also used : RVMArray(org.jikesrvm.classloader.RVMArray) TIB(org.jikesrvm.objectmodel.TIB) Entrypoint(org.vmmagic.pragma.Entrypoint) Unpreemptible(org.vmmagic.pragma.Unpreemptible) NoInline(org.vmmagic.pragma.NoInline)

Example 5 with RVMArray

use of org.jikesrvm.classloader.RVMArray 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

RVMArray (org.jikesrvm.classloader.RVMArray)32 TIB (org.jikesrvm.objectmodel.TIB)14 Entrypoint (org.vmmagic.pragma.Entrypoint)14 RVMType (org.jikesrvm.classloader.RVMType)11 RVMClass (org.jikesrvm.classloader.RVMClass)9 NoInline (org.vmmagic.pragma.NoInline)8 TypeReference (org.jikesrvm.classloader.TypeReference)7 Interruptible (org.vmmagic.pragma.Interruptible)7 RVMMethod (org.jikesrvm.classloader.RVMMethod)6 Address (org.vmmagic.unboxed.Address)6 Operand (org.jikesrvm.compilers.opt.ir.operand.Operand)4 RegisterOperand (org.jikesrvm.compilers.opt.ir.operand.RegisterOperand)4 Test (org.junit.Test)4 Instruction (org.jikesrvm.compilers.opt.ir.Instruction)3 ConditionOperand (org.jikesrvm.compilers.opt.ir.operand.ConditionOperand)3 IntConstantOperand (org.jikesrvm.compilers.opt.ir.operand.IntConstantOperand)3 LocationOperand (org.jikesrvm.compilers.opt.ir.operand.LocationOperand)3 MethodOperand (org.jikesrvm.compilers.opt.ir.operand.MethodOperand)3 TrapCodeOperand (org.jikesrvm.compilers.opt.ir.operand.TrapCodeOperand)3 TrueGuardOperand (org.jikesrvm.compilers.opt.ir.operand.TrueGuardOperand)3