bytecodes.h

java 1.1 gemini 08_16

#if FLOATBYTECODES
SELECT(DASTORE)          /* Store into double array */
        cell  hiValue   = popStack();
        cell  loValue   = popStack();
        long  index     = popStack();
        ARRAY thisArray = popStackAsType(ARRAY);
        CHECKARRAY(thisArray, index);
            thisArray->data[index * 2].cell = loValue;
            thisArray->data[index * 2 + 1].cell = hiValue;
        ENDCHECKARRAY
DONE(1)
#endif
#endif /* !REPLACESTANDARDBYTECODE */

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(AASTORE)          /* Store into object array */
        /* We cannot pop these off the stack, since a GC might happen
         * before we perform the assignment */
        OBJECT    value = topStackAsType(OBJECT);
        long      index = secondStack;
        ARRAY     thisArray = thirdStackAsType(ARRAY);
        int res;
        CLASS targetClass;
        CHECKARRAY(thisArray, index);
            targetClass = thisArray->ofClass->u.elemClass;
            if (value == NULL ||
                   isAssignableToFast(value->ofClass, targetClass)) {
                res = TRUE;
            } else {
                VMSAVE
                    /* This may cause a GC */
                    res = isAssignableTo(value->ofClass, targetClass);
                VMRESTORE
                /* GC may have occurred, need to update volatile args */
                value = topStackAsType(OBJECT);
                thisArray = thirdStackAsType(ARRAY);
            }
            lessStack(3);
            if (res) {
                thisArray->data[index].cellp = (cell*)value;
            } else {
                goto handleArrayStoreException;
            }
        ENDCHECKARRAY
DONE(1)
#endif

/* --------------------------------------------------------------------- */
#if !REPLACESTANDARDBYTECODE
#if STANDARDBYTECODES
SELECT(BASTORE)          /* Store into byte array */
        long value = popStack();
        long index = popStack();
        BYTEARRAY thisArray = popStackAsType(BYTEARRAY);
        CHECKARRAY(thisArray, index);
            thisArray->bdata[index] = (char)value;
        ENDCHECKARRAY
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(CASTORE)          /* Store into UNICODE character (16-bit) array */
        long value = popStack();
        long index = popStack();
        SHORTARRAY thisArray = popStackAsType(SHORTARRAY);
        CHECKARRAY(thisArray, index);
            thisArray->sdata[index] = (short)value;
        ENDCHECKARRAY
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(SASTORE)          /* Store into short array */
        long value = popStack();
        long index = popStack();
        SHORTARRAY thisArray = popStackAsType(SHORTARRAY);
        CHECKARRAY(thisArray, index);
            thisArray->sdata[index] = (short)value;
        ENDCHECKARRAY
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(POP)              /* Pop top operand stack word */
        oneLess;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(POP2)             /* Pop two top operand stack words */
        lessStack(2);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(DUP)              /* Duplicate top operand stack word */
        long temp = topStack;
        pushStack(temp);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(DUP_X1)     /* Duplicate top operand stack word and put two down  */
        long a = topStack;
        long b = secondStack;
        secondStack = a;
        topStack    = b;
        pushStack(a);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(DUP_X2)    /* Duplicate top operand stack word and put three down */
        long a = topStack;
        long b = secondStack;
        long c = thirdStack;
        thirdStack  = a;
        secondStack = c;
        topStack    = b;
        pushStack(a);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(DUP2)             /* Duplicate top two operand stack words */
        long a = topStack;
        long b = secondStack;
        pushStack(b);
        pushStack(a);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(DUP2_X1)  /* Duplicate top two operand stack words and put three down */
        long a = topStack;
        long b = secondStack;
        long c = thirdStack;
        thirdStack  = b;
        secondStack = a;
        topStack    = c;
        pushStack(b);
        pushStack(a);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(DUP2_X2)  /* Duplicate top two operand stack words and put four down */
        long a = topStack;
        long b = secondStack;
        long c = thirdStack;
        long d = fourthStack;
        fourthStack = b;
        thirdStack  = a;
        secondStack = d;
        topStack    = c;
        pushStack(b);
        pushStack(a);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(SWAP)             /* Swap top two operand stack words */
        long a = topStack;
        long b = secondStack;
        topStack    = b;
        secondStack = a;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(IADD)                             /* Add integer */
        long temp = popStack();
        *(long*)sp += temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(LADD)                             /* Add long */
		#if UPTODOWNSTACK
		long64 lvalue = GET_LONG(sp + 2);
		long64 rvalue = GET_LONG(sp);
		ll_inc(lvalue, rvalue);
		SET_LONG(sp + 2, lvalue);
		#else
		long64 lvalue = GET_LONG(sp - 3);
		long64 rvalue = GET_LONG(sp - 1);
		ll_inc(lvalue, rvalue);
		SET_LONG(sp - 3, lvalue);
		#endif   /* UPTODOWNSTACK */
        lessStack(2);
DONE(1)
#endif
/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(FADD)                             /* Add float */
		#if UPTODOWNSTACK
        float temp = *(float*)sp++;
		#else
        float temp = *(float*)sp--;
        #endif
        *(float*)sp += temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(DADD)                             /* Add double */
		#if UPTODOWNSTACK
        double rvalue = GET_DOUBLE(sp);
        double lvalue = GET_DOUBLE(sp + 2);
        SET_DOUBLE(sp + 2, lvalue + rvalue);
		#else
        double rvalue = GET_DOUBLE(sp-1);
        double lvalue = GET_DOUBLE(sp-3);
        SET_DOUBLE(sp - 3, lvalue + rvalue);
        #endif
        lessStack(2);
DONE(1)
#endif

/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(ISUB)                             /* Sub integer */
        long temp = popStack();
        *(long*)sp -= temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(LSUB)                             /* Sub long */
		#if UPTODOWNSTACK
		long64 lvalue = GET_LONG(sp + 2);
		long64 rvalue = GET_LONG(sp);
		ll_dec(lvalue, rvalue);
		SET_LONG(sp + 2, lvalue);
		#else
		long64 lvalue = GET_LONG(sp - 3);
		long64 rvalue = GET_LONG(sp - 1);
		ll_dec(lvalue, rvalue);
		SET_LONG(sp - 3, lvalue);
		#endif   /* UPTODOWNSTACK */
        lessStack(2);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(FSUB)                             /* Sub float */
		#if UPTODOWNSTACK
        float temp = *(float*)sp++;
		#else
        float temp = *(float*)sp--;
        #endif
        *(float*)sp -= temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(DSUB)                             /* Sub double */
		#if UPTODOWNSTACK
        double rvalue = GET_DOUBLE(sp);
        double lvalue = GET_DOUBLE(sp + 2);
        SET_DOUBLE(sp + 2, lvalue - rvalue);
        #else
        double rvalue = GET_DOUBLE(sp-1);
        double lvalue = GET_DOUBLE(sp-3);
        SET_DOUBLE(sp-3, lvalue - rvalue);
        #endif
        lessStack(2);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(IMUL)                             /* Mul integer */
        long temp = popStack();
        *(long*)sp *= temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(LMUL)                             /* Mul long */
		#if UPTODOWNSTACK
		long64 lvalue = GET_LONG(sp + 2);
		long64 rvalue = GET_LONG(sp);
		SET_LONG(sp + 2, ll_mul(lvalue, rvalue));
		#else
		long64 rvalue = GET_LONG(sp - 1);
		long64 lvalue = GET_LONG(sp - 3);
		SET_LONG(sp - 3, ll_mul(lvalue, rvalue));
		#endif   /* UPTODOWNSTACK */
        lessStack(2);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(FMUL)                             /* Mul float */
		#if UPTODOWNSTACK
        float temp = *(float*)sp++;
		#else
        float temp = *(float*)sp--;
        #endif
        *(float*)sp *= temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(DMUL)                             /* Mul double */
		#if UPTODOWNSTACK
        double rvalue = GET_DOUBLE(sp);
        double lvalue = GET_DOUBLE(sp + 2);
#if PROCESSOR_ARCHITECTURE_X86
        /* On x86, we have to do some additional magic */
        /* to get correct strictfp results.            */
        JFP_lib_dmul_x86(lvalue, rvalue);
#else
        SET_DOUBLE(sp + 2, lvalue * rvalue);
#endif
		#else
        double rvalue = GET_DOUBLE(sp-1);
        double lvalue = GET_DOUBLE(sp-3);

#if PROCESSOR_ARCHITECTURE_X86
        /* On x86, we have to do some additional magic */
        /* to get correct strictfp results.            */
        JFP_lib_dmul_x86(lvalue, rvalue);
#else
        SET_DOUBLE(sp - 3, lvalue * rvalue);
#endif
		#endif
        lessStack(2);
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(IDIV)                             /* Div integer */
        long rValue = popStack();
        long lValue = topStack;
        if (rValue == 0) {
            goto handleArithmeticException;
        } else if (lValue == 0x80000000 && rValue == -1) {
            topStack = lValue;
        } else {
            topStack = lValue / rValue;
        }
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
SELECT(LDIV)                             /* Div long */
		#if UPTODOWNSTACK
        long64 rvalue = GET_LONG(sp);
        long64 lvalue = GET_LONG(sp + 2);
		#else
        long64 rvalue = GET_LONG(sp - 1);
        long64 lvalue = GET_LONG(sp - 3);
        #endif
        if (ll_zero_eq(rvalue)) {
            goto handleArithmeticException;
        } else {
		#if UPTODOWNSTACK
            SET_LONG(sp + 2, ll_div(lvalue, rvalue));
		#else
            SET_LONG(sp - 3, ll_div(lvalue, rvalue));
		#endif
            lessStack(2);
        }
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(FDIV)                             /* Div float */
		#if UPTODOWNSTACK
        float temp = *(float*)sp++;
		#else
        float temp = *(float*)sp--;
        #endif
        *(float*)sp /= temp;
DONE(1)
#endif

/* --------------------------------------------------------------------- */

#if FLOATBYTECODES
SELECT(DDIV)                             /* Div double */
		#if UPTODOWNSTACK
        double rvalue = GET_DOUBLE(sp);
        double lvalue = GET_DOUBLE(sp + 2);
		#else
        double rvalue = GET_DOUBLE(sp-1);