Function run_test

cranelift/filetests/src/test_interpret.rs:79–120

(func_store: &FunctionStore, func: &Function, details: &Details)

}

fn run_test(func_store: &FunctionStore, func: &Function, details: &Details) -> anyhow::Result<()> {
    for comment in details.comments.iter() {
        if let Some(command) = parse_run_command(comment.text, &func.signature)? {
            trace!("Parsed run command: {command}");

            command
                .run(|func_name, run_args| {
                    // Rebuild the interpreter state on every run to ensure that we don't accidentally depend on
                    // some leftover state
                    let state = InterpreterState::default()
                        .with_function_store(func_store.clone())
                        .with_libcall_handler(|libcall: LibCall, args: LibCallValues| {
                            use LibCall::*;
                            Ok(smallvec![match (libcall, &args[..]) {
                                (CeilF32, [DataValue::F32(a)]) => DataValue::F32(a.ceil()),
                                (CeilF64, [DataValue::F64(a)]) => DataValue::F64(a.ceil()),
                                (FloorF32, [DataValue::F32(a)]) => DataValue::F32(a.floor()),
                                (FloorF64, [DataValue::F64(a)]) => DataValue::F64(a.floor()),
                                (TruncF32, [DataValue::F32(a)]) => DataValue::F32(a.trunc()),
                                (TruncF64, [DataValue::F64(a)]) => DataValue::F64(a.trunc()),
                                _ => unreachable!(),
                            }])
                        });

                    let mut args = Vec::with_capacity(run_args.len());
                    args.extend_from_slice(run_args);

                    // Because we have stored function names with a leading %, we need to re-add it.
                    let func_name = &format!("%{func_name}");
                    match Interpreter::new(state).call_by_name(func_name, &args) {
                        Ok(ControlFlow::Return(results)) => Ok(results.to_vec()),
                        Ok(e) => {
                            panic!("Unexpected returned control flow: {e:?}")
                        }
                        Err(t) => Err(format!("unexpected trap: {t:?}")),
                    }
                })
                .map_err(|e| anyhow::anyhow!("{e}"))?;
        }
    }
    Ok(())
}