cpu之top

module top(
	input wire clk,
	input wire rst
);


   wire [31:0] PC1;
   
   wire [31:0] PCF;
   
   wire Is_First;//判断第几次译码
   wire stall_id;
   wire stall_id_t;
   
   wire stall_branch;
   wire[1:0] stall_branch_t;
   
   
   wire[31:0] PCPlus4F;
   wire[31:0] InstrF;
   wire[31:0] InstrD;
   wire[31:0] PCPlus4D;
   
  
	 wire BranchD;
	 wire Jump;
	 wire [31:0] PCJump;
	 wire MemtoRegD;
	 wire MemWriteD;
	 wire MemReadD;
	 wire MemReadE;
	 wire MemReadM;
	 
	 wire[5:0]  ALUControlD;
	 wire[5:0]  ALUControl1D;
	 wire ALUSrcD;
	 wire ALUSrc1D;
	 wire RegWriteD;
	 wire[1:0] RegDstD;
	
	 wire[31:0] RD1;
	 wire[31:0] RD2;
	 wire[4:0] WriteRegD;
	
	 wire[31:0] SignlmmD;
	
	
	 wire BranchE;
	 wire MemtoRegE;
	 wire MemWriteE;
	 wire[5:0]  ALUControlE;
	 wire[5:0]  ALUControl1E;
	 wire ALUSrcE;
	 wire ALUSrc1E;
	 wire RegWriteE;
	 wire RegDstE;

	 wire [31:0] SrcAE;
	 wire [31:0] RDE;
	 wire[31:0] WriteDataE;
	
	 wire[31:0] SignlmmE;
	
	 wire[31:0] PCPlus4E;
	 
	 wire [31:0] SrcBE;
	 wire[4:0] WriteRegE;
	 
	 wire ZeroE;
	 wire[31:0] ALUOutE;
	 wire[31:0] PCBranchE;
	 
	 wire PCSrcM;
	 
	 
	 wire MemtoRegM;
	 wire MemWriteM;
	 wire RegWriteM;
	 wire [31:0] ResultM;
	
	 wire[31:0] ALUOutM;
	 wire [31:0] ReadDataM;
   wire[31:0] WriteDataM;
	 wire[4:0] WriteRegM;
	 wire[5:0]  ALUControlM;
	 

	 wire RegWriteW;
	 wire[4:0] WriteRegW;
	 
	 wire [31:0] ResultW;
	 
	 
	 wire Execute_sucess;//判断各个阶段是否成功
	 wire Memory_sucess;
	 wire Write_sucess;
   
	  
	  //进行例化
	  
	  //例化pc_reg
	  pc_reg  pc_b(.clk(clk),
	               .rst(rst),
	               .jump(Jump),
	               .pc2(PCJump),
	               .stall_branch_t(stall_branch_t),
	               .stall_id(stall_id_t),
	               .pc1(PC1),
	               .pc(PCF)
	               );
	               
	  //例化Instruction_memory
	  Instruction_memory Instruction_memory_b(
	               .ImemRdAddr(PCF),
	               .Instruction(InstrF)
	  );
	  
	  //例化RegDst_Ins
	  RegDst_Ins RegDst_Ins_b(
	               .RegDst(RegDstD),
	               .src1(InstrD[20:16]),
	               .src2(InstrD[15:11]),
	               .dst(WriteRegD)
	  
	  );
	  
	  //例化register
	  register register_b(
	  							.Clk(clk),
	  							.Execute_reg(WriteRegE),
	  							.Memory_reg(WriteRegM),
	  							.Execute_data(ALUOutE),
	  							.Memory_data(ResultM),
							    .RegARdAddr(InstrD[25:21]),
							    .RegBRdAddr(InstrD[20:16]),
							    .RegWrAddr(WriteRegW),
							    .RegWrData(ResultW),
							    .RegWrite(RegWriteW),
							    .RegARdData(RD1),
							    .RegBRdData(RD2),
							    .Execute_sucess(Execute_sucess),
							    .Memory_sucess(Memory_sucess),
							    .Write_sucess(Write_sucess)
	  
	  );
	  
	  
	  
	  //例化ALUSrc_Reg
	  ALUSrc_Reg  ALUSrc_Reg_b(
	                .ALUSrc(ALUSrcE),
	                .src1(WriteDataE),
	                .src2(SignlmmE),
	                .dst(SrcBE)
	  );
	  
	  //例化ALUSrc_Reg1
	  ALUSrc_Reg1 ALUSrc_Reg1_b(
	                .ALUSrc(ALUSrc1E),
	                .src1(RDE),
	                .src2(WriteDataE),
	                .dst(SrcAE)
	  );
	  
	  //例化ALU
	  ALU ALU_b(
	                .SrcA(SrcAE),
	                .SrcB(SrcBE),
	                .ALUCtra(ALUControlE),
	                .ALUCtrb(ALUControl1E),
	                .Zero(ZeroE),
	                .Execute_sucess(Execute_sucess),
	                .ALURes(ALUOutE)
	                
	  );
	  
	  //例化CPU_ctrl
	  CPU_ctrl CPU_ctrl_b(
	  							.OpCode(InstrD),
	                .Branch(BranchD),
	                .Jump(Jump),
	                .Execute_reg(WriteRegE),
	                .Is_First(Is_First),
	                .stall_id(stall_id),
	                .stall_branch(stall_branch),
	                
	                .MemtoReg(MemtoRegD),
	                .MemWrite(MemWriteD),
	                .MemRead(MemReadD),
	                .ALUControl_a(ALUControlD),
	                .ALUControl_b(ALUControl1D),
	                .ALUSrc(ALUSrcD),
	                .ALUSrc1(ALUSrc1D),
	                .RegWrite(RegWriteD),
	                .RegDst(RegDstD)
	  );
	  
	  //例化Branch_Zero
	  Branch_Zero Branch_Zero_b(
	                .rst(rst),
	                .Branch(BranchE),
	                .Zero(ZeroE),
	                .dst(PCSrcM)
	  );
	  
	  //例化Data_memory
	  Data_memory Data_memory_b(
	                .DmemAddr(ALUOutM),
	                .DmemWrite(MemWriteM),
	                .DmemWrData(WriteDataM),
	                .DmemRdData(ReadDataM),
	                .DmemRead(MemReadM),
	                .ALUCtra(ALUControlM)
	  );
	  
	  //例化MemtoReg_Data
	  MemtoReg_Data MemtoReg_Data_b(
	                .MemtoReg(MemtoRegM),
	                .src1(ALUOutM),
	                .src2(ReadDataM),
	                .dst(ResultM)
	  );
	  
	  //例化PCSrc_PC
	  PCSrc_PC PCSrc_PC_b(
	                .PCSrc(PCSrcM),//PCSrcM
	                .src1(PCPlus4F),
	                .src2(PCBranchE),
	                .dst(PC1)
	  );
	  
	  //例化PCPLUS4
	  PCPLUS4 PCPLUS4_b(
	  	            .pc(PCF),
	  	            .pc_out(PCPlus4F)
	  );
	  
	  //例化Sign_Extend
	  Sign_Extend Sign_Extend_b(
	                .src(InstrD[15:0]),
	                .dst(SignlmmD)
	  );
	  
	  //例化PCBranch
	  PCBranch PCBranch_b(
	                .src1(SignlmmE),
	                .src2(PCPlus4E),
	                .dst(PCBranchE)
	  );
	  
	  //例化Fetch_Decode
	  Fetch_Decode Fetch_Decode_b(
	                .clk(clk),
	                .stall_id(stall_id_t),
	                .stall_branch_t(stall_branch_t),
	                .InstrF(InstrF),
	                .PCPlus4F(PCPlus4F),
	                .InstrD(InstrD),
	                .PCPlus4D(PCPlus4D),
	                .Is_First(Is_First)
	  );
	  
	  //例化Decode_Execute
	  Decode_Execute Decode_Execute_b(
	                .clk(clk),
	                .BranchD(BranchD),
	                .MemReadD(MemReadD),
	                .MemReadE(MemReadE),
	                .MemtoRegD(MemtoRegD),
	                .MemWriteD(MemWriteD),
	                .ALUControlD(ALUControlD),
	                .ALUControl1D(ALUControl1D),
	                .ALUSrcD(ALUSrcD),
	                .ALUSrc1D(ALUSrc1D),
                  .RegWriteD(RegWriteD),
	
	                .RD1(RD1),
	                .RD2(RD2),
	                .WriteRegD(WriteRegD),
	
	                .SignlmmD(SignlmmD),
	                .PCPlus4D(PCPlus4D),
	
	
                  .BranchE(BranchE),
	                .MemtoRegE(MemtoRegE),
	                .MemWriteE(MemWriteE),
	                .ALUControlE(ALUControlE),
	                .ALUControl1E(ALUControl1E),
	                .ALUSrcE(ALUSrcE),
	                .ALUSrc1E(ALUSrc1E),
                  .RegWriteE(RegWriteE),
	
	                .RDE(RDE),
	                .WriteDataE(WriteDataE),
                  .WriteRegE(WriteRegE),
	
                  .SignlmmE(SignlmmE),
	
	                .PCPlus4E(PCPlus4E),
	                
	                .stall_id(stall_id_t)
	  );
	  
	  //例化Execute_Memory
	  Execute_Memory Execute_Memory_b(
	                .clk(clk),
	                .MemtoRegE(MemtoRegE),
                  .MemWriteE(MemWriteE),
	                .RegWriteE(RegWriteE),
	                
	                .MemReadM(MemReadM),
	                .MemReadE(MemReadE),
	                
	             
	                .ALUOutE(ALUOutE),
	                .WriteDataE(WriteDataE),
	                .WriteRegE(WriteRegE),
	                .ALUControlE(ALUControlE),
	
	                .MemtoRegM(MemtoRegM),
                  .MemWriteM(MemWriteM),
	                .RegWriteM(RegWriteM),
	
	                .ALUOutM(ALUOutM),
                  .WriteDataM(WriteDataM),
                  .WriteRegM(WriteRegM),
	                .ALUControlM(ALUControlM),
	                .Execute_sucess(Execute_sucess),
	                .Memory_sucess(Memory_sucess)
	             
	  );
	  
	  //例化Memory_Writeback
	  Memory_Writeback Memory_Writeback_b(
	                .clk(clk),
	                .RegWriteM(RegWriteM),
	                .WriteRegM(WriteRegM),
	                .ResultM(ResultM),
	                .RegWriteW(RegWriteW),
	                .WriteRegW(WriteRegW),
	                .ResultW(ResultW),
	                .Memory_sucess(Memory_sucess),
	                .Write_sucess(Write_sucess)
	  
	  );
	  
	  //例化stall_ctr
	  stall_ctr stall_ctr_b(
	                .clk(clk),
	                .rst(rst),
	                .stall_id(stall_id),
	                .stall_id_t(stall_id_t),
	                .stall_branch(stall_branch),
	                .stall_branch_t(stall_branch_t)
	  );
	  
	  //例化PCJump
	  PCJump PCJump_b(
	                .rst1(InstrD[25:0]),
	                .rst2(PCPlus4D[31:28]),
	                .dst(PCJump)
	  );
	  
	 
endmodule