1use crate::compiler::{self, Artifact, CompileMode};
2use crate::{ExecuteFn, ExitReason, FP_REG_BASE, GUEST_REG_COUNT, GUEST_TMP_COUNT, GuestState, JitResult};
3
4use liil::blocks::{BasicBlock, collect_blocks};
5use liil::nnil::{Address, AmoOp, Insn, Label, Nnil, NnilInstruction};
6
7use std::collections::{BTreeMap, BTreeSet};
8use std::fmt::Write as _;
9use std::io;
10use std::path::Path;
11use std::sync::Arc;
12
13pub struct CompiledJit {
14 artifact: Arc<Artifact>,
15 execute: ExecuteFn,
16}
17
18impl CompiledJit {
19 pub fn source_path(&self) -> &Path {
20 &self.artifact.source_path
21 }
22
23 pub fn library_path(&self) -> &Path {
24 &self.artifact.library_path
25 }
26
27 pub(crate) fn compiled_now(&self) -> bool {
28 self.artifact.compiled_now
29 }
30
31 pub(crate) fn entry(&self) -> ExecuteFn {
32 self.execute
33 }
34
35 pub(crate) unsafe fn run(&self, state: &mut GuestState) -> ExitReason {
36 unsafe { (self.execute)(state as *mut GuestState) }
37 }
38}
39
40#[derive(Debug, Clone, Copy, PartialEq, Eq)]
41enum LoadMode {
42 Raw,
43 ZeroExtend,
44 SignExtend,
45}
46
47#[derive(Debug, Clone, Copy, PartialEq, Eq)]
48enum Signedness {
49 Signed,
50 Unsigned,
51}
52
53struct RustEmitter<'a> {
54 nnil: &'a Nnil,
55 blocks: Vec<BasicBlock>,
56 block_names: BTreeMap<Address, String>,
57 unsigned_markers: BTreeSet<u64>,
58}
59
60pub fn compile_jit_multi(
61 regions: &[Nnil],
62 output_dir: &Path,
63 opt_level: u8,
64 cache_dir: Option<&Path>,
65 raw_jit: bool,
66) -> JitResult<Vec<(u64, CompiledJit)>> {
67 if regions.is_empty() {
68 return Ok(Vec::new());
69 }
70
71 let (rust_code, exports) = generate_bundle_rust_code(regions)?;
72
73 let artifact = compiler::compile(
74 &rust_code,
75 output_dir,
76 cache_dir,
77 opt_level,
78 if raw_jit {
79 CompileMode::Raw
80 } else {
81 CompileMode::Scalar },
83 )?;
84
85 let mut compiled = Vec::with_capacity(exports.len());
86
87 for (entry_pc, export_name) in exports {
88 let execute = unsafe { std::mem::transmute::<*const (), ExecuteFn>(artifact.symbol(export_name.as_bytes())?) };
89
90 compiled.push((entry_pc, CompiledJit { artifact: Arc::clone(&artifact), execute }));
91 }
92
93 Ok(compiled)
94}
95
96fn generate_bundle_rust_code(regions: &[Nnil]) -> JitResult<(String, Vec<(u64, String)>)> {
97 let mut code = genjittemplate();
98 let mut exports = Vec::with_capacity(regions.len());
99 let mut emitters = Vec::with_capacity(regions.len());
100
101 for (index, region) in regions.iter().enumerate() {
102 let entry = region.entrypoint().ok_or_else(|| io::Error::other("NNIL ist leer"))?;
103
104 let export_name = format!("execute_entry_{:x}", entry.0);
105 let prefix = format!("bundle_{index}_{:x}", entry.0);
106
107 emitters.push(RustEmitter::new(region, &prefix)?);
108 exports.push((entry.0, export_name));
109 }
110
111 let linked_blocks = emitters
112 .iter()
113 .flat_map(|emitter| emitter.block_names.iter().map(|(&address, name)| (address, name.clone())))
114 .collect::<BTreeMap<_, _>>();
115
116 for (emitter, (_, export_name)) in emitters.iter().zip(&exports) {
117 emitter.emit_region(export_name, &mut code, &linked_blocks)?;
118 }
119
120 Ok((code, exports))
121}
122
123fn genjittemplate() -> String {
125 concat!(
126 include_str!("generated.rs"),
127 "\n",
128 include_str!("constants.rs"),
129 "\nmod abi {\n",
130 include_str!("abi.rs"),
131 "\n}\nuse abi::*;\n"
132 )
133 .to_owned()
134}
135
136impl<'a> RustEmitter<'a> {
137 fn new(nnil: &'a Nnil, name_prefix: &str) -> JitResult<Self> {
138 let blocks = collect_blocks(nnil);
139
140 let block_names = blocks
141 .iter()
142 .map(|block| (block.addr, format!("{name_prefix}_block_{:x}", block.addr.0)))
143 .collect::<BTreeMap<_, _>>();
144
145 let unsigned_markers = nnil
146 .insns()
147 .iter()
148 .filter_map(|insn| match insn {
149 NnilInstruction::Unsigned { dst } => Some(dst.0),
150 _ => None,
151 })
152 .collect::<BTreeSet<_>>();
153
154 Ok(Self { nnil, blocks, block_names, unsigned_markers })
155 }
156
157 fn emit_region(
158 &self,
159 export_name: &str,
160 code: &mut String,
161 linked_blocks: &BTreeMap<Address, String>,
162 ) -> JitResult<()> {
163 let entry = self.nnil.entrypoint().ok_or_else(|| io::Error::other("cannot JIT an empty NNIL region"))?;
164 for block in &self.blocks {
165 self.emit_block(block, code, linked_blocks)?;
166 }
167
168 code.push_str("#[no_mangle]\n");
169 writeln!(code, "pub unsafe extern \"C\" fn {export_name}(state: *mut GuestState) -> ExitReason {{").unwrap();
170 code.push_str(" if state.is_null() {\n");
171 code.push_str(" return ExitReason::IndirectBranch;\n");
172 code.push_str(" }\n");
173 writeln!(code, " if (*state).pc == 0 {{ (*state).pc = {}; }}", entry.0).unwrap();
174 code.push_str(" match (*state).pc {\n");
175
176 for block in &self.blocks {
177 writeln!(code, " {} => become {}(state),", block.addr.0, self.block_name(block.addr)?).unwrap();
178 }
179
180 code.push_str(" _ => {\n");
181 code.push_str(" (*state).exit_reason = ExitReason::IndirectBranch;\n");
182 code.push_str(" ExitReason::IndirectBranch\n");
183 code.push_str(" }\n");
184 code.push_str(" }\n");
185 code.push_str("}\n\n");
186
187 Ok(())
188 }
189
190 fn emit_block(
191 &self,
192 block: &BasicBlock,
193 out: &mut String,
194 linked_blocks: &BTreeMap<Address, String>,
195 ) -> JitResult<()> {
196 writeln!(
197 out,
198 "unsafe extern \"C\" fn {}(state: *mut GuestState) -> ExitReason {{",
199 self.block_name(block.addr)?
200 )
201 .unwrap();
202
203 writeln!(out, " (*state).pc = {};", block.addr.0).unwrap();
204 out.push_str(" if let Some(reason) = control_block(state, (*state).pc) {\n");
205 out.push_str(" (*state).exit_reason = reason;\n");
206 out.push_str(" return reason;\n");
207 out.push_str(" }\n");
208
209 let mut terminated = false;
210
211 let starts = self.nnil.instruction_starts();
212
213 let boundaries: BTreeMap<usize, u64> = starts
214 .iter()
215 .map(|(pc, insn)| (insn.0 as usize, pc.0))
216 .chain([(self.nnil.insns().len(), self.nnil.pc())])
217 .collect();
218
219 let mut stores = false;
220
221 for insn_idx in block.start_insn..block.end_insn {
222 stores |= matches!(
223 self.nnil.insns()[insn_idx],
224 NnilInstruction::Store { .. } | NnilInstruction::Sc { .. } | NnilInstruction::Amo { .. }
225 );
226
227 if self.emit_insn(block, insn_idx, out, linked_blocks)? {
228 terminated = true;
229 }
230
231 if let Some(next_pc) = boundaries.get(&(insn_idx + 1)) {
232 if stores {
233 writeln!(
234 out,
235 " if (*(*state).memory).code_dirty {{ (*state).pc = {next_pc}; return ExitReason::IndirectBranch; }}"
236 )?;
237 }
238 stores = false;
239 }
240 }
241
242 if !terminated {
243 if let Some(next) = block.fallthrough {
244 writeln!(out, " (*state).pc = {};", next.0).unwrap();
245 self.write_branch_or_tailcall(next, out, 4, linked_blocks)?;
246 } else {
247 writeln!(out, " (*state).pc = {};", block.next_pc).unwrap();
248 out.push_str(" become dispatch_jit(state);\n");
249 }
250 }
251
252 out.push_str("}\n\n");
253 Ok(())
254 }
255
256 fn emit_insn(
257 &self,
258 block: &BasicBlock,
259 insn_idx: usize,
260 out: &mut String,
261 linked_blocks: &BTreeMap<Address, String>,
262 ) -> JitResult<bool> {
263 let insn = &self.nnil.insns()[insn_idx];
264
265 match insn {
266 NnilInstruction::Imm { imm } => {
267 writeln!(out, " let v_{insn_idx}: u64 = ({imm}i64) as u64;").unwrap();
268 }
269
270 NnilInstruction::Reg { reg } => {
271 self.ensure_reg(*reg)?;
272 writeln!(out, " let v_{insn_idx}: u64 = read_reg(state, {});", reg).unwrap();
273 }
274
275 NnilInstruction::TmpReg { reg } => {
276 self.ensure_tmp(*reg)?;
277 writeln!(out, " let v_{insn_idx}: u64 = *(*state).tmps.get_unchecked({});", reg).unwrap();
278 }
279
280 NnilInstruction::Add { lhs, rhs }
281 | NnilInstruction::Sub { lhs, rhs }
282 | NnilInstruction::Mul { lhs, rhs } => {
283 let operation = match insn {
284 NnilInstruction::Add { .. } => "wrapping_add",
285 NnilInstruction::Sub { .. } => "wrapping_sub",
286 _ => "wrapping_mul",
287 };
288
289 let expression = format!("v_{}.{}(v_{})", lhs.0, operation, rhs.0);
290 writeln!(out, " let v_{insn_idx}: u64 = {expression};").unwrap();
291 }
292
293 NnilInstruction::Mulh { lhs, rhs } => {
294 let expr = match (self.signedness(*lhs), self.signedness(*rhs)) {
295 (Signedness::Signed, Signedness::Signed) => {
296 format!("mulh_signed_signed(v_{}, v_{})", lhs.0, rhs.0)
297 }
298 (Signedness::Signed, Signedness::Unsigned) => {
299 format!("mulh_signed_unsigned(v_{}, v_{})", lhs.0, rhs.0)
300 }
301 (Signedness::Unsigned, Signedness::Unsigned) => {
302 format!("mulh_unsigned_unsigned(v_{}, v_{})", lhs.0, rhs.0)
303 }
304 (Signedness::Unsigned, Signedness::Signed) => {
305 format!("mulh_signed_unsigned(v_{}, v_{})", rhs.0, lhs.0)
306 }
307 };
308 writeln!(out, " let v_{insn_idx}: u64 = {expr};").unwrap();
309 }
310
311 NnilInstruction::Div { lhs, rhs } => {
312 let expr = match self.binary_signedness(*lhs, *rhs) {
313 Signedness::Signed => format!("div_signed(v_{}, v_{})", lhs.0, rhs.0),
314 Signedness::Unsigned => format!("div_unsigned(v_{}, v_{})", lhs.0, rhs.0),
315 };
316 writeln!(out, " let v_{insn_idx}: u64 = {expr};").unwrap();
317 }
318
319 NnilInstruction::Mod { lhs, rhs } => {
320 let expr = match self.binary_signedness(*lhs, *rhs) {
321 Signedness::Signed => format!("rem_signed(v_{}, v_{})", lhs.0, rhs.0),
322 Signedness::Unsigned => format!("rem_unsigned(v_{}, v_{})", lhs.0, rhs.0),
323 };
324 writeln!(out, " let v_{insn_idx}: u64 = {expr};").unwrap();
325 }
326
327 NnilInstruction::And { lhs, rhs }
328 | NnilInstruction::Or { lhs, rhs }
329 | NnilInstruction::Xor { lhs, rhs } => {
330 let operation = match insn {
331 NnilInstruction::And { .. } => "&",
332 NnilInstruction::Or { .. } => "|",
333 _ => "^",
334 };
335 let expression = format!("v_{} {operation} v_{}", lhs.0, rhs.0);
336
337 writeln!(out, " let v_{insn_idx}: u64 = {expression};").unwrap();
338 }
339
340 NnilInstruction::Sll { lhs, rhs } => {
341 writeln!(out, " let v_{insn_idx}: u64 = v_{}.wrapping_shl((v_{} & 63) as u32);", lhs.0, rhs.0)
342 .unwrap();
343 }
344
345 NnilInstruction::Srl { lhs, rhs } => {
346 writeln!(out, " let v_{insn_idx}: u64 = v_{}.wrapping_shr((v_{} & 63) as u32);", lhs.0, rhs.0)
347 .unwrap();
348 }
349
350 NnilInstruction::Sra { lhs, rhs } => {
351 writeln!(
352 out,
353 " let v_{insn_idx}: u64 = ((v_{} as i64).wrapping_shr((v_{} & 63) as u32)) as u64;",
354 lhs.0, rhs.0
355 )
356 .unwrap();
357 }
358
359 NnilInstruction::Slt { lhs, rhs } => {
360 let expr = match self.binary_signedness(*lhs, *rhs) {
361 Signedness::Signed => format!("slt_signed(v_{}, v_{})", lhs.0, rhs.0),
362 Signedness::Unsigned => format!("slt_unsigned(v_{}, v_{})", lhs.0, rhs.0),
363 };
364 writeln!(out, " let v_{insn_idx}: u64 = {expr};").unwrap();
365 }
366
367 NnilInstruction::Mov { dst, src } | NnilInstruction::Set { dst, src } => {
368 writeln!(out, " let v_{insn_idx}: u64 = v_{};", src.0).unwrap();
369 self.emit_write_target(*dst, format!("v_{insn_idx}"), out)?;
370 }
371
372 NnilInstruction::Load { dst, src, size } => {
373 self.ensure_load_store_size(*size)?;
374 let load_expr = format!(
375 "match load_le(state, v_{}, {}) {{ Some(value) => value, None => {{ (*state).pc = {}; (*state).exit_reason = ExitReason::ReadFault; return ExitReason::ReadFault; }} }}",
376 src.0, size, block.addr.0
377 );
378 writeln!(out, " let raw_{insn_idx}: u64 = {load_expr};").unwrap();
379 let value_expr = match self.load_mode(insn_idx, *dst) {
380 LoadMode::Raw | LoadMode::ZeroExtend => format!("zext(raw_{insn_idx}, {size})"),
381 LoadMode::SignExtend => format!("sext(raw_{insn_idx}, {size})"),
382 };
383 writeln!(out, " let v_{insn_idx}: u64 = {value_expr};").unwrap();
384 self.emit_write_target(*dst, format!("v_{insn_idx}"), out)?;
385 }
386
387 NnilInstruction::Store { dst, src, size } => {
388 self.ensure_load_store_size(*size)?;
389 writeln!(out, " let v_{insn_idx}: u64 = v_{};", src.0).unwrap();
390 writeln!(out, " if !store_le(state, v_{}, {}, v_{insn_idx}) {{", dst.0, size).unwrap();
391 self.emit_write_fault(block, out);
392 }
393
394 NnilInstruction::Sext { size, dst } => {
395 writeln!(out, " let v_{insn_idx}: u64 = sext(v_{}, {});", dst.0, size).unwrap();
396 }
397
398 NnilInstruction::Zext { size, dst } => {
399 writeln!(out, " let v_{insn_idx}: u64 = zext(v_{}, {});", dst.0, size).unwrap();
400 }
401
402 NnilInstruction::Signed { dst } | NnilInstruction::Unsigned { dst } => {
403 writeln!(out, " let v_{insn_idx}: u64 = v_{};", dst.0).unwrap();
404 }
405
406 NnilInstruction::Fdiv { lhs, rhs, size } => {
407 writeln!(out, " let v_{insn_idx}: u64 = fdiv_bits({}, v_{}, v_{});", size, lhs.0, rhs.0).unwrap();
408 }
409
410 NnilInstruction::IntToFloat { src, src_size, signed, dst_size } => {
411 writeln!(
412 out,
413 " let v_{insn_idx}: u64 = int_to_float_bits(v_{}, {}, {}, {});",
414 src.0, src_size, signed, dst_size
415 )
416 .unwrap();
417 }
418
419 NnilInstruction::Fence { .. } => {
420 writeln!(out, " let v_{insn_idx}: u64 = 0;").unwrap();
421 }
422
423 NnilInstruction::Jr { dst } | NnilInstruction::Jmp { dst } => {
424 if let Some(target) = self.direct_jump_target(*dst) {
425 writeln!(out, " (*state).pc = {};", target.0).unwrap();
426 if let Some(name) = linked_blocks.get(&target) {
427 writeln!(out, " become {name}(state);").unwrap();
428 } else {
429 out.push_str(" become dispatch_jit(state);\n");
430 }
431 } else {
432 writeln!(out, " (*state).pc = v_{};", dst.0).unwrap();
433 out.push_str(" become dispatch_jit(state);\n");
434 }
435 return Ok(true);
436 }
437
438 NnilInstruction::Beq { lhs, rhs, ttgt, ftgt } => {
439 self.emit_branch(format!("v_{} == v_{}", lhs.0, rhs.0), *ttgt, *ftgt, out, linked_blocks)?;
440 return Ok(true);
441 }
442
443 NnilInstruction::Bne { lhs, rhs, ttgt, ftgt } => {
444 self.emit_branch(format!("v_{} != v_{}", lhs.0, rhs.0), *ttgt, *ftgt, out, linked_blocks)?;
445 return Ok(true);
446 }
447
448 NnilInstruction::Blt { lhs, rhs, ttgt, ftgt } => {
449 let cond = match self.binary_signedness(*lhs, *rhs) {
450 Signedness::Signed => format!("(v_{} as i64) < (v_{} as i64)", lhs.0, rhs.0),
451 Signedness::Unsigned => format!("v_{} < v_{}", lhs.0, rhs.0),
452 };
453 self.emit_branch(cond, *ttgt, *ftgt, out, linked_blocks)?;
454 return Ok(true);
455 }
456
457 NnilInstruction::Bgt { lhs, rhs, ttgt, ftgt } => {
458 let cond = match self.binary_signedness(*lhs, *rhs) {
459 Signedness::Signed => format!("(v_{} as i64) > (v_{} as i64)", lhs.0, rhs.0),
460 Signedness::Unsigned => format!("v_{} > v_{}", lhs.0, rhs.0),
461 };
462 self.emit_branch(cond, *ttgt, *ftgt, out, linked_blocks)?;
463 return Ok(true);
464 }
465
466 NnilInstruction::Syscall {} => {
467 writeln!(out, " (*state).pc = {};", block.next_pc).unwrap();
468 out.push_str(" (*state).exit_reason = ExitReason::Syscall;\n");
469 out.push_str(" return ExitReason::Syscall;\n");
470 return Ok(true);
471 }
472
473 NnilInstruction::Sysbreak {} => {
474 writeln!(out, " (*state).pc = {};", block.next_pc).unwrap();
475 out.push_str(" (*state).exit_reason = ExitReason::Sysbreak;\n");
476 out.push_str(" return ExitReason::Sysbreak;\n");
477 return Ok(true);
478 }
479
480 NnilInstruction::Lr { dst, src, size } => {
481 self.ensure_load_store_size(*size)?;
482 writeln!(
483 out,
484 " let raw_{insn_idx}: u64 = match load_le(state, v_{}, {}) {{ Some(value) => value, None => {{ (*state).pc = {}; (*state).exit_reason = ExitReason::ReadFault; return ExitReason::ReadFault; }} }};",
485 src.0, size, block.addr.0
486 ).unwrap();
487 let value_expr =
488 if *size < 8 { format!("sext(raw_{insn_idx}, {})", size) } else { format!("raw_{insn_idx}") };
489 writeln!(out, " let v_{insn_idx}: u64 = {value_expr};").unwrap();
490 self.emit_write_target(*dst, format!("v_{insn_idx}"), out)?;
491 }
492
493 NnilInstruction::Sc { dst, src, addr, size } => {
494 self.ensure_load_store_size(*size)?;
495 let store_val = if *size < 8 {
496 format!("v_{} & ((1u64 << ({} * 8)) - 1)", src.0, size)
497 } else {
498 format!("v_{}", src.0)
499 };
500 writeln!(out, " let v_{insn_idx}: u64 = 0;").unwrap();
501 writeln!(out, " if !store_le(state, v_{}, {}, {}) {{", addr.0, size, store_val).unwrap();
502 self.emit_write_fault(block, out);
503 self.emit_write_target(*dst, format!("v_{insn_idx}"), out)?;
504 }
505
506 NnilInstruction::Amo { op, dst, src, addr, size } => {
507 self.ensure_load_store_size(*size)?;
508 writeln!(
509 out,
510 " let raw_{insn_idx}: u64 = match load_le(state, v_{}, {}) {{ Some(value) => value, None => {{ (*state).pc = {}; (*state).exit_reason = ExitReason::ReadFault; return ExitReason::ReadFault; }} }};",
511 addr.0, size, block.addr.0
512 ).unwrap();
513
514 let loaded =
515 if *size < 8 { format!("sext(raw_{insn_idx}, {})", size) } else { format!("raw_{insn_idx}") };
516 let rhs = if *size < 8 {
517 format!("sext(zext(v_{}, {}), {})", src.0, size, size)
518 } else {
519 format!("v_{}", src.0)
520 };
521
522 let result_expr = match op {
523 AmoOp::Swap => format!("v_{}", src.0),
524 AmoOp::Add => format!("{loaded}.wrapping_add({rhs})"),
525 AmoOp::Xor => format!("{loaded} ^ {rhs}"),
526 AmoOp::And => format!("{loaded} & {rhs}"),
527 AmoOp::Or => format!("{loaded} | {rhs}"),
528 AmoOp::Min => format!("if ({loaded} as i64) < ({rhs} as i64) {{ {loaded} }} else {{ {rhs} }}"),
529 AmoOp::Max => format!("if ({loaded} as i64) > ({rhs} as i64) {{ {loaded} }} else {{ {rhs} }}"),
530 AmoOp::Minu => format!("if {loaded} < {rhs} {{ {loaded} }} else {{ {rhs} }}"),
531 AmoOp::Maxu => format!("if {loaded} > {rhs} {{ {loaded} }} else {{ {rhs} }}"),
532 };
533
534 let store_val =
535 if *size < 8 { format!("{result_expr} & ((1u64 << ({} * 8)) - 1)", size) } else { result_expr };
536 writeln!(out, " if !store_le(state, v_{}, {}, {}) {{", addr.0, size, store_val).unwrap();
537 self.emit_write_fault(block, out);
538
539 writeln!(out, " let v_{insn_idx}: u64 = {loaded};").unwrap();
540 self.emit_write_target(*dst, format!("v_{insn_idx}"), out)?;
541 }
542 }
543
544 Ok(false)
545 }
546
547 fn emit_write_fault(&self, block: &BasicBlock, out: &mut String) {
548 writeln!(out, " (*state).pc = {};", block.addr.0).unwrap();
549 out.push_str(
550 " (*state).exit_reason = ExitReason::WriteFault;\n return ExitReason::WriteFault;\n }\n",
551 );
552 }
553
554 fn emit_branch(
555 &self,
556 condition: String,
557 ttgt: Label,
558 ftgt: Label,
559 out: &mut String,
560 linked_blocks: &BTreeMap<Address, String>,
561 ) -> JitResult<()> {
562 let ttgt_addr = self.label_address(ttgt)?;
563 let ftgt_addr = self.label_address(ftgt)?;
564
565 writeln!(out, " if {condition} {{").unwrap();
566 writeln!(out, " (*state).pc = {};", ttgt_addr.0).unwrap();
567
568 self.write_branch_or_tailcall(ttgt_addr, out, 8, linked_blocks)?;
569 out.push_str(" } else {\n");
570
571 writeln!(out, " (*state).pc = {};", ftgt_addr.0).unwrap();
572
573 self.write_branch_or_tailcall(ftgt_addr, out, 8, linked_blocks)?;
574 out.push_str(" }\n");
575 Ok(())
576 }
577
578 fn emit_write_target(&self, dst: Insn, value_expr: String, out: &mut String) -> JitResult<()> {
579 match self.nnil.insns()[dst.0 as usize] {
580 NnilInstruction::Reg { reg } => {
581 self.ensure_reg(reg)?;
582 writeln!(out, " write_reg(state, {}, {});", reg, value_expr).unwrap();
583 }
584 NnilInstruction::TmpReg { reg } => {
585 self.ensure_tmp(reg)?;
586 writeln!(out, " *(*state).tmps.get_unchecked_mut({}) = {};", reg, value_expr).unwrap();
587 }
588 ref other => {
589 return Err(io::Error::other(format!("unexpected in emitwritetarget: {other:?}")).into());
590 }
591 }
592 Ok(())
593 }
594
595 fn block_name(&self, addr: Address) -> JitResult<&str> {
596 self.block_names
597 .get(&addr)
598 .map(String::as_str)
599 .ok_or_else(|| io::Error::other(format!("missing block for address 0x{:x}", addr.0)).into())
600 }
601
602 fn label_address(&self, label: Label) -> JitResult<Address> {
603 self.nnil.label_address(label).ok_or_else(|| io::Error::other(format!("unknown label {:?}", label)).into())
604 }
605
606 fn write_branch_or_tailcall(
608 &self,
609 addr: Address,
610 out: &mut String,
611 indent: usize,
612 linked_blocks: &BTreeMap<Address, String>,
613 ) -> JitResult<()> {
614 let padding = " ".repeat(indent);
615
616 if let Some(name) = linked_blocks.get(&addr) {
617 writeln!(out, "{padding}become {name}(state);").unwrap();
618 } else {
619 writeln!(out, "{padding}become dispatch_jit(state);").unwrap();
620 }
621 Ok(())
622 }
623
624 fn direct_jump_target(&self, dst: Insn) -> Option<Address> {
625 match self.nnil.insns()[dst.0 as usize] {
626 NnilInstruction::Imm { imm } if imm >= 0 => Some(Address(imm as u64)),
627 _ => None,
628 }
629 }
630
631 fn load_mode(&self, load_idx: usize, dst: Insn) -> LoadMode {
632 if matches!(self.nnil.insns()[dst.0 as usize], NnilInstruction::Reg { reg } if reg as usize >= FP_REG_BASE) {
633 return LoadMode::Raw;
634 }
635
636 if self.unsigned_markers.contains(&(load_idx as u64)) { LoadMode::ZeroExtend } else { LoadMode::SignExtend }
637 }
638
639 fn signedness(&self, insn: Insn) -> Signedness {
640 match self.nnil.insns()[insn.0 as usize] {
641 NnilInstruction::Unsigned { .. } => Signedness::Unsigned,
642 _ => Signedness::Signed,
643 }
644 }
645
646 fn binary_signedness(&self, lhs: Insn, rhs: Insn) -> Signedness {
647 if self.signedness(lhs) == Signedness::Unsigned || self.signedness(rhs) == Signedness::Unsigned {
648 Signedness::Unsigned
649 } else {
650 Signedness::Signed
651 }
652 }
653
654 fn ensure_reg(&self, reg: u64) -> JitResult<()> {
655 if reg as usize >= GUEST_REG_COUNT {
656 Err(io::Error::other(format!("register {} exceeds register file", reg)).into())
657 } else {
658 Ok(())
659 }
660 }
661
662 fn ensure_tmp(&self, reg: u64) -> JitResult<()> {
663 if reg as usize >= GUEST_TMP_COUNT {
664 Err(io::Error::other(format!("temporary register {} exceeds tmp file", reg)).into())
665 } else {
666 Ok(())
667 }
668 }
669
670 fn ensure_load_store_size(&self, size: u64) -> JitResult<()> {
671 match size {
672 1 | 2 | 4 | 8 => Ok(()),
673 other => Err(io::Error::other(format!("memory size unsupported: {}", other)).into()),
674 }
675 }
676}