interp.c

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

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

#ifdef USE_CACHE
#define ARRAY_STORE_VAL cache.i.v2
#define ARRAY_STORE_IDX cache.i.v1
#else
#define ARRAY_STORE_VAL *--ostack
#define ARRAY_STORE_IDX *--ostack
#endif

#define ARRAY_STORE(TYPE)                         \
{                                                 \
    int val = ARRAY_STORE_VAL;                    \
    int idx = ARRAY_STORE_IDX;                    \
    Object *array = (Object *)*--ostack;          \
                                                  \
    NULL_POINTER_CHECK(array);                    \
    ARRAY_BOUNDS_CHECK(array, idx);               \
    ((TYPE *)ARRAY_DATA(array))[idx] = val;       \
    DISPATCH(0, 1);                               \
}

    DEF_OPC_012_2(
            OPC_IASTORE,
            OPC_FASTORE,
        ARRAY_STORE(int)
    )

    DEF_OPC_012(OPC_BASTORE,
        ARRAY_STORE(char);
    )

    DEF_OPC_012_2(
            OPC_CASTORE,
            OPC_SASTORE,
        ARRAY_STORE(short);
    )

    DEF_OPC_012(OPC_AASTORE, { 
        Object *obj = (Object*)ARRAY_STORE_VAL;
        int idx = ARRAY_STORE_IDX;
        Object *array = (Object *)*--ostack;

        NULL_POINTER_CHECK(array);
        ARRAY_BOUNDS_CHECK(array, idx);

        if((obj != NULL) && !arrayStoreCheck(array->class, obj->class))
            THROW_EXCEPTION("java/lang/ArrayStoreException", NULL);

        ((Object**)ARRAY_DATA(array))[idx] = obj;
        DISPATCH(0, 1);
    })

#ifdef USE_CACHE
    DEF_OPC_012_2(
            OPC_LASTORE,
            OPC_DASTORE, {
        int idx = ostack[-1];
        Object *array = (Object *)ostack[-2];

        ostack -= 2;
        NULL_POINTER_CHECK(array);
        ARRAY_BOUNDS_CHECK(array, idx);

        ((u8 *)ARRAY_DATA(array))[idx] = cache.l;
        DISPATCH(0, 1);
    })
#else
    DEF_OPC_012_2(
            OPC_LASTORE,
            OPC_DASTORE, {
        int idx = ostack[-3];
        Object *array = (Object *)ostack[-4];

        ostack -= 4;
        NULL_POINTER_CHECK(array);
        ARRAY_BOUNDS_CHECK(array, idx);

        ((u8 *)ARRAY_DATA(array))[idx] = *(u8*)&ostack[2];
        DISPATCH(0, 1);
    })
#endif

#ifdef USE_CACHE
    DEF_OPC_012(OPC_DUP_X1, {
        *ostack++ = cache.i.v2;
        DISPATCH(2, 1);
    })

    DEF_OPC_012(OPC_DUP_X2, {
        *ostack++ = ostack[-1];
        ostack[-2] = cache.i.v2;
        DISPATCH(2, 1);
    })

    DEF_OPC_012(OPC_DUP2, {
        *ostack++ = cache.i.v1;
        *ostack++ = cache.i.v2;
        DISPATCH(2, 1);
    })

    DEF_OPC_012(OPC_DUP2_X1, {
        ostack[0]  = cache.i.v2;
        ostack[1]  = ostack[-1];
        ostack[-1] = cache.i.v1;
        ostack += 2;
        DISPATCH(2, 1);
    })

    DEF_OPC_012(OPC_DUP2_X2,
        ostack[0] = ostack[-2];
        ostack[1] = ostack[-1];
        ostack[-2] = cache.i.v1;
        ostack[-1] = cache.i.v2;
        ostack += 2;
        DISPATCH(2, 1);
    )

    DEF_OPC_012(OPC_SWAP, {
        uintptr_t word1 = cache.i.v1;
        cache.i.v1 = cache.i.v2;
        cache.i.v2 = word1;
        DISPATCH(2, 1);
    })
#else /* USE_CACHE */
    DEF_OPC_012(OPC_DUP_X1, {
        uintptr_t word1 = ostack[-1];
        uintptr_t word2 = ostack[-2];
        ostack[-2] = word1;
        ostack[-1] = word2;
        *ostack++ = word1;
        DISPATCH(0, 1);
    })

    DEF_OPC_012(OPC_DUP_X2, {
        uintptr_t word1 = ostack[-1];
        uintptr_t word2 = ostack[-2];
        uintptr_t word3 = ostack[-3];
        ostack[-3] = word1;
        ostack[-2] = word3;
        ostack[-1] = word2;
        *ostack++ = word1;
        DISPATCH(0, 1);
    })

    DEF_OPC_012(OPC_DUP2, {
        ostack[0] = ostack[-2];
        ostack[1] = ostack[-1];
        ostack += 2;
        DISPATCH(0, 1);
    })

    DEF_OPC_012(OPC_DUP2_X1, {
        uintptr_t word1 = ostack[-1];
        uintptr_t word2 = ostack[-2];
        uintptr_t word3 = ostack[-3];
        ostack[-3] = word2;
        ostack[-2] = word1;
        ostack[-1] = word3;
        ostack[0]  = word2;
        ostack[1]  = word1;
        ostack += 2;
        DISPATCH(0, 1);
    })

    DEF_OPC_012(OPC_DUP2_X2, {
        uintptr_t word1 = ostack[-1];
        uintptr_t word2 = ostack[-2];
        uintptr_t word3 = ostack[-3];
        uintptr_t word4 = ostack[-4];
        ostack[-4] = word2;
        ostack[-3] = word1;
        ostack[-2] = word4;
        ostack[-1] = word3;
        ostack[0]  = word2;
        ostack[1]  = word1;
        ostack += 2;
        DISPATCH(0, 1);
    })

    DEF_OPC_012(OPC_SWAP, {
        uintptr_t word1 = ostack[-1];
        ostack[-1] = ostack[-2];
        ostack[-2] = word1;
        DISPATCH(0, 1)
    })
#endif /* USE_CACHE */

#define BINARY_OP_fp(TYPE, OP)                  \
    *(TYPE *)&ostack[-sizeof(TYPE)/4 * 2] =     \
        *(TYPE *)&ostack[-sizeof(TYPE)/4 * 2] OP\
        *(TYPE *)&ostack[-sizeof(TYPE)/4];      \
    ostack -= sizeof(TYPE)/4;                   \
    DISPATCH(0, 1);

    DEF_OPC_210(OPC_FADD,
        BINARY_OP_fp(float, +);
    )

    DEF_OPC_210(OPC_DADD,
        BINARY_OP_fp(double, +);
    )

    DEF_OPC_210(OPC_FSUB,
        BINARY_OP_fp(float, -);
    )

    DEF_OPC_210(OPC_DSUB,
        BINARY_OP_fp(double, -);
    )

    DEF_OPC_210(OPC_FMUL,
        BINARY_OP_fp(float, *);
    )

    DEF_OPC_210(OPC_DMUL,
        BINARY_OP_fp(double, *);
    )

    DEF_OPC_210(OPC_FDIV,
        BINARY_OP_fp(float, /);
    )

    DEF_OPC_210(OPC_DDIV,
        BINARY_OP_fp(double, /);
    )

#ifdef USE_CACHE
#define BINARY_OP_long(OP)                               \
    cache.l = *(long long*)&ostack[-2] OP cache.l;       \
    ostack -= 2;                                         \
    DISPATCH(2, 1);

#define ZERO_DIVISOR_CHECK_long                          \
    ZERO_DIVISOR_CHECK(cache.l);
#else
#define BINARY_OP_long(OP)                               \
    BINARY_OP_fp(long long, OP)

#define ZERO_DIVISOR_CHECK_long                          \
    ZERO_DIVISOR_CHECK(*(u8*)&ostack[-2]);
#endif

    DEF_OPC_012(OPC_LADD,
        BINARY_OP_long(+);
    )

    DEF_OPC_012(OPC_LSUB,
        BINARY_OP_long(-);
    )

    DEF_OPC_012(OPC_LMUL,
        BINARY_OP_long(*);
    )

    DEF_OPC_012(OPC_LDIV,
        ZERO_DIVISOR_CHECK_long;
        BINARY_OP_long(/);
    )

    DEF_OPC_012(OPC_LREM,
        ZERO_DIVISOR_CHECK_long;
        BINARY_OP_long(%);
    )

    DEF_OPC_012(OPC_LAND,
        BINARY_OP_long(&);
    )

    DEF_OPC_012(OPC_LOR,
        BINARY_OP_long(|);
    )

    DEF_OPC_012(OPC_LXOR,
        BINARY_OP_long(^);
    )

#ifdef USE_CACHE
#define SHIFT_OP_long(TYPE, OP)       \
{                                     \
    int shift = cache.i.v2 & 0x3f;    \
    cache.i.v2 = cache.i.v1;          \
    cache.i.v1 = *--ostack;           \
    cache.l = (TYPE)cache.l OP shift; \
    DISPATCH(2, 1);                   \
}
#else
#define SHIFT_OP_long(TYPE, OP)       \
{                                     \
    int shift = *--ostack & 0x3f;     \
    *(TYPE*)&ostack[-2] =             \
        *(TYPE*)&ostack[-2] OP shift; \
    DISPATCH(0, 1);                   \
}
#endif

    DEF_OPC_012(OPC_LSHL,
        SHIFT_OP_long(long long, <<);
    )

    DEF_OPC_012(OPC_LSHR,
        SHIFT_OP_long(long long, >>);
    )

    DEF_OPC_012(OPC_LUSHR,
        SHIFT_OP_long(unsigned long long, >>);
    )

    DEF_OPC_210(OPC_FREM, {
        float v2 = *(float *)&ostack[-1];
        float v1 = *(float *)&ostack[-2];

        *(float *)&ostack[-2] = fmod(v1, v2);
        ostack -= 1;
        DISPATCH(0, 1);
    })

    DEF_OPC_210(OPC_DREM, {
        double v2 = *(double *)&ostack[-2];
        double v1 = *(double *)&ostack[-4];

        *(double *)&ostack[-4] = fmod(v1, v2);
        ostack -= 2;
        DISPATCH(0, 1);
    })

#define UNARY_MINUS(TYPE)                    \
    *(TYPE*)&ostack[-sizeof(TYPE)/4] =       \
          -*(TYPE*)&ostack[-sizeof(TYPE)/4]; \
    DISPATCH(0, 1);

    DEF_OPC_210(OPC_LNEG,
        UNARY_MINUS(long long);
    )

    DEF_OPC_210(OPC_FNEG,
        UNARY_MINUS(float);
    )

    DEF_OPC_210(OPC_DNEG,
        UNARY_MINUS(double);
    )

    DEF_OPC_210(OPC_I2L, {
        ostack -= 1;
        PUSH_LONG((int)*ostack, 1);
    })

    DEF_OPC_012(OPC_L2I, {
       long long l;
#ifdef USE_CACHE
        l = cache.l;
#else
        ostack -= 2;
        l = *(long long*)ostack;
#endif
        PUSH_0((int)l, 1);
    })

#define OPC_int2fp(DEST_TYPE)            \
    ostack -= 1;                         \
    *(DEST_TYPE *)ostack =               \
              (DEST_TYPE)(int)*ostack;   \
    ostack += sizeof(DEST_TYPE)/4;       \
    DISPATCH(0, 1);

    DEF_OPC_210(OPC_I2F,
        OPC_int2fp(float);
    )

    DEF_OPC_210(OPC_I2D,
        OPC_int2fp(double);
    )

#define OPC_X2Y(SRC_TYPE, DEST_TYPE)     \
{                                        \
    SRC_TYPE v;                          \
    ostack -= sizeof(SRC_TYPE)/4;        \
    v = *(SRC_TYPE *)ostack;             \
    *(DEST_TYPE *)ostack = (DEST_TYPE)v; \
    ostack += sizeof(DEST_TYPE)/4;       \
    DISPATCH(0, 1);                      \
}

    DEF_OPC_210(OPC_L2F,
        OPC_X2Y(long long, float);
    )

    DEF_OPC_210(OPC_L2D,
        OPC_X2Y(long long, double);
    )

    DEF_OPC_210(OPC_F2D,
        OPC_X2Y(float, double);
    )