X-Git-Url: https://git.libre-soc.org/?p=rv32.git;a=blobdiff_plain;f=cpu_decoder.py;h=c92fb8898daea15443b74c506b45efc328ed603e;hp=d8b4680707124c8562e123f0eaa5ced7ccd159b6;hb=HEAD;hpb=eae153f27e68e99783cc2942c200d2cd11953196 diff --git a/cpu_decoder.py b/cpu_decoder.py index d8b4680..c92fb88 100644 --- a/cpu_decoder.py +++ b/cpu_decoder.py @@ -63,35 +63,35 @@ class CPUDecoder(Module): """ calculate immediate """ ci = {} - no_imm = 0x0 + no_imm = Constant(0x0, 32) # R-type: no immediate - for op in [opcode_amo, opcode_op, opcode_op_32, opcode_op_fp]: + for op in [OP.amo, OP.op, OP.op_32, OP.op_fp]: ci[op] = self.immediate.eq(no_imm) - # I-type + # I-type: sign-extended bits 20-31 im = Cat(self.instruction[20:], Replicate(self.instruction[31], 20)) - for op in [opcode_load, opcode_load_fp, opcode_misc_mem, - opcode_op_imm, opcode_op_imm_32, opcode_jalr, - opcode_system]: + for op in [OP.load, OP.load_fp, OP.misc_mem, + OP.op_imm, OP.op_imm_32, OP.jalr, + OP.system]: ci[op] = self.immediate.eq(im) # S-type im = Cat(self.instruction[7:12], self.instruction[25:31], Replicate(self.instruction[31], 21)) - for op in [opcode_store, opcode_store_fp]: + for op in [OP.store, OP.store_fp]: ci[op] = self.immediate.eq(im) # B-type im = Cat(Constant(0, 1), self.instruction[8:12], self.instruction[25:31], self.instruction[7], Replicate(self.instruction[31], 20)) - for op in [opcode_branch, ]: + for op in [OP.branch, ]: ci[op] = self.immediate.eq(im) # U-type im = Cat(Constant(0, 1), self.instruction[12:], ) - for op in [opcode_auipc, opcode_lui]: + for op in [OP.auipc, OP.lui]: ci[op] = self.immediate.eq(im) # J-type @@ -99,18 +99,18 @@ class CPUDecoder(Module): self.instruction[21:25], self.instruction[25:31], self.instruction[20], self.instruction[12:20], Replicate(self.instruction[31], 12)) - for op in [opcode_jal, ]: + for op in [OP.jal, ]: ci[op] = self.immediate.eq(im) # R4-type: no immediate - for op in [opcode_madd, opcode_msub, opcode_nmsub, opcode_nmadd]: + for op in [OP.madd, OP.msub, OP.nmsub, OP.nmadd]: ci[op] = self.immediate.eq(no_imm) # unknown - for op in [ opcode_custom_0, opcode_48b_escape_0, opcode_custom_1, - opcode_64b_escape, opcode_reserved_10101, opcode_rv128_0, - opcode_48b_escape_1, opcode_reserved_11010, - opcode_reserved_11101, opcode_rv128_1, opcode_80b_escape]: + for op in [ OP.custom_0, OP.op_48b_escape_0, OP.custom_1, + OP.op_64b_escape, OP.reserved_10101, OP.rv128_0, + OP.op_48b_escape_1, OP.reserved_11010, + OP.reserved_11101, OP.rv128_1, OP.op_80b_escape]: ci[op] = self.immediate.eq(no_imm) # default @@ -119,7 +119,7 @@ class CPUDecoder(Module): return Case(self.opcode, ci) - def _decode_funct3(self, options, action): + def _decode_funct3(self, action, options): """ decode by list of cases """ c = {} @@ -127,108 +127,100 @@ class CPUDecoder(Module): for op in options: c[op] = self.decode_action.eq(action) # default - c["default"] = \ - self.decode_action.eq(decode_action_trap_illegal_instruction) + c["default"] = self.decode_action.eq(DA.trap_illegal_instruction) return Case(self.funct3, c) def calculate_store_action(self): """ decode store action """ - return self._decode_funct3([ funct3_sb, funct3_sh, funct3_sw, ], - decode_action_store) + return self._decode_funct3(DA.store, [F3.sb, F3.sh, F3.sw, ]) def calculate_load_action(self): """ decode load action """ - return self._decode_funct3([ funct3_lb, funct3_lbu, funct3_lh, - funct3_lhu, funct3_lw, ], - decode_action_load) + return self._decode_funct3(DA.load, [F3.lb, F3.lbu, F3.lh, + F3.lhu, F3.lw, ]) def calculate_branch_action(self): """ decode branch action """ - return self._decode_funct3([ funct3_beq, funct3_bne, funct3_blt, - funct3_bge, funct3_bltu, funct3_bgeu ], - decode_action_branch) + return self._decode_funct3(DA.branch, [F3.beq, F3.bne, F3.blt, + F3.bge, F3.bltu, F3.bgeu ]) def calculate_jalr_action(self): """ decode jalr action """ - return self._decode_funct3([ funct3_jalr, ], - decode_action_jalr) + return self._decode_funct3(DA.jalr, [F3.jalr, ]) def calculate_op_action(self): - """ decode op action + """ decode op action: the arith ops, and, or, add, xor, sr/sl etc. """ c = {} immz = Constant(0, 12) regz = Constant(0, 5) - # fence - c[funct3_slli] = \ + # slli + c[F3.slli] = \ If((self.funct7 == Constant(0, 7)), - self.decode_action.eq(decode_action_op_op_imm)).\ - Else( - self.decode_action.eq(decode_action_trap_illegal_instruction)) - # fence.i - c[funct3_srli_srai] = \ + self.decode_action.eq(DA.op_op_imm) + ).Else( + self.decode_action.eq(DA.trap_illegal_instruction)) + # srli/srai + c[F3.srli_srai] = \ If((self.funct7 == Constant(0, 7) | \ (self.funct7 == Constant(0x20, 7))), - self.decode_action.eq(decode_action_op_op_imm)).\ - Else( - self.decode_action.eq(decode_action_trap_illegal_instruction)) + self.decode_action.eq(DA.op_op_imm) + ).Else( + self.decode_action.eq(DA.trap_illegal_instruction)) # default - c["default"] = \ - self.decode_action.eq(decode_action_op_op_imm) + c["default"] = self.decode_action.eq(DA.op_op_imm) return Case(self.funct3, c) def calculate_misc_action(self): - """ decode misc mem action + """ decode misc mem action: fence and fence_i """ c = {} immz = Constant(0, 12) regz = Constant(0, 5) # fence - c[funct3_fence] = \ + c[F3.fence] = \ If((self.immediate[8:12] == immz) & (self.rs1 == regz) & \ - (self.rd == regz), - self.decode_action.eq(decode_action_fence)).\ - Else( - self.decode_action.eq(decode_action_trap_illegal_instruction)) + (self.rd == regz), + self.decode_action.eq(DA.fence) + ).Else( + self.decode_action.eq(DA.trap_illegal_instruction)) # fence.i - c[funct3_fence_i] = \ + c[F3.fence_i] = \ If((self.immediate[0:12] == immz) & (self.rs1 == regz) & \ - (self.rd == regz), - self.decode_action.eq(decode_action_fence_i)).\ - Else( - self.decode_action.eq(decode_action_trap_illegal_instruction)) + (self.rd == regz), + self.decode_action.eq(DA.fence_i) + ).Else( + self.decode_action.eq(DA.trap_illegal_instruction)) # default - c["default"] = \ - self.decode_action.eq(decode_action_trap_illegal_instruction) + c["default"] = self.decode_action.eq(DA.trap_illegal_instruction) return Case(self.funct3, c) def calculate_system_action(self): - """ decode system action + """ decode opcode system: ebreak and csrs """ c = {} b1 = Constant(1, 32) regz = Constant(0, 5) # ebreak - c[funct3_ecall_ebreak] = \ - If((self.immediate != ~b1) | (self.rs1 != regz) | \ - (self.rd != regz), - self.decode_action.eq(decode_action_trap_illegal_instruction)).\ - Else( - self.decode_action.eq(decode_action_trap_ecall_ebreak)) + c[F3.ecall_ebreak] = \ + If((self.immediate == ~b1) & (self.rs1 == regz) & \ + (self.rd == regz), + self.decode_action.eq(DA.trap_ecall_ebreak) + ).Else( + self.decode_action.eq(DA.trap_illegal_instruction)) # csrs - for op in [ funct3_csrrw, funct3_csrrs, funct3_csrrc, - funct3_csrrwi, funct3_csrrsi, funct3_csrrci]: - c[op] = self.decode_action.eq(decode_action_csr) + for op in [ F3.csrrw, F3.csrrs, F3.csrrc, + F3.csrrwi, F3.csrrsi, F3.csrrci]: + c[op] = self.decode_action.eq(DA.csr) # default - c["default"] = \ - self.decode_action.eq(decode_action_trap_illegal_instruction) + c["default"] = self.decode_action.eq(DA.trap_illegal_instruction) return Case(self.funct3, c) @@ -240,28 +232,28 @@ class CPUDecoder(Module): (funct7 in the case of arith ops). """ c = {} - c[opcode_load] = self.calculate_load_action() - c[opcode_misc_mem] = self.calculate_misc_action() - c[opcode_op_imm] = self.calculate_op_action() - c[opcode_op] = self.calculate_op_action() - c[opcode_lui] = self.decode_action.eq(decode_action_lui_auipc) - c[opcode_auipc] = self.decode_action.eq(decode_action_lui_auipc) - c[opcode_store] = self.calculate_store_action() - c[opcode_branch] = self.calculate_branch_action() - c[opcode_jalr] = self.calculate_jalr_action() - c[opcode_jal] = self.decode_action.eq(decode_action_jal) - c[opcode_system] = self.calculate_system_action() + c[OP.load ] = self.calculate_load_action() + c[OP.misc_mem] = self.calculate_misc_action() + c[OP.op_imm ] = self.calculate_op_action() + c[OP.op ] = self.calculate_op_action() + c[OP.lui ] = self.decode_action.eq(DA.lui_auipc) + c[OP.auipc ] = self.decode_action.eq(DA.lui_auipc) + c[OP.store ] = self.calculate_store_action() + c[OP.branch ] = self.calculate_branch_action() + c[OP.jalr ] = self.calculate_jalr_action() + c[OP.jal ] = self.decode_action.eq(DA.jal) + c[OP.system ] = self.calculate_system_action() # big batch of unrecognised opcodes: throw trap. - for o in [ opcode_load_fp, opcode_custom_0, opcode_op_imm_32, - opcode_48b_escape_0, opcode_store_fp, opcode_custom_1, - opcode_amo, opcode_op_32, opcode_64b_escape, - opcode_madd, opcode_msub, opcode_nmsub, - opcode_nmadd, opcode_op_fp, opcode_reserved_10101, - opcode_rv128_0, opcode_48b_escape_1, opcode_reserved_11010, - opcode_reserved_11101, opcode_rv128_1, opcode_80b_escape, + for o in [ OP.load_fp, OP.custom_0, OP.op_imm_32, + OP.op_48b_escape_0, OP.store_fp, OP.custom_1, + OP.amo, OP.op_32, OP.op_64b_escape, + OP.madd, OP.msub, OP.nmsub, + OP.nmadd, OP.op_fp, OP.reserved_10101, + OP.rv128_0, OP.op_48b_escape_1, OP.reserved_11010, + OP.reserved_11101, OP.rv128_1, OP.op_80b_escape, "default", ]: - c[o] = self.decode_action.eq(decode_action_trap_illegal_instruction) + c[o] = self.decode_action.eq(DA.trap_illegal_instruction) return Case(self.opcode, c)