executejava_aligned.c

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

	CASE(opc_bipush, 2)
	    STACK_INT(0) = (CVMInt8)(pc[1]);
	    TRACE(("\tbipush %d\n", STACK_INT(0)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);

	    /* Push a 2-byte signed integer constant onto the stack. */
	CASE(opc_sipush, 3)
	    STACK_INT(0) = CVMgetInt16(pc + 1);
	    TRACE(("\tsipush %d\n", STACK_INT(0)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);

	/* A few of the non-quick opcodes */

#ifdef  CVM_CLASSLOADING
        CASE(opc_ldc, 0)
	    clobbersCpIndex = CVM_FALSE;
	    goto quicken_opcode;
        CASE(opc_ldc_w, 0)
	    clobbersCpIndex = CVM_FALSE;
	    goto quicken_opcode;
	CASE(opc_ldc2_w, 0)
	    clobbersCpIndex = CVM_FALSE;
	    goto quicken_opcode;
#else
        CASE(opc_ldc, 0)
	    goto unimplemented_opcode;
        CASE(opc_ldc_w, 0)
	    goto unimplemented_opcode;
	CASE(opc_ldc2_w, 0)
	    goto unimplemented_opcode;
#endif

	/* load from local variable */

	CASE(opc_iload, 2) {
	    CVMUint32    localNo = pc[1]; 
            CVMSlotVal32 l = locals[localNo];
	    topOfStack += 1;
	    STACK_SLOT(-1) = l;
	    TRACE(("\tiload locals[%d](%d) =>\n", localNo, STACK_INT(-1)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 0);
	}

	/* outline to make room for pc-relative table on sarm */
        CASE(opc_lload, 2)
	    CVMmemCopy64(&STACK_INFO(0).raw, &locals[pc[1]].j.raw);
	    TRACE(("\tlload locals[%d](%s) =>\n",
		   pc[1], GET_LONGCSTRING(STACK_LONG(0))));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 2);

	CASE(opc_fload, 2) {
	    CVMUint32    localNo = pc[1]; 
            CVMSlotVal32 l = locals[localNo];
	    topOfStack += 1;
	    STACK_SLOT(-1) = l;
	    TRACE(("\tfload locals[%d](%f) =>\n", localNo, STACK_FLOAT(-1)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 0);
	}

        CASE(opc_dload, 2)
	    CVMmemCopy64(&STACK_INFO(0).raw, &locals[pc[1]].j.raw);
	    TRACE(("\tdload locals[%d](%f) =>\n", pc[1], STACK_DOUBLE(0)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 2);

	CASE(opc_aload, 2) {
	    CVMUint32    localNo = pc[1]; 
            CVMSlotVal32 l = locals[localNo];
	    topOfStack += 1;
	    STACK_SLOT(-1) = l;
	    TRACE(("\taload locals[%d](0x%x) =>\n",
		   localNo, STACK_OBJECT(-1)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 0);
	}

#undef  OPC_ILOAD_n
#define OPC_ILOAD_n(num)					\
	CASE(opc_iload_##num, 1) {				\
            CVMSlotVal32 l;					\
            pc += 1;						\
            l = locals[num];					\
            topOfStack += 1;					\
	    STACK_SLOT(-1) = l;					\
	    TRACE(("\t%s locals[%d](%d) =>\n",			\
		   CVMopnames[pc[0]], num, STACK_INT(-1)));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(0, 0);		\
	}

	    OPC_ILOAD_n(0);
	    OPC_ILOAD_n(1);
	    OPC_ILOAD_n(2);
	    OPC_ILOAD_n(3);

#undef  OPC_LLOAD_n
#define OPC_LLOAD_n(num)						\
	CASE(opc_lload_##num, 1)					\
	    CVMmemCopy64(&STACK_INFO(0).raw, &locals[num].j.raw);	\
	    TRACE(("\t%s locals[%d](%s) =>\n",				\
		   CVMopnames[pc[0]], num,				\
		   GET_LONGCSTRING(STACK_LONG(0))));			\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);

	    OPC_LLOAD_n(0);
	    OPC_LLOAD_n(1);
	    OPC_LLOAD_n(2);
	    OPC_LLOAD_n(3);

#undef  OPC_FLOAD_n
#define OPC_FLOAD_n(num)					\
	CASE(opc_fload_##num, 1)      				\
	    STACK_SLOT(0) = locals[num];			\
	    TRACE(("\t%s locals[%d](%d) =>\n",			\
		   CVMopnames[pc[0]], num, STACK_FLOAT(0)));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);

	    OPC_FLOAD_n(0);
	    OPC_FLOAD_n(1);
	    OPC_FLOAD_n(2);
	    OPC_FLOAD_n(3);

#undef  OPC_DLOAD_n
#define OPC_DLOAD_n(num)						\
	CASE(opc_dload_##num, 1)       					\
	    CVMmemCopy64(&STACK_INFO(0).raw, &locals[num].j.raw);	\
	    TRACE(("\t%s locals[%d](%f) =>\n",				\
		     CVMopnames[pc[0]], num, STACK_DOUBLE(0)));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);

	    OPC_DLOAD_n(0);
	    OPC_DLOAD_n(1);
	    OPC_DLOAD_n(2);
	    OPC_DLOAD_n(3);

#undef  OPC_ALOAD_n
#define OPC_ALOAD_n(num)						\
	CASE(opc_aload_##num, 1)       					\
	    STACK_SLOT(0) = locals[num];				\
	    TRACE(("\t%s locals[%d](0x%x) =>\n",		       	\
		   CVMopnames[pc[0]], num, STACK_OBJECT(0)));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);

	    OPC_ALOAD_n(0);
	    OPC_ALOAD_n(1);
	    OPC_ALOAD_n(2);
	    OPC_ALOAD_n(3);

	/* Array load opcodes */

	/* Every array load and store opcodes starts out like this */
#define ARRAY_INTRO(T, arrayOff)				      	      \
        CVMArrayOf##T* arrObj = (CVMArrayOf##T*)STACK_OBJECT(arrayOff);       \
	CVMJavaInt     index  = STACK_INT(arrayOff + 1);		      \
        CHECK_NULL(arrObj);						      \
        /* This clever idea is from ExactVM. No need to test index >= 0.      \
	   Instead, do an unsigned comparison. Negative indices will appear   \
	   as positive numbers >= 2^31, which is just out of the range	      \
	   of legal Java array indices */				      \
	if ((CVMUint32)index >= CVMD_arrayGetLength(arrObj)) {		      \
	    goto array_index_out_of_bounds_exception;    		      \
	}

	/* 32-bit loads. These handle conversion from < 32-bit types */
#define ARRAY_LOADTO32(T, format, stackRes)				      \
        {								      \
	    ARRAY_INTRO(T, -2);						      \
	    CVMD_arrayRead##T(arrObj, index, stackRes(-2));		      \
	    TRACE(("\t%s %O[%d](" format ") ==>\n", CVMopnames[pc[0]],	      \
		   arrObj, index, stackRes(-1))); 			      \
            UPDATE_PC_AND_TOS_AND_CONTINUE_1_m1;			      \
        }

	/* 64-bit loads */
#define ARRAY_LOADTO64(T,T2)						\
        {								\
	    CVMJava##T temp64;						\
            ARRAY_INTRO(T, -2);						\
	    CVMD_arrayRead##T(arrObj, index, temp64);			\
	    CVM##T2##2Jvm(&STACK_INFO(-2).raw, temp64);			\
	    TRACE(("\t%s %O[%d](0x%X, 0x%X) ==>\n", CVMopnames[pc[0]],	\
		   arrObj, index, STACK_INT(-2), STACK_INT(-1)));      	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_0;				\
        }

        CASE(opc_iaload, 1)
	    ARRAY_LOADTO32(Int,   "%d",   STACK_INT);
        CASE(opc_laload, 1)
	    ARRAY_LOADTO64(Long,long);
        CASE(opc_faload, 1)
	    ARRAY_LOADTO32(Float, "%f",   STACK_FLOAT);
        CASE(opc_daload, 1)
	    goto opc_daload_overflow;
        CASE(opc_aaload, 1)
	    ARRAY_LOADTO32(Ref,   "0x%x", STACK_OBJECT);
        CASE(opc_baload, 1)
	    ARRAY_LOADTO32(Byte,  "%d",   STACK_INT);
        CASE(opc_caload, 1)
	    ARRAY_LOADTO32(Char,  "%d",   STACK_INT);
        CASE(opc_saload, 1)
	    ARRAY_LOADTO32(Short, "%d",   STACK_INT);

	/* store to a local variable */

	CASE(opc_istore, 2)
	    locals[pc[1]] = STACK_SLOT(-1);
	    TRACE(("\tistore %d ==> locals[%d]\n", STACK_INT(-1), pc[1]));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, -1);

	CASE(opc_lstore, 2)
	    CVMmemCopy64(&locals[pc[1]].j.raw, &STACK_INFO(-2).raw);
	    TRACE(("\tlstore %s => locals[%d]\n",
		   GET_LONGCSTRING(STACK_LONG(-2)), pc[1]));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, -2);

	CASE(opc_fstore, 2)
	    locals[pc[1]] = STACK_SLOT(-1);
	    TRACE(("\tfstore %f ==> locals[%d]\n", STACK_FLOAT(-1), pc[1]));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, -1);

	CASE(opc_dstore, 2)
	    CVMmemCopy64(&locals[pc[1]].j.raw, &STACK_INFO(-2).raw);
	    TRACE(("\tdstore %f => locals[%d]\n", STACK_DOUBLE(-2), pc[1]));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, -2);

	CASE(opc_astore, 2)
	    locals[pc[1]] = STACK_SLOT(-1);
	    TRACE(("\tastore 0x%x => locals[%d]\n", STACK_OBJECT(-1), pc[1]));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, -1);

#undef  OPC_ISTORE_n
#define OPC_ISTORE_n(num)					\
	CASE(opc_istore_##num, 1)				\
	    locals[num] = STACK_SLOT(-1);			\
	    TRACE(("\t%s %d => locals[%d]\n",			\
		   CVMopnames[pc[0]], STACK_INT(-1), num));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

	    OPC_ISTORE_n(0);
	    OPC_ISTORE_n(1);
	    OPC_ISTORE_n(2);
	    OPC_ISTORE_n(3);

#undef  OPC_LSTORE_n
#define OPC_LSTORE_n(num)						\
	CASE(opc_lstore_##num, 1)					\
	    CVMmemCopy64(&locals[num].j.raw, &STACK_INFO(-2).raw);	\
	    TRACE(("\t%s %s => locals[%d]\n",				\
		   CVMopnames[pc[0]],					\
                   GET_LONGCSTRING(STACK_LONG(-2)), num));		\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);

	    OPC_LSTORE_n(0);
	    OPC_LSTORE_n(1);
	    OPC_LSTORE_n(2);
	    OPC_LSTORE_n(3);

#undef  OPC_FSTORE_n
#define OPC_FSTORE_n(num)					\
	CASE(opc_fstore_##num, 1)      				\
	    locals[num] = STACK_SLOT(-1);			\
	    TRACE(("\t%s %f => locals[%d]\n",			\
		   CVMopnames[pc[0]], STACK_FLOAT(-1), num));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

	    OPC_FSTORE_n(0);
	    OPC_FSTORE_n(1);
	    OPC_FSTORE_n(2);
	    OPC_FSTORE_n(3);

#undef  OPC_DSTORE_n
#define OPC_DSTORE_n(num)						\
	CASE(opc_dstore_##num, 1)      					\
	    CVMmemCopy64(&locals[num].j.raw, &STACK_INFO(-2).raw);	\
	    TRACE(("\t%s %f => locals[%d]\n",				\
		   CVMopnames[pc[0]], STACK_DOUBLE(-2), num));		\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);

	    OPC_DSTORE_n(0);
	    OPC_DSTORE_n(1);
	    OPC_DSTORE_n(2);
	    OPC_DSTORE_n(3);

#undef  OPC_ASTORE_n
#define OPC_ASTORE_n(num)					\
	CASE(opc_astore_##num, 1)      				\
	    locals[num] = STACK_SLOT(-1);			\
	    TRACE(("\t%s 0x%x => locals[%d]\n",			\
		   CVMopnames[pc[0]], STACK_OBJECT(-1), num));	\
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

	    OPC_ASTORE_n(0);
	    OPC_ASTORE_n(1);
	    OPC_ASTORE_n(2);
	    OPC_ASTORE_n(3);

	/* Array store opcodes */

	/* 32-bit stores. These handle conversion to < 32-bit types */
#define ARRAY_STOREFROM32(T, format, stackSrc)				      \
        {								      \
	    ARRAY_INTRO(T, -3);						      \
	    CVMD_arrayWrite##T(arrObj, index, stackSrc(-1));		      \
	    TRACE(("\t%s " format " ==> %O[%d] ==>\n", CVMopnames[pc[0]],     \
		   stackSrc(-1), arrObj, index)); 			      \
            UPDATE_PC_AND_TOS_AND_CONTINUE_1_m3;			      \
        }

	/* 64-bit stores */
#define ARRAY_STOREFROM64(T)						    \
        {								    \
	    CVMJava##T temp64;						    \
            ARRAY_INTRO(T, -4);						    \
	    temp64 = CVMjvm2##T(&STACK_INFO(-2).raw);			    \
	    CVMD_arrayWrite##T(arrObj, index, temp64);			    \
	    TRACE(("\t%s (0x%X, 0x%X) ==> %O[%d]\n", CVMopnames[pc[0]],     \
		   STACK_INT(-2), STACK_INT(-1), arrObj, index));      	    \
	    UPDATE_PC_AND_TOS_AND_CONTINUE_1_m4;			    \
        }

        CASE(opc_iastore, 1)
	    ARRAY_STOREFROM32(Int,   "%d",   STACK_INT);
        CASE(opc_lastore, 1)
	    ARRAY_STOREFROM64(Long);
        CASE(opc_fastore, 1)
	    ARRAY_STOREFROM32(Float, "%f",   STACK_FLOAT);
        CASE(opc_dastore, 1)
	    goto opc_dastore_overflow;

	/*
	 * This one looks different because of the assignability check
	 */
        CASE(opc_aastore, 1)
	    goto opc_aastore_overflow;

        CASE(opc_bastore, 1)
	    ARRAY_STOREFROM32(Byte,  "%d",   STACK_INT);
        CASE(opc_castore, 1)
	    ARRAY_STOREFROM32(Char,  "%d",   STACK_INT);
        CASE(opc_sastore, 1)
	    ARRAY_STOREFROM32(Short, "%d",   STACK_INT);

	/* stack pop, dup, and insert opcodes */
	   
	CASE(opc_pop, 1)	 /* Discard the top item on the stack */
	    TRACE(("\tpop\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

	   
	CASE(opc_pop2, 1)	 /* Discard the top 2 items on the stack */
	    TRACE(("\tpop2\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);
	    
	CASE(opc_dup, 1) {	/* Duplicate the top item on the stack */
	    CVMJavaVal32 rhs = STACK_INFO(-1);
	    topOfStack += 1;
	    pc += 1;
	    STACK_INFO(-1) = rhs;
	    TRACE(("\tdup\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(0, 0);
	}

	CASE(opc_dup_x1, 1)	/* insert top word two down */
	    STACK_INFO(0) = STACK_INFO(-1);
	    STACK_INFO(-1) = STACK_INFO(-2);
	    STACK_INFO(-2) = STACK_INFO(0);
	    TRACE(("\tdup_x1\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);

	CASE(opc_dup_x2, 1)	/* insert top word three down  */
	    STACK_INFO(0) = STACK_INFO(-1);
	    STACK_INFO(-1) = STACK_INFO(-2);
	    STACK_INFO(-2) = STACK_INFO(-3);
	    STACK_INFO(-3) = STACK_INFO(0);
	    TRACE(("\tdup_x2\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);

	CASE(opc_dup2, 1)      	/* Duplicate the top 2 items on the stack */
	    STACK_INFO(0) = STACK_INFO(-2);
	    STACK_INFO(1) = STACK_INFO(-1);
	    TRACE(("\tdup2\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);

	CASE(opc_dup2_x1, 1)	/* insert top double three down */
	    STACK_INFO(1) = STACK_INFO(-1);
	    STACK_INFO(0) = STACK_INFO(-2);
	    STACK_INFO(-1) = STACK_INFO(-3);
	    STACK_INFO(-2) = STACK_INFO(1);
	    STACK_INFO(-3) = STACK_INFO(0);
	    TRACE(("\tdup2_x1\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);

	CASE(opc_dup2_x2, 1)	/* insert top double four down */
	    STACK_INFO(1) = STACK_INFO(-1);
	    STACK_INFO(0) = STACK_INFO(-2);
	    STACK_INFO(-1) = STACK_INFO(-3);
	    STACK_INFO(-2) = STACK_INFO(-4);
	    STACK_INFO(-3) = STACK_INFO(1);
	    STACK_INFO(-4) = STACK_INFO(0);
	    TRACE(("\tdup2_x2\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);