Skip to main content

jit/
remi.rs

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 // "normales" JIT
82        },
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
123// todo -
124fn 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    // siehe https://doc.rust-lang.org/std/keyword.become.html
607    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}