Method new

hail-fuzz/src/main.rs:543–644

(mut config: Config, global: GlobalRef)

    }

    pub fn new(mut config: Config, global: GlobalRef) -> anyhow::Result<Self> {
        let features = config::EnabledFeatures::from_env()?;
        eprintln!("HailFuzz start with features: {features:?}");
        let (mut target, mut vm) = setup_vm(&mut config, &features)?;
        icicle_fuzzing::add_debug_instrumentation(&mut vm);

        let mut path_tracer = None;
        if config.fuzzer.track_path {
            path_tracer = Some(trace::add_path_tracer(&mut vm, target.mmio_handler.unwrap())?);
        }

        let mut cmplog = None;
        if features.cmplog {
            let check_indirect =
                icicle_fuzzing::parse_bool_env("CMPLOG_CHECK_INDIRECT")?.unwrap_or(false);
            let skip_call_instrumentation =
                icicle_fuzzing::parse_bool_env("CMPLOG_NO_CALLS")?.unwrap_or(false);
            cmplog = Some(
                icicle_fuzzing::cmplog2::CmpLog2Builder::new()
                    .instrument_calls(!skip_call_instrumentation)
                    .check_indirect_pointers(check_indirect)
                    .finish(&mut vm),
            );
        }
        let mut coverage = config::configure_coverage(&config.fuzzer, &mut vm);
        target.initialize_vm(&config.fuzzer, &mut vm)?;
        coverage.reset(&mut vm);

        // Execute until the first MMIO address is read.
        let exit = target.run(&mut vm)?;
        if !matches!(exit, VmExit::UnhandledException((ExceptionCode::ReadWatch, _))) {
            anyhow::bail!(
                "Failed to initialize VM for fuzzing execution, unexpected initial exit: {}\ncallstack:\n{}",
                target.exit_string(exit),
                icicle_vm::debug::backtrace(&mut vm)
            );
        }

        let snapshot = Snapshot {
            vm: vm.snapshot(),
            coverage: coverage.snapshot_local(&mut vm),
            tracer: path_tracer.map(|x| x.snapshot(&mut vm)),
        };
        let state = State { input: MultiStream::default(), ..State::default() };

        let rng = match std::env::var("SEED") {
            Ok(seed) => {
                let seed = parse_u64_with_prefix(&seed)
                    .ok_or_else(|| anyhow::format_err!("expected number for seed: {seed}"))?;
                tracing::info!("Using fixed seed: {seed:#x}");
                SmallRng::seed_from_u64(seed)
            }
            Err(_) => SmallRng::from_entropy(),
        };

        let crash_logger = CrashLogger::new(&config)?;

        let mut global_dict = Dictionary::default();