Struct libafl::executors::shadow::ShadowExecutor

pub struct ShadowExecutor<E, SOT> { /* private fields */ }

A ShadowExecutor wraps an executor and a set of shadow observers

Implementations

impl<E, SOT> ShadowExecutor<E, SOT>where
    E: HasObservers + Debug,
    SOT: ObserversTuple<E::State> + Debug,

pub fn new(executor: E, shadow_observers: SOT) -> Self

Create a new ShadowExecutor, wrapping the given executor.

pub fn shadow_observers(&self) -> &SOT

The shadow observers are not considered by the feedbacks and the manager, mutable

pub fn shadow_observers_mut(&mut self) -> &mut SOT

The shadow observers are not considered by the feedbacks and the manager, mutable

Trait Implementations

impl<E, SOT> Debug for ShadowExecutor<E, SOT>where
    E: UsesState + Debug,
    SOT: ObserversTuple<E::State> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E, EM, SOT, Z> Executor<EM, Z> for ShadowExecutor<E, SOT>where
    E: Executor<EM, Z> + HasObservers,
    SOT: ObserversTuple<E::State>,
    EM: UsesState<State = E::State>,
    Z: UsesState<State = E::State>,

fn run_target(
    &mut self,
    fuzzer: &mut Z,
    state: &mut Self::State,
    mgr: &mut EM,
    input: &Self::Input
) -> Result<ExitKind, Error>

Instruct the target about the input and run

fn with_observers<OT>(self, observers: OT) -> WithObservers<Self, OT>where
    Self: Sized,
    OT: ObserversTuple<Self::State>,

Wraps this Executor with the given ObserversTuple to implement HasObservers.

fn post_run_reset(&mut self)

Custom Reset Handler, e.g., to reset timers

impl<E, SOT> HasObservers for ShadowExecutor<E, SOT>where
    E: HasObservers,
    SOT: ObserversTuple<E::State>,

fn observers(&self) -> &Self::Observers

Get the linked observers

fn observers_mut(&mut self) -> &mut Self::Observers

Get the linked observers (mutable)

impl<E, EM, SOT, Z> Stage<ShadowExecutor<E, SOT>, EM, Z> for ShadowTracingStage<E, EM, SOT, Z>where
    E: Executor<EM, Z> + HasObservers,
    EM: UsesState<State = E::State>,
    SOT: ObserversTuple<E::State>,
    Z: UsesState<State = E::State>,
    E::State: State + HasClientPerfMonitor + HasExecutions + HasCorpus + Debug,

fn perform(
    &mut self,
    fuzzer: &mut Z,
    executor: &mut ShadowExecutor<E, SOT>,
    state: &mut E::State,
    manager: &mut EM,
    corpus_idx: CorpusId
) -> Result<(), Error>

Run the stage

impl<E, SOT> UsesObservers for ShadowExecutor<E, SOT>where
    E: UsesObservers,

type Observers = <E as UsesObservers>::Observers

The observers type

impl<E, SOT> UsesState for ShadowExecutor<E, SOT>where
    E: UsesState,

type State = <E as UsesState>::State

The state known by this type.