remove intermediate enum / directly encode assembly

src/arch/x86_64/compile.rs

@@ -0,0 +1,83 @@
+use std::collections::HashMap;
+
+use super::*;
+use crate::backend::{LibImport, LinkedProgram, SymImport, SymTable, Symbol};
+use util::*;
+
+pub struct Encoder<'a> {
+    pub code: Code,
+    pub sym_tab: SymTable<u64>,
+    pub sym_refs: HashMap<Symbol, Vec<usize>>,
+    pub program: &'a Program<X86_64>,
+}
+
+pub fn compile(p: &Program<X86_64>) -> Result<LinkedProgram<u64>, CompilerMsg> {
+    let mut encoder = Encoder::new(p);
+
+    p.encode_data(&mut encoder.code.bytes, &mut encoder.sym_tab);
+
+    for f in &p.funcs {
+        let addr = encoder.code.bytes.len();
+        encoder.sym_tab.insert(f.sym, addr as u64);
+        for instr in &f.instrs {
+            encoder.compile_instr(instr)?;
+        }
+    }
+
+    for (pos, sym) in encoder.code.missing.drain(..) {
+        let info = encoder.program.sym_info(sym);
+        if info.external {
+            encoder.sym_refs.entry(sym).or_default().push(pos);
+        } else {
+            let addr = encoder
+                .sym_tab
+                .get(sym)
+                .ok_or(CompilerMsg::from(format!("missing symbol {}", info.name)))?;
+            encoder.code.bytes[pos..pos + 4].copy_from_slice(&addr_offset(pos, addr))
+        }
+    }
+
+    let imports = p
+        .external
+        .iter()
+        .map(|e| LibImport {
+            name: e.file.clone(),
+            syms: e
+                .syms
+                .iter()
+                .map(|&s| SymImport {
+                    name: p.sym_info(s).name.clone(),
+                    usages: encoder.sym_refs.entry(s).or_default().clone(),
+                })
+                .collect(),
+        })
+        .collect();
+
+    Ok(LinkedProgram {
+        code: encoder.code.bytes,
+        entry: p.entry.and_then(|e| encoder.sym_tab.get(e)),
+        imports,
+    })
+}
+
+type BInstr = crate::backend::Instr<X86_64>;
+impl<'a> Encoder<'a> {
+    fn compile_instr(&mut self, instr: &BInstr) -> Result<(), CompilerMsg> {
+        match instr {
+            BInstr::Asm(asm) => {
+                self.code.extend(asm);
+            }
+            _ => todo!(),
+        }
+        Ok(())
+    }
+
+    pub fn new(program: &'a Program<X86_64>) -> Self {
+        Self {
+            code: Code::default(),
+            sym_tab: SymTable::new(program.sym_count()),
+            sym_refs: Default::default(),
+            program,
+        }
+    }
+}