R型指令以上

最新推荐文章于 2023-03-02 11:47:23 发布
最新推荐文章于 2023-03-02 11:47:23 发布
阅读量214 收藏
点赞数 1
分类专栏： 笔记 文章标签： css
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51450194/article/details/128125796
版权

宏定义文件

define RstEnable 1’b1 define RstDisable 1’b0 define RomEnable 1b1 define RomDisable 1’b0 define Zero 0
define Valid 1’b1
define Invalid 1’b0
/／指令外部编码
// I 型编码
define Inst _ ori 6’b001101
define Inst _ andi 6’b001100
define Inst _ xori 6’b001110
define Inst _ addi 6’b001000
define Inst _ subi 6’b001001
define Inst _lui6’b001111
// R 型编码
define Inst _ reg 6’b000000
define Inst _ add 6’b100000
define Inst _ sub 6’b100010
define Inst _ and 6’b100100
define Inst _ or 6’b100101
define Inst _ xor 6’b100110
define Inst _ sll 6’b000000
define Inst _ srl 6’b000010
define Inst _ sra 6’b000011
/／内部供 EX 的编码
define Nop 6’b000000
define Or6’b000001
define And 6’b000010
define Xor 6’b000011
define Add 6’b000100
define Sub 6’b000101
define Lui 6’b100000/／此处重新修改了 define Sll 6’b000110
define Srl 6’b000111
define Sra 6’b001000

InstMem
include "define.v"; //6、指令存储器 module InstMem( input wire ce, input wire [31:0] addr, output reg [31:0] data ); reg [31:0] instmem [1023 : 0]; always@(*) if(ce ==RomDisable)
data = `Zero;
else
data = instmem[addr[11 : 2]];
initial
begin
//ori R0,1100 – R1 --00001100
instmem [0] = 32’h34011100;
//ori R0,0020 – R2 --00000020
instmem [1] = 32’h34020020;
//ori R0,ff00 – R3 --0000ff00
instmem [2] = 32’h3403ff00;
//ori R0,ffff – R4 --0000ffff
instmem [3] = 32’h3404ffff;
//andi R0,ffff --R5 --00000000
// instmem [4] = 32’h3005ffff;
//xori R0,ffff --R6 --0000ffff
// instmem [5] = 32’h3806ffff;
//addi R0,ffff --R7 --ffffffff
// instmem [6] = 32’h2007ffff;
//subi R0,ffff --R8 --00000001
// instmem [7] = 32’h2408ffff;
//lui R0,ffff --R9 --ffff0000
// instmem [8] = 32’h3C09ffff;

	//R1=00001100 R2=00000020
	instmem [4] = 32'b000000_00001_00010_00101_00000_100000;//add,R5,R1,R2  00001120
	instmem [5] = 32'b000000_00001_00010_00110_00000_100101;//or,R6,R1,R2   00001120
	instmem [6] = 32'b000000_00001_00010_00111_00000_100010;//sub,R7,R1,R2  000010e0
	instmem [7] = 32'b000000_00001_00010_01000_00000_100100;//and,R8,R1,R2  00000000
	instmem [8] = 32'b000000_00001_00010_01001_00000_100110;//xor,R9,R1,R2  00001120

	//lui  R0,ffff --R10 --ffff0000
	instmem [9] = 32'h3C0Affff;

	
	//R11=fffe0000 R12=7fff8000  R13=ffff8000
	// Ra=sa={25'b0,imm[10:6]}
	instmem [10] = 32'b000000_00000_01010_01011_00001_000000;//sll,R11,Ra,R10
	instmem [11] = 32'b000000_00000_01010_01100_00001_000010;//srl,R12,Ra,R10  		
	instmem [12] = 32'b000000_00000_01010_01101_00001_000011;//sra,R13,Ra,R10

  end

endmodule

ID
`include “define.v”;
//2、为操作数做准备
//把指令32的i型指令inst
//6op 5rega 5regc 16imm
//regaData regbData
module ID (
input wire rst,
input wire [31:0] inst,
input wire [31:0] regaData_i,
input wire [31:0] regbData_i,
output reg [5:0] op,
output reg [31:0] regaData,
output reg [31:0] regbData,
output reg regaRead,
output reg regbRead,
output reg regcWrite,
output reg [4:0] regaAddr,
output reg [4:0] regbAddr,
output reg [4:0] regcAddr
);
//操作指令
wire [5:0] inst_op = inst[31:26];
//扩展的立即数
reg [31:0] imm;
//用于R型指令
wire[5:0] func = inst[5:0];
//用于R型移位指令 给regaAddr赋值
wire[5:0] shamt= inst[10:6];
//用于R型移位指令 给regaData赋值
wire[31:0] sa= {27’h0,inst[10:6]};

//用于R型移位指令
always@(*)
    if(rst == `RstEnable)
      begin
        op = `Nop;            
        regaRead = `Invalid;
        regbRead = `Invalid;
        regcWrite = `Invalid;
        regaAddr = `Zero;
        regbAddr = `Zero;
        regcAddr = `Zero;
        imm    = `Zero;
      end
else	
      case(inst_op)
           `Inst_ori:
              begin
                op = `Or;                    
                regaRead = `Valid;
                regbRead = `Invalid;
                regcWrite = `Valid;
                regaAddr = inst[25:21];
                regbAddr = `Zero;
                regcAddr = inst[20:16];
                imm = {16'h0, inst[15:0]};
              end
	`Inst_andi:
	  begin
                op = `And;                    
                regaRead = `Valid;
                regbRead = `Invalid;
                regcWrite = `Valid;
                regaAddr = inst[25:21];
                regbAddr = `Zero;
                regcAddr = inst[20:16];
                imm = {16'h0, inst[15:0]};
              end
	`Inst_xori:
	  begin
                op = `Xor;                    
                regaRead = `Valid;
                regbRead = `Invalid;
                regcWrite = `Valid;
                regaAddr = inst[25:21];
                regbAddr = `Zero;
                regcAddr = inst[20:16];
                imm = {16'h0, inst[15:0]};
              end

	`Inst_addi:
	  begin
                op = `Add;                    
                regaRead = `Valid;
                regbRead = `Invalid;
                regcWrite = `Valid;
                regaAddr = inst[25:21];
                regbAddr = `Zero;
                regcAddr = inst[20:16];
                imm = {{16{inst[15]}}, inst[15:0]};
              end
	`Inst_subi:
	  begin
                op = `Sub;                    
                regaRead = `Valid;
                regbRead = `Invalid;
                regcWrite = `Valid;
                regaAddr = inst[25:21];
                regbAddr = `Zero;
                regcAddr = inst[20:16];
                imm = {{16{inst[15]}}, inst[15:0]};
              end
	`Inst_lui:
	  begin
                op = `Lui;                    
                regaRead = `Valid;
                regbRead = `Invalid;
                regcWrite = `Valid;
                regaAddr = inst[25:21];
                regbAddr = `Zero;
                regcAddr = inst[20:16];
                imm = {inst[15:0],16'h0};
              end
		`Inst_reg:
    		     case(func)
                		`Inst_add:
	                     		begin
	                            	op = `Add;
		                            regaRead = `Valid;
		                            regbRead = `Valid;
		                            regcWrite = `Valid;
		                            regaAddr = inst[25:21];
		                            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
		                            imm = `Zero;
	                            end

						`Inst_or:
						        begin
						            op = `Or;
						            regaRead = `Valid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = inst[25:21];
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end

						`Inst_sub:
						        begin
						            op = `Sub;
						            regaRead = `Valid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = inst[25:21];
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end

						`Inst_and:
						        begin
						            op = `And;
						            regaRead = `Valid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = inst[25:21];
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end


						`Inst_xor:
						        begin
						            op = `Xor;
						            regaRead = `Valid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = inst[25:21];
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end

						//修改了下面的组合逻辑两个always语句
						`Inst_sll:
						        begin
						            op = `Sll;
						            regaRead = `Invalid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = shamt;//regaRead 无效，但regaAddr不为`Zero
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end

						`Inst_srl:
						        begin
						            op = `Srl;
						            regaRead = `Invalid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = shamt;
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end

						`Inst_sra:
						        begin
						            op = `Sra;
						            regaRead = `Invalid;
						            regbRead = `Valid;
						            regcWrite = `Valid;
						            regaAddr = shamt;//无效，但不为`Zero
						            regbAddr = inst[20:16];
						            regcAddr = inst[15:11];
						            imm = `Zero;
						        end


						default:
						        begin
						            regaRead = `Invalid;
						            regbRead = `Invalid;
						            regcWrite = `Invalid;
						            regaAddr = `Zero;
						            regbAddr = `Zero;
						 		    regcAddr = `Zero;
						            imm = `Zero;
						        end
						   endcase
	default:
              begin
                op = `Nop;                    
                regaRead = `Invalid;
                regbRead = `Invalid;
                regcWrite = `Invalid;
                regaAddr = `Zero;
                regbAddr = `Zero;
                regcAddr = `Zero;
                imm = `Zero;
              end
        endcase

/*
//二选一 regaData= regaData_i : imm

always@(*)
  if(rst == `RstEnable)
      regaData = `Zero;
  else if(regaRead == `Valid)
      regaData = regaData_i;
  else	
      regaData = imm;

//二选一 regbData= regbData_i : imm
always@(*)
if(rst == RstEnable) regbData =Zero;
else if(regbRead == `Valid)
regbData = regbData_i;
else
regbData = imm;
*/

//三选一 regaData= regaData_i : imm  ：sa
always@(*)
  if(rst == `RstEnable)
      regaData = `Zero;
  else if(regaRead == `Valid)
      regaData = regaData_i;
  else if(regaRead == `Invalid && regaAddr==`Zero)
      regaData = imm;
  else 
	  regaData = sa;

//三选一 regbData= regbData_i : imm ：sa
always@(*)
if(rst == RstEnable) regbData =Zero;
else if(regbRead == Valid) regbData = regbData_i; else if(regbRead ==Invalid && regbAddr==`Zero)
regbData = imm;
else
regbData = sa;
endmodule

EX

include "define.v"; //3、执行指令模块 module EX ( input wire rst, input wire [5:0] op, input wire [31:0] regaData, input wire [31:0] regbData, input wire regcWrite_i, input wire [4:0] regcAddr_i, output reg [31:0] regcData, output wire regcWrite, output wire [4:0] regcAddr ); always@(*) if(rst ==RstEnable)
regcData = Zero; else case(op)Or:
regcData = regaData | regbData;
And: regcData = regaData & regbData;Xor:
regcData = regaData ^ regbData;
Add: regcData = regaData + regbData;Sub:
regcData = regaData - regbData;
`Lui:
regcData = regaData | regbData;

         	`Sll:
            	regcData = regbData << regaData;
          	`Srl:
            	regcData = regbData >> regaData;
			`Sra:
				regcData = ($signed(regbData)) >>> regaData;
			
            default:
                regcData = `Zero;
        endcase      
assign regcWrite = regcWrite_i;
assign regcAddr = regcAddr_i;

endmodule

芝士.玉米.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
实验四+ R型指令设计实验【计算机组成原理】
小心星的博客
11-29 1091
实验四+ R型指令设计实验【计算机组成原理】
计算机组成原理｜实现R型指令的CPU设计实验
匿名用户小易
12-10 6055
实现R型指令的CPU设计实验 一、实验目的与要求 实验目的： （1）掌握MISP R型指令的数据通路设计，掌握指令流和数据流的控制方法 （2）掌握完整的单周期CPU顶层模块的设计方法 （3）实现MISP R型指令的功能 实验要求： （1）在实验三~六的基础上，编写一个CPU模块，实现实验八指定的R型指令 （2）编写一个实验验证的顶层模块 模块设计说明 模块sy8_top为顶层模块，负责...
杭电计算机组成原理课程设计-实验十一-实现R型指令的CPU设计实验
HDU-整蛊小子-⏰☂️/蚂蚁集团研发工程师
07-21 7157
实现R型指令的CPU设计实验实验内容实验内容与原理汇编指令与.coe文件功能模块说明逻辑引脚图仿真时序波形图R-I CPU 完整代码测试用例代码探索与思考（非标准答案） 实验内容 选以下4种系统结构之一，设计一个MIPS单周期R-CPU （1）不带状态寄存器，8条指令 （2）带状态寄存器，8条指令 （3）不带状态寄存器，9条指令（多了sll） （4）带状态寄存器，9条指令（多了sll） 本文选取第4种结构进行设计 具体步骤 修改寄存器堆模块，以使$0 内容恒置全零，只读。 根据所选指令系统，修改ALU模块
计算机组成实验-第5章_R指令设计实现
程序员
04-09 1182
/*主要问题，result=AopB，如果所有的always都是posedge clk触发，则会出现不同步的问题，因为A和B的值从寄存器取出进行运算得到结果之后，结果需要等到下一个时钟周期才能写入result： 第一个时钟周期的操作是解析指令，将A和B的值从寄存器堆中取出，并且计算得到ALUoper的值。 第二个时钟周期：计算result的值。 这样result会比A和B晚一个
杭电计算机组成实验8（八）实现R型指令的CPU设计实验
DoMoreSpeakLess的博客
12-23 9679
实验内容 1. 掌握MIPS R型指令的数据通路设计，掌握指令流和数据流的控制方法 2. 掌握完整的单周期CPU顶层模块的设计方法 3. 实现MIPS R型指令的功能 解决方法 1. 分析MIPS R型指令的特点，OP均为000000b，可作为判断R型指令的依据 2. 两个源操作数分别在rs和rt字段所指定的寄存器中，而目的操作数则是在rd字段所指定的寄存器 3. 分析数据通路是从指令存储器取出的指令经过初级译码，将分解出的源寄存器rs、rt直接与寄存器堆的两个读端口A和B的寄存器地址连接，而将目的寄存器r
计组R型指令modelsim仿真
12-11
2. **编写R型指令模型**：在HDL代码中，定义R型指令的逻辑结构。这通常涉及到处理器的算术逻辑单元（ALU）、控制单元（CU）以及寄存器文件的模型。例如，一个简单的加法R型指令可能需要从两个寄存器读取操作数，通过...
杭电计组实验9-实现R-I型指令的CPU设计实验.pdf
06-20
在本实验中，学生将设计并实现一个基于R-I型指令的CPU。R-I型指令是一种常见的计算机指令格式，它包含寄存器操作和立即数操作。这种类型的指令通常用于执行算术和逻辑运算，例如加法、减法或位操作，并且允许直接...
计算机组成原理 R型CPU相关文件
06-29
R型CPU通常由五大主要部件构成：指令寄存器（IR）、程序计数器（PC）、算术逻辑单元（ALU）、通用寄存器（GRs）和控制单元（CU）。这些组件协同工作，执行计算机程序中的指令序列。IR存储当前执行的指令，PC负责跟踪...
17061833於文卓_实验10 实现R-I-J型指令的CPU设计实验1
08-08
实验报告涉及的是“实现R-I-J型指令的CPU设计实验”，这是计算机科学与技术课程中的一个实践环节，主要目标是让学生掌握MIPS架构中的不同指令类型及其处理方式。实验要求学生设计并实现一个CPU模块，该模块能处理R型...
17061833於文卓_实验8实现R型指令的CPU设计实验1
08-08
六、思考与探索实验结果记录：序号指令执行结果标志结论ZFOF100000827FFFF_FFFF00正确20001102b0000_000100正确300421
R的指令
J_ssica_L的博客
06-16 952
找r包位置的命令是 (.libPaths())
【计算机系统设计】实践笔记（2）数据通路构建：第一类R型指令分析（1）
X
11-15 6089
0 回顾 上一次实践笔记（0）我们实现了一个最简单的，能够每个上升沿+4的PC。 我们最需要关注的就是器件功能的独立性，避免内外功能混杂，同时一定要注意脑中有电路（RTL级描述的抽象电路而不是实际的门级电路，内个交给EDA工具就行）。 1 针对的指令 现在，我们分析一下R类指令，我们需要构建数据通路，而很多的R类指令是相似的，因此可以直接分析一类指令，就像所有指令都需要取指，我们就分析所有指令一样。 那么，我们要分析哪一类指令?这取决于我们准备实现的指令有什么，我们先看看。 add addu sub sub
R常用指令
尚拙的博客
08-31 1029
在一次项目中用到R指令： 计算z1.txt文件行数： awk '{print NR}' z1.txt | tail -n1 向z16文件中添加一列 name： sed -i '1 i\name' z16.txt 向z14.txt文件中增加bead_threshold_nosafety bead_threshold jaccard_threshold_nosafety jaccard_threshold等列数据 sed -i '1 i\ be...
[计算机组成原理][R-I-J型指令CPU设计实验总结]
学习之路
05-18 1万+
总算解决一大心头之患了，比想象中容易，通宵两夜，刷完了十个实验，这个实验就是最后的了。感慨颇多。特地写篇总结。 想做一件事，就立马去做把。你会发现没那么困难，往往最大的困难，是心里的困难。 培养了HDL(Hardware Description Language)思维，并行，串行混合。它先是一个电路，再才是一个程序，电路为主，程序为辅，用RTL的思维去思考。 这个实验也不怎么难，就是一个大的模拟题，
R型J型I型指令
weixin_52205764的博客
12-21 5825
立即数指令，这里注意beq和lw都是I型指令 在R型指令中包括sll指令虽然没有rs，jr指令也是R型指令 J型指令
操作系统--MIPS指令三种类型-R型-I型-J型----MIPS寻址模式/方式
热门推荐
m0_57446284的博客
05-15 3万+
操作码的长度决定了可以提供多少个指令数；操作码的编码一定要有唯一的解释 一、计算机的寻址方式 立即寻址：指令中给出操作数 直接寻址：指令中给出操作数所在的有效地址 间接寻址：指令中给出一个间接地址，间接地址在内存中寻找直接地址，直接地址读出操作数 寄存器间接寻址：指令给出寄存器编号，根据寄存器内容找出操作数 基址寻址：指令中给出一个寄存器编号，同时给出一个偏移地址，基址寄存器内容+偏移地址从内存中取操作数 二、操作码编码 定长操作码编码 扩展操作码编码 三、MIPS的指令可以分为..
用scala写一个基本五级流水线CPU(三)增加R型指令
qqNCer的博客
06-29 395
用scala写一个基本五级流水线CPU(三)增加R型指令 ctime:2020-06-28 13:01:45 +0900|1593316905 标签（空格分隔）： 技术 硬件 本次更新的代码可参考： https://github.com/Ncerzzk/SimpleCPU/tree/deeb0217751f32bda5adf748b60cf528296466a6 前面的文章中已经添加了一条最基本的ORI指令（I型指令），然而指令系统目前还很不完善，如果要增加指令的话，还需要改动大量代码。 因此，本文开始着
计算机组成原理r型指令,杭电计组实验8-实现R型指令的CPU设计实验介绍.doc
weixin_39663258的博客
07-15 1043
杭州电子科技大学计算机学院实验报告实验项目：课程名称：计算机组成原理与系统结构设计姓名： 学号： 同组姓名： 　　 学号：实验位置(机号)： 自己的笔记本实验日期： 　　　 指导教师：实验内容(算法、程序、步骤和方法)实验目的掌握灵活应用Verilog HDL进行各种描述与建模的技巧和方法。学习在ISE中设计生成M恶魔人员IP核的方法。(...
IC--CPU设计第一篇（R，I指令集测试）
最新发布
qq_44676785的博客
03-02 533
小白入门RISC第一篇，ADDI，ADD指令集测试
MIPS R型指令CPU设计实验报告
"於文卓的实验8是关于实现R型指令的CPU设计，该实验在计算机科学与技术专业课程《计算机组成原理课程设计》中进行，由冯建文老师指导。实验的主要目的是掌握MIPSR型指令的数据通路设计，理解指令流和数据流的控制，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值