run.c

< 虚拟机设计与实现> 的source code, linux版本

#include "run.h"

#include "interrupt.h"
#include "dbgdata.h"
#include "dbgcmd.h"

/* 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);	

void handleBT();
void handleBS();

void runHEC(U1 dbg)
{	
	U2 tick;
	U8 u8_temp;
	U8 start_debug_instr;

	tick = 0;
    debug = dbg;

	DBG_RUN0("initiating bytecode execution\n");

	while ((RAM[ R[$IP] ] != HALT) && (nErrors == 0) && (R[$IP] <= R[$BE]))
	{
		if (debug == TRUE)
		{ 
			readDbgCmd(); 
		}
		start_debug_instr = (U8)R[$IP];

		switch (RAM[ R[$IP] ])
		{
		case LBI:   // LBI $R, byte    BBB
			DBG_RUN0("Optimized HANDLE_LBI\n");
            R[ RAM[R[$IP] + 1] ] = (S1)RAM[R[$IP] + 2];

            R[$IP] = R[$IP] + 3;
			break;
			
		case LWI:   // LWI $R, word    BBW
			DBG_RUN0("Optimized HANDLE_LWI\n");
            R[ RAM[R[$IP] + 1] ] = (S2)*((S2 *)&RAM[R[$IP] + 2]);
            
			R[$IP] = R[$IP] + 4;
			break;
			
		case LDI:   // LDI $R, dword   BBD
			DBG_RUN0("Optimized HANDLE_LDI\n");
            R[ RAM[R[$IP] + 1] ] = (S4)*((S4 *)&RAM[R[$IP] + 2]);
			
			R[$IP] = R[$IP] + 6;
			break;
			
		case LQI:   // LQI $R, qword   BBQ
			DBG_RUN0("Optimized HANDLE_LQI\n"); 
            R[ RAM[R[$IP] + 1] ] = (S8)*((S8 *)&RAM[R[$IP] + 2]);
			
			R[$IP] = R[$IP] + 10;
			break;
			
		case LF1I:   // LF1I $F, float   BBD
			DBG_RUN0("Optimized HANDLE_LF1I\n");
            Rf[ RAM[R[$IP] + 1] ] = (F4)*((F4 *)&RAM[R[$IP] + 2]);
			
			R[$IP] = R[$IP] + 6;
			break;
			
		case LF2I:    // LF2I $R, double   BBQ
			DBG_RUN0("Optimized HANDLE_LF2I\n"); 
			Rd[ RAM[R[$IP] + 1] ] = (F8)*((F8 *)&RAM[R[$IP] + 2]);
			
			R[$IP] = R[$IP] + 10;
			break;

		case LAD:    // LAD $R, address   BBQ
			DBG_RUN0("Optimized HANDLE_LAD\n"); 
			u8_temp = (U8)*((U8 *)&RAM[R[$IP] + 2]);
            badAddress(u8_temp, R[$IP]);
			if (nErrors > 0)
				return;
	        R[ RAM[R[$IP] + 1] ] = u8_temp;
			
			R[$IP] = R[$IP] + 10;
			break;
			
		case LAI:    // LAI $R1, $R2, qword   BBBQ
			DBG_RUN0("Optimized HANDLE_LAI\n");
			u8_temp = R[ RAM[R[$IP] + 2] ] + (S8)*((S8 *)&RAM[R[$IP] + 3]);
            badAddress(u8_temp, R[$IP]);
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = u8_temp;
			
			R[$IP] = R[$IP] + 11;
			break;

		case LB:    // LB $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_LB\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]);
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)(*((S1 *)&RAM[u8_temp]));
			
			R[$IP] = R[$IP] + 3;
			break;
			
		case LW:    // LW $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_LW\n"); 
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)(*((S2 *)&RAM[u8_temp])); 

			R[$IP] = R[$IP] + 3;
			break;
			
		case LD:    // LD $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_LD\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)(*((S4 *)&RAM[u8_temp])); 

			R[$IP] = R[$IP] + 3;
			break;
			
		case LQ:    // LQ $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_LQ\n"); 
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)(*((S8 *)&RAM[u8_temp]));
			
			R[$IP] = R[$IP] + 3;
			break;
			
		case LF1:    // LF1 $F, $R2   BBB
			DBG_RUN0("Optimized HANDLE_LF1\n"); 
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
			Rf[ RAM[R[$IP] + 1] ] = *((F4 *)&RAM[u8_temp]);
			
			R[$IP] = R[$IP] + 3;
			break;
			
		case LF2:    // LF2 $D, $R2   BBB
			DBG_RUN0("Optimized HANDLE_LF2\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
			Rd[ RAM[R[$IP] + 1] ] = *((F8 *)&RAM[u8_temp]);

			R[$IP] = R[$IP] + 3; 
			break;
		
		case SB:    // SB $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_SB\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
	        RAM[u8_temp] = (S1)R[ RAM[R[$IP] + 1] ]; 

			R[$IP] = R[$IP] + 3;
			break;
			
		case SW:    // SW $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_SW\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
	        *((S2 *)&RAM[u8_temp]) = (S2)R[ RAM[R[$IP] + 1] ];

			R[$IP] = R[$IP] + 3;
			break;
			
		case SD:    // SD $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_SD\n"); 
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
	        *((S4 *)&RAM[u8_temp]) = (S4)R[ RAM[R[$IP] + 1] ];

			R[$IP] = R[$IP] + 3;
			break;
			
		case SQ:    // SQ $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_SQ\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
	        *((S8 *)&RAM[u8_temp]) = (S8)R[ RAM[R[$IP] + 1] ];

			R[$IP] = R[$IP] + 3;
			break;
			
		case SF1:    // SF1 $F, $R2   BBB
			DBG_RUN0("Optimized HANDLE_SF1\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
	        *((F4 *)&RAM[u8_temp]) = Rf[ RAM[R[$IP] + 1] ]; 

			R[$IP] = R[$IP] + 3;
			break;
			
		case SF2:    // SF2 $D, $R2   BBB
			DBG_RUN0("Optimized HANDLE_SF2\n");
			u8_temp = R[ RAM[R[$IP] + 2] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;
	        *((F8 *)&RAM[u8_temp]) = Rd[ RAM[R[$IP] + 1] ];

			R[$IP] = R[$IP] + 3;
			break;

		case PUSHB:    // PUSHB $R   BB
			DBG_RUN0("Optimized HANDLE_PUSHB\n");
			badStack(R[$SP] - 1, R[$IP]);
			if (nErrors > 0)
				return;
			R[$SP] = R[$SP] - 1; 
			RAM[ R[$SP] ] = (S1)(R[ RAM[R[$IP] + 1] ]);
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case PUSHW:    // PUSHW $R   BB
			DBG_RUN0("Optimized HANDLE_PUSHW\n");
			badStack(R[$SP] - 2, R[$IP]);
			if (nErrors > 0)
				return;
		    R[$SP] = R[$SP] - 2; 
			*((S2 *)&RAM[ R[$SP] ]) = (S2)(R[ RAM[R[$IP] + 1] ]);
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case PUSHD:    // PUSHD $R   BB
			DBG_RUN0("Optimized HANDLE_PUSHD\n");
			badStack(R[$SP] - 4, R[$IP]);
			if (nErrors > 0)
				return;
			R[$SP] = R[$SP] - 4; 
			*((S4 *)&RAM[ R[$SP] ]) = (S4)(R[ RAM[R[$IP] + 1] ]);
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case PUSHQ:    // PUSHQ $R   BB
			DBG_RUN0("Optimized HANDLE_PUSHQ\n");
			badStack(R[$SP] - 8, R[$IP]);
			if (nErrors > 0)
				return;
			R[$SP] = R[$SP] - 8; 
			*((S8 *)&RAM[ R[$SP] ]) = (S8)(R[ RAM[R[$IP] + 1] ]);
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case PUSHF1:    // PUSHF1 $F   BB
			DBG_RUN0("Optimized HANDLE_PUSHF1\n");
			badStack(R[$SP] - 4, R[$IP]);
			if (nErrors > 0)
				return;
			R[$SP] = R[$SP] - 4; 
			*((F4 *)&RAM[ R[$SP] ]) = Rf[ RAM[R[$IP] + 1] ];
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case PUSHF2:    // PUSHF2 $D   BB
			DBG_RUN0("Optimized HANDLE_PUSHF2\n");
			badStack(R[$SP] - 8, R[$IP]);
			if (nErrors > 0)
				return;
			R[$SP] = R[$SP] - 8; 
			*((F8 *)&RAM[ R[$SP] ]) = Rd[ RAM[R[$IP] + 1] ];
			
			R[$IP] = R[$IP] + 2;
			break;

		case POPB:    // POPB $R   BB
			DBG_RUN0("Optimized HANDLE_POPB\n");
			badStack(R[$SP] + 1, R[$IP]);
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)*((S1 *)&RAM[ R[$SP] ]);
			R[$SP] = R[$SP] + 1;
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case POPW:    // POPW $R   BB
			DBG_RUN0("Optimized HANDLE_POPW\n");
			badStack(R[$SP] + 2, R[$IP]);
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)*((S2 *)&RAM[ R[$SP] ]);
			R[$SP] = R[$SP] + 2;

			R[$IP] = R[$IP] + 2;
			break;
			
		case POPD:    // POPD $R   BB
			DBG_RUN0("Optimized HANDLE_POPD\n");
			badStack(R[$SP] + 4, R[$IP]);
			if (nErrors > 0)
				return;
			R[ RAM[R[$IP] + 1] ] = (S8)*((S4 *)&RAM[ R[$SP] ]);
			R[$SP] = R[$SP] + 4;
							
			R[$IP] = R[$IP] + 2;
			break;
			
		case POPQ:    // POPQ $R   BB
			DBG_RUN0("Optimized HANDLE_POPQ\n");
			badStack(R[$SP] + 8, R[$IP]);
			if (nErrors > 0)
				return;							
			R[ RAM[R[$IP] + 1] ] = (S8)*((S8 *)&RAM[ R[$SP] ]);
			R[$SP] = R[$SP] + 8;
							
			R[$IP] = R[$IP] + 2;
			break;
			
		case POPF1:    // POPF1 $F   BB
			DBG_RUN0("Optimized HANDLE_POPF1\n");
			badStack(R[$SP] + 4, R[$IP]);
			if (nErrors > 0)
				return;								
			Rf[ RAM[R[$IP] + 1] ] = (F4)*((F4 *)&RAM[ R[$SP] ]);
			R[$SP] = R[$SP] + 4;
							
			R[$IP] = R[$IP] + 2;
			break;
			
		case POPF2:    // POPF2 $D   BB
			DBG_RUN0("Optimized HANDLE_POPF2\n");
			badStack(R[$SP] + 8, R[$IP]);
			if (nErrors > 0)
				return;	
			Rd[ RAM[R[$IP] + 1] ] = (F8)*((F8 *)&RAM[ R[$SP] ]);
			R[$SP] = R[$SP] + 8;
							
			R[$IP] = R[$IP] + 2;
			break;

		case MOV:    // MOV $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_MOV\n");
			R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 2] ];
							
			R[$IP] = R[$IP] + 3;
			break;
			
		case MOVF:    // MOVF $F1, $F2   BBB
			DBG_RUN0("Optimized HANDLE_MOVF\n");
			Rf[ RAM[R[$IP] + 1] ] = Rf[ RAM[R[$IP] + 2] ];
							
			R[$IP] = R[$IP] + 3;
			break;
			
		case MOVD:    // MOVD $D1, $D2   BBB
			DBG_RUN0("Optimized HANDLE_MOVD\n");
			Rd[ RAM[R[$IP] + 1] ] = Rd[ RAM[R[$IP] + 2] ];
							
			R[$IP] = R[$IP] + 3;
			break;
			
		case JMP:    // JMP $R   BB
			DBG_RUN0("Optimized HANDLE_JMP\n");
			u8_temp = R[ RAM[R[$IP] + 1] ];
			badAddress(u8_temp, R[$IP]); 
			if (nErrors > 0)
				return;

			R[$IP] = u8_temp;
			break;
			
		case JE:    // JE $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_JE\n");
			if (R[ RAM[R[$IP] + 1] ] == R[ RAM[R[$IP] + 2] ])
			{
			    u8_temp = R[ RAM[R[$IP] + 3] ];
			    badAddress(u8_temp, R[$IP]); 
			    if (nErrors > 0)
				    return;
                R[$IP] = u8_temp;
			}
			else
			{
				R[$IP] = R[$IP] + 4; 
			}
			break;
			
		case JNE:    // JNE $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_JNE\n");
			if (R[ RAM[R[$IP] + 1] ] != R[ RAM[R[$IP] + 2] ])
			{
			    u8_temp = R[ RAM[R[$IP] + 3] ];
			    badAddress(u8_temp, R[$IP]); 
			    if (nErrors > 0)
				    return;
                R[$IP] = u8_temp;
			}
			else
			{
				R[$IP] = R[$IP] + 4; 
			}
			break;
			
		case SLT:    // SLT $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_SLT\n"); 
			if (R[ RAM[R[$IP] + 2] ] < R[ RAM[R[$IP] + 3] ])
			{
				R[ RAM[R[$IP] + 1] ] = (U8)0x1;
			}
			else
			{ 
				R[ RAM[R[$IP] + 1] ] = (U8)0; 
			}
			
			R[$IP] = R[$IP] + 4;
			break;
		
		case INT:    // INT byte   BB