Struct iced_x86::BlockEncoder

pub struct BlockEncoder { /* fields omitted */ }

Encodes instructions. It can be used to move instructions from one location to another location.

Methods

impl BlockEncoder

pub fn encode(
    bitness: u32,
    block: InstructionBlock,
    options: u32
) -> Result<BlockEncoderResult, String>

Encodes instructions. Any number of branches can be part of this block. You can use this function to move instructions from one location to another location. If the target of a branch is too far away, it'll be rewritten to a longer branch. You can disable this by passing in BlockEncoderOptions::DONT_FIX_BRANCHES. If the block has any RIP-relative memory operands, make sure the data isn't too far away from the new location of the encoded instructions. Every OS should have some API to allocate memory close (+/-2GB) to the original code location.

Errors

Returns an error message on failure.

Panics

Panics if bitness is not one of 16, 32, 64.

Arguments

• bitness: 16, 32, or 64
• block: All instructions
• options: Encoder options, see BlockEncoderOptions

Examples

use iced_x86::*;

// je short $-2
// add dh,cl
// sbb r9d,ebx
let bytes = b"\x75\xFC\x00\xCE\x41\x19\xD9";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
decoder.set_ip(0x1234_5678_9ABC_DEF0);
let instructions: Vec<_> = decoder.into_iter().collect();

// orig_rip + 8
let block = InstructionBlock::new(&instructions, 0x1234_5678_9ABC_DEF8);
let bytes = match BlockEncoder::encode(64, block, BlockEncoderOptions::NONE) {
    Err(err) => panic!("Failed: {}", err),
    Ok(result) => result.code_buffer,
};
assert_eq!(vec![0x75, 0xF4, 0x00, 0xCE, 0x41, 0x19, 0xD9], bytes);

pub fn encode_slice(
    bitness: u32,
    blocks: &[InstructionBlock],
    options: u32
) -> Result<Vec<BlockEncoderResult>, String>

Encodes instructions. Any number of branches can be part of this block. You can use this function to move instructions from one location to another location. If the target of a branch is too far away, it'll be rewritten to a longer branch. You can disable this by passing in BlockEncoderOptions::DONT_FIX_BRANCHES. If the block has any RIP-relative memory operands, make sure the data isn't too far away from the new location of the encoded instructions. Every OS should have some API to allocate memory close (+/-2GB) to the original code location.

Errors

Returns an error message on failure.

Panics

Panics if bitness is not one of 16, 32, 64.

Arguments

• bitness: 16, 32, or 64
• blocks: All instructions
• options: Encoder options, see BlockEncoderOptions

Examples

use iced_x86::*;

// je short $-2
// add dh,cl
// sbb r9d,ebx
let bytes = b"\x75\xFC\x00\xCE\x41\x19\xD9";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
decoder.set_ip(0x1234_5678_9ABC_DEF0);
let instructions1: Vec<_> = decoder.into_iter().collect();

// je short $
let bytes = b"\x75\xFE";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
decoder.set_ip(0x1234_5678);
let instructions2: Vec<_> = decoder.into_iter().collect();

// orig_rip + 8
let block1 = InstructionBlock::new(&instructions1, 0x1234_5678_9ABC_DEF8);
// a new ip
let block2 = InstructionBlock::new(&instructions2, 0x8000_4000_2000_1000);
let bytes = match BlockEncoder::encode_slice(64, &[block1, block2], BlockEncoderOptions::NONE) {
    Err(err) => panic!("Failed: {}", err),
    Ok(result) => {
        assert_eq!(2, result.len());
        assert_eq!(vec![0x75, 0xF4, 0x00, 0xCE, 0x41, 0x19, 0xD9], result[0].code_buffer);
        assert_eq!(vec![0x75, 0xFE], result[1].code_buffer);
    }
};