bytecodes.h

java 1.1 gemini 08_16

        if ((value & 0x7FFFFFFF) >= 0x5F000000) {
	        #if UPTODOWNSTACK
			oneMore;
	        #endif
            if ((value >= F_L_POS_NAN && value <= F_H_POS_NAN) ||
                (value >= F_L_NEG_NAN && value <= F_H_NEG_NAN)) {
                SET_LONG(sp, 0);   /* NaN */
            } else if (value > 0) {
                SET_LONG(sp, MAX_LONG);  /* +Infinity */
            } else if (value < 0) {
                SET_LONG(sp, MIN_LONG);  /* -Infinity */
            }
        } else {
        	float value = *(float*)sp;
	        #if UPTODOWNSTACK
			oneMore;
	        #endif
            SET_LONG(sp, float2ll(value));
        }
        #if !UPTODOWNSTACK
        oneMore;
        #endif
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(F2D)                              /* Convert float to double */
		#if UPTODOWNSTACK
		double value = (double)*(float*)sp;
        oneMore;
        SET_DOUBLE(sp, value);
		#else
        SET_DOUBLE(sp, (double)*(float*)sp);
        oneMore;
        #endif
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(D2I)                              /* Convert double to integer */

/*
 * 0x41E0000000000000L magic number for Float any number >= this number
 * will be a special case
 */
        long64 value;
		#if !UPTODOWNSTACK
        oneLess;
        #endif
        value = GET_LONG(sp);
        if ((value & 0x7FFFFFFFFFFFFFFFL) >= 0x41E0000000000000L) {
			#if UPTODOWNSTACK
	        oneLess;
	        #endif
            if ((value >= D_L_POS_NAN && value <= D_H_POS_NAN) ||
                (value >= D_L_NEG_NAN && value <= D_H_NEG_NAN)) {
                *(long*)sp = 0;   /* NaN */
            } else if (value > 0) {
                *(long*)sp = MAX_INT;  /* +Infinity */
            } else if (value < 0) {
                *(long*)sp = MIN_INT;  /* -Infinity */
            }
        } else {
        	double value = GET_DOUBLE(sp);;
			#if UPTODOWNSTACK
	        oneLess;
	        #endif
            *(long*)sp = (long)value;
        }
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(D2L)                              /* Convert double to long */

/*
 * 0x43E0000000000000L = (0x41E0000000000000L + 2e57) magic number
 * for Float any number >= this number will be a special case
 */
		#if UPTODOWNSTACK
        long64 value = GET_LONG(sp);
        if ((value & 0x7FFFFFFFFFFFFFFFL) >= 0x43E0000000000000L) {
            if ((value >= D_L_POS_NAN && value <= D_H_POS_NAN) ||
                (value >= D_L_NEG_NAN && value <= D_H_NEG_NAN)) {
                SET_LONG(sp , 0);   /* NaN */
            } else if (value > 0) {
                SET_LONG(sp, MAX_LONG);  /* +Infinity */
            } else if (value < 0) {
                SET_LONG(sp, MIN_LONG);  /* -Infinity */
            }
        } else {
            long64 value = double2ll(GET_DOUBLE(sp));
            SET_LONG(sp, value);
        }
		#else
        long64 value = GET_LONG(sp - 1);
        if ((value & 0x7FFFFFFFFFFFFFFFL) >= 0x43E0000000000000L) {
            if ((value >= D_L_POS_NAN && value <= D_H_POS_NAN) ||
                (value >= D_L_NEG_NAN && value <= D_H_NEG_NAN)) {
                SET_LONG(sp - 1, 0);   /* NaN */
            } else if (value > 0) {
                SET_LONG(sp - 1, MAX_LONG);  /* +Infinity */
            } else if (value < 0) {
                SET_LONG(sp - 1, MIN_LONG);  /* -Infinity */
            }
        } else {
            long64 value = double2ll(GET_DOUBLE(sp - 1));
            SET_LONG(sp - 1, value);
        }
        #endif
DONE(1)
#endif

/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(D2F)                              /* Convert double to float */
		#if UPTODOWNSTACK
		float value = (float)GET_DOUBLE(sp);
        oneLess;
        *(float*)sp = value;
		#else
        oneLess;
        *(float*)sp = (float)GET_DOUBLE(sp);
        #endif
DONE(1)
#endif

/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(I2B)             /* Convert integer to byte (with sign extension) */
        *(long*)sp = (signed char)*(long*)sp;
DONE(1)
#endif

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

#if STANDARDBYTECODES
SELECT(I2C)              /* Convert integer to UNICODE character */
        *(long*)sp = (unsigned short)*(long*)sp;
DONE(1)
#endif

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

#if STANDARDBYTECODES
SELECT(I2S)            /* Convert integer to short (with sign extension) */
        *(long*)sp = (short)*(long*)sp;
DONE(1)
#endif

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

#if STANDARDBYTECODES
SELECT(LCMP)                             /* Compare long */
        long result;
		#if COMPILER_SUPPORTS_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   /* UPTODOWNSTACK */
		result = lvalue < rvalue ? -1 : lvalue == rvalue ? 0 : 1;
		#else
			#if UPTODOWNSTACK
		long64 *rvalue = (long64*)(sp);
		long64 *lvalue = (long64*)(sp+2);
			#else
		long64 *rvalue = (long64*)(sp-1);
		long64 *lvalue = (long64*)(sp-3);
			#endif   /* UPTODOWNSTACK */

		signed long highLeft =  (signed long)(lvalue->high);
		signed long highRight = (signed long)(rvalue->high);
		if (highLeft == highRight) {
			unsigned long lowLeft =  (unsigned long)(lvalue->low);
			unsigned long lowRight = (unsigned long)(rvalue->low);
			result = (lowLeft < lowRight ? -1 : lowLeft > lowRight ? 1 : 0);
		} else {
			result = highLeft < highRight ? -1 : 1;
		}
		#endif
		lessStack(3);
		*(long *)sp = result;
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(FCMPL)                             /* Compare float */
        float rvalue = *(float*)sp;
		#if UPTODOWNSTACK
        float lvalue = *(float*)(sp + 1);
		#else
        float lvalue = *(float*)(sp-1);
        #endif
        oneLess;
#if PROCESSOR_ARCHITECTURE_X86
        /* On x86, we have to do some additional magic */
        /* to get correct strictfp results.            */
        JFP_lib_fcmpl_x86(lvalue, rvalue);
#else
        *(long*)sp = (lvalue >  rvalue) ?  1 :
                     (lvalue == rvalue) ?  0 : -1;
#endif
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(FCMPG)                             /* Compare float */
        float rvalue = *(float*)sp;
		#if UPTODOWNSTACK
        float lvalue = *(float*)(sp + 1);
		#else
        float lvalue = *(float*)(sp-1);
        #endif
        oneLess;
#if PROCESSOR_ARCHITECTURE_X86
        /* On x86, we have to do some additional magic */
        /* to get correct strictfp results.            */
        JFP_lib_fcmpg_x86(lvalue, rvalue);
#else
        *(long*)sp = (lvalue >  rvalue) ?  1 :
                     (lvalue == rvalue) ?  0 :
                     (lvalue <  rvalue) ? -1 : 1;
#endif
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(DCMPL)                             /* Compare double */
		#if UPTODOWNSTACK
        double rvalue = GET_DOUBLE(sp);
        double lvalue = GET_DOUBLE(sp+2);
		#else
        double rvalue = GET_DOUBLE(sp-1);
        double lvalue = GET_DOUBLE(sp-3);
        #endif
        lessStack(3);
#if PROCESSOR_ARCHITECTURE_X86
        /* On x86, we have to do some additional magic */
        /* to get correct strictfp results.            */
        JFP_lib_dcmpl_x86(lvalue, rvalue);
#else
        *(long*)sp = (lvalue >  rvalue) ?  1 :
                     (lvalue == rvalue) ?  0 : -1;
#endif
DONE(1)
#endif

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

#if FLOATBYTECODES
SELECT(DCMPG)                             /* Compare double */
		#if UPTODOWNSTACK
        double rvalue = GET_DOUBLE(sp);
        double lvalue = GET_DOUBLE(sp+2);
		#else
        double rvalue = GET_DOUBLE(sp-1);
        double lvalue = GET_DOUBLE(sp-3);
        #endif
        lessStack(3);
#if PROCESSOR_ARCHITECTURE_X86
        /* On x86, we have to do some additional magic */
        /* to get correct strictfp results.            */
        JFP_lib_dcmpg_x86(lvalue, rvalue);
#else
        *(long*)sp = (lvalue >  rvalue) ?  1 :
                     (lvalue == rvalue) ?  0 :
                     (lvalue <  rvalue) ? -1 : 1;
#endif
DONE(1)
#endif

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

#if STANDARDBYTECODES
SELECT(IFEQ)                             /* Branch if equal to zero */
        BRANCHIF( (popStack() == 0) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IFNE)                            /* Branch if different than zero */
        BRANCHIF( (popStack() != 0) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IFLT)                             /* Branch if less than zero */
        BRANCHIF( ((long)popStack() < 0) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IFGE)                       /* Branch if greater or equal to zero */
        BRANCHIF( ((long)popStack() >= 0) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IFGT)                             /* Branch if greater than zero */
        BRANCHIF( ((long)popStack() > 0) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IFLE)                          /* Branch if less or equal to zero */
        BRANCHIF( ((long)popStack() <= 0) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ICMPEQ)                        /* Branch if equal */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a == b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ICMPNE)                        /* Branch if not equal */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a != b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ICMPLT)                        /* Branch if less than */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a < b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ICMPGE)                        /* Branch if greater or equal */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a >= b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ICMPGT)                        /* Branch if greater */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a > b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ICMPLE)                        /* Branch if less or equal */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a <= b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ACMPEQ)                      /* Branch if references are equal */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a == b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(IF_ACMPNE)                  /* Branch if references are not equal */
        long b = popStack();
        long a = popStack();
        BRANCHIF( (a != b) )
DONEX
#endif

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

#if STANDARDBYTECODES
SELECT(GOTO)                       /* Branch if references are not equal */
        ip += getShort(ip + 1);
DONE_R
#endif
#endif /* !REPLACESTANDARDBYTECODE */
/* --------------------------------------------------------------------- */

#if STANDARDBYTECODES
NOTIMPLEMENTED(JSR)              /* Jump and stack return */
/***** JSR AND RET ARE NOT NEEDED IN KVM
SELECT(JSR)
        pushStackAsType(BYTE*, (ip + 3));
        ip += getShort(ip + 1);
DONE(0)
*****/
#endif

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

#i