Search in sources :

Example 6 with FieldReference

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

the class BC2IR method generateFrom.

/**
 * Generate instructions for a basic block.
 * May discover other basic blocks that need to be generated along the way.
 *
 * @param fromIndex bytecode index to start from
 */
private void generateFrom(int fromIndex) {
    if (DBG_BB || DBG_SELECTED) {
        db("generating code into " + currentBBLE + " with runoff " + runoff);
    }
    currentBBLE.setGenerated();
    endOfBasicBlock = fallThrough = false;
    lastInstr = null;
    bcodes.reset(fromIndex);
    while (true) {
        // Must keep currentBBLE.high up-to-date in case we try to jump into
        // the middle of the block we're currently generating.  Simply updating
        // high once endsBasicBlock is true doesn't enable us to catch this case.
        currentBBLE.high = instrIndex = bcodes.index();
        int code = bcodes.nextInstruction();
        if (DBG_BCPARSE) {
            db("parsing " + instrIndex + " " + code + " : 0x" + Integer.toHexString(code) + " " + JBC_name(code));
        }
        Instruction s = null;
        lastOsrBarrier = null;
        switch(code) {
            case JBC_nop:
                break;
            case JBC_aconst_null:
                push(new NullConstantOperand());
                break;
            case JBC_iconst_m1:
            case JBC_iconst_0:
            case JBC_iconst_1:
            case JBC_iconst_2:
            case JBC_iconst_3:
            case JBC_iconst_4:
            case JBC_iconst_5:
                push(new IntConstantOperand(code - JBC_iconst_0));
                break;
            case JBC_lconst_0:
            case JBC_lconst_1:
                pushDual(new LongConstantOperand(code - JBC_lconst_0));
                break;
            case JBC_fconst_0:
                push(new FloatConstantOperand(0.f));
                break;
            case JBC_fconst_1:
                push(new FloatConstantOperand(1.f));
                break;
            case JBC_fconst_2:
                push(new FloatConstantOperand(2.f));
                break;
            case JBC_dconst_0:
                pushDual(new DoubleConstantOperand(0.));
                break;
            case JBC_dconst_1:
                pushDual(new DoubleConstantOperand(1.));
                break;
            case JBC_bipush:
                push(new IntConstantOperand(bcodes.getByteValue()));
                break;
            case JBC_sipush:
                push(new IntConstantOperand(bcodes.getShortValue()));
                break;
            case JBC_ldc:
                push(getConstantOperand(bcodes.getConstantIndex()));
                break;
            case JBC_ldc_w:
                push(getConstantOperand(bcodes.getWideConstantIndex()));
                break;
            case JBC_ldc2_w:
                pushDual(getConstantOperand(bcodes.getWideConstantIndex()));
                break;
            case JBC_iload:
                s = do_iload(bcodes.getLocalNumber());
                break;
            case JBC_lload:
                s = do_lload(bcodes.getLocalNumber());
                break;
            case JBC_fload:
                s = do_fload(bcodes.getLocalNumber());
                break;
            case JBC_dload:
                s = do_dload(bcodes.getLocalNumber());
                break;
            case JBC_aload:
                s = do_aload(bcodes.getLocalNumber());
                break;
            case JBC_iload_0:
            case JBC_iload_1:
            case JBC_iload_2:
            case JBC_iload_3:
                s = do_iload(code - JBC_iload_0);
                break;
            case JBC_lload_0:
            case JBC_lload_1:
            case JBC_lload_2:
            case JBC_lload_3:
                s = do_lload(code - JBC_lload_0);
                break;
            case JBC_fload_0:
            case JBC_fload_1:
            case JBC_fload_2:
            case JBC_fload_3:
                s = do_fload(code - JBC_fload_0);
                break;
            case JBC_dload_0:
            case JBC_dload_1:
            case JBC_dload_2:
            case JBC_dload_3:
                s = do_dload(code - JBC_dload_0);
                break;
            case JBC_aload_0:
            case JBC_aload_1:
            case JBC_aload_2:
            case JBC_aload_3:
                s = do_aload(code - JBC_aload_0);
                break;
            case JBC_iaload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.IntArray);
                    }
                    s = _aloadHelper(INT_ALOAD, ref, index, TypeReference.Int);
                }
                break;
            case JBC_laload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.LongArray);
                    }
                    s = _aloadHelper(LONG_ALOAD, ref, index, TypeReference.Long);
                }
                break;
            case JBC_faload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.FloatArray);
                    }
                    s = _aloadHelper(FLOAT_ALOAD, ref, index, TypeReference.Float);
                }
                break;
            case JBC_daload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.DoubleArray);
                    }
                    s = _aloadHelper(DOUBLE_ALOAD, ref, index, TypeReference.Double);
                }
                break;
            case JBC_aaload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    TypeReference type = getRefTypeOf(ref).getArrayElementType();
                    if (VM.VerifyAssertions)
                        opt_assert(type.isReferenceType());
                    s = _aloadHelper(REF_ALOAD, ref, index, type);
                }
                break;
            case JBC_baload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    TypeReference type = getArrayTypeOf(ref);
                    if (VM.VerifyAssertions) {
                        opt_assert(type == TypeReference.ByteArray || type == TypeReference.BooleanArray);
                    }
                    if (type == TypeReference.ByteArray) {
                        s = _aloadHelper(BYTE_ALOAD, ref, index, TypeReference.Byte);
                    } else {
                        s = _aloadHelper(UBYTE_ALOAD, ref, index, TypeReference.Boolean);
                    }
                }
                break;
            case JBC_caload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.CharArray);
                    }
                    s = _aloadHelper(USHORT_ALOAD, ref, index, TypeReference.Char);
                }
                break;
            case JBC_saload:
                {
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.ShortArray);
                    }
                    s = _aloadHelper(SHORT_ALOAD, ref, index, TypeReference.Short);
                }
                break;
            case JBC_istore:
                s = do_store(bcodes.getLocalNumber(), popInt());
                break;
            case JBC_lstore:
                s = do_store(bcodes.getLocalNumber(), popLong());
                break;
            case JBC_fstore:
                s = do_store(bcodes.getLocalNumber(), popFloat());
                break;
            case JBC_dstore:
                s = do_store(bcodes.getLocalNumber(), popDouble());
                break;
            case JBC_astore:
                s = do_astore(bcodes.getLocalNumber());
                break;
            case JBC_istore_0:
            case JBC_istore_1:
            case JBC_istore_2:
            case JBC_istore_3:
                s = do_store(code - JBC_istore_0, popInt());
                break;
            case JBC_lstore_0:
            case JBC_lstore_1:
            case JBC_lstore_2:
            case JBC_lstore_3:
                s = do_store(code - JBC_lstore_0, popLong());
                break;
            case JBC_fstore_0:
            case JBC_fstore_1:
            case JBC_fstore_2:
            case JBC_fstore_3:
                s = do_store(code - JBC_fstore_0, popFloat());
                break;
            case JBC_dstore_0:
            case JBC_dstore_1:
            case JBC_dstore_2:
            case JBC_dstore_3:
                s = do_store(code - JBC_dstore_0, popDouble());
                break;
            case JBC_astore_0:
            case JBC_astore_1:
            case JBC_astore_2:
            case JBC_astore_3:
                s = do_astore(code - JBC_astore_0);
                break;
            case JBC_iastore:
                {
                    Operand val = popInt();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.IntArray);
                    }
                    s = AStore.create(INT_ASTORE, val, ref, index, new LocationOperand(TypeReference.Int), getCurrentGuard());
                }
                break;
            case JBC_lastore:
                {
                    Operand val = popLong();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.LongArray);
                    }
                    s = AStore.create(LONG_ASTORE, val, ref, index, new LocationOperand(TypeReference.Long), getCurrentGuard());
                }
                break;
            case JBC_fastore:
                {
                    Operand val = popFloat();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.FloatArray);
                    }
                    s = AStore.create(FLOAT_ASTORE, val, ref, index, new LocationOperand(TypeReference.Float), getCurrentGuard());
                }
                break;
            case JBC_dastore:
                {
                    Operand val = popDouble();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.DoubleArray);
                    }
                    s = AStore.create(DOUBLE_ASTORE, val, ref, index, new LocationOperand(TypeReference.Double), getCurrentGuard());
                }
                break;
            case JBC_aastore:
                {
                    Operand val = pop();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    TypeReference type = getRefTypeOf(ref).getArrayElementType();
                    if (VM.VerifyAssertions)
                        opt_assert(type.isReferenceType());
                    if (do_CheckStore(ref, val, type)) {
                        break;
                    }
                    s = AStore.create(REF_ASTORE, val, ref, index, new LocationOperand(type), getCurrentGuard());
                }
                break;
            case JBC_bastore:
                {
                    Operand val = popInt();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    TypeReference type = getArrayTypeOf(ref);
                    if (VM.VerifyAssertions) {
                        opt_assert(type == TypeReference.ByteArray || type == TypeReference.BooleanArray);
                    }
                    if (type == TypeReference.ByteArray) {
                        type = TypeReference.Byte;
                    } else {
                        type = TypeReference.Boolean;
                    }
                    s = AStore.create(BYTE_ASTORE, val, ref, index, new LocationOperand(type), getCurrentGuard());
                }
                break;
            case JBC_castore:
                {
                    Operand val = popInt();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.CharArray);
                    }
                    s = AStore.create(SHORT_ASTORE, val, ref, index, new LocationOperand(TypeReference.Char), getCurrentGuard());
                }
                break;
            case JBC_sastore:
                {
                    Operand val = popInt();
                    Operand index = popInt();
                    Operand ref = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(ref) || do_BoundsCheck(ref, index)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        assertIsType(ref, TypeReference.ShortArray);
                    }
                    s = AStore.create(SHORT_ASTORE, val, ref, index, new LocationOperand(TypeReference.Short), getCurrentGuard());
                }
                break;
            case JBC_pop:
                stack.pop();
                break;
            case JBC_pop2:
                stack.pop2();
                break;
            case JBC_dup:
                {
                    Operand op1 = stack.pop();
                    stack.push(op1);
                    s = pushCopy(op1);
                }
                break;
            case JBC_dup_x1:
                {
                    Operand op1 = stack.pop();
                    Operand op2 = stack.pop();
                    stack.push(op1);
                    stack.push(op2);
                    s = pushCopy(op1);
                }
                break;
            case JBC_dup_x2:
                {
                    Operand op1 = stack.pop();
                    Operand op2 = stack.pop();
                    Operand op3 = stack.pop();
                    stack.push(op1);
                    stack.push(op3);
                    stack.push(op2);
                    s = pushCopy(op1);
                }
                break;
            case JBC_dup2:
                {
                    Operand op1 = stack.pop();
                    Operand op2 = stack.pop();
                    stack.push(op2);
                    stack.push(op1);
                    s = pushCopy(op2);
                    if (s != null) {
                        appendInstruction(s);
                        s = null;
                    }
                    s = pushCopy(op1);
                }
                break;
            case JBC_dup2_x1:
                {
                    Operand op1 = stack.pop();
                    Operand op2 = stack.pop();
                    Operand op3 = stack.pop();
                    stack.push(op2);
                    stack.push(op1);
                    stack.push(op3);
                    s = pushCopy(op2);
                    if (s != null) {
                        appendInstruction(s);
                        s = null;
                    }
                    s = pushCopy(op1);
                }
                break;
            case JBC_dup2_x2:
                {
                    Operand op1 = stack.pop();
                    Operand op2 = stack.pop();
                    Operand op3 = stack.pop();
                    Operand op4 = stack.pop();
                    stack.push(op2);
                    stack.push(op1);
                    stack.push(op4);
                    stack.push(op3);
                    s = pushCopy(op2);
                    if (s != null) {
                        appendInstruction(s);
                        s = null;
                    }
                    s = pushCopy(op1);
                }
                break;
            case JBC_swap:
                {
                    stack.swap();
                }
                break;
            case JBC_iadd:
                {
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_ADD, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_ladd:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_ADD, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_fadd:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_ADD, op1, op2, TypeReference.Float);
                }
                break;
            case JBC_dadd:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryDualHelper(DOUBLE_ADD, op1, op2, TypeReference.Double);
                }
                break;
            case JBC_isub:
                {
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_SUB, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lsub:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_SUB, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_fsub:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_SUB, op1, op2, TypeReference.Float);
                }
                break;
            case JBC_dsub:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryDualHelper(DOUBLE_SUB, op1, op2, TypeReference.Double);
                }
                break;
            case JBC_imul:
                {
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_MUL, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lmul:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_MUL, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_fmul:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_MUL, op1, op2, TypeReference.Float);
                }
                break;
            case JBC_dmul:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryDualHelper(DOUBLE_MUL, op1, op2, TypeReference.Double);
                }
                break;
            case JBC_idiv:
                {
                    clearCurrentGuard();
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    if (do_IntZeroCheck(op2)) {
                        break;
                    }
                    s = _guardedBinaryHelper(INT_DIV, op1, op2, getCurrentGuard(), TypeReference.Int);
                }
                break;
            case JBC_ldiv:
                {
                    clearCurrentGuard();
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    if (do_LongZeroCheck(op2)) {
                        break;
                    }
                    s = _guardedBinaryDualHelper(LONG_DIV, op1, op2, getCurrentGuard(), TypeReference.Long);
                }
                break;
            case JBC_fdiv:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_DIV, op1, op2, TypeReference.Float);
                }
                break;
            case JBC_ddiv:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryDualHelper(DOUBLE_DIV, op1, op2, TypeReference.Double);
                }
                break;
            case JBC_irem:
                {
                    clearCurrentGuard();
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    if (do_IntZeroCheck(op2)) {
                        break;
                    }
                    s = _guardedBinaryHelper(INT_REM, op1, op2, getCurrentGuard(), TypeReference.Int);
                }
                break;
            case JBC_lrem:
                {
                    clearCurrentGuard();
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    if (do_LongZeroCheck(op2)) {
                        break;
                    }
                    s = _guardedBinaryDualHelper(LONG_REM, op1, op2, getCurrentGuard(), TypeReference.Long);
                }
                break;
            case JBC_frem:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_REM, op1, op2, TypeReference.Float);
                }
                break;
            case JBC_drem:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryDualHelper(DOUBLE_REM, op1, op2, TypeReference.Double);
                }
                break;
            case JBC_ineg:
                s = _unaryHelper(INT_NEG, popInt(), TypeReference.Int);
                break;
            case JBC_lneg:
                s = _unaryDualHelper(LONG_NEG, popLong(), TypeReference.Long);
                break;
            case JBC_fneg:
                s = _unaryHelper(FLOAT_NEG, popFloat(), TypeReference.Float);
                break;
            case JBC_dneg:
                s = _unaryDualHelper(DOUBLE_NEG, popDouble(), TypeReference.Double);
                break;
            case JBC_ishl:
                {
                    Operand op2 = popShiftInt(false);
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_SHL, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lshl:
                {
                    Operand op2 = popShiftInt(true);
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_SHL, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_ishr:
                {
                    Operand op2 = popShiftInt(false);
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_SHR, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lshr:
                {
                    Operand op2 = popShiftInt(true);
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_SHR, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_iushr:
                {
                    Operand op2 = popShiftInt(false);
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_USHR, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lushr:
                {
                    Operand op2 = popShiftInt(true);
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_USHR, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_iand:
                {
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_AND, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_land:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_AND, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_ior:
                {
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_OR, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lor:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_OR, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_ixor:
                {
                    Operand op2 = popInt();
                    Operand op1 = popInt();
                    s = _binaryHelper(INT_XOR, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_lxor:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryDualHelper(LONG_XOR, op1, op2, TypeReference.Long);
                }
                break;
            case JBC_iinc:
                {
                    int index = bcodes.getLocalNumber();
                    s = do_iinc(index, bcodes.getIncrement());
                }
                break;
            case JBC_i2l:
                s = _unaryDualHelper(INT_2LONG, popInt(), TypeReference.Long);
                break;
            case JBC_i2f:
                s = _unaryHelper(INT_2FLOAT, popInt(), TypeReference.Float);
                break;
            case JBC_i2d:
                s = _unaryDualHelper(INT_2DOUBLE, popInt(), TypeReference.Double);
                break;
            case JBC_l2i:
                s = _unaryHelper(LONG_2INT, popLong(), TypeReference.Int);
                break;
            case JBC_l2f:
                s = _unaryHelper(LONG_2FLOAT, popLong(), TypeReference.Float);
                break;
            case JBC_l2d:
                s = _unaryDualHelper(LONG_2DOUBLE, popLong(), TypeReference.Double);
                break;
            case JBC_f2i:
                s = _unaryHelper(FLOAT_2INT, popFloat(), TypeReference.Int);
                break;
            case JBC_f2l:
                s = _unaryDualHelper(FLOAT_2LONG, popFloat(), TypeReference.Long);
                break;
            case JBC_f2d:
                s = _unaryDualHelper(FLOAT_2DOUBLE, popFloat(), TypeReference.Double);
                break;
            case JBC_d2i:
                s = _unaryHelper(DOUBLE_2INT, popDouble(), TypeReference.Int);
                break;
            case JBC_d2l:
                s = _unaryDualHelper(DOUBLE_2LONG, popDouble(), TypeReference.Long);
                break;
            case JBC_d2f:
                s = _unaryHelper(DOUBLE_2FLOAT, popDouble(), TypeReference.Float);
                break;
            case JBC_int2byte:
                s = _unaryHelper(INT_2BYTE, popInt(), TypeReference.Byte);
                break;
            case JBC_int2char:
                s = _unaryHelper(INT_2USHORT, popInt(), TypeReference.Char);
                break;
            case JBC_int2short:
                s = _unaryHelper(INT_2SHORT, popInt(), TypeReference.Short);
                break;
            case JBC_lcmp:
                {
                    Operand op2 = popLong();
                    Operand op1 = popLong();
                    s = _binaryHelper(LONG_CMP, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_fcmpl:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_CMPL, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_fcmpg:
                {
                    Operand op2 = popFloat();
                    Operand op1 = popFloat();
                    s = _binaryHelper(FLOAT_CMPG, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_dcmpl:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryHelper(DOUBLE_CMPL, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_dcmpg:
                {
                    Operand op2 = popDouble();
                    Operand op1 = popDouble();
                    s = _binaryHelper(DOUBLE_CMPG, op1, op2, TypeReference.Int);
                }
                break;
            case JBC_ifeq:
                s = _intIfHelper(ConditionOperand.EQUAL());
                break;
            case JBC_ifne:
                s = _intIfHelper(ConditionOperand.NOT_EQUAL());
                break;
            case JBC_iflt:
                s = _intIfHelper(ConditionOperand.LESS());
                break;
            case JBC_ifge:
                s = _intIfHelper(ConditionOperand.GREATER_EQUAL());
                break;
            case JBC_ifgt:
                s = _intIfHelper(ConditionOperand.GREATER());
                break;
            case JBC_ifle:
                s = _intIfHelper(ConditionOperand.LESS_EQUAL());
                break;
            case JBC_if_icmpeq:
                s = _intIfCmpHelper(ConditionOperand.EQUAL());
                break;
            case JBC_if_icmpne:
                s = _intIfCmpHelper(ConditionOperand.NOT_EQUAL());
                break;
            case JBC_if_icmplt:
                s = _intIfCmpHelper(ConditionOperand.LESS());
                break;
            case JBC_if_icmpge:
                s = _intIfCmpHelper(ConditionOperand.GREATER_EQUAL());
                break;
            case JBC_if_icmpgt:
                s = _intIfCmpHelper(ConditionOperand.GREATER());
                break;
            case JBC_if_icmple:
                s = _intIfCmpHelper(ConditionOperand.LESS_EQUAL());
                break;
            case JBC_if_acmpeq:
                s = _refIfCmpHelper(ConditionOperand.EQUAL());
                break;
            case JBC_if_acmpne:
                s = _refIfCmpHelper(ConditionOperand.NOT_EQUAL());
                break;
            case JBC_goto:
                {
                    int offset = bcodes.getBranchOffset();
                    if (offset != 3) {
                        // skip generating frivolous goto's
                        s = _gotoHelper(offset);
                    }
                }
                break;
            case JBC_jsr:
                s = _jsrHelper(bcodes.getBranchOffset());
                break;
            case JBC_ret:
                s = _retHelper(bcodes.getLocalNumber());
                break;
            case JBC_tableswitch:
                {
                    bcodes.alignSwitch();
                    Operand op0 = popInt();
                    int defaultoff = bcodes.getDefaultSwitchOffset();
                    int low = bcodes.getLowSwitchValue();
                    int high = bcodes.getHighSwitchValue();
                    int number = high - low + 1;
                    if (CF_TABLESWITCH && op0 instanceof IntConstantOperand) {
                        int v1 = ((IntConstantOperand) op0).value;
                        int match = bcodes.computeTableSwitchOffset(v1, low, high);
                        int offset = match == 0 ? defaultoff : match;
                        bcodes.skipTableSwitchOffsets(number);
                        if (DBG_CF) {
                            db("changed tableswitch to goto because index (" + v1 + ") is constant");
                        }
                        s = _gotoHelper(offset);
                        break;
                    }
                    s = TableSwitch.create(TABLESWITCH, op0, null, null, new IntConstantOperand(low), new IntConstantOperand(high), generateTarget(defaultoff), null, number * 2);
                    for (int i = 0; i < number; ++i) {
                        TableSwitch.setTarget(s, i, generateTarget(bcodes.getTableSwitchOffset(i)));
                    }
                    bcodes.skipTableSwitchOffsets(number);
                    // Set branch probabilities
                    SwitchBranchProfile sp = gc.getSwitchProfile(instrIndex - bciAdjustment);
                    if (sp == null) {
                        // number targets + default
                        float approxProb = 1.0f / (number + 1);
                        TableSwitch.setDefaultBranchProfile(s, new BranchProfileOperand(approxProb));
                        for (int i = 0; i < number; ++i) {
                            TableSwitch.setBranchProfile(s, i, new BranchProfileOperand(approxProb));
                        }
                    } else {
                        TableSwitch.setDefaultBranchProfile(s, new BranchProfileOperand(sp.getDefaultProbability()));
                        for (int i = 0; i < number; ++i) {
                            TableSwitch.setBranchProfile(s, i, new BranchProfileOperand(sp.getCaseProbability(i)));
                        }
                    }
                }
                break;
            case JBC_lookupswitch:
                {
                    bcodes.alignSwitch();
                    Operand op0 = popInt();
                    int defaultoff = bcodes.getDefaultSwitchOffset();
                    int numpairs = bcodes.getSwitchLength();
                    if (numpairs == 0) {
                        s = _gotoHelper(defaultoff);
                        break;
                    }
                    if (CF_LOOKUPSWITCH && op0 instanceof IntConstantOperand) {
                        int v1 = ((IntConstantOperand) op0).value;
                        int match = bcodes.computeLookupSwitchOffset(v1, numpairs);
                        int offset = match == 0 ? defaultoff : match;
                        bcodes.skipLookupSwitchPairs(numpairs);
                        if (DBG_CF) {
                            db("changed lookupswitch to goto because index (" + v1 + ") is constant");
                        }
                        s = _gotoHelper(offset);
                        break;
                    }
                    // Construct switch
                    s = LookupSwitch.create(LOOKUPSWITCH, op0, null, null, generateTarget(defaultoff), null, numpairs * 3);
                    for (int i = 0; i < numpairs; ++i) {
                        LookupSwitch.setMatch(s, i, new IntConstantOperand(bcodes.getLookupSwitchValue(i)));
                        LookupSwitch.setTarget(s, i, generateTarget(bcodes.getLookupSwitchOffset(i)));
                    }
                    bcodes.skipLookupSwitchPairs(numpairs);
                    // Set branch probabilities
                    SwitchBranchProfile sp = gc.getSwitchProfile(instrIndex - bciAdjustment);
                    if (sp == null) {
                        // num targets + default
                        float approxProb = 1.0f / (numpairs + 1);
                        LookupSwitch.setDefaultBranchProfile(s, new BranchProfileOperand(approxProb));
                        for (int i = 0; i < numpairs; ++i) {
                            LookupSwitch.setBranchProfile(s, i, new BranchProfileOperand(approxProb));
                        }
                    } else {
                        LookupSwitch.setDefaultBranchProfile(s, new BranchProfileOperand(sp.getDefaultProbability()));
                        for (int i = 0; i < numpairs; ++i) {
                            LookupSwitch.setBranchProfile(s, i, new BranchProfileOperand(sp.getCaseProbability(i)));
                        }
                    }
                }
                break;
            case JBC_ireturn:
                _returnHelper(INT_MOVE, popInt());
                break;
            case JBC_lreturn:
                _returnHelper(LONG_MOVE, popLong());
                break;
            case JBC_freturn:
                _returnHelper(FLOAT_MOVE, popFloat());
                break;
            case JBC_dreturn:
                _returnHelper(DOUBLE_MOVE, popDouble());
                break;
            case JBC_areturn:
                {
                    Operand op0 = popRef();
                    if (VM.VerifyAssertions && !op0.isDefinitelyNull()) {
                        TypeReference retType = op0.getType();
                        assertIsAssignable(gc.getMethod().getReturnType(), retType);
                    }
                    _returnHelper(REF_MOVE, op0);
                }
                break;
            case JBC_return:
                _returnHelper(null, null);
                break;
            case JBC_getstatic:
                {
                    // field resolution
                    FieldReference ref = bcodes.getFieldReference();
                    boolean unresolved = ref.needsDynamicLink(bcodes.getMethod());
                    LocationOperand fieldOp = makeStaticFieldRef(ref);
                    Operand offsetOp;
                    TypeReference fieldType = ref.getFieldContentsType();
                    RegisterOperand t = gc.getTemps().makeTemp(fieldType);
                    if (unresolved) {
                        RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                        appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), fieldOp.copy()));
                        offsetOp = offsetrop;
                        rectifyStateWithErrorHandler();
                    } else {
                        RVMField field = ref.peekResolvedField();
                        offsetOp = new AddressConstantOperand(field.getOffset());
                        // use results of field analysis to refine type of result
                        RVMType ft = fieldType.peekType();
                        if (ft != null && ft.isClassType()) {
                            TypeReference concreteType = FieldAnalysis.getConcreteType(field);
                            if (concreteType != null) {
                                if (concreteType == fieldType) {
                                    t.setDeclaredType();
                                    t.setPreciseType();
                                } else {
                                    fieldType = concreteType;
                                    t.setPreciseType(concreteType);
                                }
                            }
                        }
                        // time.
                        if (gc.getOptions().SIMPLIFY_CHASE_FINAL_FIELDS && field.isFinal()) {
                            RVMClass declaringClass = field.getDeclaringClass();
                            boolean initializedClassAtRuntime = VM.runningVM & declaringClass.isInitialized();
                            boolean fieldFromRVMInternalClassInBootImage = declaringClass.isInBootImage() && declaringClass.getDescriptor().isRVMDescriptor();
                            // We cannot assume that non-public fields from the host JVM's class library are present in
                            // the class library used by Jikes RVM: only public fields are part of the API.
                            boolean publicFieldInBootImage = declaringClass.isInBootImage() && field.isPublic();
                            if (initializedClassAtRuntime || fieldFromRVMInternalClassInBootImage || publicFieldInBootImage) {
                                try {
                                    ConstantOperand rhs = StaticFieldReader.getStaticFieldValue(field);
                                    // VM.sysWriteln("Replaced getstatic of " + field + " with " + rhs);
                                    push(rhs, fieldType);
                                    break;
                                } catch (NoSuchFieldException e) {
                                    if (VM.runningVM) {
                                        throw new Error("Unexpected exception", e);
                                    } else {
                                    // Field not found during bootstrap due to chasing a field
                                    // only valid in the bootstrap JVM.
                                    // Although we try to avoid most cases where this could happen, we cannot
                                    // avoid all. For example, a NoSuchFieldException can occur when we're trying
                                    // to optimize a public field from Jikes RVM's class library that's not present
                                    // in the host JVM's class library (example: a field from an internal
                                    // helper class).
                                    }
                                }
                            }
                        } else if (field.isRuntimeFinal()) {
                            if (VM.VerifyAssertions)
                                opt_assert(fieldType.isBooleanType());
                            boolean rhsBool = field.getRuntimeFinalValue();
                            push(new IntConstantOperand(rhsBool ? 1 : 0));
                            break;
                        }
                    }
                    s = GetStatic.create(GETSTATIC, t, offsetOp, fieldOp);
                    if (fieldOp.mayBeVolatile()) {
                        appendInstruction(s);
                        s = Empty.create(READ_CEILING);
                    }
                    push(t.copyD2U(), fieldType);
                }
                break;
            case JBC_putstatic:
                {
                    // field resolution
                    FieldReference ref = bcodes.getFieldReference();
                    boolean unresolved = ref.needsDynamicLink(bcodes.getMethod());
                    LocationOperand fieldOp = makeStaticFieldRef(ref);
                    Operand offsetOp;
                    if (unresolved) {
                        RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                        appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), fieldOp.copy()));
                        offsetOp = offsetrop;
                        rectifyStateWithErrorHandler();
                    } else {
                        RVMField field = ref.peekResolvedField();
                        offsetOp = new AddressConstantOperand(field.getOffset());
                    }
                    TypeReference fieldType = ref.getFieldContentsType();
                    Operand r = pop(fieldType);
                    if (fieldOp.mayBeVolatile()) {
                        appendInstruction(Empty.create(WRITE_FLOOR));
                    }
                    s = PutStatic.create(PUTSTATIC, r, offsetOp, fieldOp);
                    if (fieldOp.mayBeVolatile()) {
                        appendInstruction(s);
                        s = Empty.create(FENCE);
                    }
                }
                break;
            case JBC_getfield:
                {
                    // field resolution
                    FieldReference ref = bcodes.getFieldReference();
                    boolean unresolved = ref.needsDynamicLink(bcodes.getMethod());
                    LocationOperand fieldOp = makeInstanceFieldRef(ref);
                    Operand offsetOp;
                    TypeReference fieldType = ref.getFieldContentsType();
                    RVMField field = null;
                    RegisterOperand t = gc.getTemps().makeTemp(fieldType);
                    if (unresolved) {
                        RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                        appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), fieldOp.copy()));
                        offsetOp = offsetrop;
                        rectifyStateWithErrorHandler();
                    } else {
                        field = ref.peekResolvedField();
                        offsetOp = new AddressConstantOperand(field.getOffset());
                        // use results of field analysis to refine type.
                        RVMType ft = fieldType.peekType();
                        if (ft != null && ft.isClassType()) {
                            TypeReference concreteType = FieldAnalysis.getConcreteType(field);
                            if (concreteType != null) {
                                if (concreteType == fieldType) {
                                    t.setDeclaredType();
                                    t.setPreciseType();
                                } else {
                                    fieldType = concreteType;
                                    t.setType(concreteType);
                                    t.setPreciseType();
                                }
                            }
                        }
                    }
                    Operand op1 = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(op1)) {
                        break;
                    }
                    // NB avoid String fields
                    if (op1.isConstant() && field.isFinal()) {
                        try {
                            ConstantOperand rhs = StaticFieldReader.getFieldValueAsConstant(field, op1.asObjectConstant().value);
                            push(rhs, fieldType);
                            break;
                        } catch (NoSuchFieldException e) {
                            if (VM.runningVM) {
                                // this is unexpected
                                throw new Error("Unexpected exception", e);
                            } else {
                            // Field not found during bootstrap due to chasing a field
                            // only valid in the bootstrap JVM
                            }
                        }
                    }
                    s = GetField.create(GETFIELD, t, op1, offsetOp, fieldOp, getCurrentGuard());
                    if (fieldOp.mayBeVolatile()) {
                        appendInstruction(s);
                        s = Empty.create(READ_CEILING);
                    }
                    push(t.copyD2U(), fieldType);
                }
                break;
            case JBC_putfield:
                {
                    // field resolution
                    FieldReference ref = bcodes.getFieldReference();
                    boolean unresolved = ref.needsDynamicLink(bcodes.getMethod());
                    LocationOperand fieldOp = makeInstanceFieldRef(ref);
                    TypeReference fieldType = ref.getFieldContentsType();
                    Operand offsetOp;
                    if (unresolved) {
                        RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                        appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), fieldOp.copy()));
                        offsetOp = offsetrop;
                        rectifyStateWithErrorHandler();
                    } else {
                        RVMField field = ref.peekResolvedField();
                        offsetOp = new AddressConstantOperand(field.getOffset());
                    }
                    Operand val = pop(fieldType);
                    Operand obj = popRef();
                    clearCurrentGuard();
                    if (do_NullCheck(obj)) {
                        break;
                    }
                    if (fieldOp.mayBeVolatile()) {
                        appendInstruction(Empty.create(WRITE_FLOOR));
                    }
                    s = PutField.create(PUTFIELD, val, obj, offsetOp, fieldOp, getCurrentGuard());
                    if (fieldOp.mayBeVolatile()) {
                        appendInstruction(s);
                        s = Empty.create(FENCE);
                    }
                }
                break;
            case JBC_invokevirtual:
                {
                    MethodReference ref = bcodes.getMethodReference();
                    // If it is, generate the inline code and we are done.
                    if (ref.isMagic()) {
                        boolean generated = GenerateMagic.generateMagic(this, gc, ref);
                        // all done.
                        if (generated)
                            break;
                    }
                    /* just create an osr barrier right before _callHelper
           * changes the states of locals and stacks.
           */
                    if (this.osrGuardedInline) {
                        lastOsrBarrier = _createOsrBarrier();
                    }
                    if (ref.isMiranda()) {
                        // An invokevirtual that is really an invokeinterface.
                        s = _callHelper(ref, MethodOperand.INTERFACE(ref, null));
                        if (s == null)
                            break;
                        Operand receiver = Call.getParam(s, 0);
                        RVMClass receiverType = (RVMClass) receiver.getType().peekType();
                        // null check on this parameter of call
                        clearCurrentGuard();
                        if (do_NullCheck(receiver)) {
                            // call will always raise null pointer exception
                            s = null;
                            break;
                        }
                        Call.setGuard(s, getCurrentGuard());
                        // Attempt to resolve the interface call to a particular virtual method.
                        // This is independent of whether or not the static type of the receiver is
                        // known to implement the interface and it is not that case that being able
                        // to prove one implies the other.
                        RVMMethod vmeth = null;
                        if (receiverType != null && receiverType.isInitialized() && !receiverType.isInterface()) {
                            vmeth = ClassLoaderProxy.lookupMethod(receiverType, ref);
                        }
                        if (vmeth != null) {
                            MethodReference vmethRef = vmeth.getMemberRef().asMethodReference();
                            MethodOperand mop = MethodOperand.VIRTUAL(vmethRef, vmeth);
                            if (receiver.isConstant() || (receiver.isRegister() && receiver.asRegister().isPreciseType())) {
                                mop.refine(vmeth, true);
                            }
                            Call.setMethod(s, mop);
                            boolean unresolved = vmethRef.needsDynamicLink(bcodes.getMethod());
                            if (unresolved) {
                                RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                                appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), Call.getMethod(s).copy()));
                                Call.setAddress(s, offsetrop);
                                rectifyStateWithErrorHandler();
                            } else {
                                Call.setAddress(s, new AddressConstantOperand(vmeth.getOffset()));
                            }
                            // Attempt to inline virtualized call.
                            if (maybeInlineMethod(shouldInline(s, receiver.isConstant() || (receiver.isRegister() && receiver.asRegister().isExtant()), instrIndex - bciAdjustment), s)) {
                                return;
                            }
                        }
                    } else {
                        // A normal invokevirtual.  Create call instruction.
                        boolean unresolved = ref.needsDynamicLink(bcodes.getMethod());
                        RVMMethod target = ref.peekResolvedMethod();
                        MethodOperand methOp = MethodOperand.VIRTUAL(ref, target);
                        s = _callHelper(ref, methOp);
                        if (s == null)
                            break;
                        // Must be done before null_check!
                        if (unresolved) {
                            RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                            appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), Call.getMethod(s).copy()));
                            Call.setAddress(s, offsetrop);
                            rectifyStateWithErrorHandler();
                        } else {
                            if (VM.VerifyAssertions)
                                opt_assert(target != null);
                            Call.setAddress(s, new AddressConstantOperand(target.getOffset()));
                        }
                        // null check receiver
                        Operand receiver = Call.getParam(s, 0);
                        clearCurrentGuard();
                        if (do_NullCheck(receiver)) {
                            // call will always raise null pointer exception
                            s = null;
                            break;
                        }
                        Call.setGuard(s, getCurrentGuard());
                        // Use compile time type of receiver to try reduce the number
                        // of targets.
                        // If we succeed, we'll update meth and s's method operand.
                        boolean isExtant = false;
                        boolean isPreciseType = false;
                        TypeReference tr = null;
                        if (receiver.isRegister()) {
                            RegisterOperand rop = receiver.asRegister();
                            isExtant = rop.isExtant();
                            isPreciseType = rop.isPreciseType();
                            tr = rop.getType();
                        } else {
                            isExtant = true;
                            isPreciseType = true;
                            tr = receiver.getType();
                        }
                        RVMType type = tr.peekType();
                        if (type != null && type.isResolved()) {
                            if (type.isClassType()) {
                                RVMMethod vmeth = target;
                                if (target == null || type != target.getDeclaringClass()) {
                                    vmeth = ClassLoaderProxy.lookupMethod(type.asClass(), ref);
                                }
                                if (vmeth != null) {
                                    methOp.refine(vmeth, isPreciseType || type.asClass().isFinal());
                                }
                            } else {
                                // Array: will always be calling the method defined in java.lang.Object
                                if (VM.VerifyAssertions)
                                    opt_assert(target != null, "Huh?  Target method must already be resolved if receiver is array");
                                methOp.refine(target, true);
                            }
                        }
                        // Consider inlining it.
                        if (maybeInlineMethod(shouldInline(s, isExtant, instrIndex - bciAdjustment), s)) {
                            return;
                        }
                    }
                    // noninlined CALL must be treated as potential throw of anything
                    rectifyStateWithExceptionHandlers();
                }
                break;
            case JBC_invokespecial:
                {
                    MethodReference ref = bcodes.getMethodReference();
                    RVMMethod target = ref.resolveInvokeSpecial();
                    /* just create an osr barrier right before _callHelper
           * changes the states of locals and stacks.
           */
                    if (this.osrGuardedInline) {
                        lastOsrBarrier = _createOsrBarrier();
                    }
                    s = _callHelper(ref, MethodOperand.SPECIAL(ref, target));
                    if (s == null)
                        break;
                    // NOTE: different definition of unresolved due to semantics of invokespecial.
                    if (target == null) {
                        RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                        appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), Call.getMethod(s).copy()));
                        Call.setAddress(s, offsetrop);
                        rectifyStateWithErrorHandler();
                    } else {
                        Call.setAddress(s, new AddressConstantOperand(target.getOffset()));
                    }
                    // null check receiver
                    Operand receiver = Call.getParam(s, 0);
                    clearCurrentGuard();
                    if (do_NullCheck(receiver)) {
                        // call will always raise null pointer exception
                        s = null;
                        break;
                    }
                    Call.setGuard(s, getCurrentGuard());
                    // Consider inlining it.
                    if (maybeInlineMethod(shouldInline(s, false, instrIndex - bciAdjustment), s)) {
                        return;
                    }
                    // noninlined CALL must be treated as potential throw of anything
                    rectifyStateWithExceptionHandlers();
                }
                break;
            case JBC_invokestatic:
                {
                    MethodReference ref = bcodes.getMethodReference();
                    // If it is, generate the inline code and we are done.
                    if (ref.isMagic()) {
                        boolean generated = GenerateMagic.generateMagic(this, gc, ref);
                        if (generated)
                            break;
                    }
                    // A non-magical invokestatic.  Create call instruction.
                    boolean unresolved = ref.needsDynamicLink(bcodes.getMethod());
                    RVMMethod target = ref.peekResolvedMethod();
                    /* just create an osr barrier right before _callHelper
          * changes the states of locals and stacks.
          */
                    if (this.osrGuardedInline) {
                        lastOsrBarrier = _createOsrBarrier();
                    }
                    s = _callHelper(ref, MethodOperand.STATIC(ref, target));
                    if (s == null)
                        break;
                    if (Call.conforms(s)) {
                        MethodOperand methOp = Call.getMethod(s);
                        if (methOp.getTarget() == target) {
                            // Handle possibility of dynamic linking.
                            if (unresolved) {
                                RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                                appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), Call.getMethod(s).copy()));
                                Call.setAddress(s, offsetrop);
                                rectifyStateWithErrorHandler();
                            } else {
                                Call.setAddress(s, new AddressConstantOperand(target.getOffset()));
                            }
                            // Consider inlining it.
                            if (maybeInlineMethod(shouldInline(s, false, instrIndex - bciAdjustment), s)) {
                                return;
                            }
                        }
                    }
                    // noninlined CALL must be treated as potential throw of anything
                    rectifyStateWithExceptionHandlers();
                }
                break;
            case JBC_invokeinterface:
                {
                    MethodReference ref = bcodes.getMethodReference();
                    bcodes.alignInvokeInterface();
                    RVMMethod resolvedMethod = null;
                    resolvedMethod = ref.peekInterfaceMethod();
                    /* just create an osr barrier right before _callHelper
           * changes the states of locals and stacks.
           */
                    if (this.osrGuardedInline) {
                        lastOsrBarrier = _createOsrBarrier();
                    }
                    s = _callHelper(ref, MethodOperand.INTERFACE(ref, resolvedMethod));
                    if (s == null)
                        break;
                    Operand receiver = Call.getParam(s, 0);
                    RVMClass receiverType = (RVMClass) receiver.getType().peekType();
                    boolean requiresImplementsTest = VM.BuildForIMTInterfaceInvocation;
                    // that it is not needed.
                    if (requiresImplementsTest && resolvedMethod == null) {
                        // Sigh.  Can't even resolve the reference to figure out what interface
                        // method we are trying to call. Therefore we must make generate a call
                        // to an out-of-line typechecking routine to handle it at runtime.
                        RVMMethod target = Entrypoints.unresolvedInvokeinterfaceImplementsTestMethod;
                        Instruction callCheck = Call.create2(CALL, null, new AddressConstantOperand(target.getOffset()), MethodOperand.STATIC(target), new IntConstantOperand(ref.getId()), receiver.copy());
                        if (gc.getOptions().H2L_NO_CALLEE_EXCEPTIONS) {
                            callCheck.markAsNonPEI();
                        }
                        appendInstruction(callCheck);
                        callCheck.setBytecodeIndex(RUNTIME_SERVICES_BCI);
                        // the above call subsumes the test
                        requiresImplementsTest = false;
                        // Can raise incompatible class change error.
                        rectifyStateWithErrorHandler();
                    }
                    // null check on this parameter of call. Must be done after dynamic linking!
                    clearCurrentGuard();
                    if (do_NullCheck(receiver)) {
                        // call will always raise null pointer exception
                        s = null;
                        break;
                    }
                    Call.setGuard(s, getCurrentGuard());
                    if (requiresImplementsTest) {
                        // We know what interface method the program wants to invoke.
                        // Attempt to avoid inserting the type check by seeing if the
                        // known static type of the receiver implements the desired interface.
                        RVMType interfaceType = resolvedMethod.getDeclaringClass();
                        if (receiverType != null && receiverType.isResolved() && !receiverType.isInterface()) {
                            byte doesImplement = ClassLoaderProxy.includesType(interfaceType.getTypeRef(), receiverType.getTypeRef());
                            requiresImplementsTest = doesImplement != YES;
                        }
                    }
                    // Attempt to resolve the interface call to a particular virtual method.
                    // This is independent of whether or not the static type of the receiver is
                    // known to implement the interface and it is not that case that being able
                    // to prove one implies the other.
                    RVMMethod vmeth = null;
                    if (receiverType != null && receiverType.isInitialized() && !receiverType.isInterface()) {
                        vmeth = ClassLoaderProxy.lookupMethod(receiverType, ref);
                    }
                    if (vmeth != null) {
                        MethodReference vmethRef = vmeth.getMemberRef().asMethodReference();
                        // Note that at this point requiresImplementsTest => resolvedMethod != null
                        if (requiresImplementsTest) {
                            RegisterOperand checkedReceiver = gc.getTemps().makeTemp(receiver);
                            appendInstruction(TypeCheck.create(MUST_IMPLEMENT_INTERFACE, checkedReceiver, receiver.copy(), makeTypeOperand(resolvedMethod.getDeclaringClass()), getCurrentGuard()));
                            checkedReceiver.refine(resolvedMethod.getDeclaringClass().getTypeRef());
                            Call.setParam(s, 0, checkedReceiver.copyRO());
                            receiver = checkedReceiver;
                            // Can raise incompatible class change error.
                            rectifyStateWithErrorHandler();
                        }
                        MethodOperand mop = MethodOperand.VIRTUAL(vmethRef, vmeth);
                        if (receiver.isConstant() || receiver.asRegister().isPreciseType()) {
                            mop.refine(vmeth, true);
                        }
                        Call.setMethod(s, mop);
                        boolean unresolved = vmethRef.needsDynamicLink(bcodes.getMethod());
                        if (unresolved) {
                            RegisterOperand offsetrop = gc.getTemps().makeTempOffset();
                            appendInstruction(Unary.create(RESOLVE_MEMBER, offsetrop.copyRO(), Call.getMethod(s).copy()));
                            Call.setAddress(s, offsetrop);
                            rectifyStateWithErrorHandler();
                        } else {
                            Call.setAddress(s, new AddressConstantOperand(vmeth.getOffset()));
                        }
                        // Attempt to inline virtualized call.
                        if (maybeInlineMethod(shouldInline(s, receiver.isConstant() || receiver.asRegister().isExtant(), instrIndex - bciAdjustment), s)) {
                            return;
                        }
                    } else {
                        // inline code will include DTC to ensure receiver implements the interface.
                        if (resolvedMethod != null && maybeInlineMethod(shouldInline(s, false, instrIndex - bciAdjustment), s)) {
                            return;
                        } else {
                            if (requiresImplementsTest) {
                                RegisterOperand checkedReceiver = gc.getTemps().makeTemp(receiver);
                                appendInstruction(TypeCheck.create(MUST_IMPLEMENT_INTERFACE, checkedReceiver, receiver.copy(), makeTypeOperand(resolvedMethod.getDeclaringClass()), getCurrentGuard()));
                                checkedReceiver.refine(resolvedMethod.getDeclaringClass().getTypeRef());
                                Call.setParam(s, 0, checkedReceiver.copyRO());
                            // don't have to rectify with error handlers; rectify call below subsumes.
                            }
                        }
                    }
                    // CALL must be treated as potential throw of anything
                    rectifyStateWithExceptionHandlers();
                }
                break;
            case JBC_invokedynamic:
                OptimizingCompilerException.UNREACHABLE();
                break;
            case JBC_new:
                {
                    TypeReference klass = bcodes.getTypeReference();
                    RegisterOperand t = gc.getTemps().makeTemp(klass);
                    t.setPreciseType();
                    markGuardlessNonNull(t);
                    Operator operator;
                    TypeOperand klassOp;
                    RVMClass klassType = (RVMClass) klass.peekType();
                    if (klassType != null && (klassType.isInitialized() || klassType.isInBootImage())) {
                        klassOp = makeTypeOperand(klassType);
                        operator = NEW;
                        t.setExtant();
                    } else {
                        operator = NEW_UNRESOLVED;
                        klassOp = makeTypeOperand(klass);
                    }
                    s = New.create(operator, t, klassOp);
                    push(t.copyD2U());
                    rectifyStateWithErrorHandler();
                }
                break;
            case JBC_newarray:
                {
                    RVMType array = bcodes.getPrimitiveArrayType();
                    TypeOperand arrayOp = makeTypeOperand(array);
                    RegisterOperand t = gc.getTemps().makeTemp(array.getTypeRef());
                    t.setPreciseType();
                    t.setExtant();
                    markGuardlessNonNull(t);
                    s = NewArray.create(NEWARRAY, t, arrayOp, popInt());
                    push(t.copyD2U());
                    rectifyStateWithExceptionHandler(TypeReference.JavaLangNegativeArraySizeException);
                }
                break;
            case JBC_anewarray:
                {
                    TypeReference elementTypeRef = bcodes.getTypeReference();
                    s = generateAnewarray(null, elementTypeRef);
                }
                break;
            case JBC_arraylength:
                {
                    Operand op1 = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(op1)) {
                        break;
                    }
                    if (VM.VerifyAssertions) {
                        opt_assert(getArrayTypeOf(op1).isArrayType());
                    }
                    RegisterOperand t = gc.getTemps().makeTempInt();
                    s = GuardedUnary.create(ARRAYLENGTH, t, op1, getCurrentGuard());
                    push(t.copyD2U());
                }
                break;
            case JBC_athrow:
                {
                    Operand op0 = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(op0)) {
                        break;
                    }
                    TypeReference type = getRefTypeOf(op0);
                    if (VM.VerifyAssertions)
                        assertIsAssignable(TypeReference.JavaLangThrowable, type);
                    if (!gc.getMethod().isInterruptible()) {
                        // prevent code motion in or out of uninterruptible code sequence
                        appendInstruction(Empty.create(UNINT_END));
                    }
                    endOfBasicBlock = true;
                    BasicBlock definiteTarget = rectifyStateWithExceptionHandler(type, true);
                    if (definiteTarget != null) {
                        appendInstruction(CacheOp.create(SET_CAUGHT_EXCEPTION, op0));
                        s = Goto.create(GOTO, definiteTarget.makeJumpTarget());
                        definiteTarget.setExceptionHandlerWithNormalIn();
                    } else {
                        s = Athrow.create(ATHROW, op0);
                    }
                }
                break;
            case JBC_checkcast:
                {
                    TypeReference typeRef = bcodes.getTypeReference();
                    boolean classLoading = couldCauseClassLoading(typeRef);
                    Operand op2 = pop();
                    if (typeRef.isWordLikeType()) {
                        op2 = op2.copy();
                        if (op2 instanceof RegisterOperand) {
                            ((RegisterOperand) op2).setType(typeRef);
                        }
                        push(op2);
                        if (DBG_CF)
                            db("skipped gen of checkcast to word type " + typeRef);
                        break;
                    }
                    if (VM.VerifyAssertions)
                        opt_assert(op2.isRef());
                    if (CF_CHECKCAST && !classLoading) {
                        if (op2.isDefinitelyNull()) {
                            push(op2);
                            if (DBG_CF)
                                db("skipped gen of null checkcast");
                            break;
                        }
                        // non-null, null case above
                        TypeReference type = getRefTypeOf(op2);
                        byte typeTestResult = ClassLoaderProxy.includesType(typeRef, type);
                        if (typeTestResult == YES) {
                            push(op2);
                            if (DBG_CF) {
                                db("skipped gen of checkcast of " + op2 + " from " + typeRef + " to " + type);
                            }
                            break;
                        }
                        if (typeTestResult == NO) {
                            if (isNonNull(op2)) {
                                // Definite class cast exception
                                endOfBasicBlock = true;
                                appendInstruction(Trap.create(TRAP, gc.getTemps().makeTempValidation(), TrapCodeOperand.CheckCast()));
                                rectifyStateWithExceptionHandler(TypeReference.JavaLangClassCastException);
                                if (DBG_CF)
                                    db("Converted checkcast into unconditional trap");
                                break;
                            } else {
                                // At runtime either it is null and the checkcast succeeds or it is non-null
                                // and a class cast exception is raised
                                RegisterOperand refinedOp2 = gc.getTemps().makeTemp(op2);
                                s = TypeCheck.create(CHECKCAST, refinedOp2, op2.copy(), makeTypeOperand(typeRef.peekType()));
                                refinedOp2.refine(TypeReference.NULL_TYPE);
                                push(refinedOp2.copyRO());
                                rectifyStateWithExceptionHandler(TypeReference.JavaLangClassCastException);
                                if (DBG_CF)
                                    db("Narrowed type downstream of checkcast to NULL");
                                break;
                            }
                        }
                    }
                    RegisterOperand refinedOp2 = gc.getTemps().makeTemp(op2);
                    if (classLoading) {
                        s = TypeCheck.create(CHECKCAST_UNRESOLVED, refinedOp2, op2.copy(), makeTypeOperand(typeRef));
                    } else {
                        TypeOperand typeOp = makeTypeOperand(typeRef.peekType());
                        if (isNonNull(op2)) {
                            s = TypeCheck.create(CHECKCAST_NOTNULL, refinedOp2, op2.copy(), typeOp, copyGuardFromOperand(op2));
                        } else {
                            s = TypeCheck.create(CHECKCAST, refinedOp2, op2.copy(), typeOp);
                        }
                    }
                    refinedOp2.refine(typeRef);
                    push(refinedOp2.copyRO());
                    rectifyStateWithExceptionHandler(TypeReference.JavaLangClassCastException);
                    if (classLoading)
                        rectifyStateWithErrorHandler();
                }
                break;
            case JBC_instanceof:
                {
                    TypeReference typeRef = bcodes.getTypeReference();
                    boolean classLoading = couldCauseClassLoading(typeRef);
                    Operand op2 = pop();
                    if (VM.VerifyAssertions)
                        opt_assert(op2.isRef());
                    if (CF_INSTANCEOF && !classLoading) {
                        if (op2.isDefinitelyNull()) {
                            push(new IntConstantOperand(0));
                            if (DBG_CF)
                                db("skipped gen of null instanceof");
                            break;
                        }
                        // non-null
                        TypeReference type = getRefTypeOf(op2);
                        int answer = ClassLoaderProxy.includesType(typeRef, type);
                        if (answer == YES && isNonNull(op2)) {
                            push(new IntConstantOperand(1));
                            if (DBG_CF) {
                                db(op2 + " instanceof " + typeRef + " is always true ");
                            }
                            break;
                        } else if (answer == NO) {
                            if (DBG_CF) {
                                db(op2 + " instanceof " + typeRef + " is always false ");
                            }
                            push(new IntConstantOperand(0));
                            break;
                        }
                    }
                    RegisterOperand t = gc.getTemps().makeTempInt();
                    if (classLoading) {
                        s = InstanceOf.create(INSTANCEOF_UNRESOLVED, t, makeTypeOperand(typeRef), op2);
                    } else {
                        TypeOperand typeOp = makeTypeOperand(typeRef.peekType());
                        if (isNonNull(op2)) {
                            s = InstanceOf.create(INSTANCEOF_NOTNULL, t, typeOp, op2, copyGuardFromOperand(op2));
                        } else {
                            s = InstanceOf.create(INSTANCEOF, t, typeOp, op2);
                        }
                    }
                    push(t.copyD2U());
                    if (classLoading)
                        rectifyStateWithErrorHandler();
                }
                break;
            case JBC_monitorenter:
                {
                    Operand op0 = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(op0)) {
                        break;
                    }
                    if (VM.VerifyAssertions)
                        opt_assert(op0.isRef());
                    s = MonitorOp.create(MONITORENTER, op0, getCurrentGuard());
                }
                break;
            case JBC_monitorexit:
                {
                    Operand op0 = pop();
                    clearCurrentGuard();
                    if (do_NullCheck(op0)) {
                        break;
                    }
                    s = MonitorOp.create(MONITOREXIT, op0, getCurrentGuard());
                    rectifyStateWithExceptionHandler(TypeReference.JavaLangIllegalMonitorStateException);
                }
                break;
            case JBC_wide:
                {
                    int widecode = bcodes.getWideOpcode();
                    int index = bcodes.getWideLocalNumber();
                    switch(widecode) {
                        case JBC_iload:
                            s = do_iload(index);
                            break;
                        case JBC_lload:
                            s = do_lload(index);
                            break;
                        case JBC_fload:
                            s = do_fload(index);
                            break;
                        case JBC_dload:
                            s = do_dload(index);
                            break;
                        case JBC_aload:
                            s = do_aload(index);
                            break;
                        case JBC_istore:
                            s = do_store(index, popInt());
                            break;
                        case JBC_lstore:
                            s = do_store(index, popLong());
                            break;
                        case JBC_fstore:
                            s = do_store(index, popFloat());
                            break;
                        case JBC_dstore:
                            s = do_store(index, popDouble());
                            break;
                        case JBC_astore:
                            s = do_astore(index);
                            break;
                        case JBC_iinc:
                            s = do_iinc(index, bcodes.getWideIncrement());
                            break;
                        case JBC_ret:
                            s = _retHelper(index);
                            break;
                        default:
                            OptimizingCompilerException.UNREACHABLE();
                            break;
                    }
                }
                break;
            case JBC_multianewarray:
                {
                    TypeReference arrayType = bcodes.getTypeReference();
                    int dimensions = bcodes.getArrayDimension();
                    if (dimensions == 1) {
                        s = generateAnewarray(arrayType, null);
                    } else {
                        TypeOperand typeOp = makeTypeOperand(arrayType);
                        RegisterOperand result = gc.getTemps().makeTemp(arrayType);
                        markGuardlessNonNull(result);
                        result.setPreciseType();
                        TypeReference innermostElementTypeRef = arrayType.getInnermostElementType();
                        RVMType innermostElementType = innermostElementTypeRef.peekType();
                        if (innermostElementType != null && (innermostElementType.isInitialized() || innermostElementType.isInBootImage())) {
                            result.setExtant();
                        }
                        s = Multianewarray.create(NEWOBJMULTIARRAY, result, typeOp, dimensions);
                        for (int i = 0; i < dimensions; i++) {
                            Multianewarray.setDimension(s, dimensions - i - 1, popInt());
                        }
                        push(result.copyD2U());
                        rectifyStateWithErrorHandler();
                        rectifyStateWithExceptionHandler(TypeReference.JavaLangNegativeArraySizeException);
                    }
                }
                break;
            case JBC_ifnull:
                s = _refIfNullHelper(ConditionOperand.EQUAL());
                break;
            case JBC_ifnonnull:
                s = _refIfNullHelper(ConditionOperand.NOT_EQUAL());
                break;
            case JBC_goto_w:
                {
                    int offset = bcodes.getWideBranchOffset();
                    if (offset != 5) {
                        // skip generating frivolous goto's
                        s = _gotoHelper(offset);
                    }
                }
                break;
            case JBC_jsr_w:
                s = _jsrHelper(bcodes.getWideBranchOffset());
                break;
            case JBC_impdep1:
                {
                    if (VM.BuildForAdaptiveSystem) {
                        int pseudo_opcode = bcodes.nextPseudoInstruction();
                        switch(pseudo_opcode) {
                            case PSEUDO_LoadIntConst:
                                {
                                    int value = bcodes.readIntConst();
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_LoadIntConst " + value);
                                    }
                                    push(new IntConstantOperand(value));
                                    // used for PSEUDO_InvokeStatic to recover the type info
                                    param1 = param2;
                                    param2 = value;
                                    break;
                                }
                            case PSEUDO_LoadLongConst:
                                {
                                    long value = bcodes.readLongConst();
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_LoadLongConst " + value);
                                    }
                                    pushDual(new LongConstantOperand(value));
                                    break;
                                }
                            case PSEUDO_LoadWordConst:
                                {
                                    Address a = (VM.BuildFor32Addr) ? Address.fromIntSignExtend(bcodes.readIntConst()) : Address.fromLong(bcodes.readLongConst());
                                    push(new AddressConstantOperand(a));
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWrite("PSEUDO_LoadWordConst 0x");
                                    }
                                    VM.sysWrite(a);
                                    VM.sysWriteln();
                                    break;
                                }
                            case PSEUDO_LoadFloatConst:
                                {
                                    int ibits = bcodes.readIntConst();
                                    float value = Float.intBitsToFloat(ibits);
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_LoadFloatConst " + value);
                                    }
                                    push(new FloatConstantOperand(value, Offset.zero()));
                                    break;
                                }
                            case PSEUDO_LoadDoubleConst:
                                {
                                    long lbits = bcodes.readLongConst();
                                    double value = Magic.longBitsAsDouble(lbits);
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_LoadDoubleConst " + lbits);
                                    }
                                    pushDual(new DoubleConstantOperand(value, Offset.zero()));
                                    break;
                                }
                            case PSEUDO_LoadRetAddrConst:
                                {
                                    int value = bcodes.readIntConst();
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_LoadRetAddrConst " + value);
                                    }
                                    push(new ReturnAddressOperand(value));
                                    break;
                                }
                            case PSEUDO_InvokeStatic:
                                {
                                    /* pseudo invoke static for getRefAt and cleanRefAt, both must be resolved already */
                                    int targetidx = bcodes.readIntConst();
                                    RVMMethod meth = InvokeStatic.targetMethod(targetidx);
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_Invoke " + meth);
                                        VM.sysWriteln();
                                    }
                                    s = _callHelper(meth.getMemberRef().asMethodReference(), MethodOperand.STATIC(meth));
                                    if (s == null)
                                        break;
                                    Call.setAddress(s, new AddressConstantOperand(meth.getOffset()));
                                    /* try to set the type of return register */
                                    if (targetidx == GETREFAT) {
                                        Object realObj = ObjectHolder.getRefAt(param1, param2);
                                        if (VM.VerifyAssertions)
                                            opt_assert(realObj != null);
                                        TypeReference klass = Magic.getObjectType(realObj).getTypeRef();
                                        RegisterOperand op0 = gc.getTemps().makeTemp(klass);
                                        Call.setResult(s, op0);
                                        // pop the old one and push the new return type.
                                        pop();
                                        push(op0.copyD2U(), klass);
                                    }
                                    // CALL must be treated as potential throw of anything
                                    rectifyStateWithExceptionHandlers();
                                    break;
                                }
                            case PSEUDO_InvokeCompiledMethod:
                                {
                                    int cmid = bcodes.readIntConst();
                                    // skip it
                                    int origBCIdx = bcodes.readIntConst();
                                    CompiledMethod cm = CompiledMethods.getCompiledMethod(cmid);
                                    RVMMethod meth = cm.getMethod();
                                    if (VM.TraceOnStackReplacement) {
                                        VM.sysWriteln("PSEUDO_InvokeCompiledMethod " + meth);
                                        VM.sysWriteln();
                                    }
                                    /* the bcIndex should be adjusted to the original */
                                    s = _callHelper(meth.getMemberRef().asMethodReference(), MethodOperand.COMPILED(meth, cm.getOsrJTOCoffset()));
                                    if (s == null)
                                        break;
                                    // adjust the bcindex of s to the original bytecode's index
                                    // it should be able to give the correct exception handling
                                    s.adjustBytecodeIndex(bciAdjustment);
                                    rectifyStateWithExceptionHandlers();
                                    break;
                                }
                            case PSEUDO_ParamInitEnd:
                                {
                                    break;
                                }
                            default:
                                if (VM.TraceOnStackReplacement) {
                                    VM.sysWriteln("OSR Error, no such pseudo opcode : " + pseudo_opcode);
                                }
                                OptimizingCompilerException.UNREACHABLE();
                                break;
                        }
                        break;
                    } else {
                        OptimizingCompilerException.UNREACHABLE();
                    }
                }
            default:
                OptimizingCompilerException.UNREACHABLE();
                break;
        }
        if (s != null && !currentBBLE.isSelfRegen()) {
            appendInstruction(s);
        }
        // check runoff
        if (VM.VerifyAssertions)
            opt_assert(bcodes.index() <= runoff);
        if (!endOfBasicBlock && bcodes.index() == runoff) {
            if (DBG_BB || DBG_SELECTED) {
                db("runoff occurred! current basic block: " + currentBBLE + ", runoff = " + runoff);
            }
            endOfBasicBlock = fallThrough = true;
        }
        if (endOfBasicBlock) {
            if (currentBBLE.isSelfRegen()) {
                // This block ended in a goto that jumped into the middle of it.
                // Through away all out edges from this block, they're out of date
                // because we're going to have to regenerate this block.
                currentBBLE.block.deleteOut();
                if (DBG_CFG || DBG_SELECTED) {
                    db("Deleted all out edges of " + currentBBLE.block);
                }
                return;
            }
            if (fallThrough) {
                if (VM.VerifyAssertions)
                    opt_assert(bcodes.index() < bcodes.length());
                // Get/Create fallthrough BBLE and record it as
                // currentBBLE's fallThrough.
                currentBBLE.fallThrough = getOrCreateBlock(bcodes.index());
                currentBBLE.block.insertOut(currentBBLE.fallThrough.block);
            }
            return;
        }
    }
}
Also used : LongConstantOperand(org.jikesrvm.compilers.opt.ir.operand.LongConstantOperand) Operator(org.jikesrvm.compilers.opt.ir.Operator) IntConstantOperand(org.jikesrvm.compilers.opt.ir.operand.IntConstantOperand) Address(org.vmmagic.unboxed.Address) LongConstantOperand(org.jikesrvm.compilers.opt.ir.operand.LongConstantOperand) DoubleConstantOperand(org.jikesrvm.compilers.opt.ir.operand.DoubleConstantOperand) TypeOperand(org.jikesrvm.compilers.opt.ir.operand.TypeOperand) RegisterOperand(org.jikesrvm.compilers.opt.ir.operand.RegisterOperand) OsrTypeInfoOperand(org.jikesrvm.compilers.opt.ir.operand.OsrTypeInfoOperand) NullConstantOperand(org.jikesrvm.compilers.opt.ir.operand.NullConstantOperand) FloatConstantOperand(org.jikesrvm.compilers.opt.ir.operand.FloatConstantOperand) LocationOperand(org.jikesrvm.compilers.opt.ir.operand.LocationOperand) IntConstantOperand(org.jikesrvm.compilers.opt.ir.operand.IntConstantOperand) AddressConstantOperand(org.jikesrvm.compilers.opt.ir.operand.AddressConstantOperand) MethodOperand(org.jikesrvm.compilers.opt.ir.operand.MethodOperand) TrueGuardOperand(org.jikesrvm.compilers.opt.ir.operand.TrueGuardOperand) ConditionOperand(org.jikesrvm.compilers.opt.ir.operand.ConditionOperand) Operand(org.jikesrvm.compilers.opt.ir.operand.Operand) BranchProfileOperand(org.jikesrvm.compilers.opt.ir.operand.BranchProfileOperand) TrapCodeOperand(org.jikesrvm.compilers.opt.ir.operand.TrapCodeOperand) BranchOperand(org.jikesrvm.compilers.opt.ir.operand.BranchOperand) ConstantOperand(org.jikesrvm.compilers.opt.ir.operand.ConstantOperand) RVMType(org.jikesrvm.classloader.RVMType) Instruction(org.jikesrvm.compilers.opt.ir.Instruction) CompiledMethod(org.jikesrvm.compilers.common.CompiledMethod) MethodOperand(org.jikesrvm.compilers.opt.ir.operand.MethodOperand) NullConstantOperand(org.jikesrvm.compilers.opt.ir.operand.NullConstantOperand) LocationOperand(org.jikesrvm.compilers.opt.ir.operand.LocationOperand) RegisterOperand(org.jikesrvm.compilers.opt.ir.operand.RegisterOperand) DoubleConstantOperand(org.jikesrvm.compilers.opt.ir.operand.DoubleConstantOperand) RVMField(org.jikesrvm.classloader.RVMField) TypeReference(org.jikesrvm.classloader.TypeReference) LongConstantOperand(org.jikesrvm.compilers.opt.ir.operand.LongConstantOperand) DoubleConstantOperand(org.jikesrvm.compilers.opt.ir.operand.DoubleConstantOperand) NullConstantOperand(org.jikesrvm.compilers.opt.ir.operand.NullConstantOperand) FloatConstantOperand(org.jikesrvm.compilers.opt.ir.operand.FloatConstantOperand) IntConstantOperand(org.jikesrvm.compilers.opt.ir.operand.IntConstantOperand) AddressConstantOperand(org.jikesrvm.compilers.opt.ir.operand.AddressConstantOperand) ConstantOperand(org.jikesrvm.compilers.opt.ir.operand.ConstantOperand) FieldReference(org.jikesrvm.classloader.FieldReference) AddressConstantOperand(org.jikesrvm.compilers.opt.ir.operand.AddressConstantOperand) BasicBlock(org.jikesrvm.compilers.opt.ir.BasicBlock) ExceptionHandlerBasicBlock(org.jikesrvm.compilers.opt.ir.ExceptionHandlerBasicBlock) SwitchBranchProfile(org.jikesrvm.compilers.baseline.SwitchBranchProfile) OsrPoint(org.jikesrvm.compilers.opt.ir.OsrPoint) RVMClass(org.jikesrvm.classloader.RVMClass) RVMMethod(org.jikesrvm.classloader.RVMMethod) FloatConstantOperand(org.jikesrvm.compilers.opt.ir.operand.FloatConstantOperand) TypeOperand(org.jikesrvm.compilers.opt.ir.operand.TypeOperand) BranchProfileOperand(org.jikesrvm.compilers.opt.ir.operand.BranchProfileOperand) MethodReference(org.jikesrvm.classloader.MethodReference)

Example 7 with FieldReference

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

the class LoadElimination method getCandidates.

/**
 * Do a quick pass over the IR, and return types that are candidates
 * for redundant load elimination.<p>
 *
 * Algorithm: return those types T where
 * <ul>
 *   <li>there's a load L(i) of type T
 *   <li>there's another load or store M(j) of type T, M!=L and V(i) == V(j)
 * </ul>
 * <p>
 * The result contains objects of type RVMField and TypeReference, whose
 * narrowest common ancestor is Object.
 *
 * @param ir the governing IR
 *
 * @return the types that are candidates for redundant load elimination
 */
@SuppressWarnings("unchecked")
public static HashSet<Object> getCandidates(IR ir) {
    GlobalValueNumberState valueNumbers = ir.HIRInfo.valueNumbers;
    // which types have we seen loads for?
    HashSet<Object> seenLoad = new HashSet<Object>(10);
    // which static fields have we seen stores for?
    HashSet<RVMField> seenStore = new HashSet<RVMField>(10);
    HashSet<Object> resultSet = new HashSet<Object>(10);
    HashSet<FieldReference> forbidden = new HashSet<FieldReference>(10);
    // for each type T, indices(T) gives the set of value number (pairs)
    // that identify the indices seen in memory accesses to type T.
    HashMap indices = new HashMap(10);
    for (Enumeration be = ir.getBasicBlocks(); be.hasMoreElements(); ) {
        BasicBlock bb = (BasicBlock) be.nextElement();
        if (!ir.options.FREQ_FOCUS_EFFORT || !bb.getInfrequent()) {
            for (Enumeration<Instruction> e = bb.forwardInstrEnumerator(); e.hasMoreElements(); ) {
                Instruction s = e.nextElement();
                switch(s.getOpcode()) {
                    case GETFIELD_opcode:
                        {
                            Operand ref = GetField.getRef(s);
                            FieldReference fr = GetField.getLocation(s).getFieldRef();
                            RVMField f = fr.peekResolvedField();
                            if (f == null) {
                                forbidden.add(fr);
                            } else {
                                HashSet<Integer> numbers = findOrCreateIndexSet(indices, f);
                                int v = valueNumbers.getValueNumber(ref);
                                Integer V = v;
                                if (numbers.contains(V)) {
                                    resultSet.add(f);
                                } else {
                                    numbers.add(V);
                                }
                                seenLoad.add(f);
                            }
                        }
                        break;
                    case PUTFIELD_opcode:
                        {
                            Operand ref = PutField.getRef(s);
                            FieldReference fr = PutField.getLocation(s).getFieldRef();
                            RVMField f = fr.peekResolvedField();
                            if (f == null) {
                                forbidden.add(fr);
                            } else {
                                HashSet<Integer> numbers = findOrCreateIndexSet(indices, f);
                                int v = valueNumbers.getValueNumber(ref);
                                Integer V = v;
                                if (numbers.contains(V)) {
                                    if (seenLoad.contains(f)) {
                                        resultSet.add(f);
                                    }
                                } else {
                                    numbers.add(V);
                                }
                            }
                        }
                        break;
                    case GETSTATIC_opcode:
                        {
                            FieldReference fr = GetStatic.getLocation(s).getFieldRef();
                            RVMField f = fr.peekResolvedField();
                            if (f == null) {
                                forbidden.add(fr);
                            } else {
                                if (seenLoad.contains(f) || seenStore.contains(f)) {
                                    resultSet.add(f);
                                }
                                seenLoad.add(f);
                            }
                        }
                        break;
                    case PUTSTATIC_opcode:
                        {
                            FieldReference fr = PutStatic.getLocation(s).getFieldRef();
                            RVMField f = fr.peekResolvedField();
                            if (f == null) {
                                forbidden.add(fr);
                            } else {
                                if (seenLoad.contains(f)) {
                                    resultSet.add(f);
                                }
                                seenStore.add(f);
                            }
                        }
                        break;
                    case INT_ALOAD_opcode:
                    case LONG_ALOAD_opcode:
                    case FLOAT_ALOAD_opcode:
                    case DOUBLE_ALOAD_opcode:
                    case REF_ALOAD_opcode:
                    case BYTE_ALOAD_opcode:
                    case UBYTE_ALOAD_opcode:
                    case USHORT_ALOAD_opcode:
                    case SHORT_ALOAD_opcode:
                        {
                            Operand ref = ALoad.getArray(s);
                            TypeReference type = ref.getType();
                            if (type.isArrayType()) {
                                if (!type.getArrayElementType().isPrimitiveType()) {
                                    type = TypeReference.JavaLangObjectArray;
                                }
                            }
                            Operand index = ALoad.getIndex(s);
                            HashSet<ValueNumberPair> numbers = findOrCreateIndexSet(indices, type);
                            int v1 = valueNumbers.getValueNumber(ref);
                            int v2 = valueNumbers.getValueNumber(index);
                            ValueNumberPair V = new ValueNumberPair(v1, v2);
                            if (numbers.contains(V)) {
                                resultSet.add(type);
                            } else {
                                numbers.add(V);
                            }
                            seenLoad.add(type);
                        }
                        break;
                    case INT_ASTORE_opcode:
                    case LONG_ASTORE_opcode:
                    case FLOAT_ASTORE_opcode:
                    case DOUBLE_ASTORE_opcode:
                    case REF_ASTORE_opcode:
                    case BYTE_ASTORE_opcode:
                    case SHORT_ASTORE_opcode:
                        {
                            Operand ref = AStore.getArray(s);
                            TypeReference type = ref.getType();
                            if (type.isArrayType()) {
                                if (!type.getArrayElementType().isPrimitiveType()) {
                                    type = TypeReference.JavaLangObjectArray;
                                }
                            }
                            Operand index = AStore.getIndex(s);
                            HashSet<ValueNumberPair> numbers = findOrCreateIndexSet(indices, type);
                            int v1 = valueNumbers.getValueNumber(ref);
                            int v2 = valueNumbers.getValueNumber(index);
                            ValueNumberPair V = new ValueNumberPair(v1, v2);
                            if (numbers.contains(V)) {
                                if (seenLoad.contains(type)) {
                                    resultSet.add(type);
                                }
                            } else {
                                numbers.add(V);
                            }
                        }
                        break;
                    default:
                        break;
                }
            }
        }
    }
    // remove all fields that it might refer to from the resultSet.
    for (final FieldReference fieldReference : forbidden) {
        for (Iterator i2 = resultSet.iterator(); i2.hasNext(); ) {
            Object it = i2.next();
            if (it instanceof RVMField) {
                final RVMField field = (RVMField) it;
                if (!fieldReference.definitelyDifferent(field.getMemberRef().asFieldReference())) {
                    i2.remove();
                }
            }
        }
    }
    return resultSet;
}
Also used : FieldReference(org.jikesrvm.classloader.FieldReference) Enumeration(java.util.Enumeration) HashMap(java.util.HashMap) RegisterOperand(org.jikesrvm.compilers.opt.ir.operand.RegisterOperand) Operand(org.jikesrvm.compilers.opt.ir.operand.Operand) HeapOperand(org.jikesrvm.compilers.opt.ir.operand.HeapOperand) BasicBlock(org.jikesrvm.compilers.opt.ir.BasicBlock) Instruction(org.jikesrvm.compilers.opt.ir.Instruction) RVMField(org.jikesrvm.classloader.RVMField) Iterator(java.util.Iterator) TypeReference(org.jikesrvm.classloader.TypeReference) HashSet(java.util.HashSet)

Example 8 with FieldReference

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

the class BytecodeTraverser method scanBlocks.

// //////////////////////////
// IMPLEMENTATION
// /////////////////////////
/* return true --> hit the bytecode pointed by PC */
private // which method
boolean scanBlocks(// which method
NormalMethod method, // the bytecodes
BytecodeStream bytecodes, // do a DFS or one-pass scan
boolean doDFS, // the target pcs, if doDFS
int pcs, // the local types if doDFS
byte[] ltypes, // the stack types if doDFS
byte[] stypes, // start pc
int startpc, // stack
TypeStack S, int[] stackHeights) {
    // the stack height if not doDFS
    int localsize = method.getLocalWords() - 1;
    RVMClass declaringClass = method.getDeclaringClass();
    bytecodes.reset(startpc);
    boolean found = false;
    while (bytecodes.hasMoreBytecodes()) {
        // get current pc
        int pc = bytecodes.index();
        if (visitedpc[pc] == 1) {
            return false;
        } else {
            visitedpc[pc] = 1;
        }
        if (doDFS && (pc == pcs)) {
            /* make a copy of stack frame and put into stypes. */
            byte[] stack = S.snapshot();
            System.arraycopy(stack, 0, stypes, 0, stack.length);
            return true;
        }
        if (!doDFS) {
            // record stack heights
            stackHeights[pc] = localsize + S.depth();
        }
        /* let's continue */
        int bcode = bytecodes.nextInstruction();
        if (TRACE) {
            if (bcode <= JBC_jsr_w) {
                VM.sysWriteln(pc + " : " + S.depth() + " : " + JBC_name(bcode));
            } else {
                VM.sysWriteln(pc + " : " + S.depth() + " : impdep1");
            }
        }
        switch(bcode) {
            case JBC_nop:
                break;
            case JBC_aconst_null:
                S.push(ClassTypeCode);
                break;
            case JBC_iconst_m1:
            case JBC_iconst_0:
            case JBC_iconst_1:
            case JBC_iconst_2:
            case JBC_iconst_3:
            case JBC_iconst_4:
            case JBC_iconst_5:
                S.push(IntTypeCode);
                break;
            case JBC_lconst_0:
            case JBC_lconst_1:
                /* we should do the save order as opt compiler */
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_fconst_0:
            case JBC_fconst_1:
            case JBC_fconst_2:
                S.push(FloatTypeCode);
                break;
            case JBC_dconst_0:
            case JBC_dconst_1:
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_bipush:
                bytecodes.getByteValue();
                S.push(IntTypeCode);
                break;
            case JBC_sipush:
                bytecodes.getShortValue();
                S.push(IntTypeCode);
                break;
            case JBC_ldc:
            case JBC_ldc_w:
                {
                    int cpoolidx = (bcode == JBC_ldc) ? bytecodes.getConstantIndex() : bytecodes.getWideConstantIndex();
                    byte tdesc = declaringClass.getLiteralDescription(cpoolidx);
                    switch(tdesc) {
                        case CP_INT:
                            S.push(IntTypeCode);
                            break;
                        case CP_FLOAT:
                            S.push(FloatTypeCode);
                            break;
                        case CP_STRING:
                            S.push(ClassTypeCode);
                            break;
                        case CP_CLASS:
                            S.push(ClassTypeCode);
                            break;
                        default:
                            if (VM.TraceOnStackReplacement)
                                VM.sysWriteln("ldc unknown type " + tdesc);
                            if (VM.VerifyAssertions)
                                VM._assert(VM.NOT_REACHED);
                            break;
                    }
                // end of switch
                }
                break;
            case JBC_ldc2_w:
                {
                    int cpoolidx = bytecodes.getWideConstantIndex();
                    byte tdesc = declaringClass.getLiteralDescription(cpoolidx);
                    S.push(VoidTypeCode);
                    switch(tdesc) {
                        case CP_LONG:
                            S.push(LongTypeCode);
                            break;
                        case CP_DOUBLE:
                            S.push(DoubleTypeCode);
                            break;
                        default:
                            if (VM.TraceOnStackReplacement)
                                VM.sysWriteln("ldc2_w unknown type " + tdesc);
                            if (VM.VerifyAssertions)
                                VM._assert(VM.NOT_REACHED);
                            break;
                    }
                // end of switch
                }
                break;
            case JBC_iload:
                // skip local
                bytecodes.getLocalNumber();
                S.push(IntTypeCode);
                break;
            case JBC_lload:
                // skip local
                bytecodes.getLocalNumber();
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_fload:
                // skip local
                bytecodes.getLocalNumber();
                S.push(FloatTypeCode);
                break;
            case JBC_dload:
                bytecodes.getLocalNumber();
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_aload:
                bytecodes.getLocalNumber();
                S.push(ClassTypeCode);
                break;
            case JBC_iload_0:
            case JBC_iload_1:
            case JBC_iload_2:
            case JBC_iload_3:
                S.push(IntTypeCode);
                break;
            case JBC_lload_0:
            case JBC_lload_1:
            case JBC_lload_2:
            case JBC_lload_3:
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_fload_0:
            case JBC_fload_1:
            case JBC_fload_2:
            case JBC_fload_3:
                S.push(FloatTypeCode);
                break;
            case JBC_dload_0:
            case JBC_dload_1:
            case JBC_dload_2:
            case JBC_dload_3:
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_aload_0:
            case JBC_aload_1:
            case JBC_aload_2:
            case JBC_aload_3:
                S.push(ClassTypeCode);
                break;
            case JBC_iaload:
            case JBC_baload:
            case JBC_caload:
            case JBC_saload:
                S.pop();
                S.pop();
                S.push(IntTypeCode);
                break;
            case JBC_laload:
                S.pop();
                S.pop();
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_faload:
                S.pop();
                S.pop();
                S.push(FloatTypeCode);
                break;
            case JBC_daload:
                S.pop();
                S.pop();
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_aaload:
                S.pop();
                S.pop();
                S.push(ClassTypeCode);
                break;
            case JBC_istore:
                {
                    S.pop();
                    int index = bytecodes.getLocalNumber();
                    if (doDFS)
                        ltypes[index] = IntTypeCode;
                }
                break;
            case JBC_istore_0:
            case JBC_istore_1:
            case JBC_istore_2:
            case JBC_istore_3:
                {
                    S.pop();
                    int index = bcode - JBC_istore_0;
                    if (doDFS)
                        ltypes[index] = IntTypeCode;
                }
                break;
            case JBC_lstore:
                {
                    S.pop();
                    S.pop();
                    int index = bytecodes.getLocalNumber();
                    if (doDFS) {
                        ltypes[index] = LongTypeCode;
                        ltypes[index + 1] = VoidTypeCode;
                    }
                }
                break;
            case JBC_lstore_0:
            case JBC_lstore_1:
            case JBC_lstore_2:
            case JBC_lstore_3:
                {
                    S.pop();
                    S.pop();
                    int index = bcode - JBC_lstore_0;
                    if (doDFS) {
                        ltypes[index] = LongTypeCode;
                        ltypes[index + 1] = VoidTypeCode;
                    }
                }
                break;
            case JBC_fstore:
                {
                    S.pop();
                    int index = bytecodes.getLocalNumber();
                    if (doDFS)
                        ltypes[index] = FloatTypeCode;
                }
                break;
            case JBC_fstore_0:
            case JBC_fstore_1:
            case JBC_fstore_2:
            case JBC_fstore_3:
                {
                    S.pop();
                    int index = bcode - JBC_fstore_0;
                    if (doDFS)
                        ltypes[index] = FloatTypeCode;
                }
                break;
            case JBC_dstore:
                {
                    S.pop();
                    S.pop();
                    int index = bytecodes.getLocalNumber();
                    if (doDFS) {
                        ltypes[index] = DoubleTypeCode;
                        ltypes[index + 1] = VoidTypeCode;
                    }
                }
                break;
            case JBC_dstore_0:
            case JBC_dstore_1:
            case JBC_dstore_2:
            case JBC_dstore_3:
                {
                    S.pop();
                    S.pop();
                    int index = bcode - JBC_dstore_0;
                    if (doDFS) {
                        ltypes[index] = DoubleTypeCode;
                        ltypes[index + 1] = VoidTypeCode;
                    }
                }
                break;
            case JBC_astore:
                {
                    // caution: astore may save return address type
                    int index = bytecodes.getLocalNumber();
                    byte tcode = S.pop();
                    if (doDFS)
                        ltypes[index] = tcode;
                    // for ret address.
                    if (tcode == ReturnAddressTypeCode) {
                        retaddr[index] = addr;
                        addr = -1;
                    }
                }
                break;
            case JBC_astore_0:
            case JBC_astore_1:
            case JBC_astore_2:
            case JBC_astore_3:
                {
                    // caution: astore may save return address type
                    int index = bcode - JBC_astore_0;
                    byte tcode = S.pop();
                    if (doDFS)
                        ltypes[index] = tcode;
                    // for ret address.
                    if (tcode == ReturnAddressTypeCode) {
                        retaddr[index] = addr;
                        addr = -1;
                    }
                }
                break;
            case JBC_iastore:
            case JBC_bastore:
            case JBC_castore:
            case JBC_sastore:
                S.pop(3);
                break;
            case JBC_lastore:
                S.pop(4);
                break;
            case JBC_fastore:
                S.pop(3);
                break;
            case JBC_dastore:
                S.pop(4);
                break;
            case JBC_aastore:
                S.pop(3);
                break;
            case JBC_pop:
                S.pop();
                break;
            case JBC_pop2:
                S.pop(2);
                break;
            case JBC_dup:
                {
                    byte v1 = S.peek();
                    S.push(v1);
                }
                break;
            case JBC_dup_x1:
                {
                    byte v1 = S.peek();
                    S.pop();
                    byte v2 = S.peek();
                    S.pop();
                    S.push(v1);
                    S.push(v2);
                    S.push(v1);
                }
                break;
            case JBC_dup_x2:
                {
                    byte v1 = S.peek();
                    S.pop();
                    byte v2 = S.peek();
                    S.pop();
                    byte v3 = S.peek();
                    S.pop();
                    S.push(v1);
                    S.push(v3);
                    S.push(v2);
                    S.push(v1);
                }
                break;
            case JBC_dup2:
                {
                    byte v1 = S.peek();
                    S.pop();
                    byte v2 = S.peek();
                    S.push(v1);
                    S.push(v2);
                    S.push(v1);
                }
                break;
            case JBC_dup2_x1:
                {
                    byte v1 = S.peek();
                    S.pop();
                    byte v2 = S.peek();
                    S.pop();
                    byte v3 = S.peek();
                    S.pop();
                    S.push(v2);
                    S.push(v1);
                    S.push(v3);
                    S.push(v2);
                    S.push(v1);
                }
                break;
            case JBC_dup2_x2:
                {
                    byte v1 = S.peek();
                    S.pop();
                    byte v2 = S.peek();
                    S.pop();
                    byte v3 = S.peek();
                    S.pop();
                    byte v4 = S.peek();
                    S.pop();
                    S.push(v2);
                    S.push(v1);
                    S.push(v4);
                    S.push(v3);
                    S.push(v2);
                    S.push(v1);
                }
                break;
            case JBC_swap:
                {
                    byte v1 = S.peek();
                    S.pop();
                    byte v2 = S.peek();
                    S.pop();
                    S.push(v1);
                    S.push(v2);
                }
                break;
            case JBC_iadd:
            case JBC_isub:
            case JBC_imul:
            case JBC_idiv:
            case JBC_irem:
            case JBC_iand:
            case JBC_ior:
            case JBC_ixor:
            case JBC_ishl:
            case JBC_ishr:
            case JBC_iushr:
                S.pop();
                break;
            case JBC_ladd:
            case JBC_lsub:
            case JBC_lmul:
            case JBC_ldiv:
            case JBC_lrem:
            case JBC_land:
            case JBC_lor:
            case JBC_lxor:
                S.pop(2);
                break;
            case JBC_lshl:
            case JBC_lshr:
            case JBC_lushr:
                S.pop();
                break;
            case JBC_fadd:
            case JBC_fsub:
            case JBC_fmul:
            case JBC_fdiv:
            case JBC_frem:
                S.pop();
                break;
            case JBC_dadd:
            case JBC_dsub:
            case JBC_dmul:
            case JBC_ddiv:
            case JBC_drem:
                S.pop(2);
                break;
            case JBC_ineg:
            case JBC_lneg:
            case JBC_fneg:
            case JBC_dneg:
                break;
            case JBC_iinc:
                {
                    int index = bytecodes.getLocalNumber();
                    /* int value = */
                    bytecodes.getIncrement();
                    if (doDFS)
                        ltypes[index] = IntTypeCode;
                }
                break;
            case JBC_i2l:
                S.pop();
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_i2f:
                S.pop();
                S.push(FloatTypeCode);
                break;
            case JBC_i2d:
                S.pop();
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_l2i:
                S.pop(2);
                S.push(IntTypeCode);
                break;
            case JBC_l2f:
                S.pop(2);
                S.push(FloatTypeCode);
                break;
            case JBC_l2d:
                S.pop(2);
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_f2i:
                S.pop();
                S.push(IntTypeCode);
                break;
            case JBC_f2l:
                S.pop();
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_f2d:
                S.pop();
                S.push(VoidTypeCode);
                S.push(DoubleTypeCode);
                break;
            case JBC_d2i:
                S.pop(2);
                S.push(IntTypeCode);
                break;
            case JBC_d2l:
                S.pop(2);
                S.push(VoidTypeCode);
                S.push(LongTypeCode);
                break;
            case JBC_d2f:
                S.pop(2);
                S.push(FloatTypeCode);
                break;
            case JBC_int2byte:
            case JBC_int2char:
            case JBC_int2short:
                break;
            case JBC_lcmp:
                S.pop(4);
                S.push(IntTypeCode);
                break;
            case JBC_fcmpl:
            case JBC_fcmpg:
                S.pop(2);
                S.push(IntTypeCode);
                break;
            case JBC_dcmpl:
            case JBC_dcmpg:
                S.pop(4);
                S.push(IntTypeCode);
                break;
            case JBC_ifeq:
            case JBC_ifne:
            case JBC_iflt:
            case JBC_ifge:
            case JBC_ifgt:
            case JBC_ifle:
            case JBC_ifnull:
            case JBC_ifnonnull:
                {
                    S.pop();
                    // flowthrough first
                    int nextpc = pc + 3;
                    int target = pc + bytecodes.getBranchOffset();
                    if (doDFS) {
                        // make a copy of ltypes, stypes to pass in
                        byte[] newltypes = new byte[ltypes.length];
                        byte[] newstypes = new byte[stypes.length];
                        System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                        System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                        found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, nextpc, new TypeStack(S), null);
                        if (found) {
                            // copy back the ltypes and stypes
                            System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                            System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                            return true;
                        }
                    } else {
                        found = scanBlocks(method, bytecodes, false, -1, null, null, nextpc, new TypeStack(S), stackHeights);
                    }
                    bytecodes.reset(target);
                }
                break;
            case JBC_if_icmpeq:
            case JBC_if_icmpne:
            case JBC_if_icmplt:
            case JBC_if_icmpge:
            case JBC_if_icmpgt:
            case JBC_if_icmple:
            case JBC_if_acmpeq:
            case JBC_if_acmpne:
                {
                    S.pop(2);
                    // flowthrough first
                    int nextpc = pc + 3;
                    int target = pc + bytecodes.getBranchOffset();
                    if (doDFS) {
                        // make a copy of ltypes, stypes to pass in
                        byte[] newltypes = new byte[ltypes.length];
                        byte[] newstypes = new byte[stypes.length];
                        System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                        System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                        found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, nextpc, new TypeStack(S), null);
                        if (found) {
                            // copy back the ltypes and stypes
                            System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                            System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                            return true;
                        }
                    } else {
                        found = scanBlocks(method, bytecodes, false, -1, null, null, nextpc, new TypeStack(S), stackHeights);
                    }
                    bytecodes.reset(target);
                }
                break;
            case JBC_goto:
                {
                    int offset = bytecodes.getBranchOffset();
                    if (!ignoreGotos) {
                        bytecodes.reset(pc + offset);
                    }
                }
                break;
            case JBC_goto_w:
                {
                    int offset = bytecodes.getWideBranchOffset();
                    if (!ignoreGotos) {
                        bytecodes.reset(pc + offset);
                    }
                }
                break;
            case JBC_jsr:
            case JBC_jsr_w:
                {
                    // flow through firs
                    int nextpc = pc + ((bcode == JBC_jsr) ? 3 : 5);
                    int target = pc + ((bcode == JBC_jsr) ? bytecodes.getBranchOffset() : bytecodes.getWideBranchOffset());
                    if (doDFS) {
                        // make a copy of ltypes, stypes to pass in
                        byte[] newltypes = new byte[ltypes.length];
                        byte[] newstypes = new byte[stypes.length];
                        System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                        System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                        found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, nextpc, new TypeStack(S), null);
                        if (found) {
                            // copy back the ltypes and stypes
                            System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                            System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                            return true;
                        }
                    } else {
                        found = scanBlocks(method, bytecodes, false, -1, null, null, nextpc, new TypeStack(S), stackHeights);
                    }
                    // branch to jsr subroutine
                    // remember return address for ret.
                    addr = pc + ((bcode == JBC_jsr) ? 3 : 5);
                    S.push(ReturnAddressTypeCode);
                    bytecodes.reset(target);
                }
                break;
            case JBC_ret:
                {
                    // the OPT compiler set local to null after _ret instruction,
                    // then we should clean it here also, otherwise it will
                    // throw a null pointer exception.
                    // HOWEVER, it is not part of JVM spec.
                    int index = bytecodes.getLocalNumber();
                    if (doDFS)
                        ltypes[index] = VoidTypeCode;
                    /* the ret address may be saved by a PSEUDO_LoadRetAddrConstant
          */
                    if (retaddr[index] != -1) {
                        bytecodes.reset(retaddr[index]);
                        retaddr[index] = -1;
                    } else {
                        // now we hit ret, return out
                        return false;
                    }
                }
                break;
            case JBC_tableswitch:
                {
                    S.pop();
                    bytecodes.alignSwitch();
                    int defaultval = bytecodes.getDefaultSwitchOffset();
                    int low = bytecodes.getLowSwitchValue();
                    int high = bytecodes.getHighSwitchValue();
                    // write down a list of targets
                    int npairs = high - low + 1;
                    int[] offsets = new int[npairs];
                    for (int i = 0; i < npairs; i++) {
                        offsets[i] = bytecodes.getTableSwitchOffset(i);
                    }
                    for (int i = 0; i < npairs; i++) {
                        int tgtpc = pc + offsets[i];
                        if (doDFS) {
                            // make a copy of ltypes, stypes to pass in
                            byte[] newltypes = new byte[ltypes.length];
                            byte[] newstypes = new byte[stypes.length];
                            System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                            System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                            found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, tgtpc, new TypeStack(S), null);
                            if (found) {
                                // copy back the ltypes and stypes
                                System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                                System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                                return true;
                            }
                        } else {
                            found = scanBlocks(method, bytecodes, false, -1, null, null, tgtpc, new TypeStack(S), stackHeights);
                        }
                    }
                    // default
                    {
                        int tgtpc = pc + defaultval;
                        if (doDFS) {
                            // make a copy of ltypes, stypes to pass in
                            byte[] newltypes = new byte[ltypes.length];
                            byte[] newstypes = new byte[stypes.length];
                            System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                            System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                            found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, tgtpc, new TypeStack(S), null);
                            if (found) {
                                // copy back the ltypes and stypes
                                System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                                System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                            }
                        } else {
                            found = scanBlocks(method, bytecodes, false, -1, null, null, tgtpc, new TypeStack(S), stackHeights);
                        }
                        return found;
                    }
                }
            case JBC_lookupswitch:
                {
                    // pop the key
                    S.pop();
                    bytecodes.alignSwitch();
                    int defaultval = bytecodes.getDefaultSwitchOffset();
                    int npairs = bytecodes.getSwitchLength();
                    int[] matches = new int[npairs];
                    int[] offsets = new int[npairs];
                    for (int i = 0; i < npairs; i++) {
                        matches[i] = bytecodes.getLookupSwitchValue(i);
                        offsets[i] = bytecodes.getLookupSwitchOffset(i);
                    }
                    for (int i = 0; i < npairs; i++) {
                        // int match = matches[i];
                        int offset = offsets[i];
                        int tgtpc = pc + offset;
                        if (doDFS) {
                            // make a copy of ltypes, stypes to pass in
                            byte[] newltypes = new byte[ltypes.length];
                            byte[] newstypes = new byte[stypes.length];
                            System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                            System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                            found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, tgtpc, new TypeStack(S), null);
                            if (found) {
                                // copy back the ltypes and stypes
                                System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                                System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                                return true;
                            }
                        } else {
                            found = scanBlocks(method, bytecodes, false, -1, null, null, tgtpc, new TypeStack(S), stackHeights);
                        }
                    }
                    // default
                    {
                        int tgtpc = pc + defaultval;
                        if (doDFS) {
                            // make a copy of ltypes, stypes to pass in
                            byte[] newltypes = new byte[ltypes.length];
                            byte[] newstypes = new byte[stypes.length];
                            System.arraycopy(ltypes, 0, newltypes, 0, ltypes.length);
                            System.arraycopy(stypes, 0, newstypes, 0, stypes.length);
                            found = scanBlocks(method, bytecodes, true, pcs, newltypes, newstypes, tgtpc, new TypeStack(S), null);
                            if (found) {
                                // copy back the ltypes and stypes
                                System.arraycopy(newltypes, 0, ltypes, 0, ltypes.length);
                                System.arraycopy(newstypes, 0, stypes, 0, stypes.length);
                            }
                        } else {
                            found = scanBlocks(method, bytecodes, false, -1, null, null, tgtpc, new TypeStack(S), stackHeights);
                        }
                    }
                }
                return found;
            case JBC_ireturn:
                S.pop();
                return false;
            case JBC_lreturn:
                S.pop(2);
                return false;
            case JBC_freturn:
                S.pop();
                return false;
            case JBC_dreturn:
                S.pop(2);
                return false;
            case JBC_areturn:
                S.pop();
                return false;
            case JBC_return:
                return false;
            case JBC_getfield:
                S.pop();
            case JBC_getstatic:
                {
                    FieldReference fieldRef = bytecodes.getFieldReference();
                    TypeReference ftype = fieldRef.getFieldContentsType();
                    byte tcode = ftype.getName().parseForTypeCode();
                    if ((tcode == LongTypeCode) || (tcode == DoubleTypeCode)) {
                        S.push(VoidTypeCode);
                    }
                    S.push(tcode);
                }
                break;
            case JBC_putstatic:
                {
                    FieldReference fieldRef = bytecodes.getFieldReference();
                    TypeReference ftype = fieldRef.getFieldContentsType();
                    byte tcode = ftype.getName().parseForTypeCode();
                    if ((tcode == LongTypeCode) || (tcode == DoubleTypeCode)) {
                        S.pop(2);
                    } else {
                        S.pop();
                    }
                }
                break;
            case JBC_putfield:
                {
                    FieldReference fieldRef = bytecodes.getFieldReference();
                    TypeReference ftype = fieldRef.getFieldContentsType();
                    byte tcode = ftype.getName().parseForTypeCode();
                    if ((tcode == LongTypeCode) || (tcode == DoubleTypeCode)) {
                        S.pop(2);
                    } else {
                        S.pop();
                    }
                }
                S.pop();
                break;
            case JBC_invokevirtual:
            case JBC_invokespecial:
            case JBC_invokestatic:
            case JBC_invokeinterface:
                {
                    MethodReference callee = bytecodes.getMethodReference();
                    int psize = callee.getParameterWords();
                    S.pop(psize);
                    if (bcode != JBC_invokestatic) {
                        // pop the object reference
                        S.pop();
                    }
                    TypeReference rtype = callee.getReturnType();
                    byte tcode = rtype.getName().parseForTypeCode();
                    if (tcode == VoidTypeCode) {
                    // nothing to do with void return type
                    } else {
                        if ((tcode == LongTypeCode) || (tcode == DoubleTypeCode)) {
                            S.push(VoidTypeCode);
                        }
                        S.push(tcode);
                    }
                    if (bcode == JBC_invokeinterface) {
                        bytecodes.alignInvokeInterface();
                    }
                }
                break;
            case JBC_invokedynamic:
                break;
            case JBC_new:
                // skip cpi of type
                bytecodes.getTypeReference();
                S.push(ClassTypeCode);
                break;
            case JBC_newarray:
                S.pop();
                S.push(ArrayTypeCode);
                // skip cpi of element type
                bytecodes.getArrayElementType();
                break;
            case JBC_anewarray:
                S.pop();
                S.push(ArrayTypeCode);
                // skip cpi of reference type
                bytecodes.getTypeReference();
                break;
            case JBC_arraylength:
                S.pop();
                S.push(IntTypeCode);
                break;
            case JBC_athrow:
                S.clear();
                S.push(ClassTypeCode);
                return false;
            case JBC_checkcast:
                // skip cpi of reference type
                bytecodes.getTypeReference();
                break;
            case JBC_instanceof:
                S.pop();
                S.push(IntTypeCode);
                // skip cpi of reference type
                bytecodes.getTypeReference();
                break;
            case JBC_monitorenter:
            case JBC_monitorexit:
                S.pop();
                break;
            case JBC_wide:
                {
                    int widecode = bytecodes.getWideOpcode();
                    int index = bytecodes.getWideLocalNumber();
                    switch(widecode) {
                        case JBC_iload:
                            S.push(IntTypeCode);
                            break;
                        case JBC_lload:
                            S.push(LongTypeCode);
                            break;
                        case JBC_fload:
                            S.push(FloatTypeCode);
                            break;
                        case JBC_dload:
                            S.push(DoubleTypeCode);
                            break;
                        case JBC_aload:
                            S.push(ClassTypeCode);
                            break;
                        case JBC_istore:
                            S.pop();
                            if (doDFS)
                                ltypes[index] = IntTypeCode;
                            break;
                        case JBC_lstore:
                            S.pop();
                            if (doDFS)
                                ltypes[index] = LongTypeCode;
                            break;
                        case JBC_fstore:
                            S.pop();
                            if (doDFS)
                                ltypes[index] = FloatTypeCode;
                            break;
                        case JBC_dstore:
                            S.pop();
                            if (doDFS)
                                ltypes[index] = DoubleTypeCode;
                            break;
                        case JBC_astore:
                            {
                                byte tcode = S.pop();
                                if (doDFS)
                                    ltypes[index] = tcode;
                                // for ret address.
                                if (tcode == ReturnAddressTypeCode) {
                                    retaddr[index] = addr;
                                    addr = -1;
                                }
                            }
                            break;
                        case JBC_iinc:
                            {
                                // skip increment
                                bytecodes.getWideIncrement();
                                if (doDFS)
                                    ltypes[index] = IntTypeCode;
                            }
                            break;
                        case JBC_ret:
                            if (doDFS)
                                ltypes[index] = VoidTypeCode;
                            if (retaddr[index] != -1) {
                                bytecodes.reset(retaddr[index]);
                                retaddr[index] = -1;
                            } else {
                                // now we hit ret, return out
                                return false;
                            }
                            break;
                        default:
                            if (VM.VerifyAssertions)
                                VM._assert(VM.NOT_REACHED);
                            break;
                    }
                    break;
                }
            case JBC_multianewarray:
                {
                    // skip type reference
                    bytecodes.getTypeReference();
                    int dims = bytecodes.getArrayDimension();
                    S.pop(dims);
                    S.push(ArrayTypeCode);
                }
                break;
            case JBC_impdep1:
                {
                    int pseudo_opcode = bytecodes.nextPseudoInstruction();
                    switch(pseudo_opcode) {
                        case PSEUDO_LoadIntConst:
                            // skip value
                            bytecodes.readIntConst();
                            S.push(IntTypeCode);
                            break;
                        case PSEUDO_LoadLongConst:
                            // skip value
                            bytecodes.readLongConst();
                            S.push(VoidTypeCode);
                            S.push(LongTypeCode);
                            break;
                        case PSEUDO_LoadWordConst:
                            if (VM.BuildFor32Addr) {
                                bytecodes.readIntConst();
                            } else {
                                // skip value
                                bytecodes.readLongConst();
                            }
                            S.push(WordTypeCode);
                            break;
                        case PSEUDO_LoadFloatConst:
                            // skip value
                            bytecodes.readIntConst();
                            S.push(FloatTypeCode);
                            break;
                        case PSEUDO_LoadDoubleConst:
                            // skip value
                            bytecodes.readLongConst();
                            S.push(VoidTypeCode);
                            S.push(DoubleTypeCode);
                            break;
                        case PSEUDO_LoadRetAddrConst:
                            // remember the address for ret.
                            // get address
                            addr = bytecodes.readIntConst();
                            S.push(ReturnAddressTypeCode);
                            break;
                        case PSEUDO_InvokeStatic:
                            {
                                // get METHIDX
                                int mid = bytecodes.readIntConst();
                                RVMMethod callee = InvokeStatic.targetMethod(mid);
                                int psize = callee.getParameterWords();
                                S.pop(psize);
                                TypeReference rtype = callee.getReturnType();
                                byte tcode = rtype.getName().parseForTypeCode();
                                if (tcode == VoidTypeCode) {
                                // nothing to do with void return type
                                } else {
                                    if ((tcode == LongTypeCode) || (tcode == DoubleTypeCode)) {
                                        S.push(VoidTypeCode);
                                    }
                                    S.push(tcode);
                                }
                                break;
                            }
                        /*
        case PSEUDO_CheckCast:
          bytecodes.readIntConst(); // skip type id
          break;
*/
                        case PSEUDO_InvokeCompiledMethod:
                            // cmid
                            int cmid = bytecodes.readIntConst();
                            // skip bcindex
                            bytecodes.readIntConst();
                            RVMMethod callee = CompiledMethods.getCompiledMethod(cmid).getMethod();
                            int psize = callee.getParameterWords();
                            S.pop(psize);
                            if (!callee.isStatic()) {
                                // pop receiver
                                S.pop();
                            }
                            TypeReference rtype = callee.getReturnType();
                            byte tcode = rtype.getName().parseForTypeCode();
                            if (tcode == VoidTypeCode) {
                            // nothing to do with void return type
                            } else {
                                if ((tcode == LongTypeCode) || (tcode == DoubleTypeCode)) {
                                    S.push(VoidTypeCode);
                                }
                                S.push(tcode);
                            }
                            break;
                        case PSEUDO_ParamInitEnd:
                            break;
                        default:
                            if (VM.VerifyAssertions) {
                                VM.sysWriteln(" Error, no such pseudo code : " + pseudo_opcode);
                                VM._assert(VM.NOT_REACHED);
                            }
                            return false;
                    }
                    break;
                }
            default:
                VM.sysWriteln("Unknown bytecode : " + bcode);
                return false;
        }
    }
    /* did not found the PC. */
    return false;
}
Also used : RVMMethod(org.jikesrvm.classloader.RVMMethod) FieldReference(org.jikesrvm.classloader.FieldReference) MethodReference(org.jikesrvm.classloader.MethodReference) TypeReference(org.jikesrvm.classloader.TypeReference) RVMClass(org.jikesrvm.classloader.RVMClass)

Example 9 with FieldReference

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

the class SSADictionary method getFieldHelper.

/**
 * Record the effects of a getfield instruction on the heap array
 * SSA form.  Register the heap variables that this instruction uses and
 * defs.  Note that if inserting uphi functions, a getfield defs a new
 * heap variable name.
 *
 * @param s the getfield instruction
 * @param b the basic block containing s
 */
private void getFieldHelper(Instruction s, BasicBlock b) {
    LocationOperand locOp = GetField.getLocation(s);
    FieldReference field = locOp.getFieldRef();
    registerUse(s, field);
    if (uphi) {
        registerDef(s, b, field);
    }
}
Also used : LocationOperand(org.jikesrvm.compilers.opt.ir.operand.LocationOperand) FieldReference(org.jikesrvm.classloader.FieldReference)

Example 10 with FieldReference

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

the class SSADictionary method putFieldHelper.

/**
 * Record the effects of a putfield instruction on the heap array
 * SSA form.  Register the heap variables that this instruction uses and
 * defs.
 *
 * @param s the getfield instruction
 * @param b the basic block containing s
 */
private void putFieldHelper(Instruction s, BasicBlock b) {
    LocationOperand locOp = PutField.getLocation(s);
    FieldReference field = locOp.getFieldRef();
    registerUse(s, field);
    registerDef(s, b, field);
}
Also used : LocationOperand(org.jikesrvm.compilers.opt.ir.operand.LocationOperand) FieldReference(org.jikesrvm.classloader.FieldReference)

Aggregations

FieldReference (org.jikesrvm.classloader.FieldReference)10 TypeReference (org.jikesrvm.classloader.TypeReference)6 LocationOperand (org.jikesrvm.compilers.opt.ir.operand.LocationOperand)6 RVMClass (org.jikesrvm.classloader.RVMClass)4 RVMField (org.jikesrvm.classloader.RVMField)4 RVMMethod (org.jikesrvm.classloader.RVMMethod)4 Instruction (org.jikesrvm.compilers.opt.ir.Instruction)4 MethodReference (org.jikesrvm.classloader.MethodReference)3 RVMType (org.jikesrvm.classloader.RVMType)3 Operand (org.jikesrvm.compilers.opt.ir.operand.Operand)3 RegisterOperand (org.jikesrvm.compilers.opt.ir.operand.RegisterOperand)3 HashSet (java.util.HashSet)2 RVMArray (org.jikesrvm.classloader.RVMArray)2 CompiledMethod (org.jikesrvm.compilers.common.CompiledMethod)2 BasicBlock (org.jikesrvm.compilers.opt.ir.BasicBlock)2 Operator (org.jikesrvm.compilers.opt.ir.Operator)2 IntConstantOperand (org.jikesrvm.compilers.opt.ir.operand.IntConstantOperand)2 MethodOperand (org.jikesrvm.compilers.opt.ir.operand.MethodOperand)2 TypeOperand (org.jikesrvm.compilers.opt.ir.operand.TypeOperand)2 Enumeration (java.util.Enumeration)1