Skip to main content

liil/
nnil.rs

1use std::collections::BTreeMap;
2
3macro_rules! emit_alu {
4    ($func:ident, $insn:ident) => {
5        pub fn $func(&mut self, lhs: Insn, rhs: Insn) -> Insn {
6            let ret = self.insns.len();
7            self.insns.push(NnilInstruction::$insn { lhs, rhs });
8            Insn(ret as u64)
9        }
10    };
11}
12
13macro_rules! emit_branch {
14    ($func:ident, $insn:ident) => {
15        pub fn $func(&mut self, lhs: Insn, rhs: Insn, ttgt: Label, ftgt: Label) -> Insn {
16            let ret = self.insns.len();
17            self.insns.push(NnilInstruction::$insn { lhs, rhs, ttgt, ftgt });
18            Insn(ret as u64)
19        }
20    };
21}
22
23macro_rules! emit_mem {
24    ($func:ident, $insn:ident) => {
25        pub fn $func(&mut self, dst: Insn, src: Insn, size: u64) -> Insn {
26            let ret = self.insns.len();
27            self.insns.push(NnilInstruction::$insn { dst, src, size });
28            Insn(ret as u64)
29        }
30    };
31}
32
33macro_rules! emit_ext {
34    ($func:ident, $insn:ident) => {
35        pub fn $func(&mut self, size: usize, dst: Insn) -> Insn {
36            let ret = self.insns.len();
37            self.insns.push(NnilInstruction::$insn { size, dst });
38            Insn(ret as u64)
39        }
40    };
41}
42
43macro_rules! emit_sys {
44    ($func:ident, $insn:ident) => {
45        pub fn $func(&mut self) -> Insn {
46            let ret = self.insns.len();
47            self.insns.push(NnilInstruction::$insn {});
48            Insn(ret as u64)
49        }
50    };
51}
52
53macro_rules! emit_sign {
54    ($func:ident, $insn:ident) => {
55        pub fn $func(&mut self, dst: Insn) -> Insn {
56            let ret = self.insns.len();
57            self.insns.push(NnilInstruction::$insn { dst });
58            Insn(ret as u64)
59        }
60    };
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
64pub struct Insn(pub u64);
65#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
66pub struct Label(pub u64);
67
68#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
69pub struct Address(pub u64);
70
71#[derive(Debug, Clone, Copy, PartialEq, Eq)]
72pub enum NnilInstruction {
73    Add { lhs: Insn, rhs: Insn },
74    Sub { lhs: Insn, rhs: Insn },
75    Mul { lhs: Insn, rhs: Insn },
76    Mulh { lhs: Insn, rhs: Insn },
77    Div { lhs: Insn, rhs: Insn },
78    Mod { lhs: Insn, rhs: Insn },
79    Fdiv { lhs: Insn, rhs: Insn, size: usize },
80    And { lhs: Insn, rhs: Insn },
81    Or { lhs: Insn, rhs: Insn },
82    Xor { lhs: Insn, rhs: Insn },
83    Sll { lhs: Insn, rhs: Insn },
84    Srl { lhs: Insn, rhs: Insn },
85    Sra { lhs: Insn, rhs: Insn },
86    Slt { lhs: Insn, rhs: Insn },
87
88    Mov { dst: Insn, src: Insn },
89    Set { dst: Insn, src: Insn },
90
91    Jr { dst: Insn },
92    Jmp { dst: Insn },
93
94    Beq { lhs: Insn, rhs: Insn, ttgt: Label, ftgt: Label },
95    Bne { lhs: Insn, rhs: Insn, ttgt: Label, ftgt: Label },
96    Blt { lhs: Insn, rhs: Insn, ttgt: Label, ftgt: Label },
97    Bgt { lhs: Insn, rhs: Insn, ttgt: Label, ftgt: Label },
98
99    Load { dst: Insn, src: Insn, size: u64 },
100    Store { dst: Insn, src: Insn, size: u64 },
101
102    Sext { size: usize, dst: Insn },
103    Zext { size: usize, dst: Insn },
104    Signed { dst: Insn },
105    Unsigned { dst: Insn },
106    IntToFloat { src: Insn, src_size: usize, signed: bool, dst_size: usize },
107
108    Imm { imm: i64 },
109    Reg { reg: u64 },
110    TmpReg { reg: u64 },
111
112    Syscall {},
113    Sysbreak {},
114
115    Lr { dst: Insn, src: Insn, size: u64 },
116
117    Sc { dst: Insn, src: Insn, addr: Insn, size: u64 },
118    Amo { op: AmoOp, dst: Insn, src: Insn, addr: Insn, size: u64 },
119
120    Fence { mode: u8, pred: u8, succ: u8 },
121}
122
123#[derive(Debug, Clone, Copy, PartialEq, Eq)]
124pub enum AmoOp {
125    Swap,
126    Add,
127    Xor,
128    And,
129    Or,
130    Min,
131    Max,
132    Minu,
133    Maxu,
134}
135
136pub struct Nnil {
137    /// Base address of the lifted image
138    base: u64,
139
140    /// Current address of the lifter
141    pc: u64,
142
143    /// List of all lifted instructions
144    insns: Vec<NnilInstruction>,
145
146    /// Mapping of jump targets to stable label ids
147    labels_by_addr: BTreeMap<Address, Label>,
148
149    /// Reverse lookup for branch target labels
150    label_addrs: Vec<Address>,
151
152    /// Mapping of address to corresponding NNIL instruction
153    mapping: BTreeMap<Address, Insn>,
154}
155
156impl std::fmt::Debug for Nnil {
157    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158        writeln!(f, "Base: 0x{:08x}", self.base)?;
159        writeln!(f, "PC: 0x{:08x}", self.pc)?;
160        writeln!(f, "\nInstructions:")?;
161
162        if self.mapping.is_empty() {
163            return Ok(());
164        }
165
166        for (addr, i1, i2) in self
167            .mapping
168            .iter()
169            .map_windows(|&[(&Address(addr1), &Insn(insn1)), (_, &Insn(insn2))]| (addr1, insn1, insn2))
170            .collect::<Vec<_>>()
171        {
172            if self.labels_by_addr.contains_key(&Address(addr)) {
173                writeln!(f, "\nLabel_{addr:03}:").unwrap();
174            }
175            writeln!(f, "Address: {addr:08x}").unwrap();
176            for x in i1..i2 {
177                writeln!(f, "{:8}: {:?}", x, self.insns[x as usize]).unwrap();
178            }
179        }
180
181        let (&Address(addr), &Insn(insn)) = self.mapping.last_key_value().unwrap();
182        if self.labels_by_addr.contains_key(&Address(addr)) {
183            writeln!(f, "\nLabel_{addr:03}:").unwrap();
184        }
185        writeln!(f, "Address: {addr:08x}").unwrap();
186        for x in insn..self.insns.len() as u64 {
187            writeln!(f, "{:8}: {:?}", x, self.insns[x as usize]).unwrap();
188        }
189
190        Ok(())
191    }
192}
193
194impl Default for Nnil {
195    fn default() -> Self {
196        Self::new()
197    }
198}
199
200impl Nnil {
201    pub fn new() -> Self {
202        Self {
203            base: 0,
204            pc: 0,
205            insns: Vec::new(),
206            labels_by_addr: BTreeMap::new(),
207            label_addrs: Vec::new(),
208            mapping: BTreeMap::new(),
209        }
210    }
211
212    pub fn with_base(address: u64) -> Self {
213        Self {
214            base: address,
215            pc: address,
216            insns: Vec::new(),
217            labels_by_addr: BTreeMap::new(),
218            label_addrs: Vec::new(),
219            mapping: BTreeMap::new(),
220        }
221    }
222    pub fn create_label(&mut self, addr: u64) -> Label {
223        let addr = Address(addr);
224        if let Some(label) = self.labels_by_addr.get(&addr) {
225            *label
226        } else {
227            let label = Label(self.label_addrs.len() as u64);
228            self.label_addrs.push(addr);
229            self.labels_by_addr.insert(addr, label);
230            label
231        }
232    }
233
234    pub fn new_insn(&mut self) {
235        self.mapping.insert(Address(self.pc), Insn(self.insns.len() as u64));
236    }
237    pub fn advance_by(&mut self, amount: u64) {
238        self.pc += amount;
239    }
240
241    pub fn base(&self) -> u64 {
242        self.base
243    }
244    pub fn pc(&self) -> u64 {
245        self.pc
246    }
247    pub fn entrypoint(&self) -> Option<Address> {
248        self.mapping.first_key_value().map(|(&addr, _)| addr)
249    }
250    pub fn insns(&self) -> &[NnilInstruction] {
251        &self.insns
252    }
253    pub fn instruction_starts(&self) -> &BTreeMap<Address, Insn> {
254        &self.mapping
255    }
256    pub fn labels(&self) -> &BTreeMap<Address, Label> {
257        &self.labels_by_addr
258    }
259    pub fn label_for_address(&self, addr: Address) -> Option<Label> {
260        self.labels_by_addr.get(&addr).copied()
261    }
262    pub fn label_address(&self, label: Label) -> Option<Address> {
263        self.label_addrs.get(label.0 as usize).copied()
264    }
265
266    pub fn imm(&mut self, imm: i64) -> Insn {
267        let ret = self.insns.len();
268        self.insns.push(NnilInstruction::Imm { imm });
269        Insn(ret as u64)
270    }
271    pub fn reg(&mut self, reg: u64) -> Insn {
272        let ret = self.insns.len();
273        self.insns.push(NnilInstruction::Reg { reg });
274        Insn(ret as u64)
275    }
276
277    pub fn tmp_reg(&mut self, reg: u64) -> Insn {
278        let ret = self.insns.len();
279        self.insns.push(NnilInstruction::TmpReg { reg });
280        Insn(ret as u64)
281    }
282
283    emit_alu!(add, Add);
284    emit_alu!(sub, Sub);
285    emit_alu!(mul, Mul);
286    emit_alu!(mulh, Mulh);
287    emit_alu!(div, Div);
288    emit_alu!(r#mod, Mod);
289    emit_alu!(and, And);
290    emit_alu!(or, Or);
291    emit_alu!(xor, Xor);
292    emit_alu!(sll, Sll);
293    emit_alu!(srl, Srl);
294    emit_alu!(sra, Sra);
295    emit_alu!(slt, Slt);
296
297    pub fn mov(&mut self, dst: Insn, src: Insn) -> Insn {
298        let ret = self.insns.len();
299        self.insns.push(NnilInstruction::Mov { dst, src });
300        Insn(ret as u64)
301    }
302    pub fn set(&mut self, dst: Insn, src: Insn) -> Insn {
303        let ret = self.insns.len();
304        self.insns.push(NnilInstruction::Set { dst, src });
305        Insn(ret as u64)
306    }
307
308    pub fn jr(&mut self, dst: Insn) -> Insn {
309        let ret = self.insns.len();
310        self.insns.push(NnilInstruction::Jr { dst });
311        Insn(ret as u64)
312    }
313    pub fn jmp(&mut self, dst: Insn) -> Insn {
314        let ret = self.insns.len();
315        self.insns.push(NnilInstruction::Jmp { dst });
316        Insn(ret as u64)
317    }
318
319    emit_branch!(beq, Beq);
320    emit_branch!(bne, Bne);
321    emit_branch!(blt, Blt);
322    emit_branch!(bgt, Bgt);
323
324    emit_mem!(load, Load);
325    emit_mem!(store, Store);
326
327    emit_ext!(sext, Sext);
328    emit_ext!(zext, Zext);
329    emit_sign!(signed, Signed);
330    emit_sign!(unsigned, Unsigned);
331
332    pub fn fdiv(&mut self, size: usize, lhs: Insn, rhs: Insn) -> Insn {
333        let ret = self.insns.len();
334        self.insns.push(NnilInstruction::Fdiv { lhs, rhs, size });
335        Insn(ret as u64)
336    }
337
338    pub fn int_to_float(&mut self, src: Insn, src_size: usize, signed: bool, dst_size: usize) -> Insn {
339        let ret = self.insns.len();
340        self.insns.push(NnilInstruction::IntToFloat { src, src_size, signed, dst_size });
341
342        Insn(ret as u64)
343    }
344
345    emit_sys!(syscall, Syscall);
346    emit_sys!(sysbreak, Sysbreak);
347
348    pub fn lr(&mut self, dst: Insn, src: Insn, size: u64) -> Insn {
349        let ret = self.insns.len();
350        self.insns.push(NnilInstruction::Lr { dst, src, size });
351        Insn(ret as u64)
352    }
353    pub fn sc(&mut self, dst: Insn, src: Insn, addr: Insn, size: u64) -> Insn {
354        let ret = self.insns.len();
355        self.insns.push(NnilInstruction::Sc { dst, src, addr, size });
356        Insn(ret as u64)
357    }
358    pub fn amo(&mut self, op: AmoOp, dst: Insn, src: Insn, addr: Insn, size: u64) -> Insn {
359        let ret = self.insns.len();
360        self.insns.push(NnilInstruction::Amo { op, dst, src, addr, size });
361        Insn(ret as u64)
362    }
363
364    pub fn fence(&mut self, mode: u8, pred: u8, succ: u8) -> Insn {
365        let ret = self.insns.len();
366        self.insns.push(NnilInstruction::Fence { mode, pred, succ });
367        Insn(ret as u64)
368    }
369}