more asm refactor

src/ir/arch/riscv64.rs

@@ -1,53 +1,6 @@
 use crate::{compiler::arch::riscv::*, ir::VarInst};
 
-#[derive(Copy, Clone)]
-pub enum RV64Instruction {
-    Ecall,
-    Li {
-        dest: RegRef,
-        imm: i64,
-    },
-    Mv {
-        dest: RegRef,
-        src: RegRef,
-    },
-    La {
-        dest: RegRef,
-        src: VarInst,
-    },
-    Load {
-        width: Funct3,
-        dest: RegRef,
-        offset: i64,
-        base: RegRef,
-    },
-    Store {
-        width: Funct3,
-        src: RegRef,
-        offset: i64,
-        base: RegRef,
-    },
-    Op {
-        op: Funct3,
-        funct: Funct7,
-        dest: RegRef,
-        src1: RegRef,
-        src2: RegRef,
-    },
-    OpImm {
-        op: Funct3,
-        dest: RegRef,
-        src: RegRef,
-        imm: i64,
-    },
-    OpImmF7 {
-        op: Funct3,
-        funct: Funct7,
-        dest: RegRef,
-        src: RegRef,
-        imm: i64,
-    },
-}
+pub type RV64Instruction = LinkerInstruction<RegRef, VarInst>;
 
 #[derive(Copy, Clone)]
 pub enum RegRef {
@@ -64,42 +17,3 @@ impl std::fmt::Debug for RegRef {
     }
 }
 
-impl std::fmt::Debug for RV64Instruction {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Ecall => write!(f, "ecall"),
-            Self::Li { dest, imm } => write!(f, "li {dest:?}, {imm:?}"),
-            Self::Mv { dest, src } => write!(f, "mv {dest:?}, {src:?}"),
-            Self::La { dest, src } => write!(f, "la {dest:?}, {src:?}"),
-            Self::Load {
-                width,
-                dest,
-                offset,
-                base,
-            } => write!(f, "l{} {dest:?}, {offset}({base:?})", width::str(*width)),
-            Self::Store {
-                width,
-                src,
-                offset,
-                base,
-            } => write!(f, "s{} {src:?}, {offset}({base:?})", width::str(*width)),
-            Self::Op {
-                op,
-                funct,
-                dest,
-                src1,
-                src2,
-            } => write!(f, "{} {dest:?}, {src1:?}, {src2:?}", opstr(*op, *funct)),
-            Self::OpImm { op, dest, src, imm } => {
-                write!(f, "{}i {dest:?}, {src:?}, {imm}", opstr(*op, op32i::FUNCT7))
-            }
-            Self::OpImmF7 {
-                op,
-                funct,
-                dest,
-                src,
-                imm,
-            } => write!(f, "{}i {dest:?}, {src:?}, {imm}", opstr(*op, *funct)),
-        }
-    }
-}