sigle_cpu exp

module cpu_sys(
   input    wire          clk,
   input    wire          rst,
   output   wire          dm_we,
   output   wire [31:0]   dm_addr,
   output   wire [31:0]   dm_wdata,
   output   wire          rf_we,
   output   wire [4:0]    rf_waddr,
   output   wire [31:0]   rf_wdata
);
wire  [31:0] im_addr;
wire  [31:0] im_radta,dm_rdata;
wire  [ 4:0] rf_addr1,rf_addr2;
wire  [31:0] rf_rdata1,rf_rdata2;
loongarch_cpu u_cpu(
   .clk      (clk),
   .rst      (rst),
   //im 与指令存储器的接口
   .im_addr  (im_addr),
   .im_rdata (im_radta),
   //dm 与数据存储器的接口
   .dm_addr  (dm_addr),
   .dm_we    (dm_we),
   .dm_wdata (dm_wdata),
   .dm_rdata (dm_rdata),
   //regfile 与寄存器堆的接口
   .rf_raddr1   (rf_addr1),
   .rf_rdata1   (rf_rdata1),
   .rf_raddr2   (rf_addr2),
   .rf_rdata2   (rf_rdata2),
   .rf_we       (rf_we),
   .rf_waddr    (rf_waddr),
   .rf_wdata    (rf_wdata)
);
im_4k    u_im(
   .addr    (im_addr),
   .rdata   (im_radta)
);
dm_4k    u_dm(
   .clk     (clk),
   .addr    (dm_addr),
   .we      (dm_we),
   .wdata   (dm_wdata),
   .rdata   (dm_rdata)
);
regfile  rf(
   .clk     (clk),
   .raddr1  (rf_addr1),
   .rdata1  (rf_rdata1),
   .raddr2  (rf_addr2),
   .rdata2  (rf_rdata2),
   .we      (rf_we),    
   .waddr   (rf_waddr),
   .wdata   (rf_wdata)
);
endmodule

module im_4k(
    input    wire  [31:0] addr,
    output   wire  [31:0] rdata
);
    reg [31:0] imem[1023:0];
    assign rdata = imem[addr[11:2]];
    endmodule   

module dm_4k(
   input    wire         clk,
   input    wire  [31:0] addr,
   input    wire         we,
   input    wire  [31:0] wdata,
   output   wire  [31:0] rdata
);
     
   reg [31:0] dmem[1023:0];

   always @(posedge clk) begin
      if (we)
         dmem[addr[11:2]] <= wdata;
   end
   
   assign rdata = dmem[addr[11:2]];
endmodule  

module regfile(
    input  wire        clk,
    // 1号读端口
    input  wire [ 4:0] raddr1,
    output wire [31:0] rdata1,
    // 2号读端口
    input  wire [ 4:0] raddr2,
    output wire [31:0] rdata2,
    // 写端口
    input  wire        we,       //写使能，高位有效
    input  wire [ 4:0] waddr,
    input  wire [31:0] wdata
);
    reg [31:0] rf[31:0];
    //写入always @(posedge clk) begin
    if (we) rf[waddr]<= wdata;end
    //1号读端口输出
    assign rdata1 = (raddr1==5'b0) ? 32'b0 : rf[raddr1];
    //2号读端口输出
    assign rdata2 = (raddr2==5'b0) ? 32'b0 : rf[raddr2];
endmodule

module loongarch_cpu(
    input    wire           clk,
    input    wire           rst,
    //IM 指令存储
    output   wire   [31:0]  im_addr,    //访问指令存储器的地址
    input    wire   [31:0]  im_rdata,   //访问指令存储器的读数据
    //DM 数据存储
    output   wire   [31:0]  dm_addr,    //访问数据存储器的地址
    output   reg            dm_we,      //数据存储器的写使能
    output   wire   [31:0]  dm_wdata,   //写入数据存储器的数据
    input    wire   [31:0]  dm_rdata,   //访问数据存储器的读数据
    //regfile 寄存器堆
    // 1号读端口
    output   wire   [ 4:0]  rf_raddr1,  //第一个读端口读取寄存器的地址
    input    wire   [31:0]  rf_rdata1,  //第一个读端口读取寄存器得到的数据
    // 2号读端口
    output   wire   [ 4:0]  rf_raddr2,  //第二个读端口读取寄存器的地址
    input    wire   [31:0]  rf_rdata2,  //第二个读端口读取寄存器得到的数据
    // 写端口
    output   reg            rf_we,      //写使能，高位有效
    output   wire   [ 4:0]  rf_waddr,   //需要写入的寄存器的地址
    output   reg    [31:0]  rf_wdata    //需要写入寄存器的数据
);
    // PC 寄存器与有效标志
    reg  [31:0] pc;
    wire [31:0] next_pc;
    reg         valid;
    always @(posedge clk) begin
        if (rst)
            valid <= 1'b0;
        else
            valid <= 1'b1;
    end
    always @(posedge clk) begin
        if (rst)
            pc <= 32'h0;
        else if (valid)
            pc <= next_pc;
    end
    assign im_addr = ;//使用pc值取值
    assign next_pc = ;//暂时顺序执行每个周期加4，pc+4,下一次pc为当前加4
    //读取指令
    wire [31:0] inst = im_rdata;
    //判断指令
    wire inst_ori = inst[31:22] == 10'b00_0000_1110;//ori指令的31-22位
    // 寄存器地址与立即数提取
    wire [4:0] rj = inst[9:5];
    wire [4:0] rd = inst[4:0];
    wire [11:0] ui12 = inst[21:10];
    wire [31:0] imm = {20'b0, ui12};  // 零拓展
    
    assign rf_raddr1 = ;//读取的寄存器
    // 计算 ori 结果
    wire [31:0] ori_result = ;//填写自己的代码
    assign rf_waddr  = ;// ori 写入目标是 rd
    always @(*) begin
        if (valid && inst_ori)//有效且是ori指令时寄存器写信号有效
            rf_we = 1'b1;
        else
            rf_we = 1'b0;
    end
    always @(*) begin
        if (inst_ori)
            rf_wdata = ;//填写需要写回的数据
        else
            rf_wdata = 32'b0;
    end
endmodule

`timescale 1ns / 1ps

module system_tb();
reg clk;
reg rst;
wire          dm_we,rf_we;
wire [31:0]   dm_addr,dm_wdata;
wire [4:0]    rf_waddr;
wire [31:0]   rf_wdata;
cpu_sys u_cpu_sys(
    .clk        (clk),
    .rst        (rst),
    .dm_we      (dm_we   ),
    .dm_addr    (dm_addr ),
    .dm_wdata   (dm_wdata),
    .rf_we      (rf_we   ),
    .rf_waddr   (rf_waddr),
    .rf_wdata   (rf_wdata)
);
integer i;
initial
begin
    $readmemh( "ORI.txt" , 
                u_cpu_sys.u_im.imem ) ; 
    clk = 1'b0;
    rst = 1'b1;
    #20;
    rst = 1'b0;
    #400;
    $finish;
end
always #5 clk=~clk;
always @(posedge clk) begin
    if (dm_we) begin
        $display("Data Memory Write - Addr: %h, Data: %h", dm_addr, dm_wdata);
    end
end
always @(posedge clk) begin
    if (rf_we) begin
        $display("Register File Write - Addr: %d, Data: %h", rf_waddr, rf_wdata);
    end
end
endmodule