From 35a53071aa1a1b63eb2700945e00ee494a739732 Mon Sep 17 00:00:00 2001 From: Donald Sebastian Leung Date: Thu, 23 Jul 2020 14:33:25 +0800 Subject: [PATCH] Complete generator for RV32I ISA --- insns/isa_rv32i.py | 1162 +++++++++++++++++++++++++++++++++++++++- insns/isa_rv32i_gen.py | 58 +- 2 files changed, 1209 insertions(+), 11 deletions(-) diff --git a/insns/isa_rv32i.py b/insns/isa_rv32i.py index 7160f62..3ef25e4 100644 --- a/insns/isa_rv32i.py +++ b/insns/isa_rv32i.py @@ -1,5 +1,42 @@ # Generated by isa_rv32i_gen.py from nmigen import * +from insn_lui import * +from insn_auipc import * +from insn_jal import * +from insn_jalr import * +from insn_beq import * +from insn_bne import * +from insn_blt import * +from insn_bge import * +from insn_bltu import * +from insn_bgeu import * +from insn_lb import * +from insn_lh import * +from insn_lw import * +from insn_lbu import * +from insn_lhu import * +from insn_sb import * +from insn_sh import * +from insn_sw import * +from insn_addi import * +from insn_slti import * +from insn_sltiu import * +from insn_xori import * +from insn_ori import * +from insn_andi import * +from insn_slli import * +from insn_srli import * +from insn_srai import * +from insn_add import * +from insn_sub import * +from insn_sll import * +from insn_slt import * +from insn_sltu import * +from insn_xor import * +from insn_srl import * +from insn_sra import * +from insn_or import * +from insn_and import * class rvfi_isa_rv32i(Elaboratable): def __init__(self, RISCV_FORMAL_ILEN=32, RISCV_FORMAL_XLEN=32): @@ -49,9 +86,1126 @@ class rvfi_isa_rv32i(Elaboratable): def elaborate(self, platform): m = Module() + spec_insn_lui_valid = Signal(1) + spec_insn_lui_trap = Signal(1) + spec_insn_lui_rs1_addr = Signal(5) + spec_insn_lui_rs2_addr = Signal(5) + spec_insn_lui_rd_addr = Signal(5) + spec_insn_lui_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lui_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lui_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lui_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lui_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lui_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_lui = insn_lui = rvfi_insn_lui() + m.d.comb += insn_lui.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_lui.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_lui.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_lui.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_lui.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_lui.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_lui_valid.eq(insn_lui.spec_valid) + m.d.comb += spec_insn_lui_trap.eq(insn_lui.spec_trap) + m.d.comb += spec_insn_lui_rs1_addr.eq(insn_lui.spec_rs1_addr) + m.d.comb += spec_insn_lui_rs2_addr.eq(insn_lui.spec_rs2_addr) + m.d.comb += spec_insn_lui_rd_addr.eq(insn_lui.spec_rd_addr) + m.d.comb += spec_insn_lui_rd_wdata.eq(insn_lui.spec_rd_wdata) + m.d.comb += spec_insn_lui_pc_wdata.eq(insn_lui.spec_pc_wdata) + m.d.comb += spec_insn_lui_mem_addr.eq(insn_lui.spec_mem_addr) + m.d.comb += spec_insn_lui_mem_rmask.eq(insn_lui.spec_mem_rmask) + m.d.comb += spec_insn_lui_mem_wmask.eq(insn_lui.spec_mem_wmask) + m.d.comb += spec_insn_lui_mem_wdata.eq(insn_lui.spec_mem_wdata) + + spec_insn_auipc_valid = Signal(1) + spec_insn_auipc_trap = Signal(1) + spec_insn_auipc_rs1_addr = Signal(5) + spec_insn_auipc_rs2_addr = Signal(5) + spec_insn_auipc_rd_addr = Signal(5) + spec_insn_auipc_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_auipc_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_auipc_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_auipc_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_auipc_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_auipc_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_auipc = insn_auipc = rvfi_insn_auipc() + m.d.comb += insn_auipc.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_auipc.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_auipc.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_auipc.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_auipc.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_auipc.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_auipc_valid.eq(insn_auipc.spec_valid) + m.d.comb += spec_insn_auipc_trap.eq(insn_auipc.spec_trap) + m.d.comb += spec_insn_auipc_rs1_addr.eq(insn_auipc.spec_rs1_addr) + m.d.comb += spec_insn_auipc_rs2_addr.eq(insn_auipc.spec_rs2_addr) + m.d.comb += spec_insn_auipc_rd_addr.eq(insn_auipc.spec_rd_addr) + m.d.comb += spec_insn_auipc_rd_wdata.eq(insn_auipc.spec_rd_wdata) + m.d.comb += spec_insn_auipc_pc_wdata.eq(insn_auipc.spec_pc_wdata) + m.d.comb += spec_insn_auipc_mem_addr.eq(insn_auipc.spec_mem_addr) + m.d.comb += spec_insn_auipc_mem_rmask.eq(insn_auipc.spec_mem_rmask) + m.d.comb += spec_insn_auipc_mem_wmask.eq(insn_auipc.spec_mem_wmask) + m.d.comb += spec_insn_auipc_mem_wdata.eq(insn_auipc.spec_mem_wdata) + + spec_insn_jal_valid = Signal(1) + spec_insn_jal_trap = Signal(1) + spec_insn_jal_rs1_addr = Signal(5) + spec_insn_jal_rs2_addr = Signal(5) + spec_insn_jal_rd_addr = Signal(5) + spec_insn_jal_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_jal_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_jal_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_jal_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_jal_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_jal_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_jal = insn_jal = rvfi_insn_jal() + m.d.comb += insn_jal.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_jal.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_jal.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_jal.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_jal.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_jal.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_jal_valid.eq(insn_jal.spec_valid) + m.d.comb += spec_insn_jal_trap.eq(insn_jal.spec_trap) + m.d.comb += spec_insn_jal_rs1_addr.eq(insn_jal.spec_rs1_addr) + m.d.comb += spec_insn_jal_rs2_addr.eq(insn_jal.spec_rs2_addr) + m.d.comb += spec_insn_jal_rd_addr.eq(insn_jal.spec_rd_addr) + m.d.comb += spec_insn_jal_rd_wdata.eq(insn_jal.spec_rd_wdata) + m.d.comb += spec_insn_jal_pc_wdata.eq(insn_jal.spec_pc_wdata) + m.d.comb += spec_insn_jal_mem_addr.eq(insn_jal.spec_mem_addr) + m.d.comb += spec_insn_jal_mem_rmask.eq(insn_jal.spec_mem_rmask) + m.d.comb += spec_insn_jal_mem_wmask.eq(insn_jal.spec_mem_wmask) + m.d.comb += spec_insn_jal_mem_wdata.eq(insn_jal.spec_mem_wdata) + + spec_insn_jalr_valid = Signal(1) + spec_insn_jalr_trap = Signal(1) + spec_insn_jalr_rs1_addr = Signal(5) + spec_insn_jalr_rs2_addr = Signal(5) + spec_insn_jalr_rd_addr = Signal(5) + spec_insn_jalr_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_jalr_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_jalr_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_jalr_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_jalr_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_jalr_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_jalr = insn_jalr = rvfi_insn_jalr() + m.d.comb += insn_jalr.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_jalr.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_jalr.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_jalr.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_jalr.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_jalr.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_jalr_valid.eq(insn_jalr.spec_valid) + m.d.comb += spec_insn_jalr_trap.eq(insn_jalr.spec_trap) + m.d.comb += spec_insn_jalr_rs1_addr.eq(insn_jalr.spec_rs1_addr) + m.d.comb += spec_insn_jalr_rs2_addr.eq(insn_jalr.spec_rs2_addr) + m.d.comb += spec_insn_jalr_rd_addr.eq(insn_jalr.spec_rd_addr) + m.d.comb += spec_insn_jalr_rd_wdata.eq(insn_jalr.spec_rd_wdata) + m.d.comb += spec_insn_jalr_pc_wdata.eq(insn_jalr.spec_pc_wdata) + m.d.comb += spec_insn_jalr_mem_addr.eq(insn_jalr.spec_mem_addr) + m.d.comb += spec_insn_jalr_mem_rmask.eq(insn_jalr.spec_mem_rmask) + m.d.comb += spec_insn_jalr_mem_wmask.eq(insn_jalr.spec_mem_wmask) + m.d.comb += spec_insn_jalr_mem_wdata.eq(insn_jalr.spec_mem_wdata) + + spec_insn_beq_valid = Signal(1) + spec_insn_beq_trap = Signal(1) + spec_insn_beq_rs1_addr = Signal(5) + spec_insn_beq_rs2_addr = Signal(5) + spec_insn_beq_rd_addr = Signal(5) + spec_insn_beq_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_beq_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_beq_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_beq_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_beq_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_beq_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_beq = insn_beq = rvfi_insn_beq() + m.d.comb += insn_beq.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_beq.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_beq.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_beq.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_beq.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_beq.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_beq_valid.eq(insn_beq.spec_valid) + m.d.comb += spec_insn_beq_trap.eq(insn_beq.spec_trap) + m.d.comb += spec_insn_beq_rs1_addr.eq(insn_beq.spec_rs1_addr) + m.d.comb += spec_insn_beq_rs2_addr.eq(insn_beq.spec_rs2_addr) + m.d.comb += spec_insn_beq_rd_addr.eq(insn_beq.spec_rd_addr) + m.d.comb += spec_insn_beq_rd_wdata.eq(insn_beq.spec_rd_wdata) + m.d.comb += spec_insn_beq_pc_wdata.eq(insn_beq.spec_pc_wdata) + m.d.comb += spec_insn_beq_mem_addr.eq(insn_beq.spec_mem_addr) + m.d.comb += spec_insn_beq_mem_rmask.eq(insn_beq.spec_mem_rmask) + m.d.comb += spec_insn_beq_mem_wmask.eq(insn_beq.spec_mem_wmask) + m.d.comb += spec_insn_beq_mem_wdata.eq(insn_beq.spec_mem_wdata) + + spec_insn_bne_valid = Signal(1) + spec_insn_bne_trap = Signal(1) + spec_insn_bne_rs1_addr = Signal(5) + spec_insn_bne_rs2_addr = Signal(5) + spec_insn_bne_rd_addr = Signal(5) + spec_insn_bne_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bne_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bne_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bne_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bne_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bne_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_bne = insn_bne = rvfi_insn_bne() + m.d.comb += insn_bne.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_bne.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_bne.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_bne.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_bne.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_bne.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_bne_valid.eq(insn_bne.spec_valid) + m.d.comb += spec_insn_bne_trap.eq(insn_bne.spec_trap) + m.d.comb += spec_insn_bne_rs1_addr.eq(insn_bne.spec_rs1_addr) + m.d.comb += spec_insn_bne_rs2_addr.eq(insn_bne.spec_rs2_addr) + m.d.comb += spec_insn_bne_rd_addr.eq(insn_bne.spec_rd_addr) + m.d.comb += spec_insn_bne_rd_wdata.eq(insn_bne.spec_rd_wdata) + m.d.comb += spec_insn_bne_pc_wdata.eq(insn_bne.spec_pc_wdata) + m.d.comb += spec_insn_bne_mem_addr.eq(insn_bne.spec_mem_addr) + m.d.comb += spec_insn_bne_mem_rmask.eq(insn_bne.spec_mem_rmask) + m.d.comb += spec_insn_bne_mem_wmask.eq(insn_bne.spec_mem_wmask) + m.d.comb += spec_insn_bne_mem_wdata.eq(insn_bne.spec_mem_wdata) + + spec_insn_blt_valid = Signal(1) + spec_insn_blt_trap = Signal(1) + spec_insn_blt_rs1_addr = Signal(5) + spec_insn_blt_rs2_addr = Signal(5) + spec_insn_blt_rd_addr = Signal(5) + spec_insn_blt_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_blt_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_blt_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_blt_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_blt_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_blt_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_blt = insn_blt = rvfi_insn_blt() + m.d.comb += insn_blt.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_blt.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_blt.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_blt.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_blt.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_blt.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_blt_valid.eq(insn_blt.spec_valid) + m.d.comb += spec_insn_blt_trap.eq(insn_blt.spec_trap) + m.d.comb += spec_insn_blt_rs1_addr.eq(insn_blt.spec_rs1_addr) + m.d.comb += spec_insn_blt_rs2_addr.eq(insn_blt.spec_rs2_addr) + m.d.comb += spec_insn_blt_rd_addr.eq(insn_blt.spec_rd_addr) + m.d.comb += spec_insn_blt_rd_wdata.eq(insn_blt.spec_rd_wdata) + m.d.comb += spec_insn_blt_pc_wdata.eq(insn_blt.spec_pc_wdata) + m.d.comb += spec_insn_blt_mem_addr.eq(insn_blt.spec_mem_addr) + m.d.comb += spec_insn_blt_mem_rmask.eq(insn_blt.spec_mem_rmask) + m.d.comb += spec_insn_blt_mem_wmask.eq(insn_blt.spec_mem_wmask) + m.d.comb += spec_insn_blt_mem_wdata.eq(insn_blt.spec_mem_wdata) + + spec_insn_bge_valid = Signal(1) + spec_insn_bge_trap = Signal(1) + spec_insn_bge_rs1_addr = Signal(5) + spec_insn_bge_rs2_addr = Signal(5) + spec_insn_bge_rd_addr = Signal(5) + spec_insn_bge_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bge_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bge_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bge_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bge_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bge_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_bge = insn_bge = rvfi_insn_bge() + m.d.comb += insn_bge.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_bge.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_bge.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_bge.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_bge.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_bge.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_bge_valid.eq(insn_bge.spec_valid) + m.d.comb += spec_insn_bge_trap.eq(insn_bge.spec_trap) + m.d.comb += spec_insn_bge_rs1_addr.eq(insn_bge.spec_rs1_addr) + m.d.comb += spec_insn_bge_rs2_addr.eq(insn_bge.spec_rs2_addr) + m.d.comb += spec_insn_bge_rd_addr.eq(insn_bge.spec_rd_addr) + m.d.comb += spec_insn_bge_rd_wdata.eq(insn_bge.spec_rd_wdata) + m.d.comb += spec_insn_bge_pc_wdata.eq(insn_bge.spec_pc_wdata) + m.d.comb += spec_insn_bge_mem_addr.eq(insn_bge.spec_mem_addr) + m.d.comb += spec_insn_bge_mem_rmask.eq(insn_bge.spec_mem_rmask) + m.d.comb += spec_insn_bge_mem_wmask.eq(insn_bge.spec_mem_wmask) + m.d.comb += spec_insn_bge_mem_wdata.eq(insn_bge.spec_mem_wdata) + + spec_insn_bltu_valid = Signal(1) + spec_insn_bltu_trap = Signal(1) + spec_insn_bltu_rs1_addr = Signal(5) + spec_insn_bltu_rs2_addr = Signal(5) + spec_insn_bltu_rd_addr = Signal(5) + spec_insn_bltu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bltu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bltu_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bltu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bltu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bltu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_bltu = insn_bltu = rvfi_insn_bltu() + m.d.comb += insn_bltu.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_bltu.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_bltu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_bltu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_bltu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_bltu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_bltu_valid.eq(insn_bltu.spec_valid) + m.d.comb += spec_insn_bltu_trap.eq(insn_bltu.spec_trap) + m.d.comb += spec_insn_bltu_rs1_addr.eq(insn_bltu.spec_rs1_addr) + m.d.comb += spec_insn_bltu_rs2_addr.eq(insn_bltu.spec_rs2_addr) + m.d.comb += spec_insn_bltu_rd_addr.eq(insn_bltu.spec_rd_addr) + m.d.comb += spec_insn_bltu_rd_wdata.eq(insn_bltu.spec_rd_wdata) + m.d.comb += spec_insn_bltu_pc_wdata.eq(insn_bltu.spec_pc_wdata) + m.d.comb += spec_insn_bltu_mem_addr.eq(insn_bltu.spec_mem_addr) + m.d.comb += spec_insn_bltu_mem_rmask.eq(insn_bltu.spec_mem_rmask) + m.d.comb += spec_insn_bltu_mem_wmask.eq(insn_bltu.spec_mem_wmask) + m.d.comb += spec_insn_bltu_mem_wdata.eq(insn_bltu.spec_mem_wdata) + + spec_insn_bgeu_valid = Signal(1) + spec_insn_bgeu_trap = Signal(1) + spec_insn_bgeu_rs1_addr = Signal(5) + spec_insn_bgeu_rs2_addr = Signal(5) + spec_insn_bgeu_rd_addr = Signal(5) + spec_insn_bgeu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bgeu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bgeu_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_bgeu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bgeu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_bgeu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_bgeu = insn_bgeu = rvfi_insn_bgeu() + m.d.comb += insn_bgeu.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_bgeu.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_bgeu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_bgeu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_bgeu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_bgeu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_bgeu_valid.eq(insn_bgeu.spec_valid) + m.d.comb += spec_insn_bgeu_trap.eq(insn_bgeu.spec_trap) + m.d.comb += spec_insn_bgeu_rs1_addr.eq(insn_bgeu.spec_rs1_addr) + m.d.comb += spec_insn_bgeu_rs2_addr.eq(insn_bgeu.spec_rs2_addr) + m.d.comb += spec_insn_bgeu_rd_addr.eq(insn_bgeu.spec_rd_addr) + m.d.comb += spec_insn_bgeu_rd_wdata.eq(insn_bgeu.spec_rd_wdata) + m.d.comb += spec_insn_bgeu_pc_wdata.eq(insn_bgeu.spec_pc_wdata) + m.d.comb += spec_insn_bgeu_mem_addr.eq(insn_bgeu.spec_mem_addr) + m.d.comb += spec_insn_bgeu_mem_rmask.eq(insn_bgeu.spec_mem_rmask) + m.d.comb += spec_insn_bgeu_mem_wmask.eq(insn_bgeu.spec_mem_wmask) + m.d.comb += spec_insn_bgeu_mem_wdata.eq(insn_bgeu.spec_mem_wdata) + + spec_insn_lb_valid = Signal(1) + spec_insn_lb_trap = Signal(1) + spec_insn_lb_rs1_addr = Signal(5) + spec_insn_lb_rs2_addr = Signal(5) + spec_insn_lb_rd_addr = Signal(5) + spec_insn_lb_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lb_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lb_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lb_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lb_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lb_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_lb = insn_lb = rvfi_insn_lb() + m.d.comb += insn_lb.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_lb.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_lb.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_lb.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_lb.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_lb.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_lb_valid.eq(insn_lb.spec_valid) + m.d.comb += spec_insn_lb_trap.eq(insn_lb.spec_trap) + m.d.comb += spec_insn_lb_rs1_addr.eq(insn_lb.spec_rs1_addr) + m.d.comb += spec_insn_lb_rs2_addr.eq(insn_lb.spec_rs2_addr) + m.d.comb += spec_insn_lb_rd_addr.eq(insn_lb.spec_rd_addr) + m.d.comb += spec_insn_lb_rd_wdata.eq(insn_lb.spec_rd_wdata) + m.d.comb += spec_insn_lb_pc_wdata.eq(insn_lb.spec_pc_wdata) + m.d.comb += spec_insn_lb_mem_addr.eq(insn_lb.spec_mem_addr) + m.d.comb += spec_insn_lb_mem_rmask.eq(insn_lb.spec_mem_rmask) + m.d.comb += spec_insn_lb_mem_wmask.eq(insn_lb.spec_mem_wmask) + m.d.comb += spec_insn_lb_mem_wdata.eq(insn_lb.spec_mem_wdata) + + spec_insn_lh_valid = Signal(1) + spec_insn_lh_trap = Signal(1) + spec_insn_lh_rs1_addr = Signal(5) + spec_insn_lh_rs2_addr = Signal(5) + spec_insn_lh_rd_addr = Signal(5) + spec_insn_lh_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lh_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lh_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lh_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lh_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lh_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_lh = insn_lh = rvfi_insn_lh() + m.d.comb += insn_lh.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_lh.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_lh.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_lh.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_lh.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_lh.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_lh_valid.eq(insn_lh.spec_valid) + m.d.comb += spec_insn_lh_trap.eq(insn_lh.spec_trap) + m.d.comb += spec_insn_lh_rs1_addr.eq(insn_lh.spec_rs1_addr) + m.d.comb += spec_insn_lh_rs2_addr.eq(insn_lh.spec_rs2_addr) + m.d.comb += spec_insn_lh_rd_addr.eq(insn_lh.spec_rd_addr) + m.d.comb += spec_insn_lh_rd_wdata.eq(insn_lh.spec_rd_wdata) + m.d.comb += spec_insn_lh_pc_wdata.eq(insn_lh.spec_pc_wdata) + m.d.comb += spec_insn_lh_mem_addr.eq(insn_lh.spec_mem_addr) + m.d.comb += spec_insn_lh_mem_rmask.eq(insn_lh.spec_mem_rmask) + m.d.comb += spec_insn_lh_mem_wmask.eq(insn_lh.spec_mem_wmask) + m.d.comb += spec_insn_lh_mem_wdata.eq(insn_lh.spec_mem_wdata) + + spec_insn_lw_valid = Signal(1) + spec_insn_lw_trap = Signal(1) + spec_insn_lw_rs1_addr = Signal(5) + spec_insn_lw_rs2_addr = Signal(5) + spec_insn_lw_rd_addr = Signal(5) + spec_insn_lw_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lw_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lw_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lw_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lw_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lw_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_lw = insn_lw = rvfi_insn_lw() + m.d.comb += insn_lw.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_lw.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_lw.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_lw.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_lw.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_lw.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_lw_valid.eq(insn_lw.spec_valid) + m.d.comb += spec_insn_lw_trap.eq(insn_lw.spec_trap) + m.d.comb += spec_insn_lw_rs1_addr.eq(insn_lw.spec_rs1_addr) + m.d.comb += spec_insn_lw_rs2_addr.eq(insn_lw.spec_rs2_addr) + m.d.comb += spec_insn_lw_rd_addr.eq(insn_lw.spec_rd_addr) + m.d.comb += spec_insn_lw_rd_wdata.eq(insn_lw.spec_rd_wdata) + m.d.comb += spec_insn_lw_pc_wdata.eq(insn_lw.spec_pc_wdata) + m.d.comb += spec_insn_lw_mem_addr.eq(insn_lw.spec_mem_addr) + m.d.comb += spec_insn_lw_mem_rmask.eq(insn_lw.spec_mem_rmask) + m.d.comb += spec_insn_lw_mem_wmask.eq(insn_lw.spec_mem_wmask) + m.d.comb += spec_insn_lw_mem_wdata.eq(insn_lw.spec_mem_wdata) + + spec_insn_lbu_valid = Signal(1) + spec_insn_lbu_trap = Signal(1) + spec_insn_lbu_rs1_addr = Signal(5) + spec_insn_lbu_rs2_addr = Signal(5) + spec_insn_lbu_rd_addr = Signal(5) + spec_insn_lbu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lbu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lbu_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lbu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lbu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lbu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_lbu = insn_lbu = rvfi_insn_lbu() + m.d.comb += insn_lbu.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_lbu.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_lbu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_lbu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_lbu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_lbu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_lbu_valid.eq(insn_lbu.spec_valid) + m.d.comb += spec_insn_lbu_trap.eq(insn_lbu.spec_trap) + m.d.comb += spec_insn_lbu_rs1_addr.eq(insn_lbu.spec_rs1_addr) + m.d.comb += spec_insn_lbu_rs2_addr.eq(insn_lbu.spec_rs2_addr) + m.d.comb += spec_insn_lbu_rd_addr.eq(insn_lbu.spec_rd_addr) + m.d.comb += spec_insn_lbu_rd_wdata.eq(insn_lbu.spec_rd_wdata) + m.d.comb += spec_insn_lbu_pc_wdata.eq(insn_lbu.spec_pc_wdata) + m.d.comb += spec_insn_lbu_mem_addr.eq(insn_lbu.spec_mem_addr) + m.d.comb += spec_insn_lbu_mem_rmask.eq(insn_lbu.spec_mem_rmask) + m.d.comb += spec_insn_lbu_mem_wmask.eq(insn_lbu.spec_mem_wmask) + m.d.comb += spec_insn_lbu_mem_wdata.eq(insn_lbu.spec_mem_wdata) + + spec_insn_lhu_valid = Signal(1) + spec_insn_lhu_trap = Signal(1) + spec_insn_lhu_rs1_addr = Signal(5) + spec_insn_lhu_rs2_addr = Signal(5) + spec_insn_lhu_rd_addr = Signal(5) + spec_insn_lhu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lhu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lhu_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_lhu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lhu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_lhu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_lhu = insn_lhu = rvfi_insn_lhu() + m.d.comb += insn_lhu.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_lhu.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_lhu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_lhu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_lhu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_lhu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_lhu_valid.eq(insn_lhu.spec_valid) + m.d.comb += spec_insn_lhu_trap.eq(insn_lhu.spec_trap) + m.d.comb += spec_insn_lhu_rs1_addr.eq(insn_lhu.spec_rs1_addr) + m.d.comb += spec_insn_lhu_rs2_addr.eq(insn_lhu.spec_rs2_addr) + m.d.comb += spec_insn_lhu_rd_addr.eq(insn_lhu.spec_rd_addr) + m.d.comb += spec_insn_lhu_rd_wdata.eq(insn_lhu.spec_rd_wdata) + m.d.comb += spec_insn_lhu_pc_wdata.eq(insn_lhu.spec_pc_wdata) + m.d.comb += spec_insn_lhu_mem_addr.eq(insn_lhu.spec_mem_addr) + m.d.comb += spec_insn_lhu_mem_rmask.eq(insn_lhu.spec_mem_rmask) + m.d.comb += spec_insn_lhu_mem_wmask.eq(insn_lhu.spec_mem_wmask) + m.d.comb += spec_insn_lhu_mem_wdata.eq(insn_lhu.spec_mem_wdata) + + spec_insn_sb_valid = Signal(1) + spec_insn_sb_trap = Signal(1) + spec_insn_sb_rs1_addr = Signal(5) + spec_insn_sb_rs2_addr = Signal(5) + spec_insn_sb_rd_addr = Signal(5) + spec_insn_sb_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sb_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sb_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sb_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sb_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sb_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sb = insn_sb = rvfi_insn_sb() + m.d.comb += insn_sb.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sb.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sb.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sb.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sb.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sb.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sb_valid.eq(insn_sb.spec_valid) + m.d.comb += spec_insn_sb_trap.eq(insn_sb.spec_trap) + m.d.comb += spec_insn_sb_rs1_addr.eq(insn_sb.spec_rs1_addr) + m.d.comb += spec_insn_sb_rs2_addr.eq(insn_sb.spec_rs2_addr) + m.d.comb += spec_insn_sb_rd_addr.eq(insn_sb.spec_rd_addr) + m.d.comb += spec_insn_sb_rd_wdata.eq(insn_sb.spec_rd_wdata) + m.d.comb += spec_insn_sb_pc_wdata.eq(insn_sb.spec_pc_wdata) + m.d.comb += spec_insn_sb_mem_addr.eq(insn_sb.spec_mem_addr) + m.d.comb += spec_insn_sb_mem_rmask.eq(insn_sb.spec_mem_rmask) + m.d.comb += spec_insn_sb_mem_wmask.eq(insn_sb.spec_mem_wmask) + m.d.comb += spec_insn_sb_mem_wdata.eq(insn_sb.spec_mem_wdata) + + spec_insn_sh_valid = Signal(1) + spec_insn_sh_trap = Signal(1) + spec_insn_sh_rs1_addr = Signal(5) + spec_insn_sh_rs2_addr = Signal(5) + spec_insn_sh_rd_addr = Signal(5) + spec_insn_sh_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sh_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sh_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sh_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sh_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sh_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sh = insn_sh = rvfi_insn_sh() + m.d.comb += insn_sh.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sh.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sh.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sh.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sh.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sh.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sh_valid.eq(insn_sh.spec_valid) + m.d.comb += spec_insn_sh_trap.eq(insn_sh.spec_trap) + m.d.comb += spec_insn_sh_rs1_addr.eq(insn_sh.spec_rs1_addr) + m.d.comb += spec_insn_sh_rs2_addr.eq(insn_sh.spec_rs2_addr) + m.d.comb += spec_insn_sh_rd_addr.eq(insn_sh.spec_rd_addr) + m.d.comb += spec_insn_sh_rd_wdata.eq(insn_sh.spec_rd_wdata) + m.d.comb += spec_insn_sh_pc_wdata.eq(insn_sh.spec_pc_wdata) + m.d.comb += spec_insn_sh_mem_addr.eq(insn_sh.spec_mem_addr) + m.d.comb += spec_insn_sh_mem_rmask.eq(insn_sh.spec_mem_rmask) + m.d.comb += spec_insn_sh_mem_wmask.eq(insn_sh.spec_mem_wmask) + m.d.comb += spec_insn_sh_mem_wdata.eq(insn_sh.spec_mem_wdata) + + spec_insn_sw_valid = Signal(1) + spec_insn_sw_trap = Signal(1) + spec_insn_sw_rs1_addr = Signal(5) + spec_insn_sw_rs2_addr = Signal(5) + spec_insn_sw_rd_addr = Signal(5) + spec_insn_sw_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sw_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sw_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sw_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sw_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sw_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sw = insn_sw = rvfi_insn_sw() + m.d.comb += insn_sw.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sw.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sw.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sw.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sw.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sw.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sw_valid.eq(insn_sw.spec_valid) + m.d.comb += spec_insn_sw_trap.eq(insn_sw.spec_trap) + m.d.comb += spec_insn_sw_rs1_addr.eq(insn_sw.spec_rs1_addr) + m.d.comb += spec_insn_sw_rs2_addr.eq(insn_sw.spec_rs2_addr) + m.d.comb += spec_insn_sw_rd_addr.eq(insn_sw.spec_rd_addr) + m.d.comb += spec_insn_sw_rd_wdata.eq(insn_sw.spec_rd_wdata) + m.d.comb += spec_insn_sw_pc_wdata.eq(insn_sw.spec_pc_wdata) + m.d.comb += spec_insn_sw_mem_addr.eq(insn_sw.spec_mem_addr) + m.d.comb += spec_insn_sw_mem_rmask.eq(insn_sw.spec_mem_rmask) + m.d.comb += spec_insn_sw_mem_wmask.eq(insn_sw.spec_mem_wmask) + m.d.comb += spec_insn_sw_mem_wdata.eq(insn_sw.spec_mem_wdata) + + spec_insn_addi_valid = Signal(1) + spec_insn_addi_trap = Signal(1) + spec_insn_addi_rs1_addr = Signal(5) + spec_insn_addi_rs2_addr = Signal(5) + spec_insn_addi_rd_addr = Signal(5) + spec_insn_addi_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_addi_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_addi_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_addi_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_addi_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_addi_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_addi = insn_addi = rvfi_insn_addi() + m.d.comb += insn_addi.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_addi.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_addi.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_addi.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_addi.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_addi.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_addi_valid.eq(insn_addi.spec_valid) + m.d.comb += spec_insn_addi_trap.eq(insn_addi.spec_trap) + m.d.comb += spec_insn_addi_rs1_addr.eq(insn_addi.spec_rs1_addr) + m.d.comb += spec_insn_addi_rs2_addr.eq(insn_addi.spec_rs2_addr) + m.d.comb += spec_insn_addi_rd_addr.eq(insn_addi.spec_rd_addr) + m.d.comb += spec_insn_addi_rd_wdata.eq(insn_addi.spec_rd_wdata) + m.d.comb += spec_insn_addi_pc_wdata.eq(insn_addi.spec_pc_wdata) + m.d.comb += spec_insn_addi_mem_addr.eq(insn_addi.spec_mem_addr) + m.d.comb += spec_insn_addi_mem_rmask.eq(insn_addi.spec_mem_rmask) + m.d.comb += spec_insn_addi_mem_wmask.eq(insn_addi.spec_mem_wmask) + m.d.comb += spec_insn_addi_mem_wdata.eq(insn_addi.spec_mem_wdata) + + spec_insn_slti_valid = Signal(1) + spec_insn_slti_trap = Signal(1) + spec_insn_slti_rs1_addr = Signal(5) + spec_insn_slti_rs2_addr = Signal(5) + spec_insn_slti_rd_addr = Signal(5) + spec_insn_slti_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slti_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slti_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slti_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_slti_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_slti_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_slti = insn_slti = rvfi_insn_slti() + m.d.comb += insn_slti.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_slti.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_slti.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_slti.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_slti.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_slti.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_slti_valid.eq(insn_slti.spec_valid) + m.d.comb += spec_insn_slti_trap.eq(insn_slti.spec_trap) + m.d.comb += spec_insn_slti_rs1_addr.eq(insn_slti.spec_rs1_addr) + m.d.comb += spec_insn_slti_rs2_addr.eq(insn_slti.spec_rs2_addr) + m.d.comb += spec_insn_slti_rd_addr.eq(insn_slti.spec_rd_addr) + m.d.comb += spec_insn_slti_rd_wdata.eq(insn_slti.spec_rd_wdata) + m.d.comb += spec_insn_slti_pc_wdata.eq(insn_slti.spec_pc_wdata) + m.d.comb += spec_insn_slti_mem_addr.eq(insn_slti.spec_mem_addr) + m.d.comb += spec_insn_slti_mem_rmask.eq(insn_slti.spec_mem_rmask) + m.d.comb += spec_insn_slti_mem_wmask.eq(insn_slti.spec_mem_wmask) + m.d.comb += spec_insn_slti_mem_wdata.eq(insn_slti.spec_mem_wdata) + + spec_insn_sltiu_valid = Signal(1) + spec_insn_sltiu_trap = Signal(1) + spec_insn_sltiu_rs1_addr = Signal(5) + spec_insn_sltiu_rs2_addr = Signal(5) + spec_insn_sltiu_rd_addr = Signal(5) + spec_insn_sltiu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sltiu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sltiu_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sltiu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sltiu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sltiu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sltiu = insn_sltiu = rvfi_insn_sltiu() + m.d.comb += insn_sltiu.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sltiu.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sltiu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sltiu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sltiu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sltiu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sltiu_valid.eq(insn_sltiu.spec_valid) + m.d.comb += spec_insn_sltiu_trap.eq(insn_sltiu.spec_trap) + m.d.comb += spec_insn_sltiu_rs1_addr.eq(insn_sltiu.spec_rs1_addr) + m.d.comb += spec_insn_sltiu_rs2_addr.eq(insn_sltiu.spec_rs2_addr) + m.d.comb += spec_insn_sltiu_rd_addr.eq(insn_sltiu.spec_rd_addr) + m.d.comb += spec_insn_sltiu_rd_wdata.eq(insn_sltiu.spec_rd_wdata) + m.d.comb += spec_insn_sltiu_pc_wdata.eq(insn_sltiu.spec_pc_wdata) + m.d.comb += spec_insn_sltiu_mem_addr.eq(insn_sltiu.spec_mem_addr) + m.d.comb += spec_insn_sltiu_mem_rmask.eq(insn_sltiu.spec_mem_rmask) + m.d.comb += spec_insn_sltiu_mem_wmask.eq(insn_sltiu.spec_mem_wmask) + m.d.comb += spec_insn_sltiu_mem_wdata.eq(insn_sltiu.spec_mem_wdata) + + spec_insn_xori_valid = Signal(1) + spec_insn_xori_trap = Signal(1) + spec_insn_xori_rs1_addr = Signal(5) + spec_insn_xori_rs2_addr = Signal(5) + spec_insn_xori_rd_addr = Signal(5) + spec_insn_xori_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_xori_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_xori_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_xori_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_xori_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_xori_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_xori = insn_xori = rvfi_insn_xori() + m.d.comb += insn_xori.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_xori.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_xori.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_xori.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_xori.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_xori.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_xori_valid.eq(insn_xori.spec_valid) + m.d.comb += spec_insn_xori_trap.eq(insn_xori.spec_trap) + m.d.comb += spec_insn_xori_rs1_addr.eq(insn_xori.spec_rs1_addr) + m.d.comb += spec_insn_xori_rs2_addr.eq(insn_xori.spec_rs2_addr) + m.d.comb += spec_insn_xori_rd_addr.eq(insn_xori.spec_rd_addr) + m.d.comb += spec_insn_xori_rd_wdata.eq(insn_xori.spec_rd_wdata) + m.d.comb += spec_insn_xori_pc_wdata.eq(insn_xori.spec_pc_wdata) + m.d.comb += spec_insn_xori_mem_addr.eq(insn_xori.spec_mem_addr) + m.d.comb += spec_insn_xori_mem_rmask.eq(insn_xori.spec_mem_rmask) + m.d.comb += spec_insn_xori_mem_wmask.eq(insn_xori.spec_mem_wmask) + m.d.comb += spec_insn_xori_mem_wdata.eq(insn_xori.spec_mem_wdata) + + spec_insn_ori_valid = Signal(1) + spec_insn_ori_trap = Signal(1) + spec_insn_ori_rs1_addr = Signal(5) + spec_insn_ori_rs2_addr = Signal(5) + spec_insn_ori_rd_addr = Signal(5) + spec_insn_ori_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_ori_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_ori_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_ori_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_ori_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_ori_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_ori = insn_ori = rvfi_insn_ori() + m.d.comb += insn_ori.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_ori.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_ori.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_ori.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_ori.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_ori.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_ori_valid.eq(insn_ori.spec_valid) + m.d.comb += spec_insn_ori_trap.eq(insn_ori.spec_trap) + m.d.comb += spec_insn_ori_rs1_addr.eq(insn_ori.spec_rs1_addr) + m.d.comb += spec_insn_ori_rs2_addr.eq(insn_ori.spec_rs2_addr) + m.d.comb += spec_insn_ori_rd_addr.eq(insn_ori.spec_rd_addr) + m.d.comb += spec_insn_ori_rd_wdata.eq(insn_ori.spec_rd_wdata) + m.d.comb += spec_insn_ori_pc_wdata.eq(insn_ori.spec_pc_wdata) + m.d.comb += spec_insn_ori_mem_addr.eq(insn_ori.spec_mem_addr) + m.d.comb += spec_insn_ori_mem_rmask.eq(insn_ori.spec_mem_rmask) + m.d.comb += spec_insn_ori_mem_wmask.eq(insn_ori.spec_mem_wmask) + m.d.comb += spec_insn_ori_mem_wdata.eq(insn_ori.spec_mem_wdata) + + spec_insn_andi_valid = Signal(1) + spec_insn_andi_trap = Signal(1) + spec_insn_andi_rs1_addr = Signal(5) + spec_insn_andi_rs2_addr = Signal(5) + spec_insn_andi_rd_addr = Signal(5) + spec_insn_andi_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_andi_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_andi_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_andi_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_andi_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_andi_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_andi = insn_andi = rvfi_insn_andi() + m.d.comb += insn_andi.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_andi.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_andi.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_andi.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_andi.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_andi.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_andi_valid.eq(insn_andi.spec_valid) + m.d.comb += spec_insn_andi_trap.eq(insn_andi.spec_trap) + m.d.comb += spec_insn_andi_rs1_addr.eq(insn_andi.spec_rs1_addr) + m.d.comb += spec_insn_andi_rs2_addr.eq(insn_andi.spec_rs2_addr) + m.d.comb += spec_insn_andi_rd_addr.eq(insn_andi.spec_rd_addr) + m.d.comb += spec_insn_andi_rd_wdata.eq(insn_andi.spec_rd_wdata) + m.d.comb += spec_insn_andi_pc_wdata.eq(insn_andi.spec_pc_wdata) + m.d.comb += spec_insn_andi_mem_addr.eq(insn_andi.spec_mem_addr) + m.d.comb += spec_insn_andi_mem_rmask.eq(insn_andi.spec_mem_rmask) + m.d.comb += spec_insn_andi_mem_wmask.eq(insn_andi.spec_mem_wmask) + m.d.comb += spec_insn_andi_mem_wdata.eq(insn_andi.spec_mem_wdata) + + spec_insn_slli_valid = Signal(1) + spec_insn_slli_trap = Signal(1) + spec_insn_slli_rs1_addr = Signal(5) + spec_insn_slli_rs2_addr = Signal(5) + spec_insn_slli_rd_addr = Signal(5) + spec_insn_slli_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slli_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slli_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slli_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_slli_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_slli_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_slli = insn_slli = rvfi_insn_slli() + m.d.comb += insn_slli.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_slli.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_slli.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_slli.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_slli.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_slli.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_slli_valid.eq(insn_slli.spec_valid) + m.d.comb += spec_insn_slli_trap.eq(insn_slli.spec_trap) + m.d.comb += spec_insn_slli_rs1_addr.eq(insn_slli.spec_rs1_addr) + m.d.comb += spec_insn_slli_rs2_addr.eq(insn_slli.spec_rs2_addr) + m.d.comb += spec_insn_slli_rd_addr.eq(insn_slli.spec_rd_addr) + m.d.comb += spec_insn_slli_rd_wdata.eq(insn_slli.spec_rd_wdata) + m.d.comb += spec_insn_slli_pc_wdata.eq(insn_slli.spec_pc_wdata) + m.d.comb += spec_insn_slli_mem_addr.eq(insn_slli.spec_mem_addr) + m.d.comb += spec_insn_slli_mem_rmask.eq(insn_slli.spec_mem_rmask) + m.d.comb += spec_insn_slli_mem_wmask.eq(insn_slli.spec_mem_wmask) + m.d.comb += spec_insn_slli_mem_wdata.eq(insn_slli.spec_mem_wdata) + + spec_insn_srli_valid = Signal(1) + spec_insn_srli_trap = Signal(1) + spec_insn_srli_rs1_addr = Signal(5) + spec_insn_srli_rs2_addr = Signal(5) + spec_insn_srli_rd_addr = Signal(5) + spec_insn_srli_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srli_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srli_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srli_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_srli_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_srli_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_srli = insn_srli = rvfi_insn_srli() + m.d.comb += insn_srli.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_srli.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_srli.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_srli.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_srli.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_srli.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_srli_valid.eq(insn_srli.spec_valid) + m.d.comb += spec_insn_srli_trap.eq(insn_srli.spec_trap) + m.d.comb += spec_insn_srli_rs1_addr.eq(insn_srli.spec_rs1_addr) + m.d.comb += spec_insn_srli_rs2_addr.eq(insn_srli.spec_rs2_addr) + m.d.comb += spec_insn_srli_rd_addr.eq(insn_srli.spec_rd_addr) + m.d.comb += spec_insn_srli_rd_wdata.eq(insn_srli.spec_rd_wdata) + m.d.comb += spec_insn_srli_pc_wdata.eq(insn_srli.spec_pc_wdata) + m.d.comb += spec_insn_srli_mem_addr.eq(insn_srli.spec_mem_addr) + m.d.comb += spec_insn_srli_mem_rmask.eq(insn_srli.spec_mem_rmask) + m.d.comb += spec_insn_srli_mem_wmask.eq(insn_srli.spec_mem_wmask) + m.d.comb += spec_insn_srli_mem_wdata.eq(insn_srli.spec_mem_wdata) + + spec_insn_srai_valid = Signal(1) + spec_insn_srai_trap = Signal(1) + spec_insn_srai_rs1_addr = Signal(5) + spec_insn_srai_rs2_addr = Signal(5) + spec_insn_srai_rd_addr = Signal(5) + spec_insn_srai_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srai_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srai_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srai_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_srai_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_srai_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_srai = insn_srai = rvfi_insn_srai() + m.d.comb += insn_srai.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_srai.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_srai.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_srai.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_srai.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_srai.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_srai_valid.eq(insn_srai.spec_valid) + m.d.comb += spec_insn_srai_trap.eq(insn_srai.spec_trap) + m.d.comb += spec_insn_srai_rs1_addr.eq(insn_srai.spec_rs1_addr) + m.d.comb += spec_insn_srai_rs2_addr.eq(insn_srai.spec_rs2_addr) + m.d.comb += spec_insn_srai_rd_addr.eq(insn_srai.spec_rd_addr) + m.d.comb += spec_insn_srai_rd_wdata.eq(insn_srai.spec_rd_wdata) + m.d.comb += spec_insn_srai_pc_wdata.eq(insn_srai.spec_pc_wdata) + m.d.comb += spec_insn_srai_mem_addr.eq(insn_srai.spec_mem_addr) + m.d.comb += spec_insn_srai_mem_rmask.eq(insn_srai.spec_mem_rmask) + m.d.comb += spec_insn_srai_mem_wmask.eq(insn_srai.spec_mem_wmask) + m.d.comb += spec_insn_srai_mem_wdata.eq(insn_srai.spec_mem_wdata) + + spec_insn_add_valid = Signal(1) + spec_insn_add_trap = Signal(1) + spec_insn_add_rs1_addr = Signal(5) + spec_insn_add_rs2_addr = Signal(5) + spec_insn_add_rd_addr = Signal(5) + spec_insn_add_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_add_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_add_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_add_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_add_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_add_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_add = insn_add = rvfi_insn_add() + m.d.comb += insn_add.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_add.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_add.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_add.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_add.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_add.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_add_valid.eq(insn_add.spec_valid) + m.d.comb += spec_insn_add_trap.eq(insn_add.spec_trap) + m.d.comb += spec_insn_add_rs1_addr.eq(insn_add.spec_rs1_addr) + m.d.comb += spec_insn_add_rs2_addr.eq(insn_add.spec_rs2_addr) + m.d.comb += spec_insn_add_rd_addr.eq(insn_add.spec_rd_addr) + m.d.comb += spec_insn_add_rd_wdata.eq(insn_add.spec_rd_wdata) + m.d.comb += spec_insn_add_pc_wdata.eq(insn_add.spec_pc_wdata) + m.d.comb += spec_insn_add_mem_addr.eq(insn_add.spec_mem_addr) + m.d.comb += spec_insn_add_mem_rmask.eq(insn_add.spec_mem_rmask) + m.d.comb += spec_insn_add_mem_wmask.eq(insn_add.spec_mem_wmask) + m.d.comb += spec_insn_add_mem_wdata.eq(insn_add.spec_mem_wdata) + + spec_insn_sub_valid = Signal(1) + spec_insn_sub_trap = Signal(1) + spec_insn_sub_rs1_addr = Signal(5) + spec_insn_sub_rs2_addr = Signal(5) + spec_insn_sub_rd_addr = Signal(5) + spec_insn_sub_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sub_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sub_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sub_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sub_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sub_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sub = insn_sub = rvfi_insn_sub() + m.d.comb += insn_sub.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sub.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sub.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sub.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sub.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sub.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sub_valid.eq(insn_sub.spec_valid) + m.d.comb += spec_insn_sub_trap.eq(insn_sub.spec_trap) + m.d.comb += spec_insn_sub_rs1_addr.eq(insn_sub.spec_rs1_addr) + m.d.comb += spec_insn_sub_rs2_addr.eq(insn_sub.spec_rs2_addr) + m.d.comb += spec_insn_sub_rd_addr.eq(insn_sub.spec_rd_addr) + m.d.comb += spec_insn_sub_rd_wdata.eq(insn_sub.spec_rd_wdata) + m.d.comb += spec_insn_sub_pc_wdata.eq(insn_sub.spec_pc_wdata) + m.d.comb += spec_insn_sub_mem_addr.eq(insn_sub.spec_mem_addr) + m.d.comb += spec_insn_sub_mem_rmask.eq(insn_sub.spec_mem_rmask) + m.d.comb += spec_insn_sub_mem_wmask.eq(insn_sub.spec_mem_wmask) + m.d.comb += spec_insn_sub_mem_wdata.eq(insn_sub.spec_mem_wdata) + + spec_insn_sll_valid = Signal(1) + spec_insn_sll_trap = Signal(1) + spec_insn_sll_rs1_addr = Signal(5) + spec_insn_sll_rs2_addr = Signal(5) + spec_insn_sll_rd_addr = Signal(5) + spec_insn_sll_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sll_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sll_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sll_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sll_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sll_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sll = insn_sll = rvfi_insn_sll() + m.d.comb += insn_sll.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sll.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sll.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sll.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sll.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sll.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sll_valid.eq(insn_sll.spec_valid) + m.d.comb += spec_insn_sll_trap.eq(insn_sll.spec_trap) + m.d.comb += spec_insn_sll_rs1_addr.eq(insn_sll.spec_rs1_addr) + m.d.comb += spec_insn_sll_rs2_addr.eq(insn_sll.spec_rs2_addr) + m.d.comb += spec_insn_sll_rd_addr.eq(insn_sll.spec_rd_addr) + m.d.comb += spec_insn_sll_rd_wdata.eq(insn_sll.spec_rd_wdata) + m.d.comb += spec_insn_sll_pc_wdata.eq(insn_sll.spec_pc_wdata) + m.d.comb += spec_insn_sll_mem_addr.eq(insn_sll.spec_mem_addr) + m.d.comb += spec_insn_sll_mem_rmask.eq(insn_sll.spec_mem_rmask) + m.d.comb += spec_insn_sll_mem_wmask.eq(insn_sll.spec_mem_wmask) + m.d.comb += spec_insn_sll_mem_wdata.eq(insn_sll.spec_mem_wdata) + + spec_insn_slt_valid = Signal(1) + spec_insn_slt_trap = Signal(1) + spec_insn_slt_rs1_addr = Signal(5) + spec_insn_slt_rs2_addr = Signal(5) + spec_insn_slt_rd_addr = Signal(5) + spec_insn_slt_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slt_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slt_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_slt_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_slt_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_slt_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_slt = insn_slt = rvfi_insn_slt() + m.d.comb += insn_slt.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_slt.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_slt.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_slt.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_slt.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_slt.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_slt_valid.eq(insn_slt.spec_valid) + m.d.comb += spec_insn_slt_trap.eq(insn_slt.spec_trap) + m.d.comb += spec_insn_slt_rs1_addr.eq(insn_slt.spec_rs1_addr) + m.d.comb += spec_insn_slt_rs2_addr.eq(insn_slt.spec_rs2_addr) + m.d.comb += spec_insn_slt_rd_addr.eq(insn_slt.spec_rd_addr) + m.d.comb += spec_insn_slt_rd_wdata.eq(insn_slt.spec_rd_wdata) + m.d.comb += spec_insn_slt_pc_wdata.eq(insn_slt.spec_pc_wdata) + m.d.comb += spec_insn_slt_mem_addr.eq(insn_slt.spec_mem_addr) + m.d.comb += spec_insn_slt_mem_rmask.eq(insn_slt.spec_mem_rmask) + m.d.comb += spec_insn_slt_mem_wmask.eq(insn_slt.spec_mem_wmask) + m.d.comb += spec_insn_slt_mem_wdata.eq(insn_slt.spec_mem_wdata) + + spec_insn_sltu_valid = Signal(1) + spec_insn_sltu_trap = Signal(1) + spec_insn_sltu_rs1_addr = Signal(5) + spec_insn_sltu_rs2_addr = Signal(5) + spec_insn_sltu_rd_addr = Signal(5) + spec_insn_sltu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sltu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sltu_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sltu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sltu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sltu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sltu = insn_sltu = rvfi_insn_sltu() + m.d.comb += insn_sltu.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sltu.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sltu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sltu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sltu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sltu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sltu_valid.eq(insn_sltu.spec_valid) + m.d.comb += spec_insn_sltu_trap.eq(insn_sltu.spec_trap) + m.d.comb += spec_insn_sltu_rs1_addr.eq(insn_sltu.spec_rs1_addr) + m.d.comb += spec_insn_sltu_rs2_addr.eq(insn_sltu.spec_rs2_addr) + m.d.comb += spec_insn_sltu_rd_addr.eq(insn_sltu.spec_rd_addr) + m.d.comb += spec_insn_sltu_rd_wdata.eq(insn_sltu.spec_rd_wdata) + m.d.comb += spec_insn_sltu_pc_wdata.eq(insn_sltu.spec_pc_wdata) + m.d.comb += spec_insn_sltu_mem_addr.eq(insn_sltu.spec_mem_addr) + m.d.comb += spec_insn_sltu_mem_rmask.eq(insn_sltu.spec_mem_rmask) + m.d.comb += spec_insn_sltu_mem_wmask.eq(insn_sltu.spec_mem_wmask) + m.d.comb += spec_insn_sltu_mem_wdata.eq(insn_sltu.spec_mem_wdata) + + spec_insn_xor_valid = Signal(1) + spec_insn_xor_trap = Signal(1) + spec_insn_xor_rs1_addr = Signal(5) + spec_insn_xor_rs2_addr = Signal(5) + spec_insn_xor_rd_addr = Signal(5) + spec_insn_xor_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_xor_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_xor_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_xor_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_xor_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_xor_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_xor = insn_xor = rvfi_insn_xor() + m.d.comb += insn_xor.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_xor.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_xor.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_xor.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_xor.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_xor.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_xor_valid.eq(insn_xor.spec_valid) + m.d.comb += spec_insn_xor_trap.eq(insn_xor.spec_trap) + m.d.comb += spec_insn_xor_rs1_addr.eq(insn_xor.spec_rs1_addr) + m.d.comb += spec_insn_xor_rs2_addr.eq(insn_xor.spec_rs2_addr) + m.d.comb += spec_insn_xor_rd_addr.eq(insn_xor.spec_rd_addr) + m.d.comb += spec_insn_xor_rd_wdata.eq(insn_xor.spec_rd_wdata) + m.d.comb += spec_insn_xor_pc_wdata.eq(insn_xor.spec_pc_wdata) + m.d.comb += spec_insn_xor_mem_addr.eq(insn_xor.spec_mem_addr) + m.d.comb += spec_insn_xor_mem_rmask.eq(insn_xor.spec_mem_rmask) + m.d.comb += spec_insn_xor_mem_wmask.eq(insn_xor.spec_mem_wmask) + m.d.comb += spec_insn_xor_mem_wdata.eq(insn_xor.spec_mem_wdata) + + spec_insn_srl_valid = Signal(1) + spec_insn_srl_trap = Signal(1) + spec_insn_srl_rs1_addr = Signal(5) + spec_insn_srl_rs2_addr = Signal(5) + spec_insn_srl_rd_addr = Signal(5) + spec_insn_srl_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srl_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srl_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_srl_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_srl_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_srl_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_srl = insn_srl = rvfi_insn_srl() + m.d.comb += insn_srl.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_srl.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_srl.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_srl.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_srl.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_srl.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_srl_valid.eq(insn_srl.spec_valid) + m.d.comb += spec_insn_srl_trap.eq(insn_srl.spec_trap) + m.d.comb += spec_insn_srl_rs1_addr.eq(insn_srl.spec_rs1_addr) + m.d.comb += spec_insn_srl_rs2_addr.eq(insn_srl.spec_rs2_addr) + m.d.comb += spec_insn_srl_rd_addr.eq(insn_srl.spec_rd_addr) + m.d.comb += spec_insn_srl_rd_wdata.eq(insn_srl.spec_rd_wdata) + m.d.comb += spec_insn_srl_pc_wdata.eq(insn_srl.spec_pc_wdata) + m.d.comb += spec_insn_srl_mem_addr.eq(insn_srl.spec_mem_addr) + m.d.comb += spec_insn_srl_mem_rmask.eq(insn_srl.spec_mem_rmask) + m.d.comb += spec_insn_srl_mem_wmask.eq(insn_srl.spec_mem_wmask) + m.d.comb += spec_insn_srl_mem_wdata.eq(insn_srl.spec_mem_wdata) + + spec_insn_sra_valid = Signal(1) + spec_insn_sra_trap = Signal(1) + spec_insn_sra_rs1_addr = Signal(5) + spec_insn_sra_rs2_addr = Signal(5) + spec_insn_sra_rd_addr = Signal(5) + spec_insn_sra_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sra_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sra_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_sra_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sra_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_sra_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_sra = insn_sra = rvfi_insn_sra() + m.d.comb += insn_sra.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_sra.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_sra.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_sra.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_sra.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_sra.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_sra_valid.eq(insn_sra.spec_valid) + m.d.comb += spec_insn_sra_trap.eq(insn_sra.spec_trap) + m.d.comb += spec_insn_sra_rs1_addr.eq(insn_sra.spec_rs1_addr) + m.d.comb += spec_insn_sra_rs2_addr.eq(insn_sra.spec_rs2_addr) + m.d.comb += spec_insn_sra_rd_addr.eq(insn_sra.spec_rd_addr) + m.d.comb += spec_insn_sra_rd_wdata.eq(insn_sra.spec_rd_wdata) + m.d.comb += spec_insn_sra_pc_wdata.eq(insn_sra.spec_pc_wdata) + m.d.comb += spec_insn_sra_mem_addr.eq(insn_sra.spec_mem_addr) + m.d.comb += spec_insn_sra_mem_rmask.eq(insn_sra.spec_mem_rmask) + m.d.comb += spec_insn_sra_mem_wmask.eq(insn_sra.spec_mem_wmask) + m.d.comb += spec_insn_sra_mem_wdata.eq(insn_sra.spec_mem_wdata) + + spec_insn_or_valid = Signal(1) + spec_insn_or_trap = Signal(1) + spec_insn_or_rs1_addr = Signal(5) + spec_insn_or_rs2_addr = Signal(5) + spec_insn_or_rd_addr = Signal(5) + spec_insn_or_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_or_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_or_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_or_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_or_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_or_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_or = insn_or = rvfi_insn_or() + m.d.comb += insn_or.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_or.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_or.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_or.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_or.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_or.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_or_valid.eq(insn_or.spec_valid) + m.d.comb += spec_insn_or_trap.eq(insn_or.spec_trap) + m.d.comb += spec_insn_or_rs1_addr.eq(insn_or.spec_rs1_addr) + m.d.comb += spec_insn_or_rs2_addr.eq(insn_or.spec_rs2_addr) + m.d.comb += spec_insn_or_rd_addr.eq(insn_or.spec_rd_addr) + m.d.comb += spec_insn_or_rd_wdata.eq(insn_or.spec_rd_wdata) + m.d.comb += spec_insn_or_pc_wdata.eq(insn_or.spec_pc_wdata) + m.d.comb += spec_insn_or_mem_addr.eq(insn_or.spec_mem_addr) + m.d.comb += spec_insn_or_mem_rmask.eq(insn_or.spec_mem_rmask) + m.d.comb += spec_insn_or_mem_wmask.eq(insn_or.spec_mem_wmask) + m.d.comb += spec_insn_or_mem_wdata.eq(insn_or.spec_mem_wdata) + + spec_insn_and_valid = Signal(1) + spec_insn_and_trap = Signal(1) + spec_insn_and_rs1_addr = Signal(5) + spec_insn_and_rs2_addr = Signal(5) + spec_insn_and_rd_addr = Signal(5) + spec_insn_and_rd_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_and_pc_wdata = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_and_mem_addr = Signal(self.RISCV_FORMAL_XLEN) + spec_insn_and_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_and_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8)) + spec_insn_and_mem_wdata = Signal(self.RISCV_FORMAL_XLEN) + m.submodules.insn_and = insn_and = rvfi_insn_and() + m.d.comb += insn_and.rvfi_valid.eq(self.rvfi_valid) + m.d.comb += insn_and.rvfi_insn.eq(self.rvfi_insn) + m.d.comb += insn_and.rvfi_pc_rdata.eq(self.rvfi_pc_rdata) + m.d.comb += insn_and.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata) + m.d.comb += insn_and.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata) + m.d.comb += insn_and.rvfi_mem_rdata.eq(self.rvfi_mem_rdata) + m.d.comb += spec_insn_and_valid.eq(insn_and.spec_valid) + m.d.comb += spec_insn_and_trap.eq(insn_and.spec_trap) + m.d.comb += spec_insn_and_rs1_addr.eq(insn_and.spec_rs1_addr) + m.d.comb += spec_insn_and_rs2_addr.eq(insn_and.spec_rs2_addr) + m.d.comb += spec_insn_and_rd_addr.eq(insn_and.spec_rd_addr) + m.d.comb += spec_insn_and_rd_wdata.eq(insn_and.spec_rd_wdata) + m.d.comb += spec_insn_and_pc_wdata.eq(insn_and.spec_pc_wdata) + m.d.comb += spec_insn_and_mem_addr.eq(insn_and.spec_mem_addr) + m.d.comb += spec_insn_and_mem_rmask.eq(insn_and.spec_mem_rmask) + m.d.comb += spec_insn_and_mem_wmask.eq(insn_and.spec_mem_wmask) + m.d.comb += spec_insn_and_mem_wdata.eq(insn_and.spec_mem_wdata) + + m.d.comb += self.spec_valid.eq(Mux(spec_insn_and_valid, spec_insn_and_valid, Mux(spec_insn_or_valid, spec_insn_or_valid, Mux(spec_insn_sra_valid, spec_insn_sra_valid, Mux(spec_insn_srl_valid, spec_insn_srl_valid, Mux(spec_insn_xor_valid, spec_insn_xor_valid, Mux(spec_insn_sltu_valid, spec_insn_sltu_valid, Mux(spec_insn_slt_valid, spec_insn_slt_valid, Mux(spec_insn_sll_valid, spec_insn_sll_valid, Mux(spec_insn_sub_valid, spec_insn_sub_valid, Mux(spec_insn_add_valid, spec_insn_add_valid, Mux(spec_insn_srai_valid, spec_insn_srai_valid, Mux(spec_insn_srli_valid, spec_insn_srli_valid, Mux(spec_insn_slli_valid, spec_insn_slli_valid, Mux(spec_insn_andi_valid, spec_insn_andi_valid, Mux(spec_insn_ori_valid, spec_insn_ori_valid, Mux(spec_insn_xori_valid, spec_insn_xori_valid, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_valid, Mux(spec_insn_slti_valid, spec_insn_slti_valid, Mux(spec_insn_addi_valid, spec_insn_addi_valid, Mux(spec_insn_sw_valid, spec_insn_sw_valid, Mux(spec_insn_sh_valid, spec_insn_sh_valid, Mux(spec_insn_sb_valid, spec_insn_sb_valid, Mux(spec_insn_lhu_valid, spec_insn_lhu_valid, Mux(spec_insn_lbu_valid, spec_insn_lbu_valid, Mux(spec_insn_lw_valid, spec_insn_lw_valid, Mux(spec_insn_lh_valid, spec_insn_lh_valid, Mux(spec_insn_lb_valid, spec_insn_lb_valid, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_valid, Mux(spec_insn_bltu_valid, spec_insn_bltu_valid, Mux(spec_insn_bge_valid, spec_insn_bge_valid, Mux(spec_insn_blt_valid, spec_insn_blt_valid, Mux(spec_insn_bne_valid, spec_insn_bne_valid, Mux(spec_insn_beq_valid, spec_insn_beq_valid, Mux(spec_insn_jalr_valid, spec_insn_jalr_valid, Mux(spec_insn_jal_valid, spec_insn_jal_valid, Mux(spec_insn_auipc_valid, spec_insn_auipc_valid, Mux(spec_insn_lui_valid, spec_insn_lui_valid, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_trap.eq(Mux(spec_insn_and_valid, spec_insn_and_trap, Mux(spec_insn_or_valid, spec_insn_or_trap, Mux(spec_insn_sra_valid, spec_insn_sra_trap, Mux(spec_insn_srl_valid, spec_insn_srl_trap, Mux(spec_insn_xor_valid, spec_insn_xor_trap, Mux(spec_insn_sltu_valid, spec_insn_sltu_trap, Mux(spec_insn_slt_valid, spec_insn_slt_trap, Mux(spec_insn_sll_valid, spec_insn_sll_trap, Mux(spec_insn_sub_valid, spec_insn_sub_trap, Mux(spec_insn_add_valid, spec_insn_add_trap, Mux(spec_insn_srai_valid, spec_insn_srai_trap, Mux(spec_insn_srli_valid, spec_insn_srli_trap, Mux(spec_insn_slli_valid, spec_insn_slli_trap, Mux(spec_insn_andi_valid, spec_insn_andi_trap, Mux(spec_insn_ori_valid, spec_insn_ori_trap, Mux(spec_insn_xori_valid, spec_insn_xori_trap, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_trap, Mux(spec_insn_slti_valid, spec_insn_slti_trap, Mux(spec_insn_addi_valid, spec_insn_addi_trap, Mux(spec_insn_sw_valid, spec_insn_sw_trap, Mux(spec_insn_sh_valid, spec_insn_sh_trap, Mux(spec_insn_sb_valid, spec_insn_sb_trap, Mux(spec_insn_lhu_valid, spec_insn_lhu_trap, Mux(spec_insn_lbu_valid, spec_insn_lbu_trap, Mux(spec_insn_lw_valid, spec_insn_lw_trap, Mux(spec_insn_lh_valid, spec_insn_lh_trap, Mux(spec_insn_lb_valid, spec_insn_lb_trap, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_trap, Mux(spec_insn_bltu_valid, spec_insn_bltu_trap, Mux(spec_insn_bge_valid, spec_insn_bge_trap, Mux(spec_insn_blt_valid, spec_insn_blt_trap, Mux(spec_insn_bne_valid, spec_insn_bne_trap, Mux(spec_insn_beq_valid, spec_insn_beq_trap, Mux(spec_insn_jalr_valid, spec_insn_jalr_trap, Mux(spec_insn_jal_valid, spec_insn_jal_trap, Mux(spec_insn_auipc_valid, spec_insn_auipc_trap, Mux(spec_insn_lui_valid, spec_insn_lui_trap, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_rs1_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_rs1_addr, Mux(spec_insn_or_valid, spec_insn_or_rs1_addr, Mux(spec_insn_sra_valid, spec_insn_sra_rs1_addr, Mux(spec_insn_srl_valid, spec_insn_srl_rs1_addr, Mux(spec_insn_xor_valid, spec_insn_xor_rs1_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_rs1_addr, Mux(spec_insn_slt_valid, spec_insn_slt_rs1_addr, Mux(spec_insn_sll_valid, spec_insn_sll_rs1_addr, Mux(spec_insn_sub_valid, spec_insn_sub_rs1_addr, Mux(spec_insn_add_valid, spec_insn_add_rs1_addr, Mux(spec_insn_srai_valid, spec_insn_srai_rs1_addr, Mux(spec_insn_srli_valid, spec_insn_srli_rs1_addr, Mux(spec_insn_slli_valid, spec_insn_slli_rs1_addr, Mux(spec_insn_andi_valid, spec_insn_andi_rs1_addr, Mux(spec_insn_ori_valid, spec_insn_ori_rs1_addr, Mux(spec_insn_xori_valid, spec_insn_xori_rs1_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rs1_addr, Mux(spec_insn_slti_valid, spec_insn_slti_rs1_addr, Mux(spec_insn_addi_valid, spec_insn_addi_rs1_addr, Mux(spec_insn_sw_valid, spec_insn_sw_rs1_addr, Mux(spec_insn_sh_valid, spec_insn_sh_rs1_addr, Mux(spec_insn_sb_valid, spec_insn_sb_rs1_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_rs1_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_rs1_addr, Mux(spec_insn_lw_valid, spec_insn_lw_rs1_addr, Mux(spec_insn_lh_valid, spec_insn_lh_rs1_addr, Mux(spec_insn_lb_valid, spec_insn_lb_rs1_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rs1_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_rs1_addr, Mux(spec_insn_bge_valid, spec_insn_bge_rs1_addr, Mux(spec_insn_blt_valid, spec_insn_blt_rs1_addr, Mux(spec_insn_bne_valid, spec_insn_bne_rs1_addr, Mux(spec_insn_beq_valid, spec_insn_beq_rs1_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_rs1_addr, Mux(spec_insn_jal_valid, spec_insn_jal_rs1_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_rs1_addr, Mux(spec_insn_lui_valid, spec_insn_lui_rs1_addr, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_rs2_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_rs2_addr, Mux(spec_insn_or_valid, spec_insn_or_rs2_addr, Mux(spec_insn_sra_valid, spec_insn_sra_rs2_addr, Mux(spec_insn_srl_valid, spec_insn_srl_rs2_addr, Mux(spec_insn_xor_valid, spec_insn_xor_rs2_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_rs2_addr, Mux(spec_insn_slt_valid, spec_insn_slt_rs2_addr, Mux(spec_insn_sll_valid, spec_insn_sll_rs2_addr, Mux(spec_insn_sub_valid, spec_insn_sub_rs2_addr, Mux(spec_insn_add_valid, spec_insn_add_rs2_addr, Mux(spec_insn_srai_valid, spec_insn_srai_rs2_addr, Mux(spec_insn_srli_valid, spec_insn_srli_rs2_addr, Mux(spec_insn_slli_valid, spec_insn_slli_rs2_addr, Mux(spec_insn_andi_valid, spec_insn_andi_rs2_addr, Mux(spec_insn_ori_valid, spec_insn_ori_rs2_addr, Mux(spec_insn_xori_valid, spec_insn_xori_rs2_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rs2_addr, Mux(spec_insn_slti_valid, spec_insn_slti_rs2_addr, Mux(spec_insn_addi_valid, spec_insn_addi_rs2_addr, Mux(spec_insn_sw_valid, spec_insn_sw_rs2_addr, Mux(spec_insn_sh_valid, spec_insn_sh_rs2_addr, Mux(spec_insn_sb_valid, spec_insn_sb_rs2_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_rs2_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_rs2_addr, Mux(spec_insn_lw_valid, spec_insn_lw_rs2_addr, Mux(spec_insn_lh_valid, spec_insn_lh_rs2_addr, Mux(spec_insn_lb_valid, spec_insn_lb_rs2_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rs2_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_rs2_addr, Mux(spec_insn_bge_valid, spec_insn_bge_rs2_addr, Mux(spec_insn_blt_valid, spec_insn_blt_rs2_addr, Mux(spec_insn_bne_valid, spec_insn_bne_rs2_addr, Mux(spec_insn_beq_valid, spec_insn_beq_rs2_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_rs2_addr, Mux(spec_insn_jal_valid, spec_insn_jal_rs2_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_rs2_addr, Mux(spec_insn_lui_valid, spec_insn_lui_rs2_addr, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_rd_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_rd_addr, Mux(spec_insn_or_valid, spec_insn_or_rd_addr, Mux(spec_insn_sra_valid, spec_insn_sra_rd_addr, Mux(spec_insn_srl_valid, spec_insn_srl_rd_addr, Mux(spec_insn_xor_valid, spec_insn_xor_rd_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_rd_addr, Mux(spec_insn_slt_valid, spec_insn_slt_rd_addr, Mux(spec_insn_sll_valid, spec_insn_sll_rd_addr, Mux(spec_insn_sub_valid, spec_insn_sub_rd_addr, Mux(spec_insn_add_valid, spec_insn_add_rd_addr, Mux(spec_insn_srai_valid, spec_insn_srai_rd_addr, Mux(spec_insn_srli_valid, spec_insn_srli_rd_addr, Mux(spec_insn_slli_valid, spec_insn_slli_rd_addr, Mux(spec_insn_andi_valid, spec_insn_andi_rd_addr, Mux(spec_insn_ori_valid, spec_insn_ori_rd_addr, Mux(spec_insn_xori_valid, spec_insn_xori_rd_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rd_addr, Mux(spec_insn_slti_valid, spec_insn_slti_rd_addr, Mux(spec_insn_addi_valid, spec_insn_addi_rd_addr, Mux(spec_insn_sw_valid, spec_insn_sw_rd_addr, Mux(spec_insn_sh_valid, spec_insn_sh_rd_addr, Mux(spec_insn_sb_valid, spec_insn_sb_rd_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_rd_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_rd_addr, Mux(spec_insn_lw_valid, spec_insn_lw_rd_addr, Mux(spec_insn_lh_valid, spec_insn_lh_rd_addr, Mux(spec_insn_lb_valid, spec_insn_lb_rd_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rd_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_rd_addr, Mux(spec_insn_bge_valid, spec_insn_bge_rd_addr, Mux(spec_insn_blt_valid, spec_insn_blt_rd_addr, Mux(spec_insn_bne_valid, spec_insn_bne_rd_addr, Mux(spec_insn_beq_valid, spec_insn_beq_rd_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_rd_addr, Mux(spec_insn_jal_valid, spec_insn_jal_rd_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_rd_addr, Mux(spec_insn_lui_valid, spec_insn_lui_rd_addr, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_rd_wdata.eq(Mux(spec_insn_and_valid, spec_insn_and_rd_wdata, Mux(spec_insn_or_valid, spec_insn_or_rd_wdata, Mux(spec_insn_sra_valid, spec_insn_sra_rd_wdata, Mux(spec_insn_srl_valid, spec_insn_srl_rd_wdata, Mux(spec_insn_xor_valid, spec_insn_xor_rd_wdata, Mux(spec_insn_sltu_valid, spec_insn_sltu_rd_wdata, Mux(spec_insn_slt_valid, spec_insn_slt_rd_wdata, Mux(spec_insn_sll_valid, spec_insn_sll_rd_wdata, Mux(spec_insn_sub_valid, spec_insn_sub_rd_wdata, Mux(spec_insn_add_valid, spec_insn_add_rd_wdata, Mux(spec_insn_srai_valid, spec_insn_srai_rd_wdata, Mux(spec_insn_srli_valid, spec_insn_srli_rd_wdata, Mux(spec_insn_slli_valid, spec_insn_slli_rd_wdata, Mux(spec_insn_andi_valid, spec_insn_andi_rd_wdata, Mux(spec_insn_ori_valid, spec_insn_ori_rd_wdata, Mux(spec_insn_xori_valid, spec_insn_xori_rd_wdata, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rd_wdata, Mux(spec_insn_slti_valid, spec_insn_slti_rd_wdata, Mux(spec_insn_addi_valid, spec_insn_addi_rd_wdata, Mux(spec_insn_sw_valid, spec_insn_sw_rd_wdata, Mux(spec_insn_sh_valid, spec_insn_sh_rd_wdata, Mux(spec_insn_sb_valid, spec_insn_sb_rd_wdata, Mux(spec_insn_lhu_valid, spec_insn_lhu_rd_wdata, Mux(spec_insn_lbu_valid, spec_insn_lbu_rd_wdata, Mux(spec_insn_lw_valid, spec_insn_lw_rd_wdata, Mux(spec_insn_lh_valid, spec_insn_lh_rd_wdata, Mux(spec_insn_lb_valid, spec_insn_lb_rd_wdata, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rd_wdata, Mux(spec_insn_bltu_valid, spec_insn_bltu_rd_wdata, Mux(spec_insn_bge_valid, spec_insn_bge_rd_wdata, Mux(spec_insn_blt_valid, spec_insn_blt_rd_wdata, Mux(spec_insn_bne_valid, spec_insn_bne_rd_wdata, Mux(spec_insn_beq_valid, spec_insn_beq_rd_wdata, Mux(spec_insn_jalr_valid, spec_insn_jalr_rd_wdata, Mux(spec_insn_jal_valid, spec_insn_jal_rd_wdata, Mux(spec_insn_auipc_valid, spec_insn_auipc_rd_wdata, Mux(spec_insn_lui_valid, spec_insn_lui_rd_wdata, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_pc_wdata.eq(Mux(spec_insn_and_valid, spec_insn_and_pc_wdata, Mux(spec_insn_or_valid, spec_insn_or_pc_wdata, Mux(spec_insn_sra_valid, spec_insn_sra_pc_wdata, Mux(spec_insn_srl_valid, spec_insn_srl_pc_wdata, Mux(spec_insn_xor_valid, spec_insn_xor_pc_wdata, Mux(spec_insn_sltu_valid, spec_insn_sltu_pc_wdata, Mux(spec_insn_slt_valid, spec_insn_slt_pc_wdata, Mux(spec_insn_sll_valid, spec_insn_sll_pc_wdata, Mux(spec_insn_sub_valid, spec_insn_sub_pc_wdata, Mux(spec_insn_add_valid, spec_insn_add_pc_wdata, Mux(spec_insn_srai_valid, spec_insn_srai_pc_wdata, Mux(spec_insn_srli_valid, spec_insn_srli_pc_wdata, Mux(spec_insn_slli_valid, spec_insn_slli_pc_wdata, Mux(spec_insn_andi_valid, spec_insn_andi_pc_wdata, Mux(spec_insn_ori_valid, spec_insn_ori_pc_wdata, Mux(spec_insn_xori_valid, spec_insn_xori_pc_wdata, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_pc_wdata, Mux(spec_insn_slti_valid, spec_insn_slti_pc_wdata, Mux(spec_insn_addi_valid, spec_insn_addi_pc_wdata, Mux(spec_insn_sw_valid, spec_insn_sw_pc_wdata, Mux(spec_insn_sh_valid, spec_insn_sh_pc_wdata, Mux(spec_insn_sb_valid, spec_insn_sb_pc_wdata, Mux(spec_insn_lhu_valid, spec_insn_lhu_pc_wdata, Mux(spec_insn_lbu_valid, spec_insn_lbu_pc_wdata, Mux(spec_insn_lw_valid, spec_insn_lw_pc_wdata, Mux(spec_insn_lh_valid, spec_insn_lh_pc_wdata, Mux(spec_insn_lb_valid, spec_insn_lb_pc_wdata, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_pc_wdata, Mux(spec_insn_bltu_valid, spec_insn_bltu_pc_wdata, Mux(spec_insn_bge_valid, spec_insn_bge_pc_wdata, Mux(spec_insn_blt_valid, spec_insn_blt_pc_wdata, Mux(spec_insn_bne_valid, spec_insn_bne_pc_wdata, Mux(spec_insn_beq_valid, spec_insn_beq_pc_wdata, Mux(spec_insn_jalr_valid, spec_insn_jalr_pc_wdata, Mux(spec_insn_jal_valid, spec_insn_jal_pc_wdata, Mux(spec_insn_auipc_valid, spec_insn_auipc_pc_wdata, Mux(spec_insn_lui_valid, spec_insn_lui_pc_wdata, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_mem_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_addr, Mux(spec_insn_or_valid, spec_insn_or_mem_addr, Mux(spec_insn_sra_valid, spec_insn_sra_mem_addr, Mux(spec_insn_srl_valid, spec_insn_srl_mem_addr, Mux(spec_insn_xor_valid, spec_insn_xor_mem_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_addr, Mux(spec_insn_slt_valid, spec_insn_slt_mem_addr, Mux(spec_insn_sll_valid, spec_insn_sll_mem_addr, Mux(spec_insn_sub_valid, spec_insn_sub_mem_addr, Mux(spec_insn_add_valid, spec_insn_add_mem_addr, Mux(spec_insn_srai_valid, spec_insn_srai_mem_addr, Mux(spec_insn_srli_valid, spec_insn_srli_mem_addr, Mux(spec_insn_slli_valid, spec_insn_slli_mem_addr, Mux(spec_insn_andi_valid, spec_insn_andi_mem_addr, Mux(spec_insn_ori_valid, spec_insn_ori_mem_addr, Mux(spec_insn_xori_valid, spec_insn_xori_mem_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_addr, Mux(spec_insn_slti_valid, spec_insn_slti_mem_addr, Mux(spec_insn_addi_valid, spec_insn_addi_mem_addr, Mux(spec_insn_sw_valid, spec_insn_sw_mem_addr, Mux(spec_insn_sh_valid, spec_insn_sh_mem_addr, Mux(spec_insn_sb_valid, spec_insn_sb_mem_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_addr, Mux(spec_insn_lw_valid, spec_insn_lw_mem_addr, Mux(spec_insn_lh_valid, spec_insn_lh_mem_addr, Mux(spec_insn_lb_valid, spec_insn_lb_mem_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_addr, Mux(spec_insn_bge_valid, spec_insn_bge_mem_addr, Mux(spec_insn_blt_valid, spec_insn_blt_mem_addr, Mux(spec_insn_bne_valid, spec_insn_bne_mem_addr, Mux(spec_insn_beq_valid, spec_insn_beq_mem_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_addr, Mux(spec_insn_jal_valid, spec_insn_jal_mem_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_addr, Mux(spec_insn_lui_valid, spec_insn_lui_mem_addr, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_mem_rmask.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_rmask, Mux(spec_insn_or_valid, spec_insn_or_mem_rmask, Mux(spec_insn_sra_valid, spec_insn_sra_mem_rmask, Mux(spec_insn_srl_valid, spec_insn_srl_mem_rmask, Mux(spec_insn_xor_valid, spec_insn_xor_mem_rmask, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_rmask, Mux(spec_insn_slt_valid, spec_insn_slt_mem_rmask, Mux(spec_insn_sll_valid, spec_insn_sll_mem_rmask, Mux(spec_insn_sub_valid, spec_insn_sub_mem_rmask, Mux(spec_insn_add_valid, spec_insn_add_mem_rmask, Mux(spec_insn_srai_valid, spec_insn_srai_mem_rmask, Mux(spec_insn_srli_valid, spec_insn_srli_mem_rmask, Mux(spec_insn_slli_valid, spec_insn_slli_mem_rmask, Mux(spec_insn_andi_valid, spec_insn_andi_mem_rmask, Mux(spec_insn_ori_valid, spec_insn_ori_mem_rmask, Mux(spec_insn_xori_valid, spec_insn_xori_mem_rmask, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_rmask, Mux(spec_insn_slti_valid, spec_insn_slti_mem_rmask, Mux(spec_insn_addi_valid, spec_insn_addi_mem_rmask, Mux(spec_insn_sw_valid, spec_insn_sw_mem_rmask, Mux(spec_insn_sh_valid, spec_insn_sh_mem_rmask, Mux(spec_insn_sb_valid, spec_insn_sb_mem_rmask, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_rmask, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_rmask, Mux(spec_insn_lw_valid, spec_insn_lw_mem_rmask, Mux(spec_insn_lh_valid, spec_insn_lh_mem_rmask, Mux(spec_insn_lb_valid, spec_insn_lb_mem_rmask, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_rmask, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_rmask, Mux(spec_insn_bge_valid, spec_insn_bge_mem_rmask, Mux(spec_insn_blt_valid, spec_insn_blt_mem_rmask, Mux(spec_insn_bne_valid, spec_insn_bne_mem_rmask, Mux(spec_insn_beq_valid, spec_insn_beq_mem_rmask, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_rmask, Mux(spec_insn_jal_valid, spec_insn_jal_mem_rmask, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_rmask, Mux(spec_insn_lui_valid, spec_insn_lui_mem_rmask, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_mem_wmask.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_wmask, Mux(spec_insn_or_valid, spec_insn_or_mem_wmask, Mux(spec_insn_sra_valid, spec_insn_sra_mem_wmask, Mux(spec_insn_srl_valid, spec_insn_srl_mem_wmask, Mux(spec_insn_xor_valid, spec_insn_xor_mem_wmask, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_wmask, Mux(spec_insn_slt_valid, spec_insn_slt_mem_wmask, Mux(spec_insn_sll_valid, spec_insn_sll_mem_wmask, Mux(spec_insn_sub_valid, spec_insn_sub_mem_wmask, Mux(spec_insn_add_valid, spec_insn_add_mem_wmask, Mux(spec_insn_srai_valid, spec_insn_srai_mem_wmask, Mux(spec_insn_srli_valid, spec_insn_srli_mem_wmask, Mux(spec_insn_slli_valid, spec_insn_slli_mem_wmask, Mux(spec_insn_andi_valid, spec_insn_andi_mem_wmask, Mux(spec_insn_ori_valid, spec_insn_ori_mem_wmask, Mux(spec_insn_xori_valid, spec_insn_xori_mem_wmask, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_wmask, Mux(spec_insn_slti_valid, spec_insn_slti_mem_wmask, Mux(spec_insn_addi_valid, spec_insn_addi_mem_wmask, Mux(spec_insn_sw_valid, spec_insn_sw_mem_wmask, Mux(spec_insn_sh_valid, spec_insn_sh_mem_wmask, Mux(spec_insn_sb_valid, spec_insn_sb_mem_wmask, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_wmask, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_wmask, Mux(spec_insn_lw_valid, spec_insn_lw_mem_wmask, Mux(spec_insn_lh_valid, spec_insn_lh_mem_wmask, Mux(spec_insn_lb_valid, spec_insn_lb_mem_wmask, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_wmask, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_wmask, Mux(spec_insn_bge_valid, spec_insn_bge_mem_wmask, Mux(spec_insn_blt_valid, spec_insn_blt_mem_wmask, Mux(spec_insn_bne_valid, spec_insn_bne_mem_wmask, Mux(spec_insn_beq_valid, spec_insn_beq_mem_wmask, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_wmask, Mux(spec_insn_jal_valid, spec_insn_jal_mem_wmask, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_wmask, Mux(spec_insn_lui_valid, spec_insn_lui_mem_wmask, 0)))))))))))))))))))))))))))))))))))))) + m.d.comb += self.spec_mem_wdata.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_wdata, Mux(spec_insn_or_valid, spec_insn_or_mem_wdata, Mux(spec_insn_sra_valid, spec_insn_sra_mem_wdata, Mux(spec_insn_srl_valid, spec_insn_srl_mem_wdata, Mux(spec_insn_xor_valid, spec_insn_xor_mem_wdata, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_wdata, Mux(spec_insn_slt_valid, spec_insn_slt_mem_wdata, Mux(spec_insn_sll_valid, spec_insn_sll_mem_wdata, Mux(spec_insn_sub_valid, spec_insn_sub_mem_wdata, Mux(spec_insn_add_valid, spec_insn_add_mem_wdata, Mux(spec_insn_srai_valid, spec_insn_srai_mem_wdata, Mux(spec_insn_srli_valid, spec_insn_srli_mem_wdata, Mux(spec_insn_slli_valid, spec_insn_slli_mem_wdata, Mux(spec_insn_andi_valid, spec_insn_andi_mem_wdata, Mux(spec_insn_ori_valid, spec_insn_ori_mem_wdata, Mux(spec_insn_xori_valid, spec_insn_xori_mem_wdata, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_wdata, Mux(spec_insn_slti_valid, spec_insn_slti_mem_wdata, Mux(spec_insn_addi_valid, spec_insn_addi_mem_wdata, Mux(spec_insn_sw_valid, spec_insn_sw_mem_wdata, Mux(spec_insn_sh_valid, spec_insn_sh_mem_wdata, Mux(spec_insn_sb_valid, spec_insn_sb_mem_wdata, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_wdata, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_wdata, Mux(spec_insn_lw_valid, spec_insn_lw_mem_wdata, Mux(spec_insn_lh_valid, spec_insn_lh_mem_wdata, Mux(spec_insn_lb_valid, spec_insn_lb_mem_wdata, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_wdata, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_wdata, Mux(spec_insn_bge_valid, spec_insn_bge_mem_wdata, Mux(spec_insn_blt_valid, spec_insn_blt_mem_wdata, Mux(spec_insn_bne_valid, spec_insn_bne_mem_wdata, Mux(spec_insn_beq_valid, spec_insn_beq_mem_wdata, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_wdata, Mux(spec_insn_jal_valid, spec_insn_jal_mem_wdata, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_wdata, Mux(spec_insn_lui_valid, spec_insn_lui_mem_wdata, 0)))))))))))))))))))))))))))))))))))))) return m - -test = rvfi_isa_rv32i() -test.ports() -test.elaborate(platform=None) diff --git a/insns/isa_rv32i_gen.py b/insns/isa_rv32i_gen.py index 9fa130c..8c692b1 100644 --- a/insns/isa_rv32i_gen.py +++ b/insns/isa_rv32i_gen.py @@ -3,6 +3,10 @@ with open('isa_rv32i.py', 'w') as isa_rv32i: print(strng, file=isa_rv32i) fprint("# Generated by isa_rv32i_gen.py") fprint("from nmigen import *") + with open('isa_rv32i.txt', 'r') as isa_rv32i_txt_file: + isa_rv32i_insns = isa_rv32i_txt_file.read().split('\n')[:-1] + for isa_rv32i_insn in isa_rv32i_insns: + fprint("from insn_%s import *" % isa_rv32i_insn) fprint("") fprint("class rvfi_isa_rv32i(Elaboratable):") fprint(" def __init__(self, RISCV_FORMAL_ILEN=32, RISCV_FORMAL_XLEN=32):") @@ -52,12 +56,52 @@ with open('isa_rv32i.py', 'w') as isa_rv32i: fprint(" def elaborate(self, platform):") fprint(" m = Module()") fprint("") - # TODO + for isa_rv32i_insn in isa_rv32i_insns: + fprint(" spec_insn_%s_valid = Signal(1)" % isa_rv32i_insn) + fprint(" spec_insn_%s_trap = Signal(1)" % isa_rv32i_insn) + fprint(" spec_insn_%s_rs1_addr = Signal(5)" % isa_rv32i_insn) + fprint(" spec_insn_%s_rs2_addr = Signal(5)" % isa_rv32i_insn) + fprint(" spec_insn_%s_rd_addr = Signal(5)" % isa_rv32i_insn) + fprint(" spec_insn_%s_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)" % isa_rv32i_insn) + fprint(" spec_insn_%s_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)" % isa_rv32i_insn) + fprint(" spec_insn_%s_mem_addr = Signal(self.RISCV_FORMAL_XLEN)" % isa_rv32i_insn) + fprint(" spec_insn_%s_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))" % isa_rv32i_insn) + fprint(" spec_insn_%s_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))" % isa_rv32i_insn) + fprint(" spec_insn_%s_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)" % isa_rv32i_insn) + fprint(" m.submodules.insn_%s = insn_%s = rvfi_insn_%s()" % (isa_rv32i_insn, isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += insn_%s.rvfi_valid.eq(self.rvfi_valid)" % isa_rv32i_insn) + fprint(" m.d.comb += insn_%s.rvfi_insn.eq(self.rvfi_insn)" % isa_rv32i_insn) + fprint(" m.d.comb += insn_%s.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)" % isa_rv32i_insn) + fprint(" m.d.comb += insn_%s.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)" % isa_rv32i_insn) + fprint(" m.d.comb += insn_%s.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)" % isa_rv32i_insn) + fprint(" m.d.comb += insn_%s.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)" % isa_rv32i_insn) + fprint(" m.d.comb += spec_insn_%s_valid.eq(insn_%s.spec_valid)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_trap.eq(insn_%s.spec_trap)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_rs1_addr.eq(insn_%s.spec_rs1_addr)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_rs2_addr.eq(insn_%s.spec_rs2_addr)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_rd_addr.eq(insn_%s.spec_rd_addr)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_rd_wdata.eq(insn_%s.spec_rd_wdata)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_pc_wdata.eq(insn_%s.spec_pc_wdata)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_mem_addr.eq(insn_%s.spec_mem_addr)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_mem_rmask.eq(insn_%s.spec_mem_rmask)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_mem_wmask.eq(insn_%s.spec_mem_wmask)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint(" m.d.comb += spec_insn_%s_mem_wdata.eq(insn_%s.spec_mem_wdata)" % (isa_rv32i_insn, isa_rv32i_insn)) + fprint("") + def gen_spec(strng): + result = "0" + for isa_rv32i_insn in isa_rv32i_insns: + result = "Mux(spec_insn_%s_valid, spec_insn_%s_%s, %s)" % (isa_rv32i_insn, isa_rv32i_insn, strng, result) + fprint(" m.d.comb += self.spec_%s.eq(%s)" % (strng, result)) + gen_spec("valid") + gen_spec("trap") + gen_spec("rs1_addr") + gen_spec("rs2_addr") + gen_spec("rd_addr") + gen_spec("rd_wdata") + gen_spec("pc_wdata") + gen_spec("mem_addr") + gen_spec("mem_rmask") + gen_spec("mem_wmask") + gen_spec("mem_wdata") fprint("") fprint(" return m") - - # For debugging purposes only - fprint("") - fprint("test = rvfi_isa_rv32i()") - fprint("test.ports()") - fprint("test.elaborate(platform=None)")