Method start

hail-fuzz/src/i2s/colorization.rs:82–134

(fuzzer: &mut Fuzzer)

    }

    pub fn start(fuzzer: &mut Fuzzer) -> Result<Self, StageExit>
    where
        Self: Sized,
    {
        let input_id = fuzzer.input_id.ok_or(StageExit::Skip)?;

        fuzzer.copy_current_input();
        fuzzer.reset_input_cursor().unwrap();
        let mut mutated_input = fuzzer.state.input.clone();
        randomize_input(&mut fuzzer.rng, &mut mutated_input);

        Snapshot::restore_initial(fuzzer);
        fuzzer.write_input_to_target().unwrap();
        fuzzer.execute().ok_or(StageExit::Interrupted)?;
        let original_icount = fuzzer.vm.cpu.icount();

        // If this input was generated via length extension, then we only try and colorize the newly
        // extended bytes.
        let prefix_bytes = match fuzzer.features.skip_prefix {
            true => crate::utils::count_parent_prefix(fuzzer, input_id, true),
            false => HashMap::new(),
        };

        let max_len = fuzzer.features.max_i2s_bytes;

        let mut remaining_streams = vec![];
        for (addr, stream) in &fuzzer.state.input.streams {
            if !stream.bytes.is_empty() {
                let max_len = prefix_bytes
                    .get(addr)
                    .map_or(max_len.min(stream.bytes.len()) as u32, |prefix| {
                        (stream.bytes.len() - *prefix) as u32
                    });
                tracing::debug!(
                    "{addr:#x}: colorizing up to {max_len} of {} bytes",
                    stream.bytes.len()
                );
                remaining_streams.push((*addr, max_len));
            }
        }

        Ok(Self {
            input_id,
            attempts: 0,
            mutated_input,
            remaining_streams,
            ranges: std::collections::BinaryHeap::default(),
            untainted_ranges: vec![],
            colorized_bytes: HashMap::default(),
            original_icount,
            total_execs: 0,
        })
    }

    fn fuzz_one(&mut self, fuzzer: &mut Fuzzer) -> Option<()> {
        let range = self.next_range()?;