interp.c

jam vm 最新Java虚拟机！为开源项目源代码

                                                           \
    DEF_OPC_2(OPC_IFNE,                                    \
              OPC_IFNONNULL, level,                        \
        IF_##level(!=);                                    \
    )                                                      \
                                                           \
    DEF_OPC_2(OPC_IFEQ,                                    \
              OPC_IFNULL, level,                           \
        IF_##level(==);                                    \
    )                                                      \
                                                           \
    DEF_OPC(OPC_IFLT, level,                               \
        IF_##level(<);                                     \
    )                                                      \
                                                           \
    DEF_OPC(OPC_IFGE, level,                               \
        IF_##level(>=);                                    \
    )                                                      \
                                                           \
    DEF_OPC(OPC_IFGT, level,                               \
        IF_##level(>);                                     \
    )                                                      \
                                                           \
    DEF_OPC(OPC_IFLE, level,                               \
        IF_##level(<=);                                    \
    )                                                      \
                                                           \
    DEF_OPC(OPC_IINC, level,                               \
        lvars[IINC_LVAR_IDX(pc)] += IINC_DELTA(pc);        \
        DISPATCH(level, 3);                                \
    )                                                      \
                                                           \
    DEF_OPC(OPC_POP, level,                                \
        POP1_##level;                                      \
    )                                                      \
                                                           \
    DEF_OPC(OPC_POP2, level,                               \
        ostack -= 2 - level;                               \
        DISPATCH(0, 1);                                    \
    )                                                      \
                                                           \
    DEF_OPC(OPC_DUP, level,                                \
        DUP_##level;                                       \
    )                                                      \
                                                           \
    DEF_OPC_3(OPC_IRETURN,                                 \
              OPC_ARETURN,                                 \
              OPC_FRETURN, level,                          \
        RETURN_##level;                                    \
    )                                                      \
                                                           \
    DEF_OPC(OPC_RETURN, level,                             \
        goto methodReturn;                                 \
    )                                                      \
                                                           \
    DEF_OPC(OPC_GETSTATIC_QUICK, level,                    \
        PUSH_##level(RESOLVED_FIELD(pc)->static_value, 3); \
    )                                                      \
                                                           \
    DEF_OPC(OPC_PUTSTATIC_QUICK, level,                    \
        POP_##level(RESOLVED_FIELD(pc)->static_value, 3);  \
    )                                                      \
                                                           \
    DEF_OPC(OPC_GETFIELD_THIS, level,                      \
        GETFIELD_THIS(level);                              \
    )                                                      \
                                                           \
    DEF_OPC(OPC_GETFIELD_QUICK, level,                     \
        GETFIELD_QUICK_##level;                            \
    )

#define ZERO_DIVISOR_CHECK_0                               \
    ZERO_DIVISOR_CHECK((int)ostack[-1]);

#define ZERO_DIVISOR_CHECK_1                               \
    ZERO_DIVISOR_CHECK((int)cache.i.v1);

#define ZERO_DIVISOR_CHECK_2                               \
    ZERO_DIVISOR_CHECK((int)cache.i.v2);

#ifdef USE_CACHE
#define PUSH_0(value, ins_len)                             \
    cache.i.v1 = value;                                    \
    DISPATCH(1, ins_len);
#else
#define PUSH_0(value, ins_len)                             \
    *ostack++ = value;                                     \
    DISPATCH(0, ins_len);
#endif

#define PUSH_1(value, ins_len)                             \
    cache.i.v2 = value;                                    \
    DISPATCH(2, ins_len);

#define PUSH_2(value, ins_len)                             \
    *ostack++ = cache.i.v1;                                \
    cache.i.v1 = cache.i.v2;                               \
    cache.i.v2 = value;                                    \
    DISPATCH(2, ins_len);

#define POP_0(dest, ins_len)                               \
    dest = *--ostack;                                      \
    DISPATCH(0, ins_len);

#define POP_1(dest, ins_len)                               \
    dest = cache.i.v1;                                     \
    DISPATCH(0, ins_len);

#define POP_2(dest, ins_len)                               \
    dest = cache.i.v2;                                     \
    DISPATCH(1, ins_len);

#define POP1_0                                             \
    ostack--;                                              \
    DISPATCH(0, 1);

#define POP1_1                                             \
    DISPATCH(0, 1);

#define POP1_2                                             \
    DISPATCH(1, 1);

#define DUP_0                                              \
    PUSH_0(ostack[-1], 1);

#define DUP_1                                              \
    PUSH_1(cache.i.v1, 1);

#define DUP_2                                              \
    PUSH_2(cache.i.v2, 1);

#define RETURN_0                                           \
    *lvars++ = *--ostack;                                  \
    goto methodReturn;

#define RETURN_1                                           \
    *lvars++ = cache.i.v1;                                 \
    goto methodReturn;

#define RETURN_2                                           \
    *lvars++ = cache.i.v2;                                 \
    goto methodReturn;

#define GETFIELD_QUICK_0                                   \
{                                                          \
    Object *obj = (Object *)*--ostack;                     \
    NULL_POINTER_CHECK(obj);                               \
    PUSH_0(INST_DATA(obj)[SINGLE_INDEX(pc)], 3);           \
}

#define GETFIELD_QUICK_1                                   \
{                                                          \
    Object *obj = (Object *)cache.i.v1;                    \
    NULL_POINTER_CHECK(obj);                               \
    PUSH_0(INST_DATA(obj)[SINGLE_INDEX(pc)], 3);           \
}

#define GETFIELD_QUICK_2                                   \
{                                                          \
    Object *obj = (Object *)cache.i.v2;                    \
    NULL_POINTER_CHECK(obj);                               \
    PUSH_1(INST_DATA(obj)[SINGLE_INDEX(pc)], 3);           \
}

#define UNARY_MINUS_0                                      \
{                                                          \
    int v = (int)*--ostack;                                \
    PUSH_0(-v, 1);                                         \
}

#define UNARY_MINUS_1                                      \
    PUSH_0(-(int)cache.i.v1, 1);

#define UNARY_MINUS_2                                      \
    PUSH_1(-(int)cache.i.v2, 1);

#define BINARY_OP_0(OP)                                    \
    ostack -= 2;                                           \
    PUSH_0((int)ostack[0] OP (int)ostack[1], 1);

#define BINARY_OP_1(OP)                                    \
    PUSH_0((int)*--ostack OP (int)cache.i.v1, 1);

#define BINARY_OP_2(OP)                                    \
    PUSH_0((int)cache.i.v1 OP (int)cache.i.v2, 1);

#define SHIFT_OP_0(TYPE, OP)                               \
    ostack -= 2;                                           \
    PUSH_0((TYPE)ostack[0] OP (ostack[1] & 0x1f), 1);

#define SHIFT_OP_1(TYPE, OP)                               \
    PUSH_0((TYPE)*--ostack OP (cache.i.v1 & 0x1f), 1);

#define SHIFT_OP_2(TYPE, OP)                               \
    PUSH_0((TYPE)cache.i.v1 OP (cache.i.v2 & 0x1f), 1);

#define IF_ICMP_0(COND)                                    \
    ostack -= 2;                                           \
    BRANCH((int)ostack[0] COND (int)ostack[1]);

#define IF_ICMP_1(COND)                                    \
    BRANCH((int)*--ostack COND (int)cache.i.v1);

#define IF_ICMP_2(COND)                                    \
    BRANCH((int)cache.i.v1 COND (int)cache.i.v2);

#define IF_0(COND)                                         \
    BRANCH((int)*--ostack COND 0);

#define IF_1(COND)                                         \
    BRANCH((int)cache.i.v1 COND 0);

#define IF_2(COND)                                         \
    *ostack++ = cache.i.v1;                                \
    BRANCH((int)cache.i.v2 COND 0);

#ifdef DIRECT
#define ALOAD_THIS(level)

#define GETFIELD_THIS(level)                               \
    PUSH_##level(INST_DATA(this)[pc->operand.i], 4);
#else /* DIRECT */
#define ALOAD_THIS(level)                                  \
    if(pc[1] == OPC_GETFIELD_QUICK) {                      \
        OPCODE_REWRITE(OPC_GETFIELD_THIS);                 \
        DISPATCH(level, 0);                                \
    }

#define GETFIELD_THIS(level)                               \
    PUSH_##level(INST_DATA(this)[pc[2]], 4);
#endif /* DIRECT */

    MULTI_LEVEL_OPCODES(0);

#ifdef USE_CACHE
    MULTI_LEVEL_OPCODES(1);
    MULTI_LEVEL_OPCODES(2);
#endif

    DEF_OPC_210(OPC_NOP,
        DISPATCH(0, 1);
    )

#ifdef USE_CACHE
#define PUSH_LONG(value, ins_len) \
    cache.l = value;              \
    DISPATCH(2, ins_len);
#else
#define PUSH_LONG(value, ins_len) \
    *(u8*)ostack = value;         \
    ostack += 2;                  \
    DISPATCH(0, ins_len);
#endif
    
    DEF_OPC_210_2(
            OPC_LCONST_0,
            OPC_DCONST_0,
        PUSH_LONG(0, 1);
    )

    DEF_OPC_210(OPC_DCONST_1,
        PUSH_LONG(DOUBLE_1_BITS, 1);
    )

    DEF_OPC_210(OPC_LCONST_1,
        PUSH_LONG(1, 1);
    )

    DEF_OPC_210(OPC_LDC2_W,
        PUSH_LONG(CP_LONG(cp, DOUBLE_INDEX(pc)), 3);
    )

    DEF_OPC_210_2(
            OPC_LLOAD,
            OPC_DLOAD,
        PUSH_LONG(*(u8*)(&lvars[SINGLE_INDEX(pc)]), 2);
    )

    DEF_OPC_210_2(
            OPC_LLOAD_0,
            OPC_DLOAD_0,
        PUSH_LONG(*(u8*)(&lvars[0]), 1);
    )

    DEF_OPC_210_2(
            OPC_LLOAD_1,
            OPC_DLOAD_1,
        PUSH_LONG(*(u8*)(&lvars[1]), 1);
    )

    DEF_OPC_210_2(
            OPC_LLOAD_2,
            OPC_DLOAD_2,
        PUSH_LONG(*(u8*)(&lvars[2]), 1);
    )

    DEF_OPC_210_2(
            OPC_LLOAD_3,
            OPC_DLOAD_3,
        PUSH_LONG(*(u8*)(&lvars[3]), 1);
    )

#ifdef USE_CACHE
#define POP_LONG(dest, ins_len) \
    dest = cache.l;             \
    DISPATCH(0, ins_len);
#else
#define POP_LONG(dest, ins_len) \
    ostack -= 2;                \
    dest = *(u8*)ostack;        \
    DISPATCH(0, ins_len);
#endif

    DEF_OPC_012_2(
            OPC_LSTORE,
            OPC_DSTORE,
        POP_LONG(*(u8*)(&lvars[SINGLE_INDEX(pc)]), 2);
    )

    DEF_OPC_012_2(
            OPC_LSTORE_0,
            OPC_DSTORE_0,
        POP_LONG(*(u8*)(&lvars[0]), 1);
    )

    DEF_OPC_012_2(
            OPC_LSTORE_1,
            OPC_DSTORE_1,
        POP_LONG(*(u8*)(&lvars[1]), 1);
    )

    DEF_OPC_012_2(
            OPC_LSTORE_2,
            OPC_DSTORE_2,
        POP_LONG(*(u8*)(&lvars[2]), 1);
    )

    DEF_OPC_012_2(
            OPC_LSTORE_3,
            OPC_DSTORE_3,
        POP_LONG(*(u8*)(&lvars[3]), 1);
    )

#ifdef USE_CACHE
#define ARRAY_LOAD_IDX cache.i.v2
#define ARRAY_LOAD_ARY cache.i.v1
#else
#define ARRAY_LOAD_IDX *--ostack
#define ARRAY_LOAD_ARY *--ostack
#endif

#define ARRAY_LOAD(TYPE)                              \
{                                                     \
    int idx = ARRAY_LOAD_IDX;                         \
    Object *array = (Object *)ARRAY_LOAD_ARY;         \
                                                      \
    NULL_POINTER_CHECK(array);                        \
    ARRAY_BOUNDS_CHECK(array, idx);                   \
    PUSH_0(((TYPE *)ARRAY_DATA(array))[idx], 1);      \
}

    DEF_OPC_012_2(
            OPC_IALOAD,
            OPC_FALOAD,
        ARRAY_LOAD(int)
    )

    DEF_OPC_012(OPC_AALOAD,
        ARRAY_LOAD(uintptr_t)
    )

    DEF_OPC_012(OPC_BALOAD,
        ARRAY_LOAD(signed char)
    )

    DEF_OPC_012(OPC_CALOAD,
        ARRAY_LOAD(unsigned short)
    )

    DEF_OPC_012(OPC_SALOAD,
        ARRAY_LOAD(short)
    )

    DEF_OPC_012(OPC_LALOAD, {
        int idx = ARRAY_LOAD_IDX;
        Object *array = (Object *)ARRAY_LOAD_ARY;

        NULL_POINTER_CHECK(array);
        ARRAY_BOUNDS_CHECK(array, idx);
        PUSH_LONG(((u8 *)ARRAY_DATA(array))[idx], 1);
    })

    DEF_OPC_012(OPC_DALOAD, {
        int idx = ARRAY_LOAD_IDX;
        Object *array = (Object *)ARRAY_LOAD_ARY;

        NULL_POINTER_CHECK(array);