executejava_aligned.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 1,990 行 · 第 1/5 页

	CASE(opc_swap, 1) {     /* swap top two elements on the stack */
	    CVMJavaVal32 j = STACK_INFO(-1);
	    STACK_INFO(-1) = STACK_INFO(-2);
	    STACK_INFO(-2) = j;
	    TRACE(("\tswap\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);
	}

	/* binary numeric opcodes */

#undef  OPC_INT_BINARY 
#define OPC_INT_BINARY(opname, test)					   \
	    if (test && (STACK_INT(-1) == 0)) {				   \
                goto arithmetic_exception_divide_by_zero;	   	   \
	    }								   \
            STACK_INT(-2) =						   \
		CVMint##opname(STACK_INT(-2), STACK_INT(-1));		   \
	    TRACE(("\t%s => %d\n", CVMopnames[pc[0]], STACK_INT(-2)));	   \
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

#undef  OPC_LONG_BINARY
#define OPC_LONG_BINARY(opname, test)					   \
	{								   \
	    CVMJavaLong l1, l2, r1;					   \
	    l2 = CVMjvm2Long(&STACK_INFO(-2).raw);			   \
	    if (test && CVMlongEqz(l2)) {				   \
                goto arithmetic_exception_divide_by_zero;		   \
	    }								   \
	    l1 = CVMjvm2Long(&STACK_INFO(-4).raw);			   \
	    r1 = CVMlong##opname(l1, l2);				   \
	    CVMlong2Jvm(&STACK_INFO(-4).raw, r1);			   \
	    TRACE(("\t%s => %s\n", CVMopnames[pc[0]],			   \
		   GET_LONGCSTRING(STACK_LONG(-4))));			   \
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_m2;		   	   \
	}

#undef  OPC_FLOAT_BINARY 
#define OPC_FLOAT_BINARY(opname, test)					   \
            STACK_FLOAT(-2) =						   \
		CVMfloat##opname(STACK_FLOAT(-2), STACK_FLOAT(-1));	   \
            TRACE(("\t%s => %f\n", CVMopnames[pc[0]], STACK_FLOAT (-2))); \
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

#undef  OPC_DOUBLE_BINARY 
#define OPC_DOUBLE_BINARY(opname, test)					   \
	{								   \
            CVMJavaDouble l1, l2, r;					   \
            l1 = CVMjvm2Double(&STACK_INFO(-4).raw);			   \
            l2 = CVMjvm2Double(&STACK_INFO(-2).raw);			   \
            r = CVMdouble##opname(l1, l2);				   \
            CVMdouble2Jvm(&STACK_INFO(-4).raw, r);			   \
            TRACE(("\t%s => %f\n", CVMopnames[pc[0]], STACK_DOUBLE(-4)));  \
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_m2;			   \
        }

	CASE(opc_iadd, 1)
	    OPC_INT_BINARY(Add, 0);
	CASE(opc_ladd, 1)
	    OPC_LONG_BINARY(Add, 0);
	CASE(opc_fadd, 1)
	    OPC_FLOAT_BINARY(Add, 0);
	CASE(opc_dadd, 1)
	    OPC_DOUBLE_BINARY(Add, 0);

	CASE(opc_isub, 1)
	    OPC_INT_BINARY(Sub, 0);
	CASE(opc_lsub, 1)
	    OPC_LONG_BINARY(Sub, 0);
	CASE(opc_fsub, 1)
	    OPC_FLOAT_BINARY(Sub, 0);
	CASE(opc_dsub, 1)
	    OPC_DOUBLE_BINARY(Sub, 0);
	
	CASE(opc_imul, 1)
	    OPC_INT_BINARY(Mul, 0);
	CASE(opc_lmul, 1)
	    OPC_LONG_BINARY(Mul, 0);
	CASE(opc_fmul, 1)
	    OPC_FLOAT_BINARY(Mul, 0);
	CASE(opc_dmul, 1)
	    OPC_DOUBLE_BINARY(Mul, 0);
	
	CASE(opc_idiv, 1)
	    OPC_INT_BINARY(Div, 1);
	CASE(opc_ldiv, 1)
	    goto opc_ldiv_overflow;
	CASE(opc_fdiv, 1)
	    OPC_FLOAT_BINARY(Div, 1);
	CASE(opc_ddiv, 1)
	    goto opc_ddiv_overflow;

	CASE(opc_irem, 1)
	    OPC_INT_BINARY(Rem, 1);
	CASE(opc_lrem, 1)
	    goto opc_lrem_overflow;
	CASE(opc_frem, 1)
	    goto opc_frem_overflow;
	CASE(opc_drem, 1)
	    goto opc_drem_overflow;

       /* negate the value on the top of the stack */

        CASE(opc_ineg, 1)
	   STACK_INT(-1) = CVMintNeg(STACK_INT(-1));
           TRACE(("\t%s => %d\n", CVMopnames[pc[0]], STACK_INT(-1)));
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

        CASE(opc_lneg, 1)
	{
 	   CVMJavaLong r;
	   r = CVMjvm2Long(&STACK_INFO(-2).raw);
	   r = CVMlongNeg(r);
	   CVMlong2Jvm(&STACK_INFO(-2).raw, r);
           TRACE(("\t%s => %s\n", CVMopnames[pc[0]],
		  GET_LONGCSTRING(STACK_LONG(-2))));
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);
	}

        CASE(opc_fneg, 1)
	   STACK_FLOAT(-1) = CVMfloatNeg(STACK_FLOAT(-1));
           TRACE(("\t%s => %f\n", CVMopnames[pc[0]], STACK_FLOAT(-1)));
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

        CASE(opc_dneg, 1)
	{
 	   CVMJavaDouble r;
	   r = CVMjvm2Double(&STACK_INFO(-2).raw);
	   r = CVMdoubleNeg(r);
	   CVMdouble2Jvm(&STACK_INFO(-2).raw, r);
           TRACE(("\t%s => %f\n", CVMopnames[pc[0]], STACK_DOUBLE(-2)));
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);
	}

 	/* Shift operations				   
	 * Shift left int and long: ishl, lshl           
	 * Logical shift right int and long w/zero extension: iushr, lushr
	 * Arithmetic shift right int and long w/sign extension: ishr, lshr
	 */

#undef  OPC_SHIFT_BINARY
#define OPC_SHIFT_BINARY(opcname, opname)				\
        CASE(opc_i##opcname, 1)						\
	   STACK_INT(-2) = CVMint##opname(STACK_INT(-2), STACK_INT(-1));\
           TRACE(("\t%s => %d\n", CVMopnames[pc[0]], STACK_INT(-2)));	\
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);			\
        CASE(opc_l##opcname, 1)						\
	{								\
	   CVMJavaLong v, r;						\
	   v = CVMjvm2Long(&STACK_INFO(-3).raw);			\
	   r = CVMlong##opname(v, STACK_INT(-1));			\
	   CVMlong2Jvm(&STACK_INFO(-3).raw, r);				\
           TRACE(("\t%s => %s\n", CVMopnames[pc[0]],			\
		    GET_LONGCSTRING(STACK_LONG(-3)))); 			\
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);			\
	}
      
        OPC_SHIFT_BINARY(shl, Shl);
	OPC_SHIFT_BINARY(shr, Shr);
	OPC_SHIFT_BINARY(ushr, Ushr);

	/* binary logic opcodes */

#undef  OPC_LOGICAL_BINARY 
#define OPC_LOGICAL_BINARY(opcname, opname)				\
	CASE(opc_i##opcname, 1)						\
            STACK_INT(-2) =						\
		CVMint##opname(STACK_INT(-2), STACK_INT(-1));		\
	    TRACE(("\t%s => %d\n", CVMopnames[pc[0]], STACK_INT(-2)));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);			\
	CASE(opc_l##opcname, 1)						\
	{								\
	    CVMJavaLong l1, l2, r1;					\
	    l2 = CVMjvm2Long(&STACK_INFO(-2).raw);			\
	    l1 = CVMjvm2Long(&STACK_INFO(-4).raw);			\
	    r1 = CVMlong##opname(l1, l2);				\
	    CVMlong2Jvm(&STACK_INFO(-4).raw, r1);			\
	    TRACE(("\t%s => %s\n", CVMopnames[pc[0]],			\
		   GET_LONGCSTRING(STACK_LONG(-4))));			\
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_m2;			\
	}

	OPC_LOGICAL_BINARY(and, And);
	OPC_LOGICAL_BINARY(or,  Or);
	OPC_LOGICAL_BINARY(xor, Xor);

       /* Increment local variable by constant */ 

        CASE(opc_iinc, 3) 
	{
	    CVMUint32  localNo = pc[1]; 
	    CVMInt32   incr = (CVMInt8)pc[2];
	    pc += 3;
	    locals[localNo].j.i += incr;
	    TRACE(("\tiinc locals[%d]+%d => %d\n", localNo, 
		   (CVMInt8)(incr), locals[localNo].j.i)); 
	    UPDATE_PC_AND_TOS_AND_CONTINUE(0, 0);
	}

	/* Conversion operations */

        CASE(opc_i2l, 1)   /* convert top of stack int to long */
	{
	    CVMJavaLong r;
	    r = CVMint2Long(STACK_INT(-1));
	    CVMlong2Jvm(&STACK_INFO(-1).raw, r);
            TRACE(("\ti2l => %s\n", GET_LONGCSTRING(STACK_LONG(-1))));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
	}

        CASE(opc_i2f, 1)   /* convert top of stack int to float */
	   STACK_FLOAT(-1) = CVMint2Float(STACK_INT(-1));
           TRACE(("\ti2f => %f\n", STACK_FLOAT(-1)));
           UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

        CASE(opc_i2d, 1)   /* convert top of stack int to double */
	{
	    CVMJavaDouble r;
	    r = CVMint2Double(STACK_INT(-1));
	    CVMdouble2Jvm(&STACK_INFO(-1).raw, r);
            TRACE(("\ti2d => %f\n", STACK_DOUBLE(-1)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
	}

        CASE(opc_l2i, 1)   /* convert top of stack long to int */
	{
   	    CVMJavaLong r; 
	    r = CVMjvm2Long(&STACK_INFO(-2).raw);
	    STACK_INT(-2) = CVMlong2Int(r); 
            TRACE(("\tl2i => %d\n", STACK_INT(-2)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
	}
	
        CASE(opc_l2f, 1)   /* convert top of stack long to float */
	{
   	    CVMJavaLong r; 
	    r = CVMjvm2Long(&STACK_INFO(-2).raw);
	    STACK_FLOAT(-2) = CVMlong2Float(r); 
            TRACE(("\tl2f => %f\n", STACK_FLOAT(-2)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
	}

        CASE(opc_l2d, 1)   /* convert top of stack long to double */
	{
   	    CVMJavaLong r1; 
	    CVMJavaDouble r2;
	    r1 = CVMjvm2Long(&STACK_INFO(-2).raw);
	    r2 = CVMlong2Double(r1); 
	    CVMdouble2Jvm(&STACK_INFO(-2).raw, r2);
            TRACE(("\tl2d => %f\n", STACK_DOUBLE(-2)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);
	}

        CASE(opc_f2i, 1)  /* Convert top of stack float to int */
            STACK_INT(-1) = CVMfloat2Int(STACK_FLOAT(-1)); 
            TRACE(("\tf2i => %d\n", STACK_INT(-1)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

        CASE(opc_f2l, 1)  /* convert top of stack float to long */
	    goto opc_f2l_overflow;

        CASE(opc_f2d, 1)  /* convert top of stack float to double */
	{
	    CVMJavaDouble r;
	    r = CVMfloat2Double(STACK_FLOAT(-1));
	    CVMdouble2Jvm(&STACK_INFO(-1).raw, r);
            TRACE(("\tf2d => %f\n", STACK_DOUBLE(-1)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
        }

        CASE(opc_d2i, 1)  /* convert top of stack double to int */
   	{
	    CVMJavaDouble r1;
	    CVMJavaInt r2;
	    r1 = CVMjvm2Double(&STACK_INFO(-2).raw);
	    r2 = CVMdouble2Int(r1);
	    STACK_INT(-2) = r2;
            TRACE(("\td2i => %d\n", STACK_INT(-2)));
            UPDATE_PC_AND_TOS_AND_CONTINUE_1_m1;
	}


        CASE(opc_d2l, 1)  /* convert top of stack double to long */
	    goto opc_d2l_overflow;

        CASE(opc_d2f, 1)  /* convert top of stack double to float */
   	{
	    CVMJavaDouble r;
	    r = CVMjvm2Double(&STACK_INFO(-2).raw);
	    STACK_FLOAT(-2) = CVMdouble2Float(r);
            TRACE(("\td2f => %f\n", STACK_FLOAT(-2)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
	}

        CASE(opc_i2b, 1)
	    STACK_INT(-1) = CVMint2Byte(STACK_INT(-1));
            TRACE(("\ti2b => %d\n", STACK_INT(-1)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

        CASE(opc_i2c, 1)
	    STACK_INT(-1) = CVMint2Char(STACK_INT(-1));
            TRACE(("\ti2c => %d\n", STACK_INT(-1)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

        CASE(opc_i2s, 1)
	    STACK_INT(-1) = CVMint2Short(STACK_INT(-1));
            TRACE(("\ti2s => %d\n", STACK_INT(-1)));
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, 0);

	/* comparison operators */

        CASE(opc_lcmp, 1)
	    goto opc_lcmp_overflow;

        CASE(opc_fcmpl, 1)
	{
	    STACK_INT(-2) = 
		CVMfloatCompare(STACK_FLOAT(-2), STACK_FLOAT(-1), -1);
            TRACE(("\t%s => %d\n", CVMopnames[pc[0]], STACK_INT(-2)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_m1;
	}

        CASE(opc_fcmpg, 1)
	{
	    STACK_INT(-2) =
		CVMfloatCompare(STACK_FLOAT(-2), STACK_FLOAT(-1), 1);
            TRACE(("\t%s => %d\n", CVMopnames[pc[0]], STACK_INT(-2)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_m1;
	}

        CASE(opc_dcmpl, 1)
	    goto opc_dcmpl_overflow;
        CASE(opc_dcmpg, 1)
	    goto opc_dcmpg_overflow;

	/* conditional branches */

#define COMPARISON_IF(name, comparison)					\
	CASE(opc_if##name, 0) {						\
            TRACE(("\t%s goto +%d (%staken)\n",				\
		   CVMopnames[pc[0]],					\
		   CVMgetInt16(pc + 1),					\
		   (STACK_INT(-1) comparison 0) ? "" : "not "));	\
            JVMPI_TRACE_IF((STACK_INT(-1) comparison 0));               \
            if ((STACK_INT(-1) comparison 0)) {				\
	        goto opc_if_overflow;					\
	    }								\
	    FETCH_NEXT_OPCODE(3);					\
            UPDATE_PC_AND_TOS_AND_CONTINUE(3, -1);			\
        }

#define COMPARISON_IF_ICMP(name, comparison)				     \
	CASE(opc_if_icmp##name, 0) {					     \
            TRACE(("\t%s goto +%d (%staken)\n",				     \
		   CVMopnames[pc[0]],					     \
		   CVMgetInt16(pc + 1),					     \
		   (STACK_INT(-2) comparison STACK_INT(-1)) ? "" : "not ")); \
            JVMPI_TRACE_IF((STACK_INT(-2) comparison STACK_INT(-1)));        \
            if (STACK_INT(-2) comparison STACK_INT(-1)) {		     \
	        goto opc_if_icmp_overflow;				     \
	    }								     \
	    FETCH_NEXT_OPCODE(3);					     \
            UPDATE_PC_AND_TOS_AND_CONTINUE(3, -2);	     	             \
        }

#define COMPARISON_IF_ACMP(name, comparison)				    \
	CASE(opc_if_acmp##name, 0) {					    \
            TRACE(("\t%s goto +%d (%staken)\n",				    \
		   CVMopnames[pc[0]],					    \
		   CVMgetInt16(pc + 1),					    \
                   (STACK_OBJECT(-2) comparison STACK_OBJECT(-1))	    \
		   ? "" : "not "));					    \
            JVMPI_TRACE_IF((STACK_OBJECT(-2) comparison STACK_OBJECT(-1))); \
            if (STACK_INT(-2) comparison STACK_INT(-1)) {		    \
	        goto opc_if_acmp_overflow;				    \
	    }								    \
	    FETCH_NEXT_OPCODE(3);					    \
            UPDATE_PC_AND_TOS_AND_CONTINUE(3, -2);			    \
        }

	COMPARISON_IF(eq, ==);
        COMPARISON_IF(ne, !=);
	COMPARISON_IF(lt, <);
	COMPARISON_IF(ge, >=);
	COMPARISON_IF(gt, >);
	COMPARISON_IF(le, <=);

	COMPARISON_IF_ICMP(eq, ==);
        COMPARISON_IF_ICMP(ne, !=);
	COMPARISON_IF_ICMP(lt, <);
	COMPARISON_IF_ICMP(ge, >=);
	COMPARISON_IF_ICMP(gt, >);
	COMPARISON_IF_ICMP(le, <=);

	COMPARISON_IF_ACMP(eq, ==);
        COMPARISON_IF_ACMP(ne, !=);

	/* goto