more asm cleanup

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

@@ -5,8 +5,6 @@ use crate::{
 
 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()
@@ -28,6 +26,8 @@ pub const JALR: u32 = 0b1100111;
 pub type Funct3 = Bits32<2, 0>;
 pub type Funct7 = Bits32<6, 0>;
 
+use RawInstruction as I;
+
 pub const fn r_type(
     funct7: Bits32<6, 0>,
     rs2: Reg,
@@ -77,16 +77,16 @@ pub const fn j_type(imm: Bits32<20, 1>, rd: Reg, opcode: u32) -> I {
 }
 
 pub fn opr(op: Funct3, funct: Funct7, dest: Reg, src1: Reg, src2: Reg) -> I {
-    r_type(funct, src2, src1, op.into(), dest, OP)
+    r_type(funct, src2, src1, op, 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)
+    i_type(imm.to_u(), src, op, 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(),
+        op,
         dest,
         IMM_OP,
     )

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

@@ -1,3 +1,5 @@
+use super::*;
+
 mod base;
 mod rv32i;
 mod rv32m;

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

@@ -1,6 +1,6 @@
 use crate::{compiler::arch::riscv::Reg, util::Bits32};
 
-use super::{opr, Funct3, Funct7, RawInstruction};
+use super::*;
 
 pub mod op32i {
     use super::*;
@@ -63,6 +63,34 @@ pub mod width {
     }
 }
 
-pub fn opr32i(op: Funct3, dest: Reg, src1: Reg, src2: Reg) -> RawInstruction {
-    opr(op, Bits32::new(0), dest, src1, src2)
+pub const fn ecall() -> RawInstruction {
+    i_type(Bits32::new(0), zero, Bits32::new(0), zero, SYSTEM)
+}
+pub const fn ebreak() -> RawInstruction {
+    i_type(Bits32::new(1), zero, Bits32::new(0), zero, SYSTEM)
+}
+pub const fn auipc(dest: Reg, imm: BitsI32<31, 12>) -> RawInstruction {
+    u_type(imm.to_u(), dest, AUIPC)
+}
+
+pub const fn load(width: Funct3, dest: Reg, offset: BitsI32<11, 0>, base: Reg) -> RawInstruction {
+    i_type(offset.to_u(), base, width, dest, LOAD)
+}
+
+pub const fn store(width: Funct3, src: Reg, offset: BitsI32<11, 0>, base: Reg) -> RawInstruction {
+    s_type(src, base, width, offset.to_u(), STORE)
+}
+
+pub const fn jal(dest: Reg, offset: BitsI32<20, 1>) -> RawInstruction {
+    j_type(offset.to_u(), dest, JAL)
+}
+pub const fn jalr(dest: Reg, offset: BitsI32<11, 0>, base: Reg) -> RawInstruction {
+    i_type(offset.to_u(), base, Bits32::new(0), dest, JALR)
+}
+
+pub const fn j(offset: BitsI32<20, 1>) -> RawInstruction {
+    jal(zero, offset)
+}
+pub const fn ret() -> RawInstruction {
+    jalr(zero, BitsI32::new(0), ra)
 }