pass2.cpp

虚拟机设计与实现——C/C++

				}

			}break;
			case 'J':
			{
				if(strcmp((*tptr).text,"JMP")==0){ IR(JMP,tptr);}
				else if(strcmp((*tptr).text,"JE")==0){ I3R(JE,tptr);}
				else if(strcmp((*tptr).text,"JNE")==0){ I3R(JNE,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'L':
			{
				if(strcmp((*tptr).text,"LBI")==0){ IRC(LBI,1,tptr);}
				else if(strcmp((*tptr).text,"LWI")==0){ IRC(LWI,2,tptr);}
				else if(strcmp((*tptr).text,"LDI")==0){ IRC(LDI,4,tptr);}
				else if(strcmp((*tptr).text,"LQI")==0){ IRC(LQI,8,tptr);}
				else if(strcmp((*tptr).text,"LF1I")==0){ IFC(LF1I,tptr);}
				else if(strcmp((*tptr).text,"LF2I")==0){ IDC(LF2I,tptr);}
				else if(strcmp((*tptr).text,"LB")==0){ I2R(LB,tptr);}
				else if(strcmp((*tptr).text,"LW")==0){ I2R(LW,tptr);}
				else if(strcmp((*tptr).text,"LD")==0){ I2R(LD,tptr);}
				else if(strcmp((*tptr).text,"LQ")==0){ I2R(LQ,tptr);}
				else if(strcmp((*tptr).text,"LF1")==0){ IFR(LF1,tptr);}
				else if(strcmp((*tptr).text,"LF2")==0){ IDR(LF2,tptr);}
				else if(strcmp((*tptr).text,"LAD")==0){ IRA(tptr);}
				else if(strcmp((*tptr).text,"LAI")==0){ I2RA(tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'M':
			{
				if(strcmp((*tptr).text,"MOV")==0){ I2R(MOV,tptr); }
				else if(strcmp((*tptr).text,"MOVF")==0){ I2F(MOVF,tptr); }
				else if(strcmp((*tptr).text,"MOVD")==0){ I2D(MOVD,tptr); }
				else if(strcmp((*tptr).text,"MULT")==0){ I3R(MULT,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'N':
			{
				if(strcmp((*tptr).text,"NOT")==0){ I2R(NOT,tptr);}
				else if(strcmp((*tptr).text,"NOP")==0){ I(NOP,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'O':
			{
				if(strcmp((*tptr).text,"OR")==0){ I3R(OR,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'P':
			{
				if(strcmp((*tptr).text,"PUSHB")==0){ IR(PUSHB,tptr);}
				else if(strcmp((*tptr).text,"PUSHW")==0){ IR(PUSHW,tptr);}
				else if(strcmp((*tptr).text,"PUSHD")==0){ IR(PUSHD,tptr);}
				else if(strcmp((*tptr).text,"PUSHQ")==0){ IR(PUSHQ,tptr);}
				else if(strcmp((*tptr).text,"PUSHF1")==0){ IF(PUSHF1,tptr);}
				else if(strcmp((*tptr).text,"PUSHF2")==0){ ID(PUSHF2,tptr);}
				else if(strcmp((*tptr).text,"POPB")==0){ IR(POPB,tptr);}
				else if(strcmp((*tptr).text,"POPW")==0){ IR(POPW,tptr);}
				else if(strcmp((*tptr).text,"POPD")==0){ IR(POPD,tptr);}
				else if(strcmp((*tptr).text,"POPQ")==0){ IR(POPQ,tptr);}
				else if(strcmp((*tptr).text,"POPF1")==0){ IF(POPF1,tptr);}
				else if(strcmp((*tptr).text,"POPF2")==0){ ID(POPF2,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'S':
			{
				if(strcmp((*tptr).text,"SB")==0){ I2R(SB,tptr);}
				else if(strcmp((*tptr).text,"SW")==0){ I2R(SW,tptr);}
				else if(strcmp((*tptr).text,"SD")==0){ I2R(SD,tptr);}
				else if(strcmp((*tptr).text,"SQ")==0){ I2R(SQ,tptr);}
				else if(strcmp((*tptr).text,"SF1")==0){ IFR(SF1,tptr);}
				else if(strcmp((*tptr).text,"SF2")==0){ IDR(SF2,tptr);}
				else if(strcmp((*tptr).text,"SRA")==0){ I3R(SRA,tptr);}
				else if(strcmp((*tptr).text,"SRL")==0){ I3R(SRL,tptr);}
				else if(strcmp((*tptr).text,"SL")==0){ I3R(SL,tptr);}
				else if(strcmp((*tptr).text,"SUB")==0){ I3R(SUB,tptr);}
				else if(strcmp((*tptr).text,"SLT")==0){ I3R(SLT,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			case 'X':
			{
				if(strcmp((*tptr).text,"XOR")==0){ I3R(XOR,tptr);}
				else
				{
					ERROR2("processInstructionPass1(): line %d, invalid opcode (%s)\n",(*tptr).line,(*tptr).text);
					return;
				}

			}break;
			default:
			{
				ERROR3("Pass2::processInstruction(): %s on line %lu type %s not a valid opcode\n",(*tptr).text,(*tptr).line,TokStr[(*tptr).type]);
				return;
			}
		}/*end switch*/
	}
	else
	{
		ERROR3("Pass2::processInstruction(): %s on line %lu type %s not a valid opcode\n",(*tptr).text,(*tptr).line,TokStr[(*tptr).type]);
	}
	return;

}/*end processInstruction*/

/*------------------------------------------------------------------*/

void Pass2::I(U1 opcode, struct Token *tptr) /* Instruction */
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	nBYTES = 1;

	sprintf(lineNumber,"%lu",(*tptr).line);

	strcpy(listing,(*tptr).text);
	strcat(listing," ");
	encoded[0]=opcode;

	bret = (*toker).match(&t,TOK_NO_MORE);
	if(bret!=TRUE)
	{ 
		return; 
	}

	commitToFiles(nBYTES);

	bytePosPass2 = bytePosPass2 + nBYTES;
	return;

}/*end I*/

/*------------------------------------------------------------------*/

void Pass2::IB(U1 opcode, struct Token *tptr)
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	nBYTES = 2; 

	sprintf(lineNumber,"%lu",(*tptr).line);

	strcpy(listing,(*tptr).text);
	strcat(listing," ");
	encoded[0]=opcode;

	bret = (*toker).match(&t,TOK_INT_CONST);
	if(bret==TRUE)
	{
		char number[8];
		sprintf(number,"%d",(U1)t.val);
		strcat(listing,number);
		encoded[1]=(U1)t.val;
	}
	else
	{ 
		return; 
	}

	bret = (*toker).match(&t,TOK_NO_MORE);
	if(bret!=TRUE)
	{ 
		return; 
	}

	commitToFiles(nBYTES);

	bytePosPass2 = bytePosPass2 + nBYTES;
	return;

}/*end IB*/

/*-----------------------------------------------------------------*/

void Pass2::IR(U1 opcode, struct Token *tptr) /* Instruction IntegerRegister */
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	nBYTES = 2;

	sprintf(lineNumber,"%lu",(*tptr).line);

	strcpy(listing,(*tptr).text);
	strcat(listing," ");
	encoded[0]=opcode;

	bret = (*toker).match(&t,TOK_INT_REG);
	if(bret==TRUE)
	{
		strcat(listing,t.text);
		encoded[1]=(U1)t.val;
	}
	else
	{ 
		return; 
	}

	bret = (*toker).match(&t,TOK_NO_MORE);
	if(bret!=TRUE)
	{ 
		return; 
	}

	commitToFiles(nBYTES);

	bytePosPass2 = bytePosPass2 + nBYTES;
	return;

}/*end IR*/

/*------------------------------------------------------------------*/

/* Instruction IntegerRegister Constant */

void Pass2::IRC(U1 opcode, U1 bytes, struct Token *tptr) 
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	nBYTES = 2+bytes; /*bytes = 1,2,4,8 ( byte->qword )*/

	sprintf(lineNumber,"%lu",(*tptr).line);

	strcpy(listing,(*tptr).text);
	strcat(listing," ");
	encoded[0]=opcode;

	bret = (*toker).match(&t,TOK_INT_REG);
	if(bret==TRUE)
	{
		strcat(listing,t.text);
		encoded[1]=(U1)t.val;
	}
	else
	{ 
		return; 
	}

	bret = (*toker).match(&t,TOK_COMMA);
	if(bret==TRUE){ strcat(listing,t.text); }
	else
	{ 
		return; 
	}

	t = (*toker).getNextLineToken();
	if(t.type==TOK_INT_CONST)
	{
		strcat(listing,t.text);
		switch(bytes)
		{
			case 1:
			{ 
				encoded[2] = (U1)t.val; 
			}break;
			case 2:
			{ 
				wordToBytecode((U2)t.val, &encoded[2]);
			}break;
			case 4:
			{ 
				dwordToBytecode((U4)t.val, &encoded[2]);
			}break;
			case 8:
			{ 
				qwordToBytecode(t.val, &encoded[2]);
			}break;
		}
	}
	else if(t.type==TOK_CHAR_CONST)
	{
		strcat(listing,t.text);
		encoded[2]=0;encoded[3]=0;encoded[4]=0;encoded[5]=0;
		encoded[6]=0;encoded[7]=0;encoded[8]=0;encoded[9]=0;
		
		/*encode in big-endian format*/

		switch(bytes)
		{
			case 1:{ encoded[2] = (U1)t.val; }break;
			case 2:{ encoded[3] = (U1)t.val; }break;
			case 4:{ encoded[5] = (U1)t.val; }break;
			case 8:{ encoded[9] = (U1)t.val; }break;
		}
	}
	else
	{ 
		return; 
	}

	bret = (*toker).match(&t,TOK_NO_MORE);
	if(bret!=TRUE)
	{ 
		return; 
	}

	commitToFiles(nBYTES);

	bytePosPass2 = bytePosPass2 + nBYTES;
	return;
	
}/*end IRC*/

/*------------------------------------------------------------------*/

/* Instruction IntegerRegisters identifier */

void Pass2::IRA(struct Token *tptr) 
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	struct HashTbl *hptr;

	nBYTES = 2+8; /*address = 8 bytes*/

	sprintf(lineNumber,"%lu",(*tptr).line);

	strcpy(listing,(*tptr).text);
	strcat(listing," ");
	encoded[0]=LAD;

	bret = (*toker).match(&t,TOK_INT_REG);
	if(bret==TRUE)
	{
		strcat(listing,t.text);
		encoded[1]=(U1)t.val;
	}
	else
	{ 
		return; 
	}

	bret = (*toker).match(&t,TOK_COMMA);
	if(bret==TRUE)
	{ 
		strcat(listing,t.text); 
	}
	else
	{ 
		return; 
	}

	t = (*toker).getNextLineToken();
	if(t.type==TOK_IDENTIFIER)
	{
		strcat(listing,t.text);

		/*symbol must exist*/

		hptr =  (*hashTbl).queryHashTbl(t.text);
		if(hptr==NULL)
		{
			ERROR2("IRA(): line %lu, undefined identifier %s\n",t.line,t.text);
			return;
		}
		else
		{
			/*must be symbol type =  PROC, PROC_LBL */

			U8 val;
			if((*hptr).type==PROC)
			{
				/*resolve offset/address */
				val = ((*symTbl).proc[(*hptr).index]).address; 
				qwordToBytecode(val, &encoded[2]); 
			}
			else if((*hptr).type==PROC_LBL)
			{
				/*resolve offset/address */
				val = (((*symTbl).proc[(*hptr).index]).label[(*hptr).subIndex]).address;
				qwordToBytecode(val, &encoded[2]); 
			}
			else
			{
				ERROR2("IRA(): line %lu, invalid operand for LAD %s\n",t.line,t.text);
				return;
			}
		}
	}
	else
	{ 
		ERROR2("IRA(): line %lu, invalid constant %s\n",t.line,t.text);
		return; 
	}

	bret = (*toker).match(&t,TOK_NO_MORE);
	if(bret!=TRUE){ return; }

	commitToFiles(nBYTES);

	bytePosPass2 = bytePosPass2 + nBYTES;
	return;

}/*end IRA*/

/*------------------------------------------------------------------*/

/* Instruction 2IntegerRegisters identifier */

void Pass2::I2RA(struct Token *tptr) 
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	struct HashTbl *hptr;
	nBYTES = 3+8; /*address = 8 bytes*/

	sprintf(lineNumber,"%lu",(*tptr).line);

	strcpy(listing,(*tptr).text);
	strcat(listing," ");
	encoded[0]=LAI;

	bret = (*toker).match(&t,TOK_INT_REG);
	if(bret==TRUE)
	{
		strcat(listing,t.text);
		encoded[1]=(U1)t.val;
	}
	else{ return; }

	bret = (*toker).match(&t,TOK_COMMA);
	if(bret==TRUE){ strcat(listing,t.text); }
	else{ return; }

	bret = (*toker).match(&t,TOK_INT_REG);
	if(bret==TRUE)
	{
		strcat(listing,t.text);
		encoded[2]=(U1)t.val;
	}
	else{ return; }

	bret = (*toker).match(&t,TOK_COMMA);
	if(bret==TRUE){ strcat(listing,t.text); }
	else{ return; }

	t = (*toker).getNextLineToken();
	if(t.type==TOK_IDENTIFIER)
	{
		strcat(listing,t.text);

		/*symbol must exist*/

		hptr =  (*hashTbl).queryHashTbl(t.text);
		if(hptr==NULL)
		{
			ERROR2("I2RA(): line %lu, undefined identifier %s\n",t.line,t.text);
			return;
		}
		else
		{
			/*must be symbol type = GLOBAL_VAR, PROC_RET, PROC_ARG, PROC_LOC */

			S8 val;
			if((*hptr).type==GLOBAL_VAR)
			{
				/*resolve offset/address */
				val = -((S8)((*symTbl).globVar[(*hptr).index]).offset);
				qwordToBytecode(val, &encoded[3]); 
			}
			else if((*hptr).type==PROC_RET)
			{
				/*resolve offset/address */
				val = (((*symTbl).proc[(*hptr).index]).ret).fpOffset;
				qwordToBytecode(val, &encoded[3]); 
			}
			else if((*hptr).type==PROC_ARG)
			{
				/*resolve offset/address */
				val = (((*symTbl).proc[(*hptr).index]).arg[(*hptr).subIndex]).fpOffset;
				qwordToBytecode(val, &encoded[3]); 
			}
			else if((*hptr).type==PROC_LOC)
			{
				/*resolve offset/address */
				val = (((*symTbl).proc[(*hptr).index]).local[(*hptr).subIndex]).fpOffset;
				qwordToBytecode(val, &encoded[3]); 
			}
			else
			{
				ERROR2("I2RA(): line %lu, invalid operand for LAD %s\n",t.line,t.text);
				return;
			}
		}
	}
	else
	{ 
		ERROR2("I2RA(): line %lu, invalid constant %s\n",t.line,t.text);
		return; 
	}

	bret = (*toker).match(&t,TOK_NO_MORE);
	if(bret!=TRUE){ return; }

	commitToFiles(nBYTES);

	bytePosPass2 = bytePosPass2 + nBYTES;
	return;

}/*end I2RA*/

/*------------------------------------------------------------------*/

void Pass2::I2R(U1 opcode, struct Token *tptr) /* Instruction 2IntegerRegisters */
{
	struct Token t;
	U1 bret;
	U1 nBYTES;
	nBYTES = 3;