#[path = "../tests/support/answers.rs"]
mod answers;
#[path = "../tests/support/program.rs"]
#[expect(dead_code, reason = "the dump uses part of the generator")]
mod program;
#[path = "../tests/support/random.rs"]
#[expect(dead_code, reason = "the dump uses part of the generator")]
mod random;
#[path = "support/report.rs"]
mod report;
use std::io::{BufWriter, Write as _};
use std::path::{Path, PathBuf};
use std::process::ExitCode;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{fs, thread};
use answers::Counted;
use program::{Program, random_program};
use raf_source::{MemoryTree, Namespace, TargetKind, Workspace};
use random::Draw;
const BASES: [u64; 2] = [0x0a11_ce00, 0xc0ff_ee00];
const SEEDS_PER_BASE: u64 = 8;
const ORDER_SEED: u64 = 0x0de2_0001;
struct Request {
out: PathBuf,
programs: usize,
orders: usize,
digest: bool,
jobs: usize,
}
fn usage() -> String {
"usage: answer_dump OUT [--programs N] [--orders K] [--digest] [--jobs J]".to_owned()
}
fn request(args: &[String]) -> Result<Request, String> {
let mut out = None;
let mut programs = 64;
let mut orders = 0;
let mut digest = false;
let mut jobs = thread::available_parallelism()
.map_or(1, usize::from)
.min(16);
let mut rest = args.iter();
let number = |flag: &str, value: Option<&String>| -> Result<usize, String> {
let text = value.ok_or_else(|| format!("{flag} needs a value; {}", usage()))?;
program::number::unsigned(text).ok_or_else(|| {
format!(
"{flag} {text:?} is not a whole number: invalid or overflowing unsigned integer"
)
})
};
while let Some(arg) = rest.next() {
match arg.as_str() {
"--programs" => programs = number("--programs", rest.next())?,
"--orders" => orders = number("--orders", rest.next())?,
"--jobs" => jobs = number("--jobs", rest.next())?,
"--digest" => digest = true,
flag if flag.starts_with("--") => {
return Err(format!("unknown flag {flag}; {}", usage()));
}
path if out.is_none() => out = Some(PathBuf::from(path)),
extra => return Err(format!("unexpected argument {extra:?}; {}", usage())),
}
}
if jobs == 0 {
return Err("--jobs must be at least 1".to_owned());
}
let out = out.ok_or_else(usage)?;
Ok(Request {
out,
programs,
orders,
digest,
jobs,
})
}
const CHUNK: usize = 4096;
struct Sink {
request: Request,
waiting: Vec<(String, Program)>,
file: BufWriter<fs::File>,
total: Counted,
}
impl Sink {
fn push(&mut self, label: &str, program: &Program) -> Result<(), String> {
self.waiting.push((label.to_owned(), program.clone()));
let mut draw = Draw::seeded(ORDER_SEED);
for order in 0..self.request.orders {
self.waiting.push((
format!("{label} order {order}"),
program.shuffled(&mut draw),
));
}
if self.waiting.len() >= CHUNK {
self.flush()?;
}
Ok(())
}
fn flush(&mut self) -> Result<(), String> {
let waiting = std::mem::take(&mut self.waiting);
let answered = answer_all(&waiting, self.request.jobs, self.request.digest);
for ((label, _), (text, counted)) in waiting.iter().zip(answered) {
self.total = self.total.add(counted);
let written = if self.request.digest {
writeln!(self.file, "{label} {text}")
} else {
write!(self.file, "== {label}\n{text}")
};
written
.map_err(|error| format!("cannot write {}: {error}", self.request.out.display()))?;
}
Ok(())
}
}
fn dump(sink: &mut Sink) -> Result<(), String> {
for base in BASES {
let seeds: Vec<u64> = (1..=SEEDS_PER_BASE).map(|n| base + n).collect();
let mut draws: Vec<Draw> = seeds.iter().map(|seed| Draw::seeded(*seed)).collect();
for n in 0..sink.request.programs {
let which = n % seeds.len();
let program = random_program(&mut draws[which]);
let label = format!("seed {:#x} program {}", seeds[which], n / seeds.len());
sink.push(&label, &program)?;
}
}
let corpus = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../fuzz/corpus/rustc-oracle");
let listed = |error: std::io::Error| format!("cannot list {}: {error}", corpus.display());
let mut names: Vec<String> = fs::read_dir(&corpus)
.map_err(listed)?
.map(|entry| {
entry
.map_err(listed)?
.file_name()
.into_string()
.map_err(|name| format!("a corpus file name is not UTF-8: {}", name.display()))
})
.collect::<Result<_, _>>()?;
names.sort();
for name in names {
let path = corpus.join(&name);
let text = fs::read_to_string(&path)
.map_err(|error| format!("cannot read {}: {error}", path.display()))?;
let program = Program::parse(&text).map_err(|error| format!("{name}: {error}"))?;
sink.push(&format!("corpus {name}"), &program)?;
}
sink.flush()
}
fn answer_all(
programs: &[(String, Program)],
jobs: usize,
digested: bool,
) -> Vec<(String, Counted)> {
let next = AtomicUsize::new(0);
let results: Mutex<Vec<Option<(String, Counted)>>> =
Mutex::new(programs.iter().map(|_| None).collect());
thread::scope(|scope| {
for _ in 0..jobs {
scope.spawn(|| {
loop {
let at = next.fetch_add(1, Ordering::Relaxed);
let Some((_, program)) = programs.get(at) else {
break;
};
let (mut text, counted) = answers::answers(program);
if digested {
text = format!("{:016x}", purrdf_hash::fnv::fnv1a64(text.as_bytes()));
}
results.lock().expect("the results are not poisoned")[at] =
Some((text, counted));
}
});
}
});
results
.into_inner()
.expect("the results are not poisoned")
.into_iter()
.map(|answered| answered.expect("every program was answered"))
.collect()
}
fn run(args: &[String]) -> Result<String, String> {
let request = request(args)?;
let file = fs::File::create(&request.out)
.map_err(|error| format!("cannot create {}: {error}", request.out.display()))?;
let mut sink = Sink {
request,
waiting: Vec::new(),
file: BufWriter::new(file),
total: Counted::default(),
};
dump(&mut sink)?;
sink.file
.flush()
.map_err(|error| format!("cannot write {}: {error}", sink.request.out.display()))?;
let total = sink.total;
Ok(format!(
"loads={} refused-loads={} answers={} ambiguous={} refused-surfaces={}",
total.loads, total.refused_loads, total.answers, total.ambiguous, total.refused_surfaces
))
}
fn sample() -> Result<String, String> {
let program = random_program(&mut Draw::seeded(BASES[0] + 1));
let (text, counted) = answers::answers(&program);
if counted.refused_loads != 0 {
return Err(format!("the built-in package was refused: {text}"));
}
Ok(format!("sample: {} answers\n{text}", counted.answers))
}
fn main() -> ExitCode {
report::run("answer_dump", sample, run)
}