executejava_split2.c

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

	/* Quick object field access byte-codes. The non-wide version are
	 * all lossy and are not needed when in losslessmode.
	 */

#ifndef CVM_NO_LOSSY_OPCODES
        CASE(opc_getfield_quick)
	{
            OPCODE_INTRO_DECL
	    CVMObject* directObj;
	    CVMUint32  slotIndex; 

	    directObj = STACK_OBJECT(-1);
	    OPCODE_UPDATE_NEW(pc[3]);
	    OPCODE_UPDATE_NEXT(opcode);
	    TRACE(("\t%s %O[%d](0x%X) ==>\n", CVMopnames[*pc],
		   directObj, pc[1], STACK_INT(-1)));
	    slotIndex = pc[1];
	    CHECK_NULL(directObj);
	    pc += 3;
	    CVMD_fieldRead32(directObj, slotIndex, STACK_INFO(-1));

	    CONTINUE_NEXT(opcode);
        }

        CASE(opc_putfield_quick)
	{
            OPCODE_INTRO_DECL
	    CVMUint32 slotIndex;
	    CVMObject* directObj;
	    
	    directObj = STACK_OBJECT(-2);
	    OPCODE_UPDATE_NEW(pc[3]);
	    OPCODE_UPDATE_NEXT(opcode);
	    TRACE(("\t%s (0x%X) ==> %O[%d]\n", CVMopnames[*pc],
		   STACK_INT(-1), directObj, pc[1]));
	    slotIndex = pc[1];
	    CHECK_NULL(directObj);
	    pc += 3;
	    CVMD_fieldWrite32(directObj, slotIndex, STACK_INFO(-1));
	    topOfStack -= 2;

	    CONTINUE_NEXT(opcode);
        }

	CASE(opc_agetfield_quick)
	{
            OPCODE_INTRO_DECL
	    CVMObject* directObj;
	    CVMUint32  slotIndex; 
	    CVMObject* fieldObj;

	    directObj = STACK_OBJECT(-1);
	    OPCODE_UPDATE_NEW(pc[3]);
	    OPCODE_UPDATE_NEXT(opcode);
	    TRACE(("\t%s %O[%d](0x%x) ==>\n", CVMopnames[*pc],
		   directObj, pc[1], STACK_OBJECT(-1)));
	    slotIndex = pc[1];
	    CHECK_NULL(directObj);
	    pc += 3;
	    CVMD_fieldReadRef(directObj, slotIndex, fieldObj);
	    CVMID_icellSetDirect(ee, &STACK_ICELL(-1), fieldObj); 

	    CONTINUE_NEXT(opcode);
        }

	CASE(opc_aputfield_quick)
	{
            OPCODE_INTRO_DECL
	    CVMObject* directObj;
	    CVMUint32  slotIndex; 

	    directObj = STACK_OBJECT(-2);
	    OPCODE_UPDATE_NEW(pc[3]);
	    OPCODE_UPDATE_NEXT(opcode);
	    TRACE(("\t%s (0x%x) ==> %O[%d]\n", CVMopnames[*pc],
		   STACK_OBJECT(-1), directObj, pc[1]));
	    slotIndex= pc[1];
	    CHECK_NULL(directObj);
	    pc += 3;
	    CVMD_fieldWriteRef(directObj, slotIndex, STACK_OBJECT(-1));
	    topOfStack -= 2;

	    CONTINUE_NEXT(opcode);
        }

#endif /* CVM_NO_LOSSY_OPCODES */

	CASE(opc_bipush) {
	    /* Push a 1-byte signed integer value onto the stack. */
	    OPCODE_INTRO_DECL
	    CVMInt32 c;

            c = (CVMInt8)pc[1];
	    OPCODE_UPDATE_NEW(pc[2]);
	    OPCODE_UPDATE_NEXT(opcode);
            pc += 2;
            topOfStack += 1;
	    TRACE(("\tbipush %d\n", (int)c));
	    STACK_INT(-1) = c;

	    CONTINUE_NEXT(opcode);
	}
	
	    /* Push a 2-byte signed integer constant onto the stack. */
	CASE(opc_sipush) {
	    OPCODE_INTRO_DECL
	    CVMUint8 lo;
            CVMInt16 c;
	    
	    OPCODE_UPDATE_NEW(pc[3]);
	    OPCODE_UPDATE_NEXT(opcode);
	    lo = pc[2];
	    topOfStack += 1;
	    c = pc[1];
	    pc += 3;
	    c = (c << 8) | lo;
	    
	    STACK_INT(-1) = c;
	    TRACE(("\tsipush %d\n", (int)c));
	    
	    CONTINUE_NEXT(opcode);
        }
	
	    /* load from local variable */

	CASE_NT(opc_aload)
	CASE_NT(opc_iload)
	CASE(opc_fload) {
	    OPCODE_INTRO_DECL
	    CVMUint32  localNo; 
            CVMSlotVal32 l;
		
	    localNo = pc[1];
	    OPCODE_UPDATE_NEW(pc[2]);
	    l = locals[localNo];
	    OPCODE_UPDATE_NEXT(opcode);
	    pc += 2;
	    topOfStack += 1;
	    
	    STACK_SLOT(-1) = l;

	    TRACEIF(opc_aload, ("\taload locals[%d](0x%x) =>\n",
				pc[1], STACK_OBJECT(-1)));
	    TRACEIF(opc_iload, ("\tiload locals[%d](%d) =>\n", 
				pc[1], STACK_INT(-1)));
	    TRACEIF(opc_fload, ("\tfload locals[%d](%f) =>\n", 
				pc[1], STACK_FLOAT(-1)));

	    CONTINUE_NEXT(opcode);
	}
	
	OPC_LOAD1_n(a,0);
	OPC_LOAD1_n(i,0);
	OPC_LOAD1_n(f,0);

	OPC_LOAD1_n(a,1);
	OPC_LOAD1_n(i,1);
	OPC_LOAD1_n(f,1);

	OPC_LOAD1_n(a,2);
	OPC_LOAD1_n(i,2);
	OPC_LOAD1_n(f,2);

	OPC_LOAD1_n(a,3);
	OPC_LOAD1_n(i,3);
	OPC_LOAD1_n(f,3);

	    /* store to a local variable */

	CASE_NT(opc_astore)
	CASE_NT(opc_istore)
	CASE(opc_fstore) {
	    OPCODE_INTRO_DECL
	    CVMUint32  localNo; 
            CVMSlotVal32 l;
	
	    OPCODE_UPDATE_NEW(pc[2]);
	    pc += 2;
	    topOfStack -= 1;
	    
	    l = STACK_SLOT(0);
	    localNo = pc[-1];
	    OPCODE_UPDATE_NEXT(opcode);
	    locals[localNo] = l;
	    TRACEIF(opc_astore, ("\tastore 0x%x => locals[%d]\n",
				 STACK_OBJECT(-1), pc[-1]));
	    TRACEIF(opc_istore,
		    ("\tistore %d ==> locals[%d]\n", STACK_INT(-1), pc[-1]));
	    TRACEIF(opc_fstore,
		    ("\tfstore %f ==> locals[%d]\n", STACK_FLOAT(-1), pc[-1]));

	    CONTINUE_NEXT(opcode);
	}
	
	OPC_STORE1_n(i, 0);
	OPC_STORE1_n(a, 0);
	OPC_STORE1_n(f, 0);

	OPC_STORE1_n(i, 1);
	OPC_STORE1_n(a, 1);
	OPC_STORE1_n(f, 1);

	OPC_STORE1_n(i, 2);
	OPC_STORE1_n(a, 2);
	OPC_STORE1_n(f, 2);

	OPC_STORE1_n(i, 3);
	OPC_STORE1_n(a, 3);
	OPC_STORE1_n(f, 3);
	
	    /* Push miscellaneous constants onto the stack. */

	CASE(opc_aconst_null)
	    CVMID_icellSetNull(&STACK_ICELL(0));
	    TRACE(("\t%s\n", CVMopnames[*pc]));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);

	OPC_CONST_n(opc_iconst_m1,   i,       -1);
	OPC_CONST_n(opc_iconst_0,    i,        0);
	OPC_CONST_n(opc_iconst_1,    i,        1);
	OPC_CONST_n(opc_iconst_2,    i,        2);
	OPC_CONST_n(opc_iconst_3,    i,        3);
	OPC_CONST_n(opc_iconst_4,    i,        4);
	OPC_CONST_n(opc_iconst_5,    i,        5);
	OPC_CONST_n(opc_fconst_0,    f,      0.0);
	OPC_CONST_n(opc_fconst_1,    f,      1.0);
	OPC_CONST_n(opc_fconst_2,    f,      2.0);

	   /* Load constant from constant pool: */

	CASE(opc_aldc_ind_quick) { /* Indirect String (loaded classes) */
	    CVMObjectICell* strICell = CVMcpGetStringICell(cp, pc[1]);
	    CVMID_icellAssignDirect(ee, &STACK_ICELL(0), strICell);
            TRACE(("\t%s #%d => 0x%x\n", CVMopnames[*pc],
		   pc[1], STACK_INT(0)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);
	}

        CASE_NT(opc_aldc_quick) /* aldc loads direct String refs (ROM only) */
        CASE(opc_ldc_quick)
	    STACK_INFO(0) = CVMcpGetVal32(cp, pc[1]);
            TRACE(("\t%s #%d => 0x%x\n", CVMopnames[*pc],
		   pc[1], STACK_INT(0)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);

	/* stack pop, dup, and insert opcodes */

	CASE(opc_nonnull_quick)  /* pop stack, and error if it is null */
	    TRACE(("\tnonnull_quick\n"));
	    CHECK_NULL(STACK_OBJECT(-1));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);

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

	   
	CASE(opc_pop2)		 /* Discard the top 2 items on the stack */
	    TRACE(("\tpop2\n"));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);

	    
	CASE(opc_dup) {		/* Duplicate the top item on the stack */
	    OPCODE_INTRO_DECL
	    CVMJavaVal32 rhs;
	    
	    OPCODE_UPDATE_NEW(pc[1]);
	    rhs = STACK_INFO(-1);
	    OPCODE_UPDATE_NEXT(opcode);
	    topOfStack += 1;
	    pc += 1;
	    STACK_INFO(-1) = rhs;
	    TRACE(("\tdup\n"));

	    CONTINUE_NEXT(opcode);
	}
	
	CASE(opc_dup2)		/* 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_dup_x1) {	/* insert top word two down */
	    OPCODE_INTRO_DECL
	    
	    OPCODE_UPDATE_NEW(pc[1]);
	    OPCODE_UPDATE_NEXT(opcode);
	    pc += 1;
	    topOfStack += 1;
	    STACK_INFO(-1) = STACK_INFO(-2);
	    STACK_INFO(-2) = STACK_INFO(-3);
	    STACK_INFO(-3) = STACK_INFO(-1);
	    TRACE(("\tdup_x1\n"));

	    CONTINUE_NEXT(opcode);
	}

	CASE(opc_dup_x2)	/* 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_swap) {        /* 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);
	}

	OPC_INT1_BINARY(add, Add, 0);
	OPC_INT1_BINARY(sub, Sub, 0);
	OPC_INT1_BINARY(mul, Mul, 0);
	OPC_INT1_BINARY(and, And, 0);
	OPC_INT1_BINARY(or,  Or,  0);
	OPC_INT1_BINARY(xor, Xor, 0);

	OPC_FLOAT1_BINARY(add, Add);
	OPC_FLOAT1_BINARY(sub, Sub);
	OPC_FLOAT1_BINARY(mul, Mul);
	
        OPC_SHIFT1_BINARY(shl, Shl);
	OPC_SHIFT1_BINARY(shr, Shr);
	OPC_SHIFT1_BINARY(ushr, Ushr);

       /* Increment local variable by constant */ 
        CASE(opc_iinc) 
	{
	    CVMUint32  localNo; 
	    CVMInt32   incr;
	    OPCODE_INTRO_DECL
	
	    OPCODE_UPDATE_NEW(pc[3]);
	    localNo = pc[1];
	    incr    = (CVMInt8)(pc[2]);
	    pc += 3;
	    OPCODE_UPDATE_NEXT(opcode);
	    locals[localNo].j.i += incr;
	    TRACE(("\tiinc locals[%d]+%d => %d\n", pc[1], 
		   (CVMInt8)(pc[2]), locals[pc[1]].j.i)); 

	    CONTINUE_NEXT(opcode);
	}

	/* Check if an object is an instance of given type. Throw an
	 * exception if not. */
        CASE(opc_checkcast_quick)
	{
	    CVMObject* directObj;
	    CVMClassBlock* cb;
	    
	    directObj = STACK_OBJECT(-1);
	    cb = CVMcpGetCb(cp, GET_INDEX(pc+1));   /* cb of cast type */ 
	    TRACE(("\t%s %C\n", CVMopnames[*pc], cb));
	    if (!CVMgcUnsafeIsInstanceOf(ee, directObj, cb)) {
		goto throwClassCastException;
	    } 
	    UPDATE_PC_AND_TOS_AND_CONTINUE(3, 0);
	}

	/* Check if an object is an instance of given type and store
	 * result on the stack. */
        CASE(opc_instanceof_quick)
	{
	    CVMObject* directObj;
	    CVMClassBlock* cb;
	    
	    directObj = STACK_OBJECT(-1);
	    cb = CVMcpGetCb(cp, GET_INDEX(pc+1));  /* cb of casttype */ 
	    STACK_INT(-1) = (directObj != NULL) &&
		CVMgcUnsafeIsInstanceOf(ee, directObj, cb); 
	    /* CVMgcUnsafeIsInstanceOf() may have thrown StackOverflowError */
	    if (CVMlocalExceptionOccurred(ee)) {
		goto handle_exception;
	    }
	    TRACE(("\t%s %C => %d\n", CVMopnames[*pc], cb, STACK_INT(-1)));
	    UPDATE_PC_AND_TOS_AND_CONTINUE(3, 0);
 	}

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

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

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

	/* Conversion operations */

        CASE(opc_i2f)	/* 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_f2i)  /* 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_i2b)
	    STACK_INT(-1) = CVMint2Byte(STACK_INT(-1));