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 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}