public void decode()
{
//Read the instruction from IR
string inst = IR;
//Decode it's opcode to see if it's I, or R or J:
string opcode = IR.Substring(0, 6);
switch (opcode)
{
case "000000":
//RFormat
string funct = inst.Substring(26);
instruction = Rformat[funct];
break;
case "000010":
//J
instruction = Jformat[opcode];
break;
case "000011":
//J
instruction = Jformat[opcode];
//Jformat.TryGetValue(opcode, out instruction);
break;
case "010000":
//Coproc1
Terminate_Error.Invoke("COPROC Instructions aren't supported by simulator");
break;
case "010001":
//Coproc2
Terminate_Error.Invoke("COPROC Instructions aren't supported by simulator");
break;
case "010010":
//Coproc3
Terminate_Error.Invoke("COPROC Instructions aren't supported by simulator");
break;
//Coproc4
case "010011":
Terminate_Error.Invoke("COPROC Instructions aren't supported by simulator");
break;
default:
//I instruction
instruction = Iformat[opcode];
//Iformat.TryGetValue(opcode, out instruction);
break;
}
//Increment Clock;
Decoded.Invoke();
}
public void execute()
{
/* - Execute:
* 0- If it is jump or beq ... ---> Set PC to addres in jump...
* 1- If Instruction is Interrupt (here only syscall)... well interrupt the process.
* 2- If Memory Access Instruction:
* - Place Address in Memory Address Register (MAR);
* - Then Access Memory (either read data from MDR and place in Mem, or read from Mem and place in MDR)
* 3- Else excecute (on registers);
*
*/
// 1- Check if its jump
if (instruction.format == 2)
{
//Decode Address;
string address = IR.Substring(6);
string pc_string = Convert.ToString(PC, 2);
extendbin(ref pc_string, 32);
//Put 00 in the end and the 4 most significant bits from pc in the front
address = pc_string.Substring(0, 4) + address + "00"; //Absolute Address
//Now check wether it's just jump or jump and link
if (instruction.mnemonic == "jal")
{
//set register RA = old PC +4
Register.Registers.ElementAt <Register>(31).write(PC); //JAL sets the RA to next instruction after JAL.
}
//Add that to the PC
int add = Convert.ToInt32(address, 2);
PC = add;
//Increment Clock
Excecuted.Invoke();
}
// 1- iformat
else if (instruction.format == 1)
{
//Check if it's BRANCH
switch (instruction.mnemonic)
{
case "beq":
//Check for Condition.
string rs = IR.Substring(6, 5);
string rt = IR.Substring(11, 5);
int rs_val = Register.GetValfromBIN(rs);
int rt_val = Register.GetValfromBIN(rt);
if (rt_val == rs_val)
{
//Since its a branch, calculate the address like this
//add the two zeros, then sign extend, then turn to signed int
//then add it to PC+1;
//... first load the 16 bit address :P
string address = IR.Substring(16);
address = address + "00";
signExtend(ref address, 32);
int adrs = Convert.ToInt32(address, 2);
PC = PC + adrs; //Calculate new PC;
Excecuted.Invoke();
}
//ELSE DO NOTHING, PC ALREADY INCREMENTED BY FETCH!
break;
case "bne":
rs = IR.Substring(6, 5);
rt = IR.Substring(11, 5);
rs_val = Register.GetValfromBIN(rs);
rt_val = Register.GetValfromBIN(rt);
if (rt_val != rs_val)
{
//Since its a branch, calculate the address like this
//add the two zeros, then sign extend, then turn to signed int
//then add it to PC+1;
//... first load the 16 bit address :P
string address = IR.Substring(16);
address = address + "00";
signExtend(ref address, 32);
int adrs = Convert.ToInt32(address, 2);
PC = PC + adrs; //Calculate new PC;
Excecuted.Invoke();
}
break;
case "addi":
//Get the registers, do the operation.
//Remmber this has overflow!
rs = IR.Substring(6, 5);
rt = IR.Substring(11, 5);
rs_val = Register.GetValfromBIN(rs);
string imm = IR.Substring(16);
signExtend(ref imm, 32);
//Good boy, now add and pc+1
int imm_sint = Convert.ToInt32(imm, 2);
int val = rs_val + imm_sint;
//Before writing to register, lets check for overflow.
//By translating to bitstring and seeing the size, if more than 32 bits.. overflow
if (overflow(val, 32))
{
OverFlow.Invoke();
Terminate_Error.Invoke("Overflow from instruction in PC: " + PC.ToString() + " has been detected");
}
else
{
//No Overflow, so far so good, replace value in rt by val
Register.Registers.ElementAt <Register>(Convert.ToInt32(rt, 2)).write(val);
Excecuted.Invoke();
}
break;
case "addiu":
//No Overflow;
rs = IR.Substring(6, 5);
rt = IR.Substring(11, 5);
rs_val = Register.GetValfromBIN(rs);
imm = IR.Substring(16);
signExtend(ref imm, 32);
//Good boy, now add and pc+1
imm_sint = Convert.ToInt32(imm, 2);
val = rs_val + imm_sint;
Register.Registers.ElementAt <Register>(Convert.ToInt32(rt, 2)).write(val);
Excecuted.Invoke();
break;
//Now the load store instructions
case "lb":
// CANNOT TEST MARS DUMP BEFORE ADDING LUI AND SOME OTHER STUFF
//$t = MEM[$s + offset];
//first calculate the address to load from
rs = IR.Substring(6, 5);
rt = IR.Substring(11, 5);
rs_val = Register.GetValfromBIN(rs);
imm = IR.Substring(16);
signExtend(ref imm, 32);
imm_sint = Convert.ToInt32(imm, 2);
ulong addres = (ulong)rs_val + (ulong)imm_sint;
byte value_b = Mem.loadByte(addres);
Register.Registers.ElementAt <Register>(Convert.ToInt32(rt, 2)).write(value_b);
break;
case "sb":
rs = IR.Substring(6, 5);
rt = IR.Substring(11, 5);
rs_val = Register.GetValfromBIN(rs);
rt_val = Register.GetValfromBIN(rt);
string rt_vals = Convert.ToString(rt_val, 2);
imm = IR.Substring(16);
signExtend(ref imm, 32);
imm_sint = Convert.ToInt32(imm, 2);
addres = (ulong)rs_val + (ulong)imm_sint;
//Since the way i design the memory here is to access a stream of bytes
//I need to harnes a byte from my current int
byte rt_b = Convert.ToByte(rt_vals.Substring(27));
Mem.storeByte(addres, rt_b);
break;
case "andi":
rs = IR.Substring(6, 5);
rt = IR.Substring(11, 5);
rs_val = Register.GetValfromBIN(rs);
imm = IR.Substring(16);
int imm_uval = Convert.ToInt32(imm);
int res = rs_val & imm_uval;
Register.Registers.ElementAt <Register>(Convert.ToInt32(rt, 2)).write(res);
break;
default:
break;
}
}
else if (instruction.format == 0)
{
string rs = IR.Substring(6, 5);
string rt = IR.Substring(11, 5);
string rd = IR.Substring(16, 5);
string sa = IR.Substring(21, 5);
int rs_i = Register.GetValfromBIN(rs);
int rt_i = Register.GetValfromBIN(rt);
int sa_i = Convert.ToInt32(sa, 2);
int rd_n = Convert.ToInt32(rd, 2);
//r Format;
switch (instruction.mnemonic)
{
case "add":
//Addition with overflow
//rd = rs+rt
int val = rs_i + rt_i;
//Check for overflow;
if (overflow(val, 32))
{
OverFlow.Invoke();
Terminate_Error.Invoke("Overflow from instruction in PC: " + PC.ToString() + " has been detected");
}
else
{
Register.Registers.ElementAt <Register>(rd_n).write(val);
Excecuted.Invoke();
}
break;
case "addu":
//No over Flow addition
//NOTE: Addu is broken down into three instructions in MARS, while here it is merely one instruction
val = rs_i + rt_i;
Register.Registers.ElementAt <Register>(rd_n).write(val);
Excecuted.Invoke();
break;
case "and":
val = rs_i & rt_i;
Register.Registers.ElementAt <Register>(rd_n).write(val);
Excecuted.Invoke();
break;
case "or":
val = rs_i | rt_i;
Register.Registers.ElementAt <Register>(rd_n).write(val);
Excecuted.Invoke();
break;
case "syscall":
Syscall();
break;
default:
break;
}
}
//Increment Cycle
clock++;
}
