run.c

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

			DBG_RUN0("Optimized HANDLE_INT\n");
			handleInt( (U1)RAM[R[$IP] + 1] );
	        if (nErrors > 0)
				return;
			
			R[$IP] = R[$IP] + 2;
			break;
			
		case DI:    // DI   B
			DBG_RUN0("Optimized HANDLE_DI\n");
			interruptOn = FALSE;
						
			R[$IP] = R[$IP] + 1;
			break;
			
		case EI:    // EI   B
			DBG_RUN0("Optimized HANDLE_EI\n");
			interruptOn = TRUE;					
			
			R[$IP] = R[$IP] + 1;
			break;
			
		case NOP:    // NOP   B
			DBG_RUN0("Optimized HANDLE_NOP\n");
			
			R[$IP] = R[$IP] + 1;
			break;

		case AND:    // AND $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_AND\n");
			R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 2] ] & R[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case OR:    // OR $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_OR\n");
			R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 2] ] | R[ RAM[R[$IP] +3 ] ];

			R[$IP] = R[$IP] + 4;
			break;
			
		case XOR:    // XOR $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_XOR\n");
			R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 2] ] ^ R[ RAM[R[$IP] + 3] ];
			
			R[$IP] = R[$IP] + 4;
			break;
			
		case NOT:    // NOT $R1, $R2   BBB
			DBG_RUN0("Optimized HANDLE_NOT\n");
			R[ RAM[R[$IP] + 1] ] = ~ R[ RAM[R[$IP] + 2] ];
						
			R[$IP] = R[$IP] + 3;
			break;
			
		case BT:    // BT $R1, $R2, $R3   BBBB
			handleBT();
			if (nErrors > 0)
				return;
			break;
			
		case BS:    // BS $R1, $R2   BBB
			handleBS();
			if (nErrors > 0)
				return;
			break;

		case SRA:    // SRA $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_SRA\n");
			R[ RAM[R[$IP] + 1] ] = ((S8)R[ RAM[R[$IP] + 2] ]) >> ((S8)R[ RAM[R[$IP] + 3] ]);
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case SRL:    // SRL $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_SRL\n");
			R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 2] ] >> R[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case SL:    // SL $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_SL\n"); 
			R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 2] ] << R[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;

		case ADD:    // ADD $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_ADD\n");
			R[ RAM[R[$IP] + 1] ] = ((S8)R[ RAM[R[$IP] + 2] ]) + ((S8)R[ RAM[R[$IP] + 3] ]);
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case SUB:    // SUB $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_SUB\n");
			R[ RAM[R[$IP] + 1] ] = ((S8)R[ RAM[R[$IP] + 2] ]) - ((S8)R[ RAM[R[$IP] + 3] ]);
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case MULT:    // MULT $R1, $R2, $R3   BBBB
			DBG_RUN0("Optimized HANDLE_MULT\n");
			R[ RAM[R[$IP] + 1] ] = ((S8)R[ RAM[R[$IP] + 2] ]) * ((S8)R[ RAM[R[$IP] + 3] ]);
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case DIV:    // DIV $R1, $R2, $R3, $R4   BBBBB
			DBG_RUN0("Optimized HANDLE_DIV\n");
	        if (R[ RAM[R[$IP] + 4] ] == 0)
			{ 
				ERROR0("Divide by zero!");
				return;
			}
			else
			{ 
				R[ RAM[R[$IP] + 1] ] = ((S8)R[ RAM[R[$IP] + 3] ]) / ((S8)R[ RAM[R[$IP] + 4] ]);
				R[ RAM[R[$IP] + 2] ] = ((S8)R[ RAM[R[$IP] + 3] ]) % ((S8)R[ RAM[R[$IP] + 4] ]);
			}

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

		case CAST_IF:    // CAST_IF $R, $F   BBB
			DBG_RUN0("Optimized CAST_IF\n");
			R[ RAM[R[$IP] + 1] ] = (S8)Rf[ RAM[R[$IP] + 2] ];
						
			R[$IP] = R[$IP] + 3;
			break;
			
		case CAST_ID:    // CAST_ID $R, $D   BBB
			DBG_RUN0("Optimized CAST_ID\n");
			R[ RAM[R[$IP] + 1] ] = (S8)Rd[ RAM[R[$IP] + 2] ];
						
			R[$IP] = R[$IP] + 3;
			break;
			
		case CAST_FI:    // CAST_FI $F, $R   BBB
			DBG_RUN0("Optimized CAST_FI\n");
			Rf[ RAM[R[$IP] + 1] ] = (F4)((S8)R[ RAM[R[$IP] + 2] ]);
						
			R[$IP] = R[$IP] + 3;
			break;
			
		case CAST_FD:    // CAST_FD $F, $D   BBB
			DBG_RUN0("Optimized CAST_FD\n");
			Rf[ RAM[R[$IP] + 1] ] = (F4)Rd[ RAM[R[$IP] + 2] ];
						
			R[$IP] = R[$IP] + 3;
			break;
			
		case CAST_DI:    // CAST_DI $D, $R   BBB
			DBG_RUN0("Optimized CAST_DI\n");
			Rd[ RAM[R[$IP] + 1] ] = (F8)((S8)R[ RAM[R[$IP] + 2] ]);
						
			R[$IP] = R[$IP] + 3;
			break;
			
		case CAST_DF:    // CAST_DF $D, $F   BBB
			DBG_RUN0("Optimized CAST_DF\n");
			Rd[ RAM[R[$IP] + 1] ] = (F8)Rf[ RAM[R[$IP] + 2] ];
						
			R[$IP] = R[$IP] + 3;
			break;

		case FADD:    // FADD $F1, $F2, $F3   BBBB
			DBG_RUN0("Optimized HANDLE_FADD\n"); 
			Rf[ RAM[R[$IP] + 1] ] = Rf[ RAM[R[$IP] + 2] ] + Rf[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case FSUB:    // FSUB $F1, $F2, $F3   BBBB
			DBG_RUN0("Optimized HANDLE_FSUB\n");
			Rf[ RAM[R[$IP] + 1] ] = Rf[ RAM[R[$IP] + 2] ] - Rf[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case FMULT:    // FMULT $F1, $F2, $F3   BBBB
			DBG_RUN0("Optimized HANDLE_FMULT\n");
			Rf[ RAM[R[$IP] + 1] ] = Rf[ RAM[R[$IP] + 2] ] * Rf[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case FDIV:    // FDIV $F1, $F2, $F3   BBBB
			DBG_RUN0("Optimized HANDLE_FDIV\n"); 
			Rf[ RAM[R[$IP] + 1] ] = Rf[ RAM[R[$IP] + 2] ] / Rf[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case FSLT:    // FSLT $F1, $F2, $F3   BBBB
			DBG_RUN0("Optimized HANDLE_FSLT\n");
		    if (Rf[ RAM[R[$IP] + 2] ] < Rf[ RAM[R[$IP] + 3] ])
			{ 
				Rf[ RAM[R[$IP] + 1] ] = 1.0; 
			}
		    else
			{ 
				Rf[ RAM[R[$IP] + 1] ] = 0.0; 
			}
		
			R[$IP] = R[$IP] + 4;
			break;

		case DADD:    // DADD $D1, $D2, $D3   BBBB
			DBG_RUN0("Optimized HANDLE_DADD\n");
			Rd[ RAM[R[$IP] + 1] ] = Rd[ RAM[R[$IP] + 2] ] + Rd[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case DSUB:    // DSUB $D1, $D2, $D3   BBBB
			DBG_RUN0("Optimized HANDLE_DSUB\n");
			Rd[ RAM[R[$IP] + 1] ] = Rd[ RAM[R[$IP] + 2] ] - Rd[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case DMULT:    // DMULT $D1, $D2, $D3   BBBB
			DBG_RUN0("Optimized HANDLE_DMULT\n");
			Rd[ RAM[R[$IP] + 1] ] = Rd[ RAM[R[$IP] + 2] ] * Rd[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case DDIV:    // DDIV $D1, $D2, $D3   BBBB
			DBG_RUN0("Optimized HANDLE_DDIV\n");
			Rd[ RAM[R[$IP] + 1] ] = Rd[ RAM[R[$IP] + 2] ] / Rd[ RAM[R[$IP] + 3] ];
						
			R[$IP] = R[$IP] + 4;
			break;
			
		case DSLT:    // DSLT $D1, $D2, $D3   BBBB
			DBG_RUN0("Optimized HANDLE_DSLT\n");
		    if (Rd[ RAM[R[$IP] + 2] ] < Rd[ RAM[R[$IP] + 3] ])
			{ 
				Rd[ RAM[R[$IP] + 1] ] = 1.0; 
			}
		    else
			{ 
				Rd[ RAM[R[$IP] + 1] ] = 0.0; 
			}
		
			R[$IP] = R[$IP] + 4;
			break;

		default:
			ERROR0("run(): fatal error: bad instruction.\n");

			xmlBegin();
			fprintf(errPtr, "run(): ");
			fprintf(errPtr, "bad instruction (%d) ", RAM[R[$IP]]);
			fprintf(errPtr, "at address = ");
			fpU8(errPtr, (U8)R[$IP]);
			fprintf(errPtr, "\n");
			xmlEnd();
			return;
		
		} /*end switch*/

		if (debug == TRUE)
		{ 
			printDbgInstr(start_debug_instr); 
		}

		tick++;
		if (tick == 65535)
			tick = 0;

	} /*end while*/

	if (RAM[ R[$IP] ] == HALT)
	{
	    DBG_RUN0("HALT instruction executed\n");
	}
	else
	{
        DBG_RUN0("the last instruction executed\n");
    }

	return;

}/*end run*/


void badAddress(U8 arg, U8 currentbyte)
{	
	if (arg > R[$TOP]) 
	{ 
		ERROR0("badAddress(): invalid address literal");
		
		xmlBegin();
		fprintf(errPtr, "badAddress(): invalid address literal ");
		fpU8(errPtr, arg); 
		fprintf(errPtr, " at memory location "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();

		return;
	}
	return;

}

void badStack(U8 arg, U8 currentbyte)
{
	if (arg <= R[$HE]) 
	{ 
		ERROR0("badStack(): stack overflow into heap");

		xmlBegin();
		fprintf(errPtr, "badStack(): ");
		fpU8(errPtr, arg); 
		fprintf(errPtr, " stack overflow into heap "); 
		fprintf(errPtr, "at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();

		return;
	}
	else if (arg > R[$TOP])
	{
		ERROR0("badStack(): stack underflow beyond $TOP");

		xmlBegin();
		fprintf(errPtr, "badStack(): ");
		fpU8(errPtr, arg); 
		fprintf(errPtr, " stack underflow beyond $TOP "); 
		fprintf(errPtr, "at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();

		return;
	}
	return;

}/*end badStack*/ 

void badHeap(U8 arg, U8 currentbyte)
{
	if (arg < R[$HS]) 
	{ 
		ERROR0("badHeap(): below heap");

		xmlBegin();
		fprintf(errPtr, "badHeap(): ");
		fpU8(errPtr, arg); 
		fprintf(errPtr, " below start of heap "); 
		fprintf(errPtr, "at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();

		return;
	}
	else if (arg > R[$HE])
	{
		ERROR0("badHeap(): beyond end of heap");

		xmlBegin();
		fprintf(errPtr, "badHeap(): ");
		fpU8(errPtr, arg); 
		fprintf(errPtr, " beyond end of heap "); 
		fprintf(errPtr, "at address "); 
		fpU8(errPtr, currentbyte); 
		xmlEnd();

		return;
	}
	return;

}/*end badHeap*/

void handleBT()
{
	int index;
	U8 mask;
	U8 bit;    /* 0-63 */

	DBG_RUN0("handleBT\n"); 
	
	bit = R[ RAM[R[$IP] + 3] ]; 
	if (bit > 63)
	{
		ERROR0("handleBT(): bit index is out of range");
		return;
	}
	
	mask = (U8)0x1;
	for (index = 0; index < bit; index++)
	{
		mask = mask * 2;
	}

	mask = R[ RAM[R[$IP] + 2] ] & mask;
	if (mask > 0)
	{ 
		R[ RAM[R[$IP] + 1] ] = 0x1; 
	}
	else
	{ 
		R[ RAM[R[$IP] + 1] ] = 0x0; 
	}
	
	R[$IP] = R[$IP] + 4;
	return;

}

void handleBS()
{
	int index;
	U8 mask;
	U8 bit; /* 0-63 */

	DBG_RUN0("handleBS\n"); 

	bit = R[ RAM[R[$IP] + 2] ];
	if (bit > 63)
	{
		ERROR0("handleBS(): bit index is out of range");
		return;
	}

	mask = (U8)0x1;
	for (index = 0; index < bit; index++)
	{
		mask = mask * 2;
	}

	R[ RAM[R[$IP] + 1] ] = R[ RAM[R[$IP] + 1] ] | mask;

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

} /*end handleBS*/