Struct libafl_cc::cfg::CfgEdge

pub struct CfgEdge<T>
where
    T: HasWeight<T>,
{
    pub xored_loc: usize,
    pub top_node_loc: usize,
    pub bottom_node_loc: usize,
    pub calling_func: String,
    pub successor_basic_blocks: Vec<usize>,
    pub successor_edges: Vec<usize>,
    pub metadata: Option<T>,
}

An edge in the CFG.

Fields

xored_loc: usize

The index of the coverage map AFL inserts to, which is (prev_loc >> 1) ^ cur_loc.

top_node_loc: usize

The from node’s index (i.e., prev_loc) in the edge.

bottom_node_loc: usize

The to node’s index (i.e., cur_loc) in the edge.

calling_func: String

Name of the function that contains such edge. For anonymous function, it is “__”.

successor_basic_blocks: Vec<usize>

Indexes of successor block.

successor_edges: Vec<usize>

prev_loc >> 1 ^ cur_loc of edges connecting [CfgEdge.bottom_node_loc] to successor blocks.

metadata: Option<T>

Custom metadata.

Implementations

impl<T> CfgEdge<T>

where T: HasWeight<T>,

pub fn add_successor(&mut self, successor_loc: usize)

Add a successor for an edge.

pub fn get_weight(&self) -> u32

Calculate the weight of an edge.

Trait Implementations

impl<T> Debug for CfgEdge<T>

where T: HasWeight<T> + Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for CfgEdge<T>

where T: HasWeight<T> + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for CfgEdge<T>

where T: HasWeight<T> + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.