reformat.c

c/c++虚拟机linux版本

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                                                   +
+  reformat.c - implements the verification stage                   +
+                                                                   +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ macros								                            + 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

/*#define DBG_FMT		1*/

#ifdef DBG_FMT
#define DBG_FMT0(str);				printf("reformat(): "); printf(str);
#define DBG_FMT1(str,arg1);			printf("reformat(): "); printf(str,arg1);
#define DBG_FMT2(str,arg1,arg2);	printf("reformat(): "); printf(str,arg1,arg2);
#define DBG_FMT_PU8(str,arg);		printf("reformat(): "); printf(str); pU8(arg); printf("\n\n");
#define DBG_FMT_PS8(str,arg);		printf("reformat(): "); printf(str); pS8(arg); printf("\n\n");		
#else
#define DBG_FMT0(str);
#define DBG_FMT1(str,arg1);
#define DBG_FMT2(str,arg1,arg2); 
#define DBG_FMT_PU8(str,arg);
#define DBG_FMT_PS8(str,arg);
#endif	

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ public prototypes                                                 + 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

U1 reformat();

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ private prototypes                                                + 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void badIntReg(U1 arg, U8 currentbyte);		
void badFltReg(U1 arg, U8 currentbyte);
void badDblReg(U1 arg, U8 currentbyte);	

/* use when have raw bytes instead of U8 ( would use badAddress )*/

void checkAddress(U1 *arr, U8 cb); 

/* make sure don't have incomplete instruction*/

void checkCurrentByte(U8 cb, U8 end);

/* end of an instruction is allowed to be at end of bytecode*/

void checkEndCurrentByte(U8 cb, U8 end);

/* following three are used only at runtime */

void badAddress(U8 arg, U8 currentbyte);
void badStack(U8 arg, U8 currentbyte);	
void badHeap(U8 arg, U8 currentbyte);	


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
+ function definitions                                              +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

/*
	re-format bytecode numeric operands to native 
	( prevents redundant runtime work ).

	This also performs verification to make sure that:
	1) instruction opcodes are valid
	2) register arguments are actual registers of necessary type
	3) immediate address values are in range [ 0 , $TOP ]
	4) Haven't prematurely hit end of bytecode instruction
*/

U1 reformat()
{
	U8 current_byte;
	U8 stop;

	current_byte = 0;
	stop = R[$HS];

	DBG_FMT0("initiating reformat\n\n");
	DBG_FMT_PU8("starting at address->",current_byte);
	DBG_FMT_PU8("stop address->",stop);

	while(current_byte < stop)
	{
		switch(RAM[current_byte])
		{
			case LBI:	/* LBI $r1, byte_constant  BBB */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				DBG_FMT1("byte %d\n\n",(S1)RAM[current_byte]);
				current_byte = current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LWI:	/* LWI $r1, word_constant  BBW */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_WORD(RAM,current_byte);
				DBG_FMT1("word %hd\n\n",*((S2 *)&RAM[current_byte]));
				current_byte = current_byte+2;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LDI:	/* LDI $r1, dword_constant  BBD */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_DWORD(RAM,current_byte);
				DBG_FMT1("dword %ld\n\n",*((S4 *)&RAM[current_byte]));
				current_byte = current_byte+4;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LQI:	/* LQI $r1, qword_constant  BBQ*/
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_QWORD(RAM,current_byte);
				DBG_FMT_PS8("qword ",*((S8 *)&RAM[current_byte]));
				current_byte = current_byte+8;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LF1I:	/* LF1I $f1, float_constant  BBD */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badFltReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",Rf_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_DWORD(RAM,current_byte);
				DBG_FMT1("float %g\n\n",*((F4 *)&RAM[current_byte]));
				current_byte = current_byte+4;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LF2I:	/* LQI $d1, double_constant  BBQ*/
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badDblReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",Rd_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_QWORD(RAM,current_byte);
				DBG_FMT1("float %g\n\n",*((F8 *)&RAM[current_byte]));
				current_byte = current_byte+8;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LAD:	/* LAD $r1, address = BBQ */ 
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_QWORD(RAM,current_byte);
				checkAddress(RAM,current_byte);
				DBG_FMT_PU8("address ",*((U8 *)&RAM[current_byte]));
				current_byte = current_byte+8;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LAI:   /* LAI $r1, $r2, qword     BBBQ*/
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				FORMAT_QWORD(RAM,current_byte);
				DBG_FMT_PS8("qword ",*((S8 *)&RAM[current_byte]));
				current_byte = current_byte+8;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LB:	/* LB $r1,$r2	BBB */
			case LW:
			case LD:
			case LQ:
			case SB:	/* SB $r1,$r2   BBB*/ 
			case SW:
			case SD:
			case SQ:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LF1:	/*  LF1  $f1, $r1   BBB */
			case SF1:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badFltReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",Rf_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case LF2:	/*  LF2  $d1, $r1   BBB */
			case SF2:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badDblReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",Rd_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case PUSHB:	/* PUSHB $r1  BB */
			case PUSHW:
			case PUSHD:
			case PUSHQ:
			case POPB:	/* POPB $r1   BB*/
			case POPW:
			case POPD:
			case POPQ:
			case JMP:	/* JMP $r1	BB*/
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case PUSHF1: /* PUSHF1 $f */
			case POPF1:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badFltReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",Rf_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case PUSHF2:  /* PUSHF2 $d */
			case POPF2:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badDblReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",Rd_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case MOVF:	/* MOVF $f1, $f2 */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badFltReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",Rf_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badFltReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",Rf_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case MOVD:  /* MOVF $d1, $d2 */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badDblReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",Rd_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badDblReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",Rd_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case MOV:	/* MOV $r1, $r2    BBB */
			case NOT:  
			case BS:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;
			case JE:	/*JE $r1, $r2, $r3	BBBB */
			case JNE:
			case SLT:
			case AND:	/*AND $r1, $r2, $r3	BBBB*/
			case OR:
			case XOR:
			case BT:
			case SRA:	/*SRA  $r1, $r2, $r3  BBBB */
			case SRL:
			case SL:
			case ADD:	/* ADD $r1, $r2, $r3  BBBB*/
			case SUB:
			case MULT:
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				badIntReg(RAM[current_byte],current_byte);
				DBG_FMT1("operand %s\n\n",R_STR[RAM[current_byte]]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break; 
			case INT: /* INT #vector	BB */
			{
				DBG_FMT1("opcode %s\n",I_Set[RAM[current_byte]]);
				current_byte++;
				checkCurrentByte(current_byte,stop);

				DBG_FMT1("vector %d\n\n",RAM[current_byte]);
				current_byte++;
				checkEndCurrentByte(current_byte,stop);

			}break;