Struct evmil::Offset

pub struct Offset(pub u16);

Used to simplify calculation of label offsets.

Tuple Fields

0: u16

Implementations

impl Offset

pub fn width(&self) -> u16

Determine the width of this offset (in bytes).

Examples found in repository

src/bytecode.rs (line 106)

    fn update_offsets(&self, offsets: &mut [Offset]) -> bool {
        let mut changed = false;
        let mut offset = 0u16;
        // Calculate label offsets
        for b in &self.bytecodes {
            match b {
                Instruction::JUMPDEST(lab) => {
                    // Extract old offset
                    let oldoff = offsets[*lab];
                    // Construct new offset
                    let newoff = Offset(offset);
                    // Check!
                    if oldoff != newoff {
                        // Offset has changed, but the key thing is
                        // whether or not its _width_ has changed.
                        changed |= oldoff.width() != newoff.width();
                        // Update new offset.
                        offsets[*lab] = newoff;
                    }
                }
                Instruction::PUSH(bs) => offset = offset + (bs.len() as u16),
                Instruction::PUSHL(lab) => {
                    // This time calculate a more accurate figure.
                    offset = offset + offsets[*lab].width()
                }
                _ => {}
            }
            offset = offset + 1;
        }
        //
        changed
    }

src/instruction.rs (line 290)

    pub fn opcode(&self, offsets: &[Offset]) -> Result<u8,Error> {
        let op = match self {
            // 0s: Stop and Arithmetic Operations
            Instruction::STOP => 0x00,
            Instruction::ADD => 0x01,
            Instruction::MUL => 0x02,
            Instruction::SUB => 0x03,
            Instruction::DIV => 0x04,
            Instruction::SDIV => 0x05,
            Instruction::MOD => 0x06,
            Instruction::SMOD => 0x07,
            Instruction::ADDMOD => 0x08,
            Instruction::MULMOD => 0x09,
            Instruction::EXP => 0x0a,
            Instruction::SIGNEXTEND => 0x0b,
            // 10s: Comparison & Bitwise Logic Operations
            Instruction::LT => 0x10,
            Instruction::GT => 0x11,
            Instruction::SLT => 0x12,
            Instruction::SGT => 0x13,
            Instruction::EQ => 0x14,
            Instruction::ISZERO => 0x15,
            Instruction::AND => 0x16,
            Instruction::OR => 0x17,
            Instruction::XOR => 0x18,
            Instruction::NOT => 0x19,
            Instruction::BYTE => 0x1a,
            Instruction::SHL => 0x1b,
            Instruction::SHR => 0x1c,
            Instruction::SAR => 0x1d,
            // 20s: Keccak256
            Instruction::KECCAK256 => 0x20,
            // 30s: Environmental Information
            Instruction::ADDRESS => 0x30,
            Instruction::BALANCE => 0x31,
            Instruction::ORIGIN => 0x32,
            Instruction::CALLER => 0x33,
            Instruction::CALLVALUE => 0x34,
            Instruction::CALLDATALOAD => 0x35,
            Instruction::CALLDATASIZE => 0x36,
            Instruction::CALLDATACOPY => 0x37,
            Instruction::CODESIZE => 0x38,
            Instruction::CODECOPY => 0x39,
            Instruction::GASPRICE => 0x3a,
            Instruction::EXTCODESIZE => 0x3b,
            Instruction::EXTCODECOPY => 0x3c,
            Instruction::RETURNDATASIZE => 0x3d,
            Instruction::RETURNDATACOPY => 0x3e,
            Instruction::EXTCODEHASH => 0x3f,
            // 40s: Block Information
            Instruction::BLOCKHASH => 0x40,
            Instruction::COINBASE => 0x41,
            Instruction::TIMESTAMP => 0x42,
            Instruction::NUMBER => 0x43,
            Instruction::DIFFICULTY => 0x44,
            Instruction::GASLIMIT => 0x45,
            Instruction::CHAINID => 0x46,
            Instruction::SELFBALANCE => 0x47,
            // 50s: Stack, Memory, Storage and Flow Operations
            Instruction::POP => 0x50,
            Instruction::MLOAD => 0x51,
            Instruction::MSTORE => 0x52,
            Instruction::MSTORE8 => 0x53,
            Instruction::SLOAD => 0x54,
            Instruction::SSTORE => 0x55,
            Instruction::JUMP => 0x56,
            Instruction::JUMPI => 0x57,
            Instruction::PC => 0x58,
            Instruction::MSIZE => 0x59,
            Instruction::GAS => 0x5a,
            Instruction::JUMPDEST(_) => 0x5b,
            //
            // 60s & 70s: Push Operations
            Instruction::PUSH(bs) => {
                if bs.len() == 0 || bs.len() > 32 {
                    return Err(Error::InvalidPush);
                } else {
                    (0x5f + bs.len()) as u8
                }
            }
            //
            Instruction::PUSHL(lab) => {
                let offset = &offsets[*lab];
                if offset.width() == 2 { 0x61 }
                else { 0x60 }
            }
            // 80s: Duplication Operations
            Instruction::DUP(n) => {
                if *n == 0 || *n > 32 {
                    return Err(Error::InvalidDup);
                }
                0x7f + n
            }
            // 90s: Swap Operations
            Instruction::SWAP(n) => {
                if *n == 0 || *n > 32 {
                    return Err(Error::InvalidDup);
                }
                0x8f + n
            }
            // a0s: Log Operations
            Instruction::LOG(n) => {
                if *n > 4 {
                    return Err(Error::InvalidDup);
                }
                0xa0 + n
            }
            // f0s: System Operations
            Instruction::CREATE => 0xf0,
            Instruction::CALL => 0xf1,
            Instruction::CALLCODE => 0xf2,
            Instruction::RETURN => 0xf3,
            Instruction::DELEGATECALL => 0xf4,
            Instruction::CREATE2 => 0xf5,
            Instruction::STATICCALL => 0xfa,
            Instruction::REVERT => 0xfd,
            Instruction::INVALID => 0xfe,
            Instruction::SELFDESTRUCT => 0xff,
            //
            Instruction::DATA(bytes) => {
                 panic!("Invalid instruction ({:?})",self);
            }
        };
        //
        Ok(op)
    }

pub fn to_bytes(&self) -> Vec<u8>

Examples found in repository

src/instruction.rs (line 177)

    pub fn encode(&self, offsets: &[Offset], bytes: &mut Vec<u8>) -> Result<(),Error> {
        // Push opcode
        bytes.push(self.opcode(&offsets)?);
        // Push operands (if applicable)
        match self {
            Instruction::PUSH(args) => {
                bytes.extend(args);
            }
            Instruction::PUSHL(idx) => {
                bytes.extend(offsets[*idx].to_bytes());
            }
            _ => {
                // All other instructions have no operands.
            }
        }
        //
        Ok(())
    }

Trait Implementations

impl Clone for Offset

fn clone(&self) -> Offset

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq<Offset> for Offset

fn eq(&self, other: &Offset) -> 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 Offset

impl StructuralPartialEq for Offset