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: u64,
139
140 pc: u64,
142
143 insns: Vec<NnilInstruction>,
145
146 labels_by_addr: BTreeMap<Address, Label>,
148
149 label_addrs: Vec<Address>,
151
152 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}