work

src/arch/x86_64/compile.rs

@@ -12,18 +12,13 @@ pub struct Encoder<'a> {
 }
 
 #[derive(Clone, Copy)]
-pub struct VarUse {
+pub struct RegUse {
     pos: usize,
-    reg: Option<Reg>,
+    // required var, if any
-}
+    var: Option<VarId>,
-pub type VarUses = HashMap<VarId, VecDeque<VarUse>>;
-pub type RegUses = [VecDeque<usize>; 16];
-
-impl VarUse {
-    pub fn min(self, other: Self) -> Self {
-        if self.pos <= other.pos { self } else { other }
-    }
 }
+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);
@@ -34,7 +29,7 @@ pub fn compile(p: &Program<X86_64>) -> Result<LinkedProgram<u64>, CompilerMsg> {
         let addr = encoder.code.bytes.len();
         encoder.sym_tab.insert(f.sym, addr as u64);
         let mut segments = Vec::new();
-        calc_uses(&mut segments, &f.body);
+        calc_uses(&mut segments, &f.body, p);
     }
 
     for f in &p.funcs {
@@ -87,36 +82,38 @@ pub struct SegUses {
     reg: RegUses,
 }
 
-pub fn calc_uses(segments: &mut Vec<SegUses>, body: &Body<X86_64>) -> (usize, usize) {
+pub fn calc_uses(
+    segments: &mut Vec<SegUses>,
+    body: &Body<X86_64>,
+    p: &Program<X86_64>,
+) -> (usize, usize) {
     let mut pos = 0;
     let seg_i = segments.len();
     segments.push(Default::default());
     let mut vars = VarUses::default();
     let mut regs = RegUses::default();
-    let volatile = [
-        rax, rbx, rcx, rdx, rbp, rsp, rsi, rdi, r8, r9, r10, r11, r12, r13, r14, r15,
-    ]
-    .map(|r| r.reg());
     macro_rules! push {
         ($var:ident) => {
-            push!($var, VarUse { pos: 0, reg: None })
+            push!($var, 0)
         };
         ($var:ident, $pos:expr) => {
-            vars.entry($var.clone()).or_default().push_back(VarUse {
+            vars.entry($var.clone()).or_default().push_back(pos + $pos)
-                pos: $pos.pos + pos,
-                reg: $pos.reg,
-            })
         };
     }
     for instr in body {
         match instr {
             BInstr::Set { dst, src: _ } => push!(dst),
             BInstr::Call { dst, f, args } => {
+                let conv = &p.call_convs[p.funcs[f].conv];
                 push!(dst);
-                for (i, arg) in args.iter().enumerate() {
+
+                for &reg in conv.scratch() {
+                    regs[reg as usize].push_back(RegUse { pos, var: None });
+                }
+                for (i, &arg) in args.iter().enumerate() {
                     push!(arg);
-                    if i < 8 {
+                    if let Some(&reg) = conv.param().get(i) {
-                        regs[i].push_back(pos);
+                        regs[reg as usize].back_mut().unwrap().var = Some(arg);
                     }
                 }
             }
@@ -132,8 +129,8 @@ pub fn calc_uses(segments: &mut Vec<SegUses>, body: &Body<X86_64>) -> (usize, us
             BInstr::If { cond, then, else_ } => {
                 push!(cond);
                 pos += 1;
-                let (seg_i1, len1) = calc_uses(segments, then);
+                let (seg_i1, len1) = calc_uses(segments, then, p);
-                let (seg_i2, len2) = calc_uses(segments, else_);
+                let (seg_i2, len2) = calc_uses(segments, else_, p);
                 // insert closest usages
                 for (var, poss1) in &segments[seg_i1].var {
                     if let Some(poss2) = segments[seg_i2].var.get(var) {
@@ -151,7 +148,7 @@ pub fn calc_uses(segments: &mut Vec<SegUses>, body: &Body<X86_64>) -> (usize, us
                 continue;
             }
             BInstr::Loop(instrs) => {
-                let (seg_i2, len) = calc_uses(segments, instrs);
+                let (seg_i2, len) = calc_uses(segments, instrs, p);
                 // insert closest usages
                 for (var, poss) in &segments[seg_i2].var {
                     push!(var, poss[0]);
@@ -175,15 +172,22 @@ pub fn calc_uses(segments: &mut Vec<SegUses>, body: &Body<X86_64>) -> (usize, us
                 }
             }
             BInstr::Asm(asm) => {
-                for &(reg, var) in &asm.args {
+                let mut used = HashSet::new();
-                    push!(
+                for i in &asm.instrs {
-                        var,
+                    if let Some(reg) = i.dst_reg() {
-                        VarUse {
+                        used.insert(reg.reg());
-                            pos: 0,
-                            reg: Some(reg)
                     }
-                    );
+                }
-                    regs[reg as usize].push_back(pos);
+                for &(reg, var) in &asm.args {
+                    push!(var);
+                    used.remove(&reg);
+                    regs[reg as usize].push_back(RegUse {
+                        pos,
+                        var: Some(var),
+                    });
+                }
+                for reg in used {
+                    regs[reg as usize].push_back(RegUse { pos, var: None });
                 }
             }
         }
@@ -208,7 +212,7 @@ impl<'a> Encoder<'a> {
         let mut used = HashSet::default();
         let mut vars = HashSet::default();
         for &instr in &asm.instrs {
-            if let Some(regw) = instr.regw_set() {
+            if let Some(regw) = instr.dst_reg() {
                 used.insert(regw.reg());
             }
             for var in instr.vars() {

src/arch/x86_64/mod.rs

@@ -28,7 +28,27 @@ impl Arch for X86_64 {
     }
 }
 
-pub struct CallConv {
+pub enum CallConv {
-    volatile: Vec<Reg>,
+    SystemV,
-    nonvolatile: Vec<Reg>,
+}
+
+impl CallConv {
+    pub fn param(&self) -> &[Reg] {
+        use regs::*;
+        match self {
+            Self::SystemV => &[rdi, rsi, rdx, rcx, r8, r9],
+        }
+    }
+    pub fn scratch(&self) -> &[Reg] {
+        use regs::*;
+        match self {
+            Self::SystemV => &[rax, rdi, rsi, rdx, rcx, r8, r9, r10, r11],
+        }
+    }
+    pub fn ret(&self) -> &[Reg] {
+        use regs::*;
+        match self {
+            Self::SystemV => &[rax, rdx],
+        }
+    }
 }

src/arch/x86_64/types/asm.rs

@@ -21,7 +21,7 @@ pub enum Instr {
 }
 
 impl Instr {
-    pub fn regw_set(&self) -> Option<RegW> {
+    pub fn dst_reg(&self) -> Option<RegW> {
         match self {
             Instr::Mov { dst, src: _ } => dst.reg(),
             Instr::Push(_) => None,

src/arch/x86_64/types/reg.rs

@@ -124,6 +124,14 @@ use filter;
 
 macro_rules! def_regs {
     ($reg:ident; $($val:literal : $B64:ident $B32:ident $B16:ident $B8:ident $(norex=$B8H:ident)? $(!$imp:tt)?,)*) => {
+        pub mod regs {
+            $(
+            #[allow(non_upper_case_globals)]
+            pub const $B64: u8 = $val;
+            )*
+        }
+        pub mod regws {
+            use super::*;
             $(
             #[allow(non_upper_case_globals)]
             pub const $B64: $reg = $reg::new($val, Width::B64, false);
@@ -182,9 +190,7 @@ macro_rules! def_regs {
                     })
                 }
             }
+        }
     };
 }
-
 use def_regs;
-
-use crate::arch::x86_64::Imm;

src/backend/ir/id.rs

@@ -1,5 +1,21 @@
 ids!(VarId FnId);
 
+impl<A: Arch> Index<FnId> for Vec<Func<A>> {
+    type Output = Func<A>;
+
+    fn index(&self, index: FnId) -> &Self::Output {
+        &self[index.0]
+    }
+}
+
+impl<A: Arch> Index<&FnId> for Vec<Func<A>> {
+    type Output = Func<A>;
+
+    fn index(&self, index: &FnId) -> &Self::Output {
+        &self[index.0]
+    }
+}
+
 macro_rules! ids {
     ($($name:ident)*) => {
         $(
@@ -8,4 +24,8 @@ macro_rules! ids {
         )*
     };
 }
+use std::ops::Index;
+
 use ids;
+
+use crate::{arch::Arch, backend::Func};