3 * Copyright 2018 Jacob Lifshay
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in all
13 * copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 from migen
.fhdl
import verilog
31 from migen
.fhdl
.structure
import _Operator
33 from riscvdefs
import *
36 class MemoryInterface
:
37 fetch_address
= Signal(32, name
="memory_interface_fetch_address") # XXX [2:]
38 fetch_data
= Signal(32, name
="memory_interface_fetch_data")
39 fetch_valid
= Signal(name
="memory_interface_fetch_valid")
40 rw_address
= Signal(32, name
="memory_interface_rw_address") # XXX [2:]
41 rw_byte_mask
= Signal(4, name
="memory_interface_rw_byte_mask")
42 rw_read_not_write
= Signal(name
="memory_interface_rw_read_not_write")
43 rw_active
= Signal(name
="memory_interface_rw_active")
44 rw_data_in
= Signal(32, name
="memory_interface_rw_data_in")
45 rw_data_out
= Signal(32, name
="memory_interface_rw_data_out")
46 rw_address_valid
= Signal(name
="memory_interface_rw_address_valid")
47 rw_wait
= Signal(name
="memory_interface_rw_wait")
51 funct7
= Signal(7, name
="decoder_funct7")
52 funct3
= Signal(3, name
="decoder_funct3")
53 rd
= Signal(5, name
="decoder_rd")
54 rs1
= Signal(5, name
="decoder_rs1")
55 rs2
= Signal(5, name
="decoder_rs2")
56 immediate
= Signal(32, name
="decoder_immediate")
57 opcode
= Signal(7, name
="decoder_opcode")
58 act
= Signal(decode_action
, name
="decoder_action")
61 def __init__(self
, comb
):
63 self
.mpie
= Signal(name
="mstatus_mpie")
64 self
.mie
= Signal(name
="mstatus_mie")
65 self
.mprv
= Signal(name
="mstatus_mprv")
66 self
.tsr
= Signal(name
="mstatus_tsr")
67 self
.tw
= Signal(name
="mstatus_tw")
68 self
.tvm
= Signal(name
="mstatus_tvm")
69 self
.mxr
= Signal(name
="mstatus_mxr")
70 self
._sum
= Signal(name
="mstatus_sum")
71 self
.xs
= Signal(name
="mstatus_xs")
72 self
.fs
= Signal(name
="mstatus_fs")
73 self
.mpp
= Signal(2, name
="mstatus_mpp")
74 self
.spp
= Signal(name
="mstatus_spp")
75 self
.spie
= Signal(name
="mstatus_spie")
76 self
.upie
= Signal(name
="mstatus_upie")
77 self
.sie
= Signal(name
="mstatus_sie")
78 self
.uie
= Signal(name
="mstatus_uie")
81 if n
in ['mpp', 'comb'] or n
.startswith("_"):
83 self
.comb
+= getattr(self
, n
).eq(0x0)
84 self
.comb
+= self
.mpp
.eq(0b11)
91 def get_ls_misaligned(self
, ls
, funct3
, load_store_address_low_2
):
92 return Case(funct3
[:2],
93 { F3
.sb
: ls
.eq(Constant(0)),
94 F3
.sh
: ls
.eq(load_store_address_low_2
[0] != 0),
95 F3
.sw
: ls
.eq(load_store_address_low_2
[0:2] != Constant(0, 2)),
96 "default": ls
.eq(Constant(1))
99 def get_lsbm(self
, dc
):
100 return Cat(Constant(1),
101 Mux((dc
.funct3
[1] | dc
.funct3
[0]),
102 Constant(1), Constant(0)),
104 Constant(0b11, 2), Constant(0, 2)))
107 self
.clk
= ClockSignal()
108 self
.reset
= ResetSignal()
109 self
.tty_write
= Signal()
110 self
.tty_write_data
= Signal(8)
111 self
.tty_write_busy
= Signal()
112 self
.switch_2
= Signal()
113 self
.switch_3
= Signal()
114 self
.led_1
= Signal()
115 self
.led_3
= Signal()
117 ram_size
= Constant(0x8000)
118 ram_start
= Constant(0x10000, 32)
119 reset_vector
= Signal(32)
122 reset_vector
.eq(ram_start
)
123 mtvec
.eq(ram_start
+ 0x40)
127 l
.append(Signal(32, name
="register%d" % i
))
130 mi
= MemoryInterface()
132 mii
= Instance("cpu_memory_interface", name
="memory_instance",
133 p_ram_size
= ram_size
,
134 p_ram_start
= ram_start
,
137 i_fetch_address
= mi
.fetch_address
,
138 o_fetch_data
= mi
.fetch_data
,
139 o_fetch_valid
= mi
.fetch_valid
,
140 i_rw_address
= mi
.rw_address
,
141 i_rw_byte_mask
= mi
.rw_byte_mask
,
142 i_rw_read_not_write
= mi
.rw_read_not_write
,
143 i_rw_active
= mi
.rw_active
,
144 i_rw_data_in
= mi
.rw_data_in
,
145 o_rw_data_out
= mi
.rw_data_out
,
146 o_rw_address_valid
= mi
.rw_address_valid
,
147 o_rw_wait
= mi
.rw_wait
,
148 o_tty_write
= self
.tty_write
,
149 o_tty_write_data
= self
.tty_write_data
,
150 i_tty_write_busy
= self
.tty_write_busy
,
151 i_switch_2
= self
.switch_2
,
152 i_switch_3
= self
.switch_3
,
153 o_led_1
= self
.led_1
,
158 fetch_act
= Signal(fetch_action
)
159 fetch_target_pc
= Signal(32)
160 fetch_output_pc
= Signal(32)
161 fetch_output_instruction
= Signal(32)
162 fetch_output_st
= Signal(fetch_output_state
)
164 fs
= Instance("CPUFetchStage", name
="fetch_stage",
167 o_memory_interface_fetch_address
= mi
.fetch_address
,
168 i_memory_interface_fetch_data
= mi
.fetch_data
,
169 i_memory_interface_fetch_valid
= mi
.fetch_valid
,
170 i_fetch_action
= fetch_act
,
171 i_target_pc
= fetch_target_pc
,
172 o_output_pc
= fetch_output_pc
,
173 o_output_instruction
= fetch_output_instruction
,
174 o_output_state
= fetch_output_st
,
175 i_reset_vector
= reset_vector
,
182 cd
= Instance("CPUDecoder", name
="decoder",
183 i_instruction
= fetch_output_instruction
,
184 o_funct7
= dc
.funct7
,
185 o_funct3
= dc
.funct3
,
189 o_immediate
= dc
.immediate
,
190 o_opcode
= dc
.opcode
,
191 o_decode_action
= dc
.act
195 register_rs1
= Signal(32)
196 register_rs2
= Signal(32)
197 self
.comb
+= If(dc
.rs1
== 0,
200 register_rs1
.eq(registers
[dc
.rs1
-1]))
201 self
.comb
+= If(dc
.rs2
== 0,
204 register_rs2
.eq(registers
[dc
.rs2
-1]))
206 load_store_address
= Signal(32)
207 load_store_address_low_2
= Signal(2)
209 self
.comb
+= load_store_address
.eq(dc
.immediate
+ register_rs1
)
210 self
.comb
+= load_store_address_low_2
.eq(
211 dc
.immediate
[:2] + register_rs1
[:2])
213 load_store_misaligned
= Signal()
215 lsa
= self
.get_ls_misaligned(load_store_misaligned
, dc
.funct3
,
216 load_store_address_low_2
)
219 # XXX rwaddr not 31:2 any more
220 self
.comb
+= mi
.rw_address
.eq(load_store_address
[2:])
222 unshifted_load_store_byte_mask
= Signal(4)
224 self
.comb
+= unshifted_load_store_byte_mask
.eq(self
.get_lsbm(dc
))
226 # XXX yuck. this will cause migen simulation to fail
227 # (however conversion to verilog works)
228 self
.comb
+= mi
.rw_byte_mask
.eq(
229 _Operator("<<", [unshifted_load_store_byte_mask
,
230 load_store_address_low_2
]))
233 b3
= Mux(load_store_address_low_2
[1],
234 Mux(load_store_address_low_2
[0], register_rs2
[0:8],
236 Mux(load_store_address_low_2
[0], register_rs2
[16:24],
237 register_rs2
[24:32]))
238 b2
= Mux(load_store_address_low_2
[1], register_rs2
[0:8],
240 b1
= Mux(load_store_address_low_2
[0], register_rs2
[0:8],
242 b0
= register_rs2
[0:8]
244 self
.comb
+= mi
.rw_data_in
.eq(Cat(b0
, b1
, b2
, b3
))
247 unmasked_loaded_value
= Signal(32)
249 b0
= Mux(load_store_address_low_2
[1],
250 Mux(load_store_address_low_2
[0], mi
.rw_data_out
[24:32],
251 mi
.rw_data_out
[16:24]),
252 Mux(load_store_address_low_2
[0], mi
.rw_data_out
[15:8],
253 mi
.rw_data_out
[0:8]))
254 b1
= Mux(load_store_address_low_2
[1], mi
.rw_data_out
[24:31],
255 mi
.rw_data_out
[8:16])
256 b23
= mi
.rw_data_out
[16:32]
258 self
.comb
+= unmasked_loaded_value
.eq(Cat(b0
, b1
, b23
))
261 loaded_value
= Signal(32)
263 b0
= unmasked_loaded_value
[0:8]
264 b1
= Mux(dc
.funct3
[0:2] == 0,
265 Replicate(~dc
.funct3
[2] & unmasked_loaded_value
[7], 8),
266 unmasked_loaded_value
[8:16])
267 b2
= Mux(dc
.funct3
[1] == 0,
268 Replicate(~dc
.funct3
[2] &
269 Mux(dc
.funct3
[0], unmasked_loaded_value
[15],
270 unmasked_loaded_value
[7]),
272 unmasked_loaded_value
[16:32])
274 self
.comb
+= loaded_value
.eq(Cat(b0
, b1
, b2
))
276 self
.comb
+= mi
.rw_active
.eq(~self
.reset
277 & (fetch_output_st
== fetch_output_state_valid
)
278 & ~load_store_misaligned
279 & ((dc
.act
& (DA
.load | DA
.store
)) != 0))
281 self
.comb
+= mi
.rw_read_not_write
.eq(~dc
.opcode
[5])
286 alu_result
= Signal(32)
288 self
.comb
+= alu_a
.eq(register_rs1
)
289 self
.comb
+= alu_b
.eq(Mux(dc
.opcode
[5],
293 ali
= Instance("cpu_alu", name
="alu",
294 i_funct7
= dc
.funct7
,
295 i_funct3
= dc
.funct3
,
296 i_opcode
= dc
.opcode
,
299 o_result
= alu_result
303 lui_auipc_result
= Signal(32)
304 self
.comb
+= lui_auipc_result
.eq(Mux(dc
.opcode
[5],
306 dc
.immediate
+ fetch_output_pc
))
308 self
.comb
+= fetch_target_pc
.eq(Cat(0,
309 Mux(dc
.opcode
!= OP
.jalr
,
310 fetch_output_pc
[1:32],
311 register_rs1
[1:32] + dc
.immediate
[1:32])))
313 misaligned_jump_target
= Signal()
314 self
.comb
+= misaligned_jump_target
.eq(fetch_target_pc
[1])
316 branch_arg_a
= Signal(32)
317 branch_arg_b
= Signal(32)
318 self
.comb
+= branch_arg_a
.eq(Cat( register_rs1
[0:31],
319 register_rs1
[31] ^ ~dc
.funct3
[1]))
320 self
.comb
+= branch_arg_b
.eq(Cat( register_rs2
[0:31],
321 register_rs2
[31] ^ ~dc
.funct3
[1]))
323 branch_taken
= Signal()
324 self
.comb
+= branch_taken
.eq(dc
.funct3
[0] ^
326 branch_arg_a
< branch_arg_b
,
327 branch_arg_a
== branch_arg_b
))
331 mscratch
= Signal(32)
332 self
.comb
+= mcause
.eq(0)
333 self
.comb
+= mepc
.eq(0) # 32'hXXXXXXXX;
334 self
.comb
+= mscratch
.eq(0) # 32'hXXXXXXXX;
336 mstatus
= MStatus(self
.comb
)
338 if __name__
== "__main__":
340 print(verilog
.convert(example
,
343 example
.tty_write_data
,
344 example
.tty_write_busy
,
356 parameter mie_seie = 0;
357 parameter mie_ueie = 0;
358 parameter mie_stie = 0;
359 parameter mie_utie = 0;
360 parameter mie_ssie = 0;
361 parameter mie_usie = 0;
363 task reset_to_initial;
367 mscratch = 32'hXXXXXXXX;
373 registers['h01] <= 32'hXXXXXXXX;
374 registers['h02] <= 32'hXXXXXXXX;
375 registers['h03] <= 32'hXXXXXXXX;
376 registers['h04] <= 32'hXXXXXXXX;
377 registers['h05] <= 32'hXXXXXXXX;
378 registers['h06] <= 32'hXXXXXXXX;
379 registers['h07] <= 32'hXXXXXXXX;
380 registers['h08] <= 32'hXXXXXXXX;
381 registers['h09] <= 32'hXXXXXXXX;
382 registers['h0A] <= 32'hXXXXXXXX;
383 registers['h0B] <= 32'hXXXXXXXX;
384 registers['h0C] <= 32'hXXXXXXXX;
385 registers['h0D] <= 32'hXXXXXXXX;
386 registers['h0E] <= 32'hXXXXXXXX;
387 registers['h0F] <= 32'hXXXXXXXX;
388 registers['h10] <= 32'hXXXXXXXX;
389 registers['h11] <= 32'hXXXXXXXX;
390 registers['h12] <= 32'hXXXXXXXX;
391 registers['h13] <= 32'hXXXXXXXX;
392 registers['h14] <= 32'hXXXXXXXX;
393 registers['h15] <= 32'hXXXXXXXX;
394 registers['h16] <= 32'hXXXXXXXX;
395 registers['h17] <= 32'hXXXXXXXX;
396 registers['h18] <= 32'hXXXXXXXX;
397 registers['h19] <= 32'hXXXXXXXX;
398 registers['h1A] <= 32'hXXXXXXXX;
399 registers['h1B] <= 32'hXXXXXXXX;
400 registers['h1C] <= 32'hXXXXXXXX;
401 registers['h1D] <= 32'hXXXXXXXX;
402 registers['h1E] <= 32'hXXXXXXXX;
403 registers['h1F] <= 32'hXXXXXXXX;
407 task write_register(input [4:0] register_number, input [31:0] value);
409 if(register_number != 0)
410 registers[register_number] <= value;
414 function [31:0] evaluate_csr_funct3_operation(input [2:0] funct3, input [31:0] previous_value, input [31:0] written_value);
417 `funct3_csrrw, `funct3_csrrwi:
418 evaluate_csr_funct3_operation = written_value;
419 `funct3_csrrs, `funct3_csrrsi:
420 evaluate_csr_funct3_operation = written_value | previous_value;
421 `funct3_csrrc, `funct3_csrrci:
422 evaluate_csr_funct3_operation = ~written_value & previous_value;
424 evaluate_csr_funct3_operation = 32'hXXXXXXXX;
429 parameter misa_a = 1'b0;
430 parameter misa_b = 1'b0;
431 parameter misa_c = 1'b0;
432 parameter misa_d = 1'b0;
433 parameter misa_e = 1'b0;
434 parameter misa_f = 1'b0;
435 parameter misa_g = 1'b0;
436 parameter misa_h = 1'b0;
437 parameter misa_i = 1'b1;
438 parameter misa_j = 1'b0;
439 parameter misa_k = 1'b0;
440 parameter misa_l = 1'b0;
441 parameter misa_m = 1'b0;
442 parameter misa_n = 1'b0;
443 parameter misa_o = 1'b0;
444 parameter misa_p = 1'b0;
445 parameter misa_q = 1'b0;
446 parameter misa_r = 1'b0;
447 parameter misa_s = 1'b0;
448 parameter misa_t = 1'b0;
449 parameter misa_u = 1'b0;
450 parameter misa_v = 1'b0;
451 parameter misa_w = 1'b0;
452 parameter misa_x = 1'b0;
453 parameter misa_y = 1'b0;
454 parameter misa_z = 1'b0;
485 parameter mvendorid = 32'b0;
486 parameter marchid = 32'b0;
487 parameter mimpid = 32'b0;
488 parameter mhartid = 32'b0;
490 function [31:0] make_mstatus(input mstatus_tsr,
496 input [1:0] mstatus_xs,
497 input [1:0] mstatus_fs,
498 input [1:0] mstatus_mpp,
507 make_mstatus = {(mstatus_xs == 2'b11) | (mstatus_fs == 2'b11),
531 wire mip_meip = 0; // TODO: implement external interrupts
532 parameter mip_seip = 0;
533 parameter mip_ueip = 0;
534 wire mip_mtip = 0; // TODO: implement timer interrupts
535 parameter mip_stip = 0;
536 parameter mip_utip = 0;
537 parameter mip_msip = 0;
538 parameter mip_ssip = 0;
539 parameter mip_usip = 0;
541 wire csr_op_is_valid;
543 function `fetch_action get_fetch_action(
544 input `fetch_output_state fetch_output_state,
545 input `decode_action decode_action,
546 input load_store_misaligned,
547 input memory_interface_rw_address_valid,
548 input memory_interface_rw_wait,
550 input misaligned_jump_target,
551 input csr_op_is_valid
554 case(fetch_output_state)
555 `fetch_output_state_empty:
556 get_fetch_action = `fetch_action_default;
557 `fetch_output_state_trap:
558 get_fetch_action = `fetch_action_ack_trap;
559 `fetch_output_state_valid: begin
560 if((decode_action & `decode_action_trap_illegal_instruction) != 0) begin
561 get_fetch_action = `fetch_action_error_trap;
563 else if((decode_action & `decode_action_trap_ecall_ebreak) != 0) begin
564 get_fetch_action = `fetch_action_noerror_trap;
566 else if((decode_action & (`decode_action_load | `decode_action_store)) != 0) begin
567 if(load_store_misaligned | ~memory_interface_rw_address_valid) begin
568 get_fetch_action = `fetch_action_error_trap;
570 else if(memory_interface_rw_wait) begin
571 get_fetch_action = `fetch_action_wait;
574 get_fetch_action = `fetch_action_default;
577 else if((decode_action & `decode_action_fence_i) != 0) begin
578 get_fetch_action = `fetch_action_fence;
580 else if((decode_action & `decode_action_branch) != 0) begin
581 if(branch_taken) begin
582 if(misaligned_jump_target) begin
583 get_fetch_action = `fetch_action_error_trap;
586 get_fetch_action = `fetch_action_jump;
591 get_fetch_action = `fetch_action_default;
594 else if((decode_action & (`decode_action_jal | `decode_action_jalr)) != 0) begin
595 if(misaligned_jump_target) begin
596 get_fetch_action = `fetch_action_error_trap;
599 get_fetch_action = `fetch_action_jump;
602 else if((decode_action & `decode_action_csr) != 0) begin
604 get_fetch_action = `fetch_action_default;
606 get_fetch_action = `fetch_action_error_trap;
609 get_fetch_action = `fetch_action_default;
613 get_fetch_action = 32'hXXXXXXXX;
618 assign fetch_action = get_fetch_action(
621 load_store_misaligned,
622 memory_interface_rw_address_valid,
623 memory_interface_rw_wait,
625 misaligned_jump_target,
631 mstatus_mpie = mstatus_mie;
633 mepc = (fetch_action == `fetch_action_noerror_trap) ? fetch_output_pc + 4 : fetch_output_pc;
634 if(fetch_action == `fetch_action_ack_trap) begin
635 mcause = `cause_instruction_access_fault;
637 else if((decode_action & `decode_action_trap_illegal_instruction) != 0) begin
638 mcause = `cause_illegal_instruction;
640 else if((decode_action & `decode_action_trap_ecall_ebreak) != 0) begin
641 mcause = decoder_immediate[0] ? `cause_machine_environment_call : `cause_breakpoint;
643 else if((decode_action & `decode_action_load) != 0) begin
644 if(load_store_misaligned)
645 mcause = `cause_load_address_misaligned;
647 mcause = `cause_load_access_fault;
649 else if((decode_action & `decode_action_store) != 0) begin
650 if(load_store_misaligned)
651 mcause = `cause_store_amo_address_misaligned;
653 mcause = `cause_store_amo_access_fault;
655 else if((decode_action & (`decode_action_branch | `decode_action_jal | `decode_action_jalr)) != 0) begin
656 mcause = `cause_instruction_address_misaligned;
659 mcause = `cause_illegal_instruction;
664 wire [11:0] csr_number = decoder_immediate;
665 wire [31:0] csr_input_value = decoder_funct3[2] ? decoder_rs1 : register_rs1;
666 wire csr_reads = decoder_funct3[1] | (decoder_rd != 0);
667 wire csr_writes = ~decoder_funct3[1] | (decoder_rs1 != 0);
669 function get_csr_op_is_valid(input [11:0] csr_number, input csr_reads, input csr_writes);
700 get_csr_op_is_valid = 0;
711 get_csr_op_is_valid = ~csr_writes;
720 get_csr_op_is_valid = 1;
727 // TODO: CSRs not implemented yet
728 get_csr_op_is_valid = 0;
733 assign csr_op_is_valid = get_csr_op_is_valid(csr_number, csr_reads, csr_writes);
735 wire [63:0] cycle_counter = 0; // TODO: implement cycle_counter
736 wire [63:0] time_counter = 0; // TODO: implement time_counter
737 wire [63:0] instret_counter = 0; // TODO: implement instret_counter
739 always @(posedge clk) begin:main_block
744 case(fetch_output_state)
745 `fetch_output_state_empty: begin
747 `fetch_output_state_trap: begin
750 `fetch_output_state_valid: begin:valid
751 if((fetch_action == `fetch_action_error_trap) | (fetch_action == `fetch_action_noerror_trap)) begin
754 else if((decode_action & `decode_action_load) != 0) begin
755 if(~memory_interface_rw_wait)
756 write_register(decoder_rd, loaded_value);
758 else if((decode_action & `decode_action_op_op_imm) != 0) begin
759 write_register(decoder_rd, alu_result);
761 else if((decode_action & `decode_action_lui_auipc) != 0) begin
762 write_register(decoder_rd, lui_auipc_result);
764 else if((decode_action & (`decode_action_jal | `decode_action_jalr)) != 0) begin
765 write_register(decoder_rd, fetch_output_pc + 4);
767 else if((decode_action & `decode_action_csr) != 0) begin:csr
768 reg [31:0] csr_output_value;
769 reg [31:0] csr_written_value;
770 csr_output_value = 32'hXXXXXXXX;
771 csr_written_value = 32'hXXXXXXXX;
774 csr_output_value = cycle_counter[31:0];
777 csr_output_value = time_counter[31:0];
780 csr_output_value = instret_counter[31:0];
783 csr_output_value = cycle_counter[63:32];
786 csr_output_value = time_counter[63:32];
789 csr_output_value = instret_counter[63:32];
791 `csr_mvendorid: begin
792 csr_output_value = mvendorid;
795 csr_output_value = marchid;
798 csr_output_value = mimpid;
801 csr_output_value = mhartid;
804 csr_output_value = misa;
807 csr_output_value = make_mstatus(mstatus_tsr,
823 csr_written_value = evaluate_csr_funct3_operation(decoder_funct3, csr_output_value, csr_input_value);
825 mstatus_mpie = csr_written_value[7];
826 mstatus_mie = csr_written_value[3];
830 csr_output_value = 0;
831 csr_output_value[11] = mie_meie;
832 csr_output_value[9] = mie_seie;
833 csr_output_value[8] = mie_ueie;
834 csr_output_value[7] = mie_mtie;
835 csr_output_value[5] = mie_stie;
836 csr_output_value[4] = mie_utie;
837 csr_output_value[3] = mie_msie;
838 csr_output_value[1] = mie_ssie;
839 csr_output_value[0] = mie_usie;
840 csr_written_value = evaluate_csr_funct3_operation(decoder_funct3, csr_output_value, csr_input_value);
842 mie_meie = csr_written_value[11];
843 mie_mtie = csr_written_value[7];
844 mie_msie = csr_written_value[3];
848 csr_output_value = mtvec;
851 csr_output_value = mscratch;
852 csr_written_value = evaluate_csr_funct3_operation(decoder_funct3, csr_output_value, csr_input_value);
854 mscratch = csr_written_value;
857 csr_output_value = mepc;
858 csr_written_value = evaluate_csr_funct3_operation(decoder_funct3, csr_output_value, csr_input_value);
860 mepc = csr_written_value;
863 csr_output_value = mcause;
864 csr_written_value = evaluate_csr_funct3_operation(decoder_funct3, csr_output_value, csr_input_value);
866 mcause = csr_written_value;
869 csr_output_value = 0;
870 csr_output_value[11] = mip_meip;
871 csr_output_value[9] = mip_seip;
872 csr_output_value[8] = mip_ueip;
873 csr_output_value[7] = mip_mtip;
874 csr_output_value[5] = mip_stip;
875 csr_output_value[4] = mip_utip;
876 csr_output_value[3] = mip_msip;
877 csr_output_value[1] = mip_ssip;
878 csr_output_value[0] = mip_usip;
882 write_register(decoder_rd, csr_output_value);
884 else if((decode_action & (`decode_action_fence | `decode_action_fence_i | `decode_action_store | `decode_action_branch)) != 0) begin