IC知识积累——06_RISCV寄存器组的代码

最新推荐文章于 2023-09-27 00:00:48 发布
最新推荐文章于 2023-09-27 00:00:48 发布
阅读量439 收藏 1
点赞数 3
分类专栏： IC知识积累
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33766313/article/details/109841454
版权

RISCV寄存器组代码

// Copyright 2017 ETH Zurich and University of Bologna.
// Copyright and related rights are licensed under the Solderpad Hardware
// License, Version 0.51 (the \u201cLicense\u201d); you may not use this file except in
// compliance with the License.  You may obtain a copy of the License at
// http://solderpad.org/licenses/SHL-0.51. Unless required by applicable law
// or agreed to in writing, software, hardware and materials distributed under
// this License is distributed on an \u201cAS IS\u201d BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.


// Engineer:       Antonio Pullini - pullinia@iis.ee.ethz.ch                  //
//                                                                            //
// Additional contributions by:                                               //
//                 Sven Stucki - svstucki@student.ethz.ch                     //
//                 Michael Gautschi - gautschi@iis.ee.ethz.ch                 //
//                                                                            //
// Design Name:    RISC-V register file                                       //
// Project Name:   RI5CY                                                      //
// Language:       SystemVerilog                                              //
//                                                                            //
// Description:    Register file with 31x 32 bit wide registers. Register 0   //
//                 is fixed to 0. This register file is based on latches and  //
//                 is thus smaller than the flip-flop based register file.    //
//                 Also supports the fp-register file now if FPU=1            //
//                                                                            //


module riscv_register_file
#(
  parameter ADDR_WIDTH    = 5,
  parameter DATA_WIDTH    = 32,
  parameter FPU           = 0
)
(
  // Clock and Reset
  input  logic                   clk,
  input  logic                   rst_n,

  input  logic                   test_en_i,

  //Read port R1
  input  logic [ADDR_WIDTH-1:0]  raddr_a_i,
  output logic [DATA_WIDTH-1:0]  rdata_a_o,

  //Read port R2
  input  logic [ADDR_WIDTH-1:0]  raddr_b_i,
  output logic [DATA_WIDTH-1:0]  rdata_b_o,

  //Read port R3
  input  logic [ADDR_WIDTH-1:0]  raddr_c_i,
  output logic [DATA_WIDTH-1:0]  rdata_c_o,

  // Write port W1
  input  logic [ADDR_WIDTH-1:0]   waddr_a_i,
  input  logic [DATA_WIDTH-1:0]   wdata_a_i,
  input  logic                    we_a_i,

  // Write port W2
  input  logic [ADDR_WIDTH-1:0]   waddr_b_i,
  input  logic [DATA_WIDTH-1:0]   wdata_b_i,
  input  logic                    we_b_i
);

   // number of integer registers
   localparam    NUM_WORDS     = 2**(ADDR_WIDTH-1);
   // number of floating point registers
   localparam    NUM_FP_WORDS  = 2**(ADDR_WIDTH-1);
   localparam    NUM_TOT_WORDS = FPU ? NUM_WORDS + NUM_FP_WORDS : NUM_WORDS;
      
   // integer register file
   logic [DATA_WIDTH-1:0]         mem[NUM_WORDS];
   logic [NUM_TOT_WORDS-1:1]      waddr_onehot_a;
   logic [NUM_TOT_WORDS-1:1]      waddr_onehot_b, waddr_onehot_b_q;
   logic [NUM_TOT_WORDS-1:1]      mem_clocks;
   logic [DATA_WIDTH-1:0]         wdata_a_q;
   logic [DATA_WIDTH-1:0]         wdata_b_q;

   logic                          clk_int;

   // fp register file
   logic [DATA_WIDTH-1:0]         mem_fp[NUM_FP_WORDS];

   int                            unsigned i;
   int                            unsigned j;
   int                            unsigned k;
   int                            unsigned l;

   genvar                         x;
   genvar                         y;


   //-----------------------------------------------------------------------------
   //-- YSW ADD  : mem sigs test 
   //-----------------------------------------------------------------------------

   logic    [31:0]          mem_register_ila_0    ;
   logic    [31:0]          mem_register_ila_1    ;
   logic    [31:0]          mem_register_ila_2    ;
   logic    [31:0]          mem_register_ila_3    ;
   logic    [31:0]          mem_register_ila_4    ;
   logic    [31:0]          mem_register_ila_5    ;
   logic    [31:0]          mem_register_ila_6    ;
   logic    [31:0]          mem_register_ila_7    ;
   logic    [31:0]          mem_register_ila_8    ;
   logic    [31:0]          mem_register_ila_9    ;
   logic    [31:0]          mem_register_ila_10   ;
   logic    [31:0]          mem_register_ila_11   ;
   logic    [31:0]          mem_register_ila_12   ;
   logic    [31:0]          mem_register_ila_13   ;
   logic    [31:0]          mem_register_ila_14   ;
   logic    [31:0]          mem_register_ila_15   ;
   logic    [31:0]          mem_register_ila_16   ;
   logic    [31:0]          mem_register_ila_17   ;
   logic    [31:0]          mem_register_ila_18   ;
   logic    [31:0]          mem_register_ila_19   ;
   logic    [31:0]          mem_register_ila_20   ;
   logic    [31:0]          mem_register_ila_21   ;
   logic    [31:0]          mem_register_ila_22   ;
   logic    [31:0]          mem_register_ila_23   ;
   logic    [31:0]          mem_register_ila_24   ;
   logic    [31:0]          mem_register_ila_25   ;
   logic    [31:0]          mem_register_ila_26   ;
   logic    [31:0]          mem_register_ila_27   ;
   logic    [31:0]          mem_register_ila_28   ;
   logic    [31:0]          mem_register_ila_29   ;
   logic    [31:0]          mem_register_ila_30   ;
   logic    [31:0]          mem_register_ila_31   ;

   assign      mem_register_ila_0     =   mem[0 ]      ;
   assign      mem_register_ila_1     =   mem[1 ]      ;
   assign      mem_register_ila_2     =   mem[2 ]      ;
   assign      mem_register_ila_3     =   mem[3 ]      ;
   assign      mem_register_ila_4     =   mem[4 ]      ;
   assign      mem_register_ila_5     =   mem[5 ]      ;
   assign      mem_register_ila_6     =   mem[6 ]      ;
   assign      mem_register_ila_7     =   mem[7 ]      ;
   assign      mem_register_ila_8     =   mem[8 ]      ;
   assign      mem_register_ila_9     =   mem[9 ]      ;
   assign      mem_register_ila_10    =   mem[10]      ;
   assign      mem_register_ila_11    =   mem[11]      ;
   assign      mem_register_ila_12    =   mem[12]      ;
   assign      mem_register_ila_13    =   mem[13]      ;
   assign      mem_register_ila_14    =   mem[14]      ;
   assign      mem_register_ila_15    =   mem[15]      ;
   assign      mem_register_ila_16    =   mem[16]      ;
   assign      mem_register_ila_17    =   mem[17]      ;
   assign      mem_register_ila_18    =   mem[18]      ;
   assign      mem_register_ila_19    =   mem[19]      ;
   assign      mem_register_ila_20    =   mem[20]      ;
   assign      mem_register_ila_21    =   mem[21]      ;
   assign      mem_register_ila_22    =   mem[22]      ;
   assign      mem_register_ila_23    =   mem[23]      ;
   assign      mem_register_ila_24    =   mem[24]      ;
   assign      mem_register_ila_25    =   mem[25]      ;
   assign      mem_register_ila_26    =   mem[26]      ;
   assign      mem_register_ila_27    =   mem[27]      ;
   assign      mem_register_ila_28    =   mem[28]      ;
   assign      mem_register_ila_29    =   mem[29]      ;
   assign      mem_register_ila_30    =   mem[30]      ;
   assign      mem_register_ila_31    =   mem[31]      ;
   //-----------------------------------------------------------------------------
   //-- READ : Read address decoder RAD
   //-----------------------------------------------------------------------------
   if (FPU == 1) begin
      assign rdata_a_o = raddr_a_i[5] ? mem_fp[raddr_a_i[4:0]] : mem[raddr_a_i[4:0]];
      assign rdata_b_o = raddr_b_i[5] ? mem_fp[raddr_b_i[4:0]] : mem[raddr_b_i[4:0]];
      assign rdata_c_o = raddr_c_i[5] ? mem_fp[raddr_c_i[4:0]] : mem[raddr_c_i[4:0]];
   end else begin
      assign rdata_a_o = mem[raddr_a_i[4:0]];
      assign rdata_b_o = mem[raddr_b_i[4:0]];
      assign rdata_c_o = mem[raddr_c_i[4:0]];
   end     

   //-----------------------------------------------------------------------------
   // WRITE : SAMPLE INPUT DATA
   //---------------------------------------------------------------------------

   cluster_clock_gating CG_WE_GLOBAL
     (
      .clk_i     ( clk             ),
      .en_i      ( we_a_i | we_b_i ),
      .test_en_i ( test_en_i       ),
      .clk_o     ( clk_int         )
      );

   // use clk_int here, since otherwise we don't want to write anything anyway
   always_ff @(posedge clk_int, negedge rst_n)
     begin : sample_waddr
        if (~rst_n) begin
           wdata_a_q        <= '0;
           wdata_b_q        <= '0;
           waddr_onehot_b_q <= '0;
        end else begin
           if(we_a_i)
             wdata_a_q <= wdata_a_i;

           if(we_b_i)
             wdata_b_q <= wdata_b_i;

           waddr_onehot_b_q <= waddr_onehot_b;
        end
     end

   //-----------------------------------------------------------------------------
   //-- WRITE : Write Address Decoder (WAD), combinatorial process
   //-----------------------------------------------------------------------------
   always_comb
     begin : p_WADa
        for(i = 1; i < NUM_TOT_WORDS; i++)
          begin : p_WordItera
             if ( (we_a_i == 1'b1 ) && (waddr_a_i == i) )
               waddr_onehot_a[i] = 1'b1;
             else
               waddr_onehot_a[i] = 1'b0;
          end
     end

   always_comb
     begin : p_WADb
        for(j = 1; j < NUM_TOT_WORDS; j++)
          begin : p_WordIterb
             if ( (we_b_i == 1'b1 ) && (waddr_b_i == j) )
               waddr_onehot_b[j] = 1'b1;
             else
               waddr_onehot_b[j] = 1'b0;
          end
     end

   //-----------------------------------------------------------------------------
   //-- WRITE : Clock gating (if integrated clock-gating cells are available)
   //-----------------------------------------------------------------------------
   generate
      for(x = 1; x < NUM_TOT_WORDS; x++)
        begin : CG_CELL_WORD_ITER
           cluster_clock_gating CG_Inst
             (
              .clk_i     ( clk_int                               ),
              .en_i      ( waddr_onehot_a[x] | waddr_onehot_b[x] ),
              .test_en_i ( test_en_i                             ),
              .clk_o     ( mem_clocks[x]                         )
              );
        end
   endgenerate
   
   //-----------------------------------------------------------------------------
   //-- WRITE : Write operation
   //-----------------------------------------------------------------------------
   //-- Generate M = WORDS sequential processes, each of which describes one
   //-- word of the memory. The processes are synchronized with the clocks
   //-- ClocksxC(i), i = 0, 1, ..., M-1
   //-- Use active low, i.e. transparent on low latches as storage elements
   //-- Data is sampled on rising clock edge

   // Integer registers
   always_latch
     begin : latch_wdata
        // Note: The assignment has to be done inside this process or Modelsim complains about it
        mem[0] = '0;

        for(k = 1; k < NUM_WORDS; k++)
          begin : w_WordIter
             if(mem_clocks[k] == 1'b1)
               mem[k] = waddr_onehot_b_q[k] ? wdata_b_q : wdata_a_q;
          end
     end
   
   if (FPU == 1) begin
   // Floating point registers
   always_latch
     begin : latch_wdata_fp
        if (FPU == 1) begin
           for(l = 0; l < NUM_FP_WORDS; l++)
             begin : w_WordIter
                if(mem_clocks[l+NUM_WORDS] == 1'b1)
                  mem_fp[l] = waddr_onehot_b_q[l+NUM_WORDS] ? wdata_b_q : wdata_a_q;
             end
        end
     end
   end
endmodule

其中包含了各种技巧：
1、用parameter常数来控制assign的选取：

   //-----------------------------------------------------------------------------
   //-- READ : Read address decoder RAD
   //-----------------------------------------------------------------------------
   if (FPU == 1) begin
      assign rdata_a_o = raddr_a_i[5] ? mem_fp[raddr_a_i[4:0]] : mem[raddr_a_i[4:0]];
      assign rdata_b_o = raddr_b_i[5] ? mem_fp[raddr_b_i[4:0]] : mem[raddr_b_i[4:0]];
      assign rdata_c_o = raddr_c_i[5] ? mem_fp[raddr_c_i[4:0]] : mem[raddr_c_i[4:0]];
   end else begin
      assign rdata_a_o = mem[raddr_a_i[4:0]];
      assign rdata_b_o = mem[raddr_b_i[4:0]];
      assign rdata_c_o = mem[raddr_c_i[4:0]];
   end

2、时钟门控原语，可用于时钟的暂停于信号采样

 //-----------------------------------------------------------------------------
   // WRITE : SAMPLE INPUT DATA
   //---------------------------------------------------------------------------

   cluster_clock_gating CG_WE_GLOBAL
     (
      .clk_i     ( clk             ),
      .en_i      ( we_a_i | we_b_i ),
      .test_en_i ( test_en_i       ),
      .clk_o     ( clk_int         )
      );

   // use clk_int here, since otherwise we don't want to write anything anyway
   always_ff @(posedge clk_int, negedge rst_n)
     begin : sample_waddr
        if (~rst_n) begin
           wdata_a_q        <= '0;
           wdata_b_q        <= '0;
           waddr_onehot_b_q <= '0;
        end else begin
           if(we_a_i)
             wdata_a_q <= wdata_a_i;

           if(we_b_i)
             wdata_b_q <= wdata_b_i;

           waddr_onehot_b_q <= waddr_onehot_b;
        end
     end

3、for循环的使用

   //-----------------------------------------------------------------------------
   //-- WRITE : Write Address Decoder (WAD), combinatorial process
   //-----------------------------------------------------------------------------
   always_comb
     begin : p_WADa
        for(i = 1; i < NUM_TOT_WORDS; i++)
          begin : p_WordItera
             if ( (we_a_i == 1'b1 ) && (waddr_a_i == i) )
               waddr_onehot_a[i] = 1'b1;
             else
               waddr_onehot_a[i] = 1'b0;
          end
     end

   always_comb
     begin : p_WADb
        for(j = 1; j < NUM_TOT_WORDS; j++)
          begin : p_WordIterb
             if ( (we_b_i == 1'b1 ) && (waddr_b_i == j) )
               waddr_onehot_b[j] = 1'b1;
             else
               waddr_onehot_b[j] = 1'b0;
          end
     end

   //-----------------------------------------------------------------------------
   //-- WRITE : Clock gating (if integrated clock-gating cells are available)
   //-----------------------------------------------------------------------------
   generate
      for(x = 1; x < NUM_TOT_WORDS; x++)
        begin : CG_CELL_WORD_ITER
           cluster_clock_gating CG_Inst
             (
              .clk_i     ( clk_int                               ),
              .en_i      ( waddr_onehot_a[x] | waddr_onehot_b[x] ),
              .test_en_i ( test_en_i                             ),
              .clk_o     ( mem_clocks[x]                         )
              );
        end
   endgenerate
俺是菜鸡
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【RISC-V】RISC-V寄存器
qq_43194080的博客
08-28 5733
【代码】【RISC-V】RISC-V寄存器简介。
RISC-V-----指令集介绍
GANHUIJUN的博客
05-30 3217
RISCV的指令介绍
RISC-V基础之函数调用（二）栈与寄存器（包含实例）
欢迎交流！
08-03 2335
在函数结束时，diffofsums从堆栈上恢复这些寄存器的值，释放它的堆栈空间，并返回。堆栈指针sp（寄存器2）是一个普通的RISC-V寄存器，按照惯例，指向堆栈的顶部。函数调用时，为了避免函数修改除了a0之外的其他寄存器的值，造成主程序的寄存器内容被破坏，需要在函数执行前将需要修改的寄存器的值保存到堆栈上，然后在函数返回前将它们从堆栈上恢复。上图代码示例展示了一个改进的diffofsums函数，它在修改t0,t1和s3寄存器之前将它们保存到堆栈上，并在返回前将它们从堆栈上恢复。
RISC-V学习笔记（二）
weixin_46492844的博客
06-18 7590
RISCV架构设计了32个通用整数寄存器和一个程序计数寄存器(PC)，如下所示。通用寄存器的长度在32位架构中为32位，在64位架构中为64位，下面介绍32个通用寄存器中比较重要的几个寄存器：x0：这个寄存器恒为0，读取的值永远为0。ra：用于保存函数调用返回地址，作用类似ARM架构中的lr寄存器。sp：用于保存栈地址，RISCV下和ARM下一样，一般使用满减栈方式。fp：用于保存栈帧，作用类似ARM下的bp寄存器。a0~a7：用于传递函数调用的参数，并且a0一般用于保存函数返回值。RISCV架构下有三种特
RISC-V学习笔记（二）：RISC-V寄存器和指令系统
最新发布
weixin_75067193的博客
09-27 1338
摆烂才是王道
RISV-V架构的寄存器介绍
weixin_42031299的博客
09-13 5550
（1） 通用寄存器：寄存器的功能没有提前定义，是给编写代码的程序员使用的，具体寄存器里保存的数据是什么含义，是由编写代码的程序员决定；（2）系统寄存器：和处理器模式相关的寄存器，寄存器的每个bit都已经提前定义好，程序员只能按照规则来操作系统寄存器。比如：M、S、U各个模式下的系统寄存器，每个寄存器的每个bit都已经定义好了含义；
sifive_RISCV_开源verilog代码
08-24
在sifive_RISCV_开源verilog代码中，Verilog被用来描述RISC-V核心的逻辑电路，包括寄存器、算术逻辑单元（ALU）、分支预测、内存接口等组件。这些组件组合起来，形成了一个完整的RISC-V处理器核心。 sifive_E31_...
riscv-spec-v2.2（指令集架构文档）.zip_RISCV_riscv set指令_riscv指令_指令集_精简指令集
07-14
在《riscv-spec-v2.2》文档中，你会找到关于RISC-V指令格式、寻址模式、寄存器分配、异常处理、特权级别、中断和调试支持等详细信息。通过深入阅读这份文档，开发者和硬件设计师可以全面理解如何编写兼容RISC-V的...
gpr.zip_32位堆寄存器_gpr 寄存器_gpr寄存器_savegpr_27_寄存器堆
09-21
"gpr.zip_32位堆寄存器_gpr寄存器_gpr寄存器_savegpr_27_寄存器堆"这个标题涉及到的核心概念是通用寄存器（General Purpose Registers，简称GPRs）和32位寄存器堆。 首先，我们来详细了解一下32位堆寄存器。在...
以太网PHY寄存器分析.zip_childrenr1l_phy 寄存器_phy寄存器_以太网 PHY 寄存器_以太网phy
07-14
以太网PHY（Physical Layer，物理层）是网络通信中数据传输的基础，它负责将数字信号转换为可以在物理介质上...无论是对于设备制造商还是网络运维人员，理解这些知识都至关重要，因为它直接影响到网络的稳定性和效率。
ADC.rar_dsp adc寄存器_dspadc寄存器
09-19
**ADC（模数转换器）在DSP中的应用与寄存器配置** 在数字信号处理（DSP）领域，ADC（模拟到数字转换器）是至关重要的组成部分，它将连续的模拟信号转换为离散的数字信号，以便进行后续的数字处理。在本案例中，我们...
一文学懂risc-v汇编操作
m0_62730135的博客
09-10 9250
深入浅出的介绍各种risc-v指令以及介绍程序是如何在内存中组织起来的。
RISC-V 整型通用寄存器介绍
17岁boy的博客
08-17 2619
x0/zerox0寄存器又被称为zero寄存器，它的读写是无效的，它的值只能为0，这是为了让编译器进行优化上面这段汇编的作用是进行相加运算，将x2和x3寄存器的值相加的结果并放入x1寄存器，但是如果x3寄存器的值为0当RISC-V处理器执行这条指令的时不会去读取x0寄存器的值，会直接按0来运算，这样就可以省去与0做运算时读取的步骤。RISC-V处理器在设计时只要涉及到x0寄存器的读取一律按0来处理不会去读取x0的寄存器，这么做的目的是为了方便编译器优化某些运算。
RISC-V指令集
热门推荐
m0_47329175的博客
10-04 2万+
RV32I有32个通用寄存器，以及一个PC寄存器。其中有一个通过硬件设置的值恒为 0 的 x0 寄存器。
【RISC-V】寄存器
Embedded Guru
05-21 1854
32个64位整型通用寄存器，x0~x3132个浮点数通用寄存器， f0~f31。
RiscV汇编基础学习
runafterhit的博客
12-23 1912
RiscV的基础指令：根据寄存器位宽和地址空间不同，分为32、64、128位三种不同整数指令集（用I表示）。整数指令集包括算术、逻辑、分支、访存（访问内存）指令等，已经可以实现一个完整的软件栈。RiscV的扩展指令：一些CPU有更多的功能要求，如 M：乘除法、取模求余指令；F：单精度浮点指令；D：双精度浮点指令Q：四倍浮点指令；A：原子操作指令，例如常见的cas（compare and swap）指令；C：压缩指令，主要用于改善程序大小；
【RISC-V】risc-v架构学习笔记（架构初学）
m0_67403188的博客
07-31 7310
RISC-V架构提供31个用户可修改的通用(基本)寄存器，即x1到x31，以及一个额外的只读寄存器x0，硬连接到0。x0寄存器的一个常见用途是帮助将其他寄存器初始化为零。共有31个通用寄存器。其中7个是临时寄存器(t0t6)。a0a7用于函数参数。s0s11用于保存寄存器或函数定义内。一个堆栈指针，一个全局指针和一个线程指针寄存器。一个返回地址寄存器(x1)，用于存储函数调用的返回地址。一个程序计数器(pc)。PC保存着当前指令的地址。所有寄存器都可以作为通用寄存器使用。...
RISC-V汇编快速入门
I_O_fly的博客
09-30 3487
pc的作用非常重要，cpu执行当前指令，pc指向下一条指令，当cpu执行完当前指令以后，cpu就会去读pc，从而找到下一条要执行的指令的位置，然后就继续执行下一条指令，而pc的值也会相应的更新。没错，跳转的本质其实只是简单的改变pc的值，当执行到 jal ra, 100这条语句时，pc的值是这条指令的下一条指令的地址，当cpu执行的时候，cpu就会把pc 的值放到ra 中，再把pc的值更改位pc+200,执行完以后，cpu继续读取pc的值，就会到pc+200的地方去执行指令，从而实现跳转的功能。
【【萌新的RISC-V学习之再看计算机组成与设计大收获总六】】
weixin_50965981的博客
09-16 169
萌新的RISC-V学习之再看计算机组成与设计大收获总六 非常有意思 重要的一个 看了大有收获
ALU_Result寄存器的作用
06-13
ALU_Result寄存器是计算机中的一个寄存器，它用于存储ALU（算术逻辑单元）执行完毕后的结果。ALU_Result寄存器通常由多个比特位组成，可以存储不同长度的数据。它的作用包括： 1. 存储计算结果：当ALU执行完毕后，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

俺是菜鸡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值