第4章
Zicsr拡張の実装

    const OP_SYSTEM: logic<7> = 7'b1110011;

    // 制御に使うフラグ用の構造体
    struct InstCtrl {
        itype   : InstType   , // 命令の形式
        rwb_en  : logic      , // レジスタに書き込むかどうか
        is_lui  : logic      , // LUI命令である
        is_aluop: logic      , // ALUを利用する命令である
        is_jump : logic      , // ジャンプ命令である
        is_load : logic      , // ロード命令である
        is_csr  : logic      , // CSR命令である
        funct3  : logic   <3>, // 命令のfunct3フィールド
        funct7  : logic   <7>, // 命令のfunct7フィールド
    }

                                           is_csrを追加
    ctrl = {case op {                           ↓
        OP_LUI   : {InstType::U, T, T, F, F, F, F},
        OP_AUIPC : {InstType::U, T, F, F, F, F, F},
        OP_JAL   : {InstType::J, T, F, F, T, F, F},
        OP_JALR  : {InstType::I, T, F, F, T, F, F},
        OP_BRANCH: {InstType::B, F, F, F, F, F, F},
        OP_LOAD  : {InstType::I, T, F, F, F, T, F},
        OP_STORE : {InstType::S, F, F, F, F, F, F},
        OP_OP    : {InstType::R, T, F, T, F, F, F},
        OP_OP_IMM: {InstType::I, T, F, T, F, F, F},
        OP_SYSTEM: {InstType::I, T, F, F, F, F, T},
        default  : {InstType::X, F, F, F, F, F, F},
    }, f3, f7};

import eei::*;
import corectrl::*;

module csrunit (
    clk     : input  clock       ,
    rst     : input  reset       ,
    valid   : input  logic       ,
    ctrl    : input  InstCtrl    ,
    csr_addr: input  logic   <12>,
    rs1     : input  UIntX       ,
    rdata   : output UIntX       ,
) {
    // CSRR(W|S|C)[I]命令かどうか
    let is_wsc: logic = ctrl.is_csr && ctrl.funct3[1:0] != 0;
}

    var csru_rdata: UIntX;

    inst csru: csrunit (
        clk                       ,
        rst                       ,
        valid   : inst_valid      ,
        ctrl    : inst_ctrl       ,
        csr_addr: inst_bits[31:20],
        rs1     : if inst_ctrl.funct3[2] == 1 && inst_ctrl.funct3[1:0] != 0 {
            {1'b0 repeat XLEN - $bits(rs1_addr), rs1_addr} // rs1を0で拡張する
        } else {
            rs1_data
        },
        rdata: csru_rdata,
    );

    let rd_addr: logic<5> = inst_bits[11:7];
    let wb_data: UIntX    = if inst_ctrl.is_lui {
        inst_imm
    } else if inst_ctrl.is_jump {
        inst_pc + 4
    } else if inst_ctrl.is_load {
        memu_rdata
    } else if inst_ctrl.is_csr {
        csru_rdata
    } else {
        alu_result
    };

    if inst_ctrl.is_csr {
        $display("  csr rdata : %h", csru_rdata);
    }

    // CSRのアドレス
    enum CsrAddr: logic<12> {
        MTVEC = 12'h305,
    }

    // CSR
    var mtvec: UIntX;

    // wmasks
    const MTVEC_WMASK: UIntX = 'hffff_fffc;

    var wmask: UIntX; // write mask
    var wdata: UIntX; // write data

     always_comb {
        // read
        rdata = case csr_addr {
            CsrAddr::MTVEC: mtvec,
            default       : 'x,
        };
        // write
        wmask = case csr_addr {
            CsrAddr::MTVEC: MTVEC_WMASK,
            default       : 0,
        };
        wdata = case ctrl.funct3[1:0] {
            2'b01  : rs1,
            2'b10  : rdata | rs1,
            2'b11  : rdata & ~rs1,
            default: 'x,
        } & wmask;
    }

    always_ff {
        if_reset {
            mtvec = 0;
        } else {
            if valid {
                if is_wsc {
                    case csr_addr {
                        CsrAddr::MTVEC: mtvec = wdata;
                        default       : {}
                    }
                }
            }
        }
    }

305bd0f3 // 0: csrrwi x1, mtvec, 0b10111
30502173 // 4: csrrs  x2, mtvec, x0

    // CSRのアドレス
    enum CsrAddr: logic<12> {
        MTVEC = 12'h305,
        MEPC = 12'h341,
        MCAUSE = 12'h342,
    }

    enum CsrCause: UIntX {
        ENVIRONMENT_CALL_FROM_M_MODE = 11,
    }

    const MTVEC_WMASK : UIntX = 'hffff_fffc;
    const MEPC_WMASK  : UIntX = 'hffff_fffc;
    const MCAUSE_WMASK: UIntX = 'hffff_ffff;

    // CSR
    var mtvec : UIntX;
    var mepc  : UIntX;
    var mcause: UIntX;

    rdata = case csr_addr {
        CsrAddr::MTVEC : mtvec,
        CsrAddr::MEPC  : mepc,
        CsrAddr::MCAUSE: mcause,
        default        : 'x,
    };

    wmask = case csr_addr {
        CsrAddr::MTVEC : MTVEC_WMASK,
        CsrAddr::MEPC  : MEPC_WMASK,
        CsrAddr::MCAUSE: MCAUSE_WMASK,
        default        : 0,
    };

always_ff {
    if_reset {
        mtvec  = 0;
        mepc   = 0;
        mcause = 0;
    } else {
        if valid {
            if is_wsc {
                case csr_addr {
                    CsrAddr::MTVEC : mtvec  = wdata;
                    CsrAddr::MEPC  : mepc   = wdata;
                    CsrAddr::MCAUSE: mcause = wdata;
                    default        : {}
                }
            }
        }
    }
}

module csrunit (
    clk        : input  clock       ,
    rst        : input  reset       ,
    valid      : input  logic       ,
    pc         : input  Addr        ,
    ctrl       : input  InstCtrl    ,
    rd_addr    : input  logic   <5> ,
    csr_addr   : input  logic   <12>,
    rs1        : input  UIntX       ,
    rdata      : output UIntX       ,
    raise_trap : output logic       ,
    trap_vector: output Addr        ,
) {

    var csru_rdata      : UIntX;
    var csru_raise_trap : logic;
    var csru_trap_vector: Addr ;

    inst csru: csrunit (
        clk                       ,
        rst                       ,
        valid   : inst_valid      ,
        pc      : inst_pc         ,
        ctrl    : inst_ctrl       ,
        rd_addr                   ,
        csr_addr: inst_bits[31:20],
        rs1     : if inst_ctrl.funct3[2] == 1 && inst_ctrl.funct3[1:0] != 0 {
            {1'b0 repeat XLEN - $bits(rs1_addr), rs1_addr} // rs1を0で拡張する
        } else {
            rs1_data
        },
        rdata      : csru_rdata,
        raise_trap : csru_raise_trap,
        trap_vector: csru_trap_vector,
    );

    assign control_hazard = inst_valid && (
        csru_raise_trap ||
        inst_ctrl.is_jump ||
        inst_is_br(inst_ctrl) && brunit_take
    );
    assign control_hazard_pc_next = if csru_raise_trap {
        csru_trap_vector ← トラップするとき、trap_vectorに飛ぶ
    } else if inst_is_br(inst_ctrl) {
        inst_pc + inst_imm
    } else {
        alu_result
    };

    // ECALL命令かどうか
    let is_ecall: logic = ctrl.is_csr && csr_addr == 0 && rs1[4:0] == 0 && ctrl.funct3 == 0 && rd_addr == 0;

    // Exception
    let raise_expt: logic = valid && is_ecall;
    let expt_cause: UIntX = CsrCause::ENVIRONMENT_CALL_FROM_M_MODE;

    // Trap
    assign raise_trap  = raise_expt;
    let trap_cause : UIntX = expt_cause;
    assign trap_vector = mtvec;

always_ff {
    if_reset {
        ...
    } else {
        if valid {
            if raise_trap { ← トラップ時の動作
                mepc   = pc;
                mcause = trap_cause;
            } else {
                if is_wsc {
                    ...

    if inst_ctrl.is_csr {
        $display("  csr rdata : %h", csru_rdata);
        $display("  csr trap  : %b", csru_raise_trap);
        $display("  csr vec   : %h", csru_trap_vector);
    }

30585073 //  0: csrrwi x0, mtvec, 0x10
00000073 //  4: ecall
00000000 //  8:
00000000 //  c:
342020f3 // 10: csrrs x1, mcause, x0
34102173 // 14: csrrs x2, mepc, x0

    // MRET命令かどうか
    let is_mret: logic = ctrl.is_csr && csr_addr == 12'b0011000_00010 && rs1[4:0] == 0 && ctrl.funct3 == 0 && rd_addr == 0;

    // Trap
    assign raise_trap  = raise_expt || (valid && is_mret);
    let trap_cause : UIntX = expt_cause;
    assign trap_vector = if raise_expt {
        mtvec
    } else {
        mepc
    };

34185073 //  0: csrrwi x0, mepc, 0x10
30200073 //  4: mret
00000000 //  8:
00000000 //  c:
00000013 // 10: addi x0, x0, 0