Struct evmil::Block

pub struct Block {
    pub start: usize,
    pub end: usize,
}

Identifies a sequential block of instructions within the original bytecode sequence. That is, a sequence does not contain a jump destination (other than at the very start), and ends either with a terminating instruction (e.g. RETURN, REVERT, etc) or an unconditional branch (to another block).

Fields

start: usize

Starting offset (in bytes) of this block.

end: usize

End offset (in bytes) of this block. That is the first byte which is not part of this block.

Implementations

impl Block

pub fn new(start: usize, end: usize) -> Self

Examples found in repository

src/disassembler.rs (line 253)

    fn scan_blocks(bytes: &[u8]) -> Vec<Block> {
        let mut blocks = Vec::new();
        // Current position in bytecodes
        let mut pc = 0;
        // Identifies start of current block.
        let mut start = 0;
        // Parse the block
        while pc < bytes.len() {
            // Decode instruction at the current position
            let insn = Instruction::decode(pc,&bytes);
            // Increment PC for next instruction
            pc = pc + insn.length(&[]);
            // Check whether terminating instruction
            match insn {
                JUMPDEST(n) => {
                    // Determine whether start of this block, or next
                    // block.
                    if (pc - 1) != start {
                        // Start of next block
                        blocks.push(Block::new(start,pc-1));
                        start = pc - 1;
                    }
                }
                INVALID|JUMP|RETURN|REVERT|STOP => {
                    blocks.push(Block::new(start,pc));
                    start = pc;
                }
                _ => {}
            }
        }
        // Append last block (if necessary)
        if start != pc {
            blocks.push(Block::new(start,pc));
        }
        // Done
        blocks
    }

pub fn encloses(&self, pc: usize) -> bool

Check whether this block encloses (i.e. includes) the given bytecode address.

Examples found in repository

src/disassembler.rs (line 139)

    pub fn get_block(&self, pc: usize) -> usize {
        for i in 0..self.blocks.len() {
            if self.blocks[i].encloses(pc) {
                return i;
            }
        }
        panic!("invalid bytecode address");
    }

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl PartialEq<Block> for Block

fn eq(&self, other: &Block) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Block

impl Eq for Block

impl StructuralEq for Block

impl StructuralPartialEq for Block