Function compile_and_run_kernel

tests/integration/plic_external_irq.rs:45–102

(kernel_src: &str)

"#;

fn compile_and_run_kernel(kernel_src: &str) -> (String, Option<i64>, u64) {
    let snippet_manifest = BuildManifest::from_file(
        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/kernel_snippet.build"),
    )
    .expect("kernel snippet build file parse");
    let stdlib_objs = CompilationPipeline::compile_stdlib_objects(TargetMode::Kernel)
        .expect("kernel stdlib compile");
    // Kernel module deps (trap_handler, vmm, ...) from the closure; drop `my_kernel` so the
    // test's own kmain supplies the entry.
    let kernel_objs =
        CompilationPipeline::compile_kernel_module_objects().expect("kernel modules compile");

    let user_pipeline = CompilationPipeline::new();
    let user = user_pipeline.compile(kernel_src).expect("kernel compile");
    let (_, user_tokens) = user_pipeline.compile_ir_to_assembly_with_tokens(&user.ir_program);
    let mut user_obj = user_pipeline.assemble(&user_tokens).expect("user assemble");
    for export in &snippet_manifest.abi_exports {
        user_obj.mark_entry_global(export);
    }

    let mut modules: Vec<(&str, &AssembledOutput)> =
        stdlib_objs.iter().map(|(n, o)| (n.as_str(), o)).collect();
    for (name, obj) in &kernel_objs {
        if name != "my_kernel" {
            modules.push((name.as_str(), obj));
        }
    }
    modules.push(("user", &user_obj));
    let assembled = user_pipeline
        .link_assembled_objects(&modules)
        .expect("link");
    let mut vm = VirtualMachine::new_kernel(&assembled);

    // Run for a bit to let kernel boot
    let boot_run = vm.run(500_000);
    let uart_after_boot = boot_run.uart_output.clone();

    // Now inject a UART RX byte
    vm.uart_receive(0x41); // 'A'

    // Run for more steps to process the interrupt
    let run = vm.run(100_000);

    // Get the CSRs to check scause
    let csrs = vm.peek_csrs();
    let scause = csrs.scause;

    let exit = match run.outcome {
        StepOutcome::Halted(code) => Some(code),
        _ => None,
    };

    (
        format!("{}\n{}", uart_after_boot, run.uart_output),
        exit,
        scause,
    )
}