stuffé

src/arch/x86_64/compile.rs

@@ -11,15 +11,6 @@ pub struct Encoder<'a> {
     pub vars: VarMap,
 }
 
-#[derive(Clone, Copy)]
-pub struct RegUse {
-    pos: usize,
-    // required var, if any
-    var: Option<VarId>,
-}
-pub type VarUses = HashMap<VarId, VecDeque<usize>>;
-pub type RegUses = [VecDeque<RegUse>; 16];
-
 pub fn compile(p: &Program<X86_64>) -> Result<LinkedProgram<u64>, CompilerMsg> {
     let mut encoder = Encoder::new(p);
 
@@ -78,8 +69,15 @@ pub fn compile(p: &Program<X86_64>) -> Result<LinkedProgram<u64>, CompilerMsg> {
 
 #[derive(Default)]
 pub struct SegUses {
-    var: VarUses,
+    var: HashMap<VarId, VecDeque<usize>>,
-    reg: RegUses,
+    reg: [VecDeque<RegUse>; 16],
+}
+
+#[derive(Clone, Copy)]
+pub struct RegUse {
+    pos: usize,
+    // required var, if any
+    var: Option<VarId>,
 }
 
 pub fn calc_uses(
@@ -90,14 +88,16 @@ pub fn calc_uses(
     let mut pos = 0;
     let seg_i = segments.len();
     segments.push(Default::default());
-    let mut vars = VarUses::default();
+    let mut uses = SegUses::default();
-    let mut regs = RegUses::default();
     macro_rules! push {
         ($var:ident) => {
             push!($var, 0)
         };
         ($var:ident, $pos:expr) => {
-            vars.entry($var.clone()).or_default().push_back(pos + $pos)
+            uses.var
+                .entry($var.clone())
+                .or_default()
+                .push_back(pos + $pos)
         };
     }
     for instr in body {
@@ -108,12 +108,12 @@ pub fn calc_uses(
                 push!(dst);
 
                 for &reg in conv.scratch() {
-                    regs[reg as usize].push_back(RegUse { pos, var: None });
+                    uses.reg[reg as usize].push_back(RegUse { pos, var: None });
                 }
                 for (i, &arg) in args.iter().enumerate() {
                     push!(arg);
                     if let Some(&reg) = conv.param().get(i) {
-                        regs[reg as usize].back_mut().unwrap().var = Some(arg);
+                        uses.reg[reg as usize].back_mut().unwrap().var = Some(arg);
                     }
                 }
             }
@@ -181,20 +181,19 @@ pub fn calc_uses(
                 for &(reg, var) in &asm.args {
                     push!(var);
                     used.remove(&reg);
-                    regs[reg as usize].push_back(RegUse {
+                    uses.reg[reg as usize].push_back(RegUse {
                         pos,
                         var: Some(var),
                     });
                 }
                 for reg in used {
-                    regs[reg as usize].push_back(RegUse { pos, var: None });
+                    uses.reg[reg as usize].push_back(RegUse { pos, var: None });
                 }
             }
         }
         pos += 1;
     }
-    segments[seg_i].var = vars;
+    segments[seg_i] = uses;
-    segments[seg_i].reg = regs;
     return (seg_i, pos);
 }