sim_proc.cpp

run mips program using C++

#include "sim_proc.h"

using namespace std;


/////////////////////////////////////////////////////////
// # NAME: Fok On Man
// # ID: 06035253
// # EMAIL: cs_fom
// # Lab Section: LA1D
// # Class Number:
/////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////
//
//
//  The following part needs your work
//
//
/////////////////////////////////////////////////////////
unsigned int Simulator::Fetch(unsigned int pc)
{
	unsigned int IR;
	IR = prog.LoadInstr(pc);
	if(IR == -1 || IR == 0)
		return IR;	// finishes execution

	PC = PC + 4;
	ALUOut = PC;

	// update the signals
	signals.PCWrite = 1;
	signals.PCSource = 0;
	signals.IorD = 0;
	signals.IRWrite = 1;
	signals.MemRead = 1;
	signals.MemWrite = 0;
	signals.ALUSrcA = 0;
	signals.ALUSrcB = 1;
	signals.RegWrite = 0;

	PrintAllSignalsAndRegs();
	return IR;
}

unsigned int Simulator::Decode(const unsigned int IR)
{
	A = GetRS (IR);
	B = GetRT (IR);

	unsigned int Extend = GetIM(IR);		// store the value that need to be extended

	 if (Extend >= ( 1 << 15))		// extension
		Extend = Extend | (65535 << 16);

	ALUOut = PC + (Extend << 2);

	//update signals
	signals.PCWrite = 0;
	signals.PCWriteCond = 0;
	signals.IRWrite = 0;
	signals.MemRead = 0;
	signals.MemWrite = 0;
	signals.ALUSrcA = 0;
	signals.ALUSrcB = 3;
	signals.RegWrite = 0;

	PrintAllSignalsAndRegs();
	return 1;
}

unsigned int Simulator::Execute(const unsigned int IR)
{
	if (GetOP(IR) == 0)		// for R-type
	{
		 if (GetFN(IR) == 8)		// jr
		{
			PC = A;

			//update signals
			signals.PCWrite = 1;
			signals.PCSource = 3;
			signals.IRWrite = 0;
			signals.MemRead = 0;
			signals.MemWrite = 0;
			signals.RegWrite = 0;

			PrintAllSignalsAndRegs();
			return 0;
		}

		if (GetFN(IR) == 32)		// add
			ALUOut = A + B;

		if (GetFN(IR) == 34)		// sub
			ALUOut = A - B;

		if (GetFN(IR) == 36)		// and
			ALUOut = A & B;

		if (GetFN(IR) == 37)		// or
			ALUOut = A | B;

		if (GetFN(IR) == 42)		// slt
			ALUOut = A < B;

		//update signals
		signals.PCWrite = 0;
		signals.PCWriteCond = 0;
		signals.IRWrite = 0;
		signals.MemRead = 0;
		signals.MemWrite = 0;
 	 	signals.ALUSrcA = 1;
		signals.ALUSrcB = 0;
		signals.RegWrite = 0;

		PrintAllSignalsAndRegs();
		return 1;
 	}
 	else
 	{
		unsigned int Extend = GetIM(IR);		// store the value that need to be extended

		if (Extend >= ( 1 << 15))		// extension
			Extend = Extend | (65535 << 16);

		if  (GetOP(IR) == 2)		// j
		{
			PC = ((PC >> 28 << 28) | (GetAD(IR) << 2));

			// update signals
			signals.PCWrite = 1;
			signals.PCSource = 2;
			signals.IRWrite = 0;
			signals.MemRead = 0;
			signals.MemWrite = 0;
			signals.RegWrite = 0;

			PrintAllSignalsAndRegs();
			return 0;
		}

		if  (GetOP(IR) == 4)		// beq
		{
			if (A == B)
				PC = ALUOut;

			//update signals
			signals.PCWrite = 0;
			signals.PCWriteCond = 1;
			signals.PCSource = 1;
			signals.IRWrite = 0;
			signals.MemRead = 0;
			signals.MemWrite = 0;
			signals.ALUSrcA = 1;
			signals.ALUSrcB = 0;
			signals.RegWrite = 0;

			PrintAllSignalsAndRegs();
			return 0;
		}

		if  (GetOP(IR) == 8)		// addi
			ALUOut = A + Extend;

		if  (GetOP(IR) == 35)		// lw
			ALUOut = A + Extend;

		if  (GetOP(IR) == 43)		// sw
			ALUOut = A + Extend;

		//update signals
		signals.PCWrite = 0;
		signals.PCWriteCond = 0;
		signals.IRWrite = 0;
		signals.MemRead = 0;
		signals.MemWrite = 0;
		signals.ALUSrcA = 1;
		signals.ALUSrcB = 2;
		signals.RegWrite = 0;

		PrintAllSignalsAndRegs();
		return 1;
	}
}

unsigned int Simulator::MemoryAccess(const unsigned int IR)
{
	// update signals
	signals.PCWrite = 0;
	signals.PCWriteCond = 0;
	signals.IRWrite = 0;

	if (GetOP(IR) == 0)		// for R-type: add, sub, and, or, slt
	{
		SetRD (IR, ALUOut);	// save the result to IR[15-11]

		// update signals
		signals.PCWrite = 0;
		signals.PCWriteCond = 0;
		signals.IRWrite = 0;
		signals.MemRead = 0;
		signals.MemWrite = 0;
		signals.RegDst = 1;
		signals.MemtoReg = 0;
		signals.RegWrite = 1;

		PrintAllSignalsAndRegs();
		return 0;
	}

	if  (GetOP(IR) == 8)		// addi
	{
		SetRT (IR, ALUOut);	// save the result to IR[20-16]

		// update signals
		signals.PCWrite = 0;
		signals.PCWriteCond = 0;
		signals.IRWrite = 0;
		signals.MemRead = 0;
		signals.MemWrite = 0;
		signals.RegDst = 0;
		signals.MemtoReg = 0;
		signals.RegWrite = 1;

		PrintAllSignalsAndRegs();
		return 0;
	}

	if  (GetOP(IR) == 35)		// lw
	{
		MDR = 0;

		// update signals
		signals.PCWrite = 0;
		signals.PCWriteCond = 0;
		signals.IRWrite = 0;
		signals.IorD = 1;
		signals.MemRead = 1;
		signals.RegWrite = 0;

		PrintAllSignalsAndRegs();
		return 1;
	}

	if  (GetOP(IR) == 43)		// sw
	{
		signals.PCWrite = 0;
		signals.PCWriteCond = 0;
		signals.IRWrite = 0;
		signals.IorD = 1;
		signals.MemRead = 0;
		signals.MemWrite = 1;
		signals.RegWrite = 0;

		PrintAllSignalsAndRegs();
		return 0;
	}
}

unsigned int Simulator::WriteBack(const unsigned int IR)
{
	SetRT (IR, MDR);

	// update the signals
	signals.PCWrite = 0;
	signals.PCWriteCond = 0;
	signals.IRWrite = 0;
	signals.MemRead = 0;
	signals.MemWrite = 0;
	signals.RegDst = 0;
	signals.MemtoReg = 1;
	signals.RegWrite = 1;

	PrintAllSignalsAndRegs();
	return 1;
}

// PC is initialized to zero, which is the start address of the program
int Simulator::StartSimulation(Program p)
{
	unsigned int IR;
	prog = p;

	while(true)
	{
		// The simulator will terminate when IR == 0
		// IR == -1 indicates the value of PC is wrong
		IR = Fetch(PC);
		switch(IR)
		{
		case 0:
			cout<<"The simulation finishes successfully!"<<endl;
			return 0;	// quit normally
		case -1:
			cout<<"The simulation breaks due to some fault!"<<endl;
			return 1;	// quit with error
		}

		Decode(IR);

        if (Execute(IR))
			if (MemoryAccess(IR))
				WriteBack(IR);

		cout<<endl;
	}
}

unsigned int Simulator::GetRT(const unsigned int IR)		// IR[20-16]
{
	unsigned int n = IR << 11 >> 27;

	for(int i=0;i<REGISTER_NUM;i++)
	{
		if(prog.RegSet[i].code == n)
			return prog.RegSet[i].value;
	}
	assert(1);
}

unsigned int Simulator::GetRD(const unsigned int IR)		// IR[15-11]
{
	unsigned int n = IR << 16 >> 27;

	for(int i=0;i<REGISTER_NUM;i++)
	{
		if(prog.RegSet[i].code == n)
			return prog.RegSet[i].value;
	}
	assert(1);
}

unsigned int Simulator::GetSH(const unsigned int IR)		// IR[10-6]
{
	return IR << 21 >> 27;
}

unsigned int Simulator::GetFN(const unsigned int IR)		// IR[5-0]
{
	return IR << 26 >> 26;
}

unsigned int Simulator::GetIM(const unsigned int IR)		// IR[15-0]
{
	return IR << 16 >> 16;
}

unsigned int Simulator::GetAD(const unsigned int IR)		// IR[25-0]
{
	return IR << 6 >> 6;
}

void Simulator::SetRD(const unsigned int IR, unsigned int value)		// updae IR[15-11]
{
	unsigned int n = IR << 16 >> 27;

	for(int i=0;i<REGISTER_NUM;i++)
	{
		if(prog.RegSet[i].code == n)
		{
			prog.RegSet[i].value = value;
			return;
		}
	}
}

/////////////////////////////////////////////////////////
//
//
//  The following part is not allowed to be modified
//
//
/////////////////////////////////////////////////////////
int main(int argc, char** argv)
{
	/**initialization*/
	ifPrintOut = true;		//default: printing output information on screen is abled.
	ifWriteToFile = false;  //default: printing output information to file is disabled.
	strcpy(outputFile,"output.txt"); //default: output.txt is the default output file.
	strcpy(inputFile,"ex1.s");
	Program p;
	Simulator s;

	if(getInputPram(argc, argv)==1)
	{
		if(p.LoadProgram(inputFile) <= 0)  //ex1.s is the default input file.
		{
			cout<<"Wrong program file!"<<endl;
			return 0;
		}
		fp = fopen(outputFile,"w");
		if(ifPrintOut)
			printTitle();
		s.StartSimulation(p);
		fclose(fp);
	}
	return 0;
}
//////////////////////////////////////////////////////

int getInputPram(int argc, char** argv)
{
	if(argc>1)
	{
		if(strcmp(argv[1],"-o")==0)
		{
			ifPrintOut=false;
			ifWriteToFile=true;
			strcpy(outputFile, "output.txt");
			if(argc>2)
			{
				strcpy(outputFile,argv[2]);
				if(argc>3)
				{
					if(strcmp(argv[3],"-i")==0)
					{
						if(argc>4)
						{
							strcpy(inputFile,argv[4]);
							return 1;
						}
						else
						{
							cout<<"wrong parameters"<<endl;
							cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
							return 0;
						}
					}
					else
					{
						cout<<"wrong parameters"<<endl;
						cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
						return 0;
					}
				}
				else
					return 1;
			}
			else
			{
				cout<<"wrong parameters"<<endl;
				cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
				return 0;
			}
		}
		else if(strcmp(argv[1],"-i")==0)
		{
			if(argc>2)
			{
				strcpy(inputFile,argv[2]);
				if(argc>3)
				{
					if(strcmp(argv[3],"-o")==0)
					{
						ifPrintOut=false;
						ifWriteToFile=true;
						if(argc>4)
						{
							strcpy(outputFile,argv[4]);
							return 1;
						}
						else
						{
							cout<<"wrong parameters"<<endl;
							cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
							return 0;
						}
					}
					else
					{
						cout<<"wrong parameters"<<endl;
						cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
						return 0;
					}
				}
				else
					return 1;
			}
			else
			{
				cout<<"wrong parameters"<<endl;
				cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
				return 0;
			}
		}
		else
		{
			cout<<"wrong parameters"<<endl;
			cout<<"Usage: [-i inputFile][-o outputFile]"<<endl;
			return 0;
		}
	}
	else
		return 1;
}

void printTitle()
{
        cout<<"Start simulation (print all signals and registers):"<<endl<<endl;
	cout<<"singals sequence: PCWrite-PCWriteCond-PCSrc-IorD-IRWrite-MemRead-MemWrite-RegDst-ALUSrcA-ALUSrcB-MemtoReg-RegWrite\n"<<endl;
	cout<<"PC\tsignals\t\t\t\tA\tB\tALUOut\ts0\ts1\ts2\ts3\ts4\ts5\ts6\ts7"<<endl;
}


Simulator::Simulator()
{
	PC = 0;
	A = 0;
	B = 0;
	ALUOut = 0;
	MDR = 0;
	signals.IorD     = 0;
	signals.IRWrite  = 0;
	signals.RegDst   = 0;
	signals.RegWrite = 0;
	signals.MemtoReg = 0;
	signals.MemRead  = 0;
	signals.MemWrite = 0;
	signals.ALUSrcA  = 0;
	signals.ALUSrcB	 = 0;
	signals.PCWrite  = 0;
	signals.PCWriteCond  = 0;
	signals.PCSource = 0;
}

Simulator::~Simulator()
{
}

void Simulator::PrintAllSignalsAndRegs()
{
	int i, j = 0;
	char signalTable[64];
	signalTable[j++] = (signals.PCWrite   == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.PCWriteCond == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = ((signals.PCSource/2) == 0)?'0':'1';
	signalTable[j++] = ((signals.PCSource%2) == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.IorD     == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.IRWrite  == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.MemRead  == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.MemWrite == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.RegDst   == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = ((signals.ALUSrcA) == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = ((signals.ALUSrcB/2) == 0)?'0':'1';
	signalTable[j++] = ((signals.ALUSrcB%2) == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.MemtoReg == 0)?'0':'1';
	signalTable[j++] = '-';
	signalTable[j++] = (signals.RegWrite == 0)?'0':'1';

	if(ifPrintOut)
	{
		cout<<hex<<"0x"<<PC<<"\t";
		// output all signals
		for(i=0;i<j;i++)
			cout<<signalTable[i];
		cout<<"\t";
		// output all registers
		cout<<hex<<"0x"<<A<<"\t"<<"0x"<<B<<"\t"<<"0x"<<ALUOut<<"\t";
		cout<<hex<<"0x"<<prog.RegSet[16].value<<"\t";	// $s0
		cout<<hex<<"0x"<<prog.RegSet[17].value<<"\t";	// $s1
		cout<<hex<<"0x"<<prog.RegSet[18].value<<"\t";	// $s2
		cout<<hex<<"0x"<<prog.RegSet[19].value<<"\t";	// $s3
		cout<<hex<<"0x"<<prog.RegSet[20].value<<"\t";	// $s4
		cout<<hex<<"0x"<<prog.RegSet[21].value<<"\t";	// $s5
		cout<<hex<<"0x"<<prog.RegSet[22].value<<"\t";	// $s6
		cout<<hex<<"0x"<<prog.RegSet[23].value<<"\t";	// $s7
		cout<<endl;
	}

	if(ifWriteToFile)
	{
		//FILE *fp = fopen(outputFile, "w");
		if(fp!=NULL)
		{
			//fseek(fp, 0, SEEK_END);
			fprintf(fp, "%d\t", PC);
			for(i=0; i<j;i++)
			{
				fprintf(fp,"%c",signalTable[i]);
			}
			fprintf(fp,"\t");

			fprintf(fp,"%d\t%d\t%d\t",A,B,ALUOut);

			for(i=16; i<=23;i++)
			{
				fprintf(fp,"%d\t",prog.RegSet[i].value);
			}
			fprintf(fp,"\n");
		}
	}

}

unsigned int Simulator::GetOP(const unsigned int IR)
{
	return IR >> 26;
}
unsigned int Simulator::GetRS(const unsigned int IR)
{
	unsigned int n = IR << 6 >> 27;
	for(int i=0;i<REGISTER_NUM;i++)
	{
		if(prog.RegSet[i].code == n)
			return prog.RegSet[i].value;
	}
	assert(1);
}

void Simulator::SetRT(const unsigned int IR, unsigned int value)
{
	unsigned int n = IR << 11 >> 27;
	for(int i=0;i<REGISTER_NUM;i++)
	{
		if(prog.RegSet[i].code == n)
		{
			prog.RegSet[i].value = value;
			return;
		}
	}
}