processor.v

MIPS CPU tested in Icarus Verilog

		    .Src2(Src),
		    .ALUOP(Aluop),
		    .RegDest(Regdest),
		    .Memory_Read(Memread),
		    .Memory_Write(Memwrite),
		    .Mem2Reg(Mem2reg),
		    .IntFP(Intfp),
		    .ArSh(Arsh));

   assign 		  In0Sum2 = FetchDecode[57:32];

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Hazard Unit;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   HazardUnit hazard (.Clock(FastClock),
		      .Reset(Reset),
		      .Instruction(FetchDecode[31:0]),
		      .MemWb_WrReg(MemoryWriteBack[4:0]),
		      .ExMem_WrReg(ExecuteMemory[4:0]),
		      .DecEx_WrRegRd(DecodeExecute[9:5]),
		      .DecEx_WrRegRt(DecodeExecute[14:10]),
		      .DecEx_RegDest(Regdest),
		      .DecEx_WrRF(DecodeExecute[154]),
		      .ExMem_WrRF(ExecuteMemory[74]),
		      .MemWb_WrRF(MemoryWriteBack[72]),
		      .HazardSelect(hazardSel),
		      .FetchDec_Write(fdWr), //?
		      .PC_Write(PC)); //?

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Hazard Mux;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   MUX_2_1 #18 MuxHaz (.AInput({Wr_RF,Mem2reg,Memread,Memwrite,Arsh,Intfp,BranchS,Regdest,Aluop,Src}),
		       .BInput(18'b0),
		       .Select(hazardSel),
		       .Output(Signals));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Left Shift;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   leftShift #26 LeftShift (.AInput({10'b0000000000,Instruction[15:0]}),
			    .Output(In1Sum2));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Adder 2 (PC+1+offset);;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   adder Adder2 (.AInput(In0Sum2),
		 .BInput(In1Sum2),
		 .Output(OutSum2));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Mux Dir A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   MUX_3_1 #5 SrcAMux (.AInput(FetchDecode[25:21]),
		       .BInput(FetchDecode[20:16]),
		       .CInput(FetchDecode[15:11]),
		       .Select({Intfp,Arsh}),
		       .Output(OutSrcAMux));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Register File;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
//   RegisterFile Registers (.Resetb(Reset),
//			   .Clock(FastClock),
//			   .ReadAddressA(OutSrcAMux),
//			   .ReadDataA(DataA),
//			   .ReadAddressB(FetchDecode[20:16]),
//			   .ReadDataB(DataB),
//			   .WriteAddress(MemoryWriteBack[4:0]),
//			   .WriteData(OutM2RMuxInWrData),
//			   .Write(MemoryWriteBack[72]));

   RegisterFile RF_0 (.Resetb(Reset),
		      .Clock(FastClock),
		      .ReadAddressA(OutSrcAMux),
		      .ReadAddressB(FetchDecode[20:16]),
		      .ReadDataA(DataA),
		      .ReadDataB(DataB),
		      .WriteAddress(MemoryWriteBack[4:0]),
		      .Write(MemoryWriteBack[72]),
		      .WriteData(OutM2RMuxInWrData));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Extension-32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   signExtension #16 Ext32 (.AInput(FetchDecode[15:0]),
			    .Output(Immed_Ext_32));

   //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Execute Modules!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   assign 		  In1BranchMux = DecodeExecute[136:111];

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;RegDest MUX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   assign 		  In0DestMux = DecodeExecute[14:10];
   assign 		  In1DestMux = DecodeExecute[9:5];
   assign 		  In2DestMux = DecodeExecute[4:0];
   assign 		  RegDest_Sig = DecodeExecute[145:144];
   MUX_3_1 #5 RegDest_Mux (.AInput(In0DestMux),
			   .BInput(In1DestMux),
			   .CInput(In2DestMux),
			   .Select(RegDest_Sig),
			   .Output(OutDestMux));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Forwarding Unit;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ForwardUnit forward (.Clock(FastClock),
			.Reset(Reset),
			.AddressA(OutSrcAMux),
			.AddressB(FetchDecode[20:16]),
			.ExDest(OutDestMux),
			.MemDest(ExecuteMemory[4:0]),
			.WbDest(MemoryWriteBack[4:0]),
			.DecEx_WrRF(DecodeExecute[154]),
			.ExMem_WrRF(ExecuteMemory[74]),
			.MemWb_WrRF(MemoryWriteBack[72]),
			.Forward1(fw1Sel),
			.Forward2(fw2Sel));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Forwarding MUX 1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   MUX_3_1 #32 FWMux1 (.AInput(DecodeExecute[110:79]),
		       .BInput(ExecuteMemory[68:37]),
		       .CInput(OutM2RMuxInWrData),
		       .Select(fw1Sel),
		       .Output(dataA));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Forwarding MUX 2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   MUX_3_1 #32 FWMux2 (.AInput(DecodeExecute[78:47]),
		       .BInput(ExecuteMemory[68:37]),
		       .CInput(OutM2RMuxInWrData),
		       .Select(fw2Sel),
		       .Output(In0AluMux));
   
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ALU MUX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
//   assign 		  In0AluMux = DecodeExecute[78:47];
   assign 		  In1AluMux = DecodeExecute[46:15];
   assign 		  Src2_Sig = DecodeExecute[137];
   MUX_2_1 #32 ALUMux (.AInput(In0AluMux),
		       .BInput(In1AluMux),
		       .Select(Src2_Sig),
		       .Output(dataB_OutAluMux));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ALU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
//   assign 		  dataA = DecodeExecute[110:79];
   assign 		  ALUOP_Sig = DecodeExecute[143:138];
   ALU32 ALU (.AInput(dataA),
	      .BInput(dataB_OutAluMux),
	      .OpCode(ALUOP_Sig),
	      .Clock(FastClock),
	      .Reset(Reset),
	      .Output(ALURes),
	      .Overflow(Overflow),
	      .Zero(Zero));
   assign 		  Branch_Sig = DecodeExecute[146];
   assign 		  BranchSel = Branch_Sig & Zero;

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;FPU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   FPU32 FPU (.AInput(dataA),
	      .BInput(dataB_OutAluMux),
	      .OpCode(ALUOP_Sig),
	      .Clock(FastClock),
	      .Reset(Reset),
	      .Output(FPURes),
	      .Overflow(Overflow),
	      .Zero(Zero));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ALU/FPU MUX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   assign 		  IntFP_Sig = DecodeExecute[147];
   MUX_2_1 #32 ALU_FPU_Mux (.AInput(ALURes),
			    .BInput(FPURes),
			    .Select(IntFP_Sig),
			    .Output(ALU_FPU_Out));

   assign 		  MSignals = DecodeExecute[150:149];
   assign 		  WBSignals = DecodeExecute[154:151];

   //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Memory Modules!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Data Memory;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%Data Memory needs instantiation%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   //The output of the memory is DataBusRead
   assign 		  memdataAddress = ExecuteMemory[68:37];
   assign 		  memdataWrData = ExecuteMemory[36:5];
   assign 		  mem_read = ExecuteMemory[70];
   assign 		  mem_write = ExecuteMemory[69];

   assign 		  WbSignals = ExecuteMemory[74:71];
   assign 		  reg_Dest = ExecuteMemory[4:0];

   assign 		  MemoryWrite = mem_write;
   assign 		  DataBusWrite = memdataWrData;
   assign 		  AddressBusData = memdataAddress;
   assign 		  MemoryRead = mem_read;

   //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Write Back Modules!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;E24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   assign 		  memRdData = MemoryWriteBack[68:37];
   signExtension #24 e24 (.AInput(memRdData[7:0]),
			  .Output(sign24));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Z24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   zeroExtension #24 z24 (.AInput(memRdData[7:0]),
			  .Output(zero24));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;E16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   signExtension #16 e16 (.AInput(memRdData[15:0]),
			  .Output(sign16));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Z24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   zeroExtension #16 z16 (.AInput(memRdData[15:0]),
			  .Output(zero16));

   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Mem2Reg MUX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   assign 		  ALU_FPU_Res = MemoryWriteBack[36:5];
   assign 		  memtoreg = MemoryWriteBack[71:69];
   MUX_6_1 #32 M2RMux (.AInput(ALU_FPU_Res),
		       .BInput(sign24),
		       .CInput(zero24),
		       .DInput(sign16),
		       .EInput(zero16),
		       .FInput(memRdData),
		       .Select(memtoreg),
		       .Output(OutM2RMuxInWrData));

   assign 		  OutRegDestMuxWB = MemoryWriteBack[4:0];
   assign 		  write_rf = MemoryWriteBack[72];

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//-------------------------------------------------------------------------------------------------------------------------
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

   always @ (posedge SlowClock)
     begin
	if(Reset == 1'b1)
	  begin //Clear all stage registers
	     FetchDecode[57:0] = {26'b0,6'b111111,26'b0};
	     DecodeExecute[154:0] = 0;
	     ExecuteMemory[74:0] = 0;
	     MemoryWriteBack[72:0] = 0;
	  end
	else
	  begin
	     //**********FetchDecode Latch***************
	     FetchDecode[31:0] <= InstructionBusRead;
	     FetchDecode[57:32] <= In0_Branch_Mux_Out_Sum1;

	     //**********DecodeExecute Latch***************
	     DecodeExecute[4:0] <= Instruction[10:6];
	     DecodeExecute[9:5] <= Instruction[15:11];
	     DecodeExecute[14:10] <= Instruction[20:16];
	     DecodeExecute[46:15] <= Immed_Ext_32;
	     DecodeExecute[78:47] <= DataB;
	     DecodeExecute[110:79] <= DataA;
	     DecodeExecute[136:111] <= OutSum2;
	     DecodeExecute[154:137] <= Signals;
	     //DecodeExecute[137] <= Src;
	     //DecodeExecute[143:138] <= Aluop;
	     //DecodeExecute[145:144] <= Regdest;
	     //DecodeExecute[146] <= BranchS;
	     //DecodeExecute[147] <= Intfp;
	     //DecodeExecute[148] <= Arsh;
	     //DecodeExecute[149] <= Memwrite;
	     //DecodeExecute[150] <= Memread;
	     //DecodeExecute[153:151] <= Mem2reg;
	     //DecodeExecute[154] <= Wr_RF;

	     //**********ExecuteMemory Latch***************
	     ExecuteMemory[4:0] <= OutDestMux;
	     ExecuteMemory[36:5] <= In0AluMux;
	     ExecuteMemory[68:37] <= ALU_FPU_Out;
	     ExecuteMemory[70:69] <= MSignals;
	     ExecuteMemory[74:71] <= WBSignals;

	     //**********MemoryWriteBack Latch***************
	     MemoryWriteBack[4:0] <= reg_Dest;
	     MemoryWriteBack[36:5] <= memdataAddress;
	     MemoryWriteBack[68:37] <= DataBusRead;
	     MemoryWriteBack[72:69] <= WbSignals;
	  end // else: !if(Reset == 1'b1)
     end // always @ (posedge SlowClock)
endmodule // processor