refactor asm more

src/compiler/arch/riscv/instr/base.rs

@@ -0,0 +1,93 @@
+use crate::{
+    compiler::arch::riscv::Reg,
+    util::{Bits32, BitsI32},
+};
+
+pub struct RawInstruction(u32);
+
+use RawInstruction as I;
+
+impl RawInstruction {
+    pub fn to_le_bytes(&self) -> impl IntoIterator<Item = u8> {
+        self.0.to_le_bytes().into_iter()
+    }
+    pub fn to_be_bytes(&self) -> impl IntoIterator<Item = u8> {
+        self.0.to_be_bytes().into_iter()
+    }
+}
+
+pub const SYSTEM: u32 = 0b1110011;
+pub const LOAD: u32 = 0b0000011;
+pub const STORE: u32 = 0b0100011;
+pub const AUIPC: u32 = 0b0010111;
+pub const IMM_OP: u32 = 0b0010011;
+pub const OP: u32 = 0b0110011;
+pub const JAL: u32 = 0b1101111;
+pub const JALR: u32 = 0b1100111;
+
+pub type Funct3 = Bits32<2, 0>;
+pub type Funct7 = Bits32<6, 0>;
+
+pub const fn r_type(
+    funct7: Bits32<6, 0>,
+    rs2: Reg,
+    rs1: Reg,
+    funct3: Bits32<2, 0>,
+    rd: Reg,
+    opcode: u32,
+) -> I {
+    I((funct7.val() << 25)
+        + (rs2.val() << 20)
+        + (rs1.val() << 15)
+        + (funct3.val() << 12)
+        + (rd.val() << 7)
+        + opcode)
+}
+pub const fn i_type(imm: Bits32<11, 0>, rs1: Reg, funct: Funct3, rd: Reg, opcode: u32) -> I {
+    I((imm.val() << 20) + (rs1.val() << 15) + (funct.val() << 12) + (rd.val() << 7) + opcode)
+}
+pub const fn s_type(rs2: Reg, rs1: Reg, funct3: Funct3, imm: Bits32<11, 0>, opcode: u32) -> I {
+    I((imm.bits(11, 5) << 25)
+        + (rs2.val() << 20)
+        + (rs1.val() << 15)
+        + (funct3.val() << 12)
+        + (imm.bits(4, 0) << 7)
+        + opcode)
+}
+pub const fn b_type(rs2: Reg, rs1: Reg, funct3: Funct3, imm: Bits32<12, 1>, opcode: u32) -> I {
+    I((imm.bit(12) << 31)
+        + (imm.bits(10, 5) << 25)
+        + (rs2.val() << 20)
+        + (rs1.val() << 15)
+        + (funct3.val() << 8)
+        + (imm.bits(4, 1) << 8)
+        + (imm.bit(11) << 7)
+        + opcode)
+}
+pub const fn u_type(imm: Bits32<31, 12>, rd: Reg, opcode: u32) -> I {
+    I((imm.bits(31, 12) << 12) + (rd.val() << 7) + opcode)
+}
+pub const fn j_type(imm: Bits32<20, 1>, rd: Reg, opcode: u32) -> I {
+    I((imm.bit(20) << 31)
+        + (imm.bits(10, 1) << 21)
+        + (imm.bit(11) << 20)
+        + (imm.bits(19, 12) << 12)
+        + (rd.val() << 7)
+        + opcode)
+}
+
+pub fn opr(op: Funct3, funct: Funct7, dest: Reg, src1: Reg, src2: Reg) -> I {
+    r_type(funct, src2, src1, op.into(), dest, OP)
+}
+pub fn opi(op: Funct3, dest: Reg, src: Reg, imm: BitsI32<11, 0>) -> RawInstruction {
+    i_type(imm.to_u(), src, op.into(), dest, IMM_OP)
+}
+pub fn opif7(op: Funct3, funct: Funct7, dest: Reg, src: Reg, imm: BitsI32<4, 0>) -> I {
+    i_type(
+        Bits32::new(imm.to_u().val() + (funct.val() << 5)),
+        src,
+        op.into(),
+        dest,
+        IMM_OP,
+    )
+}