一、OpenMIPS指令集CPU的ori指令的实现

于 2024-04-11 15:45:40 发布
阅读量1.4k 收藏 16
点赞数 31
分类专栏： 自己动手写CPU：OpenMIPS CPU实现 文章标签： fpga开发 Verilog VCS verdi Makefile
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44463933/article/details/137637699
版权

前言

根据“自己动手写CPU”这本书学习，自己动手实现一个MIPS指令集的CPU。
本文章实现了一个ori指令即“或”操作的五级流水线，后续会持续添加其他指令完善此CPU。

文章作为学习笔记持续更新，源代码也在github上持续更新
项目源码https://github.com/yizhixiaohuihui/OpenMIPS.git

一、设计实现ori指令的OpenMIPS处理器

实现ori指令的OpenMIPS五级流水线结构图
在这里插入图片描述

说明：

1.1、取指阶段：取出指令存储器中的指令，同时PC值递增，准备取下一条指令

  1. PC模块(pc_reg.v)：给出指令地址
`include "../rtl/defines.v"

module pc_reg(
	input	wire							clk, 
	input wire								rst,
	output reg[`InstAddrBus]		pc,	// 要读取的指令地址
	output reg                    			ce // ָ指令存储器使能信号
);

	always @ (posedge clk) begin
		if (rst == `RstEnable) begin
			ce <= `ChipDisable;					// 复位的时候指令存储器禁用
		end 
		else begin
			ce <= `ChipEnable;					// 复位结束后指令存储器使能
		end
	end

	always @ (posedge clk) begin
		if (ce == `ChipDisable) begin
			pc <= 32'h00000000;
		end 
		else begin
	 		pc <= pc + 4'h4;					// pc+4指向下一条指令地址（一条指令32位对应4字节）
		end
	end
endmodule
  1. IF/ID模块(if_id.v)：暂时保存取指阶段取得的指令
`include "../rtl/defines.v"

module if_id(
	input	wire				 		clk,
	input wire							rst,
	input wire[`InstAddrBus]	 if_pc,		  // 取指阶段取得的指令对应的地址
	input wire[`InstBus]       		if_inst,	// 取指阶段取得的指令
	output reg[`InstAddrBus] 	 id_pc,		// 译码阶段的指令对应的地址
	output reg[`InstBus] 			id_inst   // 译码阶段的指令
);

	always @ (posedge clk) begin
		if (rst == `RstEnable) begin
			id_pc <= `ZeroWord;
			id_inst <= `ZeroWord;
	    end 
	    else begin	// 其余时刻向下传递取指阶段的值
		  id_pc <= if_pc;
		  id_inst <= if_inst;
		end
	end
endmodule

1.2、译码阶段：对取到的指令进行译码 -> 给出要进行的运算类型，以及参与运算的操作数

  1. Regfile模块(regfile.v)：实现32个32位通用整数寄存器，可以同时进行两个寄存器的读操作和一个寄存器的写操作
`include "../rtl/defines.v"

module regfile(

	input	wire									clk,
	input wire										rst,

	// write port
	input wire										we,
	input wire[`RegAddrBus]					waddr,
	input wire[`RegBus]						   wdata,
	
	// read port 1
	input wire										re1,
	input wire[`RegAddrBus]			  		raddr1,
	output reg[`RegBus]           			  rdata1,
	
	// read port 2
	input wire										re2,
	input wire[`RegAddrBus]			  		raddr2,
	output reg[`RegBus]           			  rdata2
	
);
	// 1. define 32's 32bits registers
	reg[`RegBus]  regs[0:`RegNum-1];

	// 2. write operation
	always @ (posedge clk) begin
		if (rst == `RstDisable) begin
			// we enable and write operation destination register != 0
			if((we == `WriteEnable) && (waddr != `RegNumLog2'h0)) begin
				regs[waddr] <= wdata;
			end
		end
	end
	
	// Notice: read operation is Combinatorial logic
	// 3. read port1's read operation
	always @ (*) begin
		if(rst == `RstEnable) begin
			  rdata1 <= `ZeroWord;
	  	end 
		else if(raddr1 == `RegNumLog2'h0) begin
	  		rdata1 <= `ZeroWord;
	  	end 
		// if read port1 want read register is same as the register to write
	  	else if((raddr1 == waddr) && (we == `WriteEnable) && (re1 == `ReadEnable)) begin
	  	  rdata1 <= wdata;
	  	end 
		else if(re1 == `ReadEnable) begin
	      rdata1 <= regs[raddr1];
	  	end 
		// if read port1 can't be used
		else begin
	      rdata1 <= `ZeroWord;
	  	end
	end

	// 4. read port2's read operation
	always @ (*) begin
		if(rst == `RstEnable) begin
			  rdata2 <= `ZeroWord;
	  	end 
		else if(raddr2 == `RegNumLog2'h0) begin
	  		rdata2 <= `ZeroWord;
	  	end 
		else if((raddr2 == waddr) && (we == `WriteEnable) && (re2 == `ReadEnable)) begin
	  	  rdata2 <= wdata;
	  	end 
		else if(re2 == `ReadEnable) begin
	      rdata2 <= regs[raddr2];
	  	end 
		else begin
	      rdata2 <= `ZeroWord;
	  	end
	end

endmodule
  1. ID模块(id.v)：对指令进行译码，得到最终运算的类型、子类型、源操作数1、源操作数2、要写入的目的寄存器地址等信息
`include "../rtl/defines.v"

module id(

	input wire								 rst,
	input wire[`InstAddrBus]		  pc_i,
	input wire[`InstBus]          		 inst_i,

	// readed regfile's data
	input wire[`RegBus]           		reg1_data_i,
	input wire[`RegBus]           		reg2_data_i,

	// ouput to Regfile's message
	output reg                    			reg1_read_o,	// Regfile reg1's ReadEnable
	output reg                    			reg2_read_o,    // Regfile reg2's ReadEnable
	output reg[`RegAddrBus]       	reg1_addr_o,
	output reg[`RegAddrBus]       	reg2_addr_o, 	      
	
	// sent Execution stage message
	output reg[`AluOpBus]         	  aluop_o,
	output reg[`AluSelBus]        	  alusel_o,
	output reg[`RegBus]           	   reg1_o,
	output reg[`RegBus]           	   reg2_o,
	output reg[`RegAddrBus]       	wd_o,
	output reg                    		    wreg_o
);
	// instructions code
    wire[5:0] op = inst_i[31:26]; // ori: judge 26-31bit can judge ori instruction
    wire[4:0] op2 = inst_i[10:6];
    wire[5:0] op3 = inst_i[5:0];
    wire[4:0] op4 = inst_i[20:16];

	// store immediate num that execute instructions need
    reg[`RegBus]	imm;

	// instruction is valid or not
    reg instvalid;
  
	// 1. decode instructions
	always @ (*) begin	
		if (rst == `RstEnable) begin
			aluop_o <= `EXE_NOP_OP;
			alusel_o <= `EXE_RES_NOP;
			wd_o <= `NOPRegAddr;
			wreg_o <= `WriteDisable;
			instvalid <= `InstValid;
			reg1_read_o <= 1'b0;
			reg2_read_o <= 1'b0;
			reg1_addr_o <= `NOPRegAddr;
			reg2_addr_o <= `NOPRegAddr;
			imm <= 32'h0;			
	    end 
		else begin
			aluop_o <= `EXE_NOP_OP;
			alusel_o <= `EXE_RES_NOP;
			wd_o <= inst_i[15:11];
			wreg_o <= `WriteDisable;
			instvalid <= `InstInvalid;	   
			reg1_read_o <= 1'b0;
			reg2_read_o <= 1'b0;
			reg1_addr_o <= inst_i[25:21];	// rs register's address
			reg2_addr_o <= inst_i[20:16];	// rt register's address
			imm <= `ZeroWord;			
		    case (op)
		  		`EXE_ORI:			begin   // judge is ori ins 
		  			wreg_o <= `WriteEnable;		// ori need write in destination register
					aluop_o <= `EXE_OR_OP;	// aiuop is or operation
		  			alusel_o <= `EXE_RES_LOGIC; // logic operation
					reg1_read_o <= 1'b1;	// only need read rs
					reg2_read_o <= 1'b0;	// immediate num not need read from reg
					imm <= {16'h0, inst_i[15:0]}; // extend immediate num to unsinged 32 bits		
					wd_o <= inst_i[20:16]; // rt: destination register's address to write 
					instvalid <= `InstValid;	
		  		end 							 
		    	default:			begin
		    	end
		  endcase		  //case op			
		end       //if
	end         //always
	
	// 2. choose source num2
	always @ (*) begin
		if(rst == `RstEnable) begin
			reg1_o <= `ZeroWord;
	  	end 
		else if(reg1_read_o == 1'b1) begin
	  		reg1_o <= reg1_data_i; // rs
	  	end 
		else if(reg1_read_o == 1'b0) begin
	  		reg1_o <= imm;
	  	end 
		else begin
	    	reg1_o <= `ZeroWord;
	  	end
	end
	
	// 3. choose source num2 
	always @ (*) begin
		if(rst == `RstEnable) begin
			reg2_o <= `ZeroWord;
	  	end 
		else if(reg2_read_o == 1'b1) begin
	  		reg2_o <= reg2_data_i;	// rt
	  	end 
		else if(reg2_read_o == 1'b0) begin
	  		reg2_o <= imm;
	  	end 
		else begin
	    	reg2_o <= `ZeroWord;
	  	end
	end

endmodule
  1. ID/EX模块(id_ex.v)：将ID模块译码阶段取得的结果在下个时钟传递到流水线执行阶段
`include "../rtl/defines.v"

module id_ex(

	input	wire						clk,
	input wire							rst,

	
	// message from decodeStage
	input wire[`AluOpBus]        id_aluop,
	input wire[`AluSelBus]       id_alusel,
	input wire[`RegBus]           id_reg1,
	input wire[`RegBus]           id_reg2,
	input wire[`RegAddrBus]     id_wd,
	input wire                    		id_wreg,	
	
	// message sent to executeStage
	output reg[`AluOpBus]        ex_aluop,
	output reg[`AluSelBus]       ex_alusel,
	output reg[`RegBus]           ex_reg1,
	output reg[`RegBus]           ex_reg2,
	output reg[`RegAddrBus]     ex_wd,
	output reg                    		ex_wreg
	
);

	always @ (posedge clk) begin
		if (rst == `RstEnable) begin
			ex_aluop <= `EXE_NOP_OP;
			ex_alusel <= `EXE_RES_NOP;
			ex_reg1 <= `ZeroWord;
			ex_reg2 <= `ZeroWord;
			ex_wd <= `NOPRegAddr;
			ex_wreg <= `WriteDisable;
		end 
		else begin		
			ex_aluop <= id_aluop;
			ex_alusel <= id_alusel;
			ex_reg1 <= id_reg1;
			ex_reg2 <= id_reg2;
			ex_wd <= id_wd;
			ex_wreg <= id_wreg;		
		end
	end
	
endmodule

1.3、执行阶段：依据译码阶段的结果，对源操作数1、源操作数2、进行指定的运算

  1. EX模块(ex.v)：从ID/EX模块得到运算的类型、子类型、源操作数1、源操作数2、要写入的目的寄存器地址，并依据这些数据进行计算
`include "../rtl/defines.v"

module ex(

	input wire										rst,
	
	// message rom decodeStage
	input wire[`AluOpBus]        aluop_i,
	input wire[`AluSelBus]       alusel_i,
	input wire[`RegBus]           reg1_i,
	input wire[`RegBus]           reg2_i,
	input wire[`RegAddrBus]     wd_i,
	input wire                    		wreg_i,

	// execute result
	output reg[`RegAddrBus]     wd_o,
	output reg                    		wreg_o,
	output reg[`RegBus]			   wdata_o
	
);
	// save logic op result
	reg[`RegBus] logicout;

	
	// 1. according aluop_i to operate
	always @ (*) begin
		if(rst == `RstEnable) begin
			logicout <= `ZeroWord;
		end 
		else begin
			case (aluop_i)
				`EXE_OR_OP:			begin
					logicout <= reg1_i | reg2_i;
				end
				default:				begin
					logicout <= `ZeroWord;
				end
			endcase
		end    
	end      


	// 2. according alusel_i to choose an op result as last result
	always @ (*) begin
		wd_o <= wd_i;	// detinationReg's address need write 
		wreg_o <= wreg_i; // write reg enable
		case ( alusel_i ) 
			`EXE_RES_LOGIC:		begin
				wdata_o <= logicout; // save op result
			end
			default:					begin
				wdata_o <= `ZeroWord;
			end
		endcase
	end	

endmodule
  1. EX/MEM模块(ex_mem.v)：将执行阶段取得的运算结果在下个时钟传递到流水线访存阶段
`include "../rtl/defines.v"

module ex_mem(

	input wire						  	  clk,
	input wire							  rst,
	
	
	// message from executeStage
	input wire[`RegAddrBus]       ex_wd,
	input wire                    		  ex_wreg,
	input wire[`RegBus]				ex_wdata, 	
	
	// message sent to accessStage
	output reg[`RegAddrBus]      mem_wd,
	output reg                   		 mem_wreg,
	output reg[`RegBus]				mem_wdata
	
);


	always @ (posedge clk) begin
		if(rst == `RstEnable) begin
			mem_wd <= `NOPRegAddr;
			mem_wreg <= `WriteDisable;
		  	mem_wdata <= `ZeroWord;	
		end 
		else begin
			mem_wd <= ex_wd;
			mem_wreg <= ex_wreg;
			mem_wdata <= ex_wdata;			
		end    
	end      
			
endmodule

1.4、访存阶段：由于ori指令不需要访问数据存储器，所以在访存阶段不做任何事，只是简单地将执行阶段的结果向写回阶段传递

  1. MEM模块(mem.v)：将输入的执行阶段的结果直接作为输出
`include "../rtl/defines.v"

module mem(
	input wire							rst,
	
	// message from executeStage
	input wire[`RegAddrBus]     wd_i,
	input wire                    		wreg_i,
	input wire[`RegBus]			   wdata_i,
	
	// result in accessStage
	output reg[`RegAddrBus]     wd_o,
	output reg                   		wreg_o,
	output reg[`RegBus]			   wdata_o
	
);

	
	always @ (*) begin
		if(rst == `RstEnable) begin
			wd_o <= `NOPRegAddr;
			wreg_o <= `WriteDisable;
		  	wdata_o <= `ZeroWord;
		end else begin
		  	wd_o <= wd_i;
			wreg_o <= wreg_i;
			wdata_o <= wdata_i;
		end   
	end      
			
endmodule
  1. MEM/WB模块(mem_wb.v)：将访存阶段的运算结果，在下一个时钟传递到回写阶段
`include "../rtl/defines.v"

module mem_wb(

	input	wire						clk,
	input wire							rst,
	
	// accessStage result 
	input wire[`RegAddrBus]     mem_wd,
	input wire                    		mem_wreg,
	input wire[`RegBus]			   mem_wdata,

	// message sent to writeBackStage
	output reg[`RegAddrBus]    wb_wd,
	output reg                   	   wb_wreg,
	output reg[`RegBus]			  wb_wdata	       
	
);


	always @ (posedge clk) begin
		if(rst == `RstEnable) begin
			wb_wd <= `NOPRegAddr;
			wb_wreg <= `WriteDisable;
		  wb_wdata <= `ZeroWord;	
		end else begin
			wb_wd <= mem_wd;
			wb_wreg <= mem_wreg;
			wb_wdata <= mem_wdata;
		end    //if
	end      //always
			

endmodule

1.5、回写阶段：将指令的运算结果写入目的寄存器

  1. Regfile模块(regfile.v):将指令的运算结果写入目的寄存器

ori指令格式
在这里插入图片描述

地址为rs的寄存器的值 = 立即数 or 地址为rt的寄存器的值
目的操作数 = 源操作数1 || 源操作数2

1.6、顶层模块

在这里插入图片描述

`include "../rtl/defines.v"

module openmips(

	input wire clk,
	input wire rst,
	
	input wire[`RegBus] rom_data_i, // instruction get from instructionRomemary
	output wire[`RegBus] rom_addr_o, // address ouput to instructionRomemary
	output wire rom_ce_o // instructionRomemary enable
	
);
	// PC -> IF/ID
	wire[`InstAddrBus] pc;

	// IF/ID -> ID
	wire[`InstAddrBus] id_pc_i;
	wire[`InstBus] id_inst_i;
	
	// ID -> ID/EX
	wire[`AluOpBus] id_aluop_o;
	wire[`AluSelBus] id_alusel_o;
	wire[`RegBus] id_reg1_o;
	wire[`RegBus] id_reg2_o;
	wire id_wreg_o;
	wire[`RegAddrBus] id_wd_o;
	
	// ID/EX -> EX
	wire[`AluOpBus] ex_aluop_i;
	wire[`AluSelBus] ex_alusel_i;
	wire[`RegBus] ex_reg1_i;
	wire[`RegBus] ex_reg2_i;
	wire ex_wreg_i;
	wire[`RegAddrBus] ex_wd_i;
	
	// EX -> EX/MEM
	wire ex_wreg_o;
	wire[`RegAddrBus] ex_wd_o;
	wire[`RegBus] ex_wdata_o;

	// Ex/MEM -> MEM
	wire mem_wreg_i;
	wire[`RegAddrBus] mem_wd_i;
	wire[`RegBus] mem_wdata_i;

	// MEM -> MEM/WB 
	wire mem_wreg_o;
	wire[`RegAddrBus] mem_wd_o;
	wire[`RegBus] mem_wdata_o;
	
	// MEM/WB -> WB
	wire wb_wreg_i;
	wire[`RegAddrBus] wb_wd_i;
	wire[`RegBus] wb_wdata_i;
	
	// ID <-> Regfile
	wire reg1_read;
	wire reg2_read;
	wire[`RegBus] reg1_data;
	wire[`RegBus] reg2_data;
	wire[`RegAddrBus] reg1_addr;
	wire[`RegAddrBus] reg2_addr;
  
  
	pc_reg pc_reg0(
		.clk(clk),
		.rst(rst),
		.pc(pc),
		.ce(rom_ce_o)	
			
	);
	
  assign rom_addr_o = pc;

	if_id if_id0(
		.clk(clk),
		.rst(rst),
		.if_pc(pc),
		.if_inst(rom_data_i),
		.id_pc(id_pc_i),
		.id_inst(id_inst_i)      	
	);
	
	id id0(
		.rst(rst),
		.pc_i(id_pc_i),
		.inst_i(id_inst_i),

		.reg1_data_i(reg1_data),
		.reg2_data_i(reg2_data),

		.reg1_read_o(reg1_read),
		.reg2_read_o(reg2_read), 	  

		.reg1_addr_o(reg1_addr),
		.reg2_addr_o(reg2_addr), 
	  
		.aluop_o(id_aluop_o),
		.alusel_o(id_alusel_o),
		.reg1_o(id_reg1_o),
		.reg2_o(id_reg2_o),
		.wd_o(id_wd_o),
		.wreg_o(id_wreg_o)
	);

	regfile regfile1(
		.clk (clk),
		.rst (rst),
		.we	(wb_wreg_i),
		.waddr (wb_wd_i),
		.wdata (wb_wdata_i),
		.re1 (reg1_read),
		.raddr1 (reg1_addr),
		.rdata1 (reg1_data),
		.re2 (reg2_read),
		.raddr2 (reg2_addr),
		.rdata2 (reg2_data)
	);

	id_ex id_ex0(
		.clk(clk),
		.rst(rst),
		
		.id_aluop(id_aluop_o),
		.id_alusel(id_alusel_o),
		.id_reg1(id_reg1_o),
		.id_reg2(id_reg2_o),
		.id_wd(id_wd_o),
		.id_wreg(id_wreg_o),
	
		.ex_aluop(ex_aluop_i),
		.ex_alusel(ex_alusel_i),
		.ex_reg1(ex_reg1_i),
		.ex_reg2(ex_reg2_i),
		.ex_wd(ex_wd_i),
		.ex_wreg(ex_wreg_i)
	);		
	
	ex ex0(
		.rst(rst),
	
		.aluop_i(ex_aluop_i),
		.alusel_i(ex_alusel_i),
		.reg1_i(ex_reg1_i),
		.reg2_i(ex_reg2_i),
		.wd_i(ex_wd_i),
		.wreg_i(ex_wreg_i),
	  
		.wd_o(ex_wd_o),
		.wreg_o(ex_wreg_o),
		.wdata_o(ex_wdata_o)
		
	);


  ex_mem ex_mem0(
		.clk(clk),
		.rst(rst),
	  
		.ex_wd(ex_wd_o),
		.ex_wreg(ex_wreg_o),
		.ex_wdata(ex_wdata_o),
	
		.mem_wd(mem_wd_i),
		.mem_wreg(mem_wreg_i),
		.mem_wdata(mem_wdata_i)
   	
	);
	

	mem mem0(
		.rst(rst),
	
		.wd_i(mem_wd_i),
		.wreg_i(mem_wreg_i),
		.wdata_i(mem_wdata_i),
	  
		.wd_o(mem_wd_o),
		.wreg_o(mem_wreg_o),
		.wdata_o(mem_wdata_o)
	);

 
	mem_wb mem_wb0(
		.clk(clk),
		.rst(rst),

		.mem_wd(mem_wd_o),
		.mem_wreg(mem_wreg_o),
		.mem_wdata(mem_wdata_o),
	
		.wb_wd(wb_wd_i),
		.wb_wreg(wb_wreg_i),
		.wb_wdata(wb_wdata_i)
									       	
	);

endmodule

二、验证设计正确性

2.1 指令存储器ROM

在这里插入图片描述

  1. 在初始化指令存储器时使用了initial过程语句，不能被综合工具支持，若想被综合修改初始化指令存储器的方法
  2. $readmemh读取数据的系统函数，表示从inst_rom.data文件中读取数据以初始化inst_mem
  3. OpenMIPS是按字节寻址的，而此处定义的指令存储器的每个地址是一个32bit的字，所以要将OpenMIPS给出的地址除以4再使用
    在这里插入图片描述

2.2最小SOPC

为了验证建立一个SOPC：OpenMIPS从指令存储器读取指令，指令进入OpenMIPS开始执行
在这里插入图片描述

`include "../rtl/defines.v"

module openmips_min_sopc(

	input wire clk,
	input wire rst
	
);

	//openmips <-> ROM
	wire[`InstAddrBus] inst_addr;
	wire[`InstBus] inst;
	wire rom_ce;
 

	openmips openmips0(
			.clk(clk),
			.rst(rst),
		
			.rom_addr_o(inst_addr),
			.rom_data_i(inst),
			.rom_ce_o(rom_ce)
		
		);
	
	inst_rom inst_rom0(
		.addr(inst_addr),
		.inst(inst),
		.ce(rom_ce)	
	);


endmodule

2.3使用VCS和verdi联合仿真

“自己动手写CPU”这本书是在windows环境下用modelsim软件进行仿真验证，而众所周知工业界都是在Linux环境下使用VCS和verdi进行仿真验证，因此本文使用Linux环境进行验证并可以学习一些VCS和verdi软件的使用。

如何得到inst_rom.data文件参考文章https://blog.youkuaiyun.com/yvbycf/article/details/128359374

testbench文件


`include "../rtl/defines.v"
`timescale 1ns/1ps

module openmips_min_sopc_tb();

  reg CLOCK_50;
  reg rst;
  
       
  initial begin
    CLOCK_50 = 1'b0;
    // cycle is 20ns: 50Mhz
    forever #10 CLOCK_50 = ~CLOCK_50;
  end
      
  initial begin
    rst = `RstEnable;
    
    // min sopc start run
    #195 rst= `RstDisable;
    #1000 $stop;
  end
       
  openmips_min_sopc openmips_min_sopc0(
		.clk(CLOCK_50),
		.rst(rst)	
	);

  initial	begin
	    $fsdbDumpfile("tb.fsdb"); // generate "tb.fsdb"
	    // $fsdbDumpvars(0, openmips_min_sopc_tb,  "+mda"); // dump tb and dut ports, "+mda"->dump mem
	    $fsdbDumpvars(0, openmips_min_sopc_tb); // dump tb and dut ports
        $fsdbDumpMDA( ); // dump mem

end

endmodule

注意：

  • 要在vedi中显示波形需要使用 $fsdbDumpfile( )函数指定波形文件名
  • 要使用函数$fsdbDumpvars( )去dump tb和dut的端口加载波形
  • 要加载寄存器数组的波形，需要使用$fsdbDumpMDA( )函数

我们使用Makefile文件控制VCS和verdi联合仿真
Makfile文件


all  : vcs verdi

vcs   :
	vcs  \
              -f filelist.f  \
              -timescale=1ns/1ps \
              -debug_acc+dmptf -debug_region+cell+encrypt  -full64  -R  +vc  +v2k  -sverilog  -debug_all  \
              -P ${LD_LIBRARY_PATH}/novas.tab  ${LD_LIBRARY_PATH}/pli.a  \
              |  tee  vcs.log  

verdi  :
	verdi -f filelist.f -ssf tb.fsdb 

clean  :
	 rm  -rf  *~  core  csrc  simv*  vc_hdrs.h  ucli.key  urg* *.log  novas.* *.fsdb* verdiLog  64* DVEfiles *.vpd

在文件夹sim/下使用命令

make vcs
make verdi

即可仿真及打开verdi查看波形
如何编写Makefile进行vcs+verdi联合仿真可参考本人的另一篇博客VCS + verdi + Makefile

仿真波形图
在这里插入图片描述

  1. if_inst是取到的指令，从仿真可知，依次取出inst_rom.data中的指令
  2. 观察regs[1]、regs[2]、regs[3]、regs[4]的最终值，可知OpenMIPS正确执行了程序

三、链接汇总

项目源码https://github.com/yizhixiaohuihui/OpenMIPS.git
如何得到inst_rom.data文件参考文章https://blog.youkuaiyun.com/yvbycf/article/details/128359374
如何编写Makefile进行vcs+verdi联合仿真可参考本人的另一篇博客VCS + verdi + Makefile

ORI指令实现代码
dieyouxiu的博客
01-09 1243
ori指令
手把手教你自己动手写cpu（十三）--第一条“ori“ 指令
最新发布
MHD0815的博客
09-22 814
在计算机体系结构中，"ori" 是一种常见的汇编语言指令，在不同的处理器架构中有着不同的含义。在 MIPS 架构中，指令用于将一个立即数与寄存器中的值进行逻辑或（OR）运算，并将结果存储到目标寄存器中。请注意，在真实的处理器设计中，还需要考虑更多细节，比如异常处理、流水线冲突等。进行逻辑或运算，并将结果存储到寄存器。假设我们要实现这样一个功能：将寄存器。类来模拟寄存器文件，并且实现了一个。是其中一个操作数所在的位置，而。是另一个操作数，它是一个常数值。在这个例子中，我们定义了一个。在实际的 CPU 中，
自己动手写处理器之第四阶段（1）——第一条指令ori的实现
aofan9566的博客
02-26 1201
将陆续上传本人写的新书《自己动手写处理器》（尚未出版），今天是第11篇，我尽量每周四篇 第4章 第一条指令ori的实现 前面几章介绍了非常多预备知识，也描绘了即将要实现的OpenMIPS处理器的蓝图，各位读者是不是早已摩拳擦掌，迫切希望一展身手了，好吧，本章我们将实现OpenMIPS处理器的第一条指令ori，为什么选择这条指令作为我们实现的第一条指令呢...
ori指令的测试
dieyouxiu的博客
01-09 946
ori 自己动手写cpu
第一条ori指令的实现
望庐的博客
10-10 1788
参照《自己动手写CPU》第四章初步建立MIPS五级流水线结构，实现ori指令。
Single_instruction_cycle_OpenMIPS:通过学习《自己动手写CPU》，将书中实现的兼容MIPS32指令集架构的处理器——OpenMIPS（五级流水线结构），简化成单指令周期实现的处理器
04-28
通过学习《自己动手写CPU》，将书中实现的兼容MIPS32指令集架构的处理器——OpenMIPS（五级流水线结构），简化成单指令周期实现的处理器 根据以下顺序查看效果更佳： ：通过学习《自己动手写CPU》第四章，学习了MIPS...
简化MIPS处理器：实现单指令周期OpenMIPS
资源摘要信息:"通过阅读《自己动手写CPU》这本书，我们可以通过学习，将原书中实现的兼容MIPS32指令集架构的五级流水线处理器OpenMIPS简化为单指令周期处理器。MIPS（Microprocessor without Interlocked Pipeline ...
第十一章：异常相关指令的实现
dieyouxiu的博客
02-01 2297
11.1 MIPS32架构中定义的异常类型 在MIPS32架构中，有一些事件要打断程序的正常执行流程，这些事件有中断（Interrupt)、陷阱（Trap)、系统调用（System Call)以及其他任何可以打断程序正常执行流程的情况，统称为异常。异常类型及其优先级如表所示。 OpenMIPS处理器只实现对其中6种异常情况的处理，列举如下： 硬件复位 中断（包含软中断、硬中断） syscall系统调用 无效指令 溢出 自陷指令引发的异常 异常发生后，会进入异常处理例程进行具体的异常处理，处理结束后，返回
单指令周期CPU——移动操作指令的实现
Zach_z的博客
01-21 3329
单指令周期CPU MIPS 移动操作指令
第五章逻辑、移位操作与空指令的实现
dieyouxiu的博客
01-10 4446
上一章建立了原始的OpenMIPS五级流水线结构，但是只实现了一条ori指令，从本章开始，将逐步完善。本章首先讨论了流水线数据相关问题，然后修改OpenMIPS以解决问题。接着对逻辑、移位操作和空指令的指令格式、用法进行了一一说明。 5.1流水线数据相关问题 流水线中经常有一些被称为“相关”的情况发生，它使得指令序列中下一条指令无法按照设计周期执行，这些“相关”会降低流水线的性能，流水线中的相关分为以下三种类型。 结构相关：在指令执行过程中，由于硬件资源满足不了指令执行的要求，发生硬件资源冲突而产生的相关
OpenMIPS_Verilog
01-22
openmips 架构的verilog代码，仅供学习参考使用，希望对开发cpu架构有所帮助
OpenMIPS快速入门手册（实践版）
09-11
OpenMIPS快速入门手册（实践版）主要包含相关技术的规范，以及OpenMIPS引脚的定义与使用 OpenMIPS快速入门手册（实践版）
OpenMIPS_VerilogHDL_Study_v1.1.rar
01-28
OpenMIPS处理器，是一款具有哈佛结构的32位标量处理器，兼容MIPS32 Release 1指令集架构（后文不再注明Release 1）。这种优点是能够使用现有的MIPS编译环境，如：GCC编译器等。OpenMIPS的设计目标例如以下。 五级整数流水线，各自是：取指、译码、运行、訪存、回写 哈佛结构。分开的指令、数据接口 32个32位整数寄存器 大端模式 向量化异常处理。支持精确异常处理 支持6个外部中断 具有32bit数据、地址总线宽度 能实现单周期乘法 支持延迟转移 兼容MIPS32指令集架构。支持MIPS32指令集中的全部整数指令 大多数指令能够在一个时钟周期内完毕
OpenMIPS教学版讲解
09-22
OpenMIPS开始于2013年8月，目的是开发一款32位、兼容MIPS32指令集的开源软核处理器，便于老师教学、学生体会理解计算机体系结构课程的相关知识，同时也可以做实际用途。OpenMIPS将坚持自由软件的理念，保持开源的形式，同时采用商业友好的LGPL授权。
关于OpenMips
amugou的专栏
04-30 847
1、编译，参见《自己动手写CPU》P97 mips-linux-as.exe -mips32 inst_rom.s -o inst_rom.o 2、如何查看Section信息，参见《自己动手写CPU》P99 mips-linux-readelf.exe -S inst_rom.o 3、链接 mips-linux-ld.exe -T  ram.ld inst_rom.o -o in
【自己动手写CPU】OpenMIPS处理器
m0_51403396的博客
08-20 597
在写指令之前，自己动手写cpu那本书还介绍了OpenMIPS处理器计划实现的五级流水线，介绍了该处理器的接口，解释各个源码文件的作用，最后描述OpenMIPS处理器的实现方法。 设计目标 五级流水线 流水线：流水线是指将计算机指令处理过程拆分为多个步骤，并通过多个硬件处理单元并行执行来加快指令执行速度。 ...
CPU设计实战-第一条指令ori的实现即最简单的五级流水线的实现
m0_55502433的博客
02-01 1815
defines.v此文件定义了下面模块中所用到一些宏定义，如常用的数据宽度，数据长度以及指令码的定义。使用头文件只需在模块最前面加上`include"defines.v"//全局//指令//AluOp//AluSel//指令存储器inst_rom//通用寄存器regfile。
4. 第一条ORI的实现
dieyouxiu的博客
01-08 2462
ori指令介绍
第一条指令ori的实现
一枚咸鱼的博客
04-13 483
这其实就是一个帧格式 `include "defines.v" module pc_reg( input wire clk, input wire rst, output reg [`InstAddrBus] pc, //InstAddrBus为宏定义 31:0 代表ROM的地址总线宽度 output reg ce ); //同步复位 //如果复位，则使能信号ce拉0禁用，否则置1 always @ (posedg
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值