riscv-sodor-rv32_3stage(3)

现在分析的是consts.scala。这两个文件的主要作用是定义一些常量。

consts.scala：

package Sodor
package constants
{

import chisel3._
import chisel3.util._


trait SodorProcConstants
{
   //************************************
   // Machine Parameters

   //声明两个memory的端口。
   val NUM_MEMORY_PORTS = 2;

   // if the front-end ONLY predicts PC+4, this simplifies quite a bit of logic.
   // First, the PC select mux never needs to compute ExePC + 4 on a branch
   // redirect (since PC+4 is always predicted).
   // Second, JAL can write-back to rd the ExePC, since it will already be PC+4
   // relative to the JAL.
   //做最简单的预测，每次都是当前PC+4，不需要计算执行PC+4的分支(即一条指令可能是跳转指令或
   //者是分支指令，由现在的A跳转到C，C是作为一个PC数值存在于该指令中的，这里的意思是只需
   //要计算A+4的值就可以，不需要额外计算C+4这个分支的值。)
   //跳转指令执行时，将PC+4的值(即错误预测的ExePC值)回写至rd中，即使回写的这个PC可能以后
   //都不会用。这是因为默认预测的PC永远是+4的，遇到跳转指令，这个预测就是错误的，回写只是一
   //个默认的操作。3stage还只是PC+4的预测，还没有BTB的分支预测功能。
   val PREDICT_PCP4 = true; require(PREDICT_PCP4==true) // no BTB, etc, added yet

   //************************************
   // Debugging
   val PRINT_COMMIT_LOG = false
}

trait ScalarOpConstants
{
   //************************************
   // Control Signals

   val Y      = true.B
   val N      = false.B
   //PC的选择信号
   //PC_4  		---  	PC+4 			--- 位宽为3bits的信号，0值
   //PC_BR 		---  分支目标 			--- 位宽为3bits的信号，1值
   //PC_J  		---  跳转目标 			--- 位宽为3bits的信号，2值
   //PC_JR 		---  跳转寄存器目标 		--- 位宽为3bits的信号，3值
	//PC_EXC 	---  异常 				--- 位宽为3bits的信号，4值
   // PC Select Signal
   val PC_4   = 0.asUInt(3.W)  // PC + 4
   val PC_BR  = 1.asUInt(3.W)  // branch_target
   val PC_J   = 2.asUInt(3.W)  // jump_target
   val PC_JR  = 3.asUInt(3.W)  // jump_reg_target
   val PC_EXC = 4.asUInt(3.W)  // exception

   //分支类型
   //BR_N	---	下一个PC				---	位宽为4bits的信号，0值
   //BR_NE	---	不等于				---	位宽为4bits的信号，1值
   //BR_EQ	---	等于				---	位宽为4bits的信号，2值
   //BR_GE	---	大于等于				---	位宽为4bits的信号，3值
   //BR_GEU	---	大于等于(无符号数)	---	位宽为4bits的信号，4值
   //BR_LT	---	小于				---	位宽为4bits的信号，5值
   //BR_LTU	---	小于(无符号数)		---	位宽为4bits的信号，6值
   //BR_J	---	跳转				---	位宽为4bits的信号，7值
   //BR_JR	---	寄存器跳转			---	位宽为4bits的信号，8值
   // Branch Type
   val BR_N   = 0.asUInt(4.W)  // Next
   val BR_NE  = 1.asUInt(4.W)  // Branch on NotEqual
   val BR_EQ  = 2.asUInt(4.W)  // Branch on Equal
   val BR_GE  = 3.asUInt(4.W)  // Branch on Greater/Equal
   val BR_GEU = 4.asUInt(4.W)  // Branch on Greater/Equal Unsigned
   val BR_LT  = 5.asUInt(4.W)  // Branch on Less Than
   val BR_LTU = 6.asUInt(4.W)  // Branch on Less Than Unsigned
   val BR_J   = 7.asUInt(4.W)  // Jump
   val BR_JR  = 8.asUInt(4.W)  // Jump Register

   //rs1寄存器操作选择信号
   //OP1_RS1	---	rs1寄存器						---	位宽为2bits的信号，0值
   //OP1_IMU	---	立即数，U-type					---	位宽为2bits的信号，1值
   //OP1_IMZ	---	rs1的零扩展字段，用于CSRI指令	---	位宽为2bits的信号，2值
   //OP1_X	---	rs1寄存器						---	位宽为2bits的信号，0值
   // RS1 Operand Select Signal
   val OP1_RS1 = 0.asUInt(2.W) // Register Source #1
   val OP1_IMU = 1.asUInt(2.W) // immediate, U-type
   val OP1_IMZ = 2.asUInt(2.W) // zero-extended 5-bit immediate; used by CSRI instructions
   val OP1_X   = 0.asUInt(2.W)

   //rs2寄存器操作选择信号
   //OP2_RS2	---	rs2寄存器						---	位宽为2bits的信号，0值
   //OP2_IMI	---	立即数，I-type					---	位宽为2bits的信号，1值
   //OP2_IMS	---	立即数，S-type					---	位宽为2bits的信号，2值
   //OP2_PC	---	PC							---	位宽为2bits的信号，3值
   //OP2_X	---	rs2寄存器						---	位宽为2bits的信号，0值
   // RS2 Operand Select Signal
   val OP2_RS2 = 0.asUInt(2.W) // Register Source #2
   val OP2_IMI = 1.asUInt(2.W) // immediate, I-type
   val OP2_IMS = 2.asUInt(2.W) // immediate, S-type
   val OP2_PC  = 3.asUInt(2.W) // PC
   val OP2_X   = 0.asUInt(2.W)

   //寄存器文件写使能信号
   //REN_0	---	flase，不使能						---	位宽为1bit的信号，false值
   //REN_1	---	true，使能							---	位宽为1bit的信号，true值
   //REN_X	---	flase，不使能						---	位宽为1bit的信号，false值
   // Register File Write Enable Signal
   val REN_0   = false.B
   val REN_1   = true.B
   val REN_X   = false.B

   //回写选择信号
   //WB_ALU	---	回写ALU						---	位宽为2bits的信号，0值
   //WB_MEM	---	回写memory					---	位宽为2bits的信号，1值
   //WB_PC4	---	回写PC						---	位宽为2bits的信号，2值
   //WB_CSR	---	回写CSR寄存器				---	位宽为2bits的信号，3值
   //WB_X	---	不操作						---	位宽为2bits的信号，0值
   // Writeback Select Signal
   val WB_ALU  = 0.asUInt(2.W)
   val WB_MEM  = 1.asUInt(2.W)
   val WB_PC4  = 2.asUInt(2.W)
   val WB_CSR  = 3.asUInt(2.W)
   val WB_X    = 0.asUInt(2.W)

  //内存函数的类型
   //MWR_R	---	读						---	位宽为2bits的信号，0值
   //MWR_W	---	写						---	位宽为2bits的信号，1值
   //MWR_F	---	FENCE					---	位宽为2bits的信号，2值
   //MWR_X	---	不操作					---	位宽为2bits的信号，0值
   // Memory Function Type (Read,Write,Fence) Signal
   val MWR_R   = 0.asUInt(2.W)
   val MWR_W   = 1.asUInt(2.W)
   val MWR_F   = 2.asUInt(2.W)
   val MWR_X   = 0.asUInt(2.W)

   //memory写使能信号
   //MEN_0	---	flase，不使能						---	位宽为1bit的信号，false值
   //MEN_1	---	true，使能							---	位宽为1bit的信号，true值
   //MEN_X	---	flase，不使能						---	位宽为1bit的信号，false值
   // Memory Enable Signal
   val MEN_0   = false.B
   val MEN_1   = true.B
   val MEN_X   = false.B

   //memory掩蔽类型信号
   //MSK_B	---	1字节						---	位宽为3bits的信号，0值
   //MSK_BU	---	1字节(无符号)					---	位宽为3bits的信号，1值
   //MSK_H	---	half-word(半字)					---	位宽为3bits的信号，2值
   //MSK_HU	---	half-word(半字)					---	位宽为3bits的信号，3值
   //MSK_W	---	word(4字节)					---	位宽为3bits的信号，4值
   //MSK_X	---	word(4字节)					---	位宽为3bits的信号，4值
   // Memory Mask Type Signal
   val MSK_B   = 0.asUInt(3.W)
   val MSK_BU  = 1.asUInt(3.W)
   val MSK_H   = 2.asUInt(3.W)
   val MSK_HU  = 3.asUInt(3.W)
   val MSK_W   = 4.asUInt(3.W)
   val MSK_X   = 4.asUInt(3.W)

   //cache flush操作，同步
   //M_N		---	不操作						---	位宽为3bits的信号，0值
   //M_SI		---	指令流同步					---	位宽为3bits的信号，1值
   //M_SD	---	数据流同步					---	位宽为3bits的信号，2值
   //M_FA		---	刷新全部cache					---	位宽为3bits的信号，3值
   //M_FD	---	刷新dcache					---	位宽为3bits的信号，4值
   // Cache Flushes & Sync Primitives
   val M_N      = 0.asUInt(3.W)
   val M_SI     = 1.asUInt(3.W)   // synch instruction stream
   val M_SD     = 2.asUInt(3.W)   // synch data stream
   val M_FA     = 3.asUInt(3.W)   // flush all caches
   val M_FD     = 4.asUInt(3.W)   // flush data cache

   //内存函数的类型
   //MT_READ		---	读						---	位宽为2bits的信号，0值
   //MT_WRITE	---	写						---	位宽为2bits的信号，1值
   //MT_FENCE	---	FENCE					---	位宽为2bits的信号，2值
   // Memory Functions (read, write, fence)
   val MT_READ  = 0.asUInt(2.W)
   val MT_WRITE = 1.asUInt(2.W)
   val MT_FENCE = 2.asUInt(2.W)


}

}