Skip to main content

remu/
main.rs

1mod debugger;
2use clap::{Parser, ValueEnum};
3
4use jit::{ExitReason, GuestMemory, JitRuntime, ProgramImage, RemuConfig};
5use lifter::{RiscVArch, lift_block};
6
7use std::env;
8use std::fs;
9use std::io;
10use std::path::{Path, PathBuf};
11use std::time::{SystemTime, UNIX_EPOCH};
12
13#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
14enum Backend {
15    Jit,
16    Avx512,
17}
18
19#[derive(Parser, Debug)]
20#[command(name = "remu")]
21struct Cli {
22    input_file: PathBuf,
23
24    #[arg(long, value_enum, default_value_t = Backend::Jit)]
25    backend: Backend,
26
27    #[arg(long)]
28    no_aot: bool,
29
30    #[arg(long)]
31    sysroot: Option<PathBuf>,
32
33    #[arg(long)]
34    workdir: Option<PathBuf>,
35
36    #[arg(short, long)]
37    verbose: bool,
38
39    #[arg(long)]
40    debug: bool,
41
42    #[arg(
43        long,
44        default_value_t = 2,
45        value_parser = clap::value_parser!(u8).range(0..=2)
46    )]
47    jit_opt_level: u8,
48
49    #[arg(long)]
50    no_jit_cache: bool,
51
52    #[arg(long)]
53    raw_jit: bool,
54
55    #[arg(last = true)]
56    guest_args: Vec<String>,
57}
58
59fn main() {
60    if let Err(error) = run(Cli::parse()) {
61        eprintln!("remu: {error}");
62        std::process::exit(1);
63    }
64}
65
66fn run(cli: Cli) -> jit::JitResult<()> {
67    if cli.backend == Backend::Avx512 && (cli.debug || cli.raw_jit) {
68        return Err(io::Error::other("--debug and --raw-jit laufen noch nicht mit avx backend").into());
69    }
70
71    let output_dir = create_output_dir(&cli.input_file)?;
72    let program = ProgramImage::from_elf_bytes(&fs::read(&cli.input_file)?)?;
73
74    println!("\n\n----- ELF loaded -----");
75    println!("Input: {}", cli.input_file.display());
76    println!("Output dir: {}", output_dir.display());
77    println!("Entry point: 0x{:x}", program.entry_pc);
78
79    let mut argv = vec![input_basename(&cli.input_file)];
80    argv.extend(cli.guest_args);
81
82    let cache_dir = (!cli.no_jit_cache).then(|| project_root().join("jit-tmp/cache"));
83
84    let process = RemuConfig {
85        argv,
86        envp: Vec::new(),
87        sysroot: cli.sysroot,
88        workdir: cli.workdir,
89        jit_opt_level: cli.jit_opt_level,
90        jit_cache_dir: cache_dir.clone(),
91        raw_jit: cli.raw_jit,
92    };
93
94    let lift = |memory: &GuestMemory, pc| lift_block(RiscVArch::Rv64, memory, pc).map_err(Into::into);
95
96    let mut runtime = JitRuntime::init_runtime(program, process, output_dir.clone(), lift)?;
97    runtime.set_verbose(cli.verbose);
98
99    if cli.backend == Backend::Avx512 {
100        let config = vector::VectorConfig {
101            output_dir,
102            cache_dir,
103            opt_level: cli.jit_opt_level,
104            argv: runtime.process_config().argv.clone(),
105            sysroot: runtime.process_config().sysroot.clone(),
106            workdir: runtime.process_config().workdir.clone(),
107            ..vector::VectorConfig::default()
108        };
109
110        let mut vector = vector::VectorRuntime::from_template(runtime.memory(), runtime.state(), lift, config)?;
111
112        let snapshot = vector.snapshot()?;
113        let results = vector.run_batch(&snapshot, [&[]; vector::LANES], u64::MAX, |_, _, _| Ok(()))?;
114
115        for (lane, result) in results.iter().enumerate() {
116            println!(
117                "lane {lane}: exit={:?}, status={:?}, pc=0x{:x}, a0/x10={}, sp/x2=0x{:x}, fault=0x{:x} {:?}, blocks={}, last-syscall={:?}",
118                result.exit,
119                result.exit_status,
120                result.pc,
121                result.registers[10],
122                result.registers[2],
123                result.fault_address,
124                result.fault_access,
125                result.blocks,
126                result.last_syscall,
127            );
128        }
129        println!("cached vector blocks = {}", vector.cache_len());
130        return Ok(());
131    }
132
133    if !cli.no_aot {
134        // todo
135        runtime.precompile()?;
136    }
137
138    let exit_reason = if cli.debug { debugger::run_debugger(&mut runtime)? } else { runtime.run()? };
139
140    let state = runtime.state();
141
142    println!("Exit reason: {exit_reason:?}");
143    println!("pc = 0x{:x}", state.pc);
144    println!("a0/x10 = {}", state.regs[10]);
145    println!("sp/x2 = 0x{:x}", state.regs[2]);
146    println!("fault_addr = 0x{:x}", state.fault_addr);
147    println!("fault_access = {:?}", state.fault_access);
148    println!("cached regions = {}", runtime.cache_len());
149
150    match exit_reason {
151        ExitReason::UnhandledHostCall => {
152            println!("UnhandledHostCall");
153        }
154        ExitReason::GuestExit => {
155            println!("GuestExit");
156        }
157        _ => {}
158    }
159    Ok(())
160}
161
162fn create_output_dir(input_file: &Path) -> io::Result<PathBuf> {
163    let root = project_root().join("output");
164    fs::create_dir_all(&root)?;
165
166    let file_name = input_basename(input_file);
167    let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).map_err(io::Error::other)?.as_nanos();
168
169    let output_dir = root.join(format!("run-{file_name}-{}-{timestamp}", std::process::id()));
170
171    fs::create_dir_all(&output_dir)?;
172
173    Ok(output_dir)
174}
175
176fn project_root() -> PathBuf {
177    Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap().to_path_buf()
178}
179
180fn input_basename(input_file: &Path) -> String {
181    input_file.file_name().unwrap_or(input_file.as_os_str()).to_string_lossy().into_owned()
182}