Struct iced_x86::BlockEncoder

pub struct BlockEncoder { /* fields omitted */ }

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

Implementations

impl BlockEncoder

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

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 if it failed to encode one or more instructions.

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::with_ip(64, bytes, 0x1234_5678_9ABC_DEF0, DecoderOptions::NONE);
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!(bytes, vec![0x75, 0xF4, 0x00, 0xCE, 0x41, 0x19, 0xD9]);

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

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 if it failed to encode one or more instructions.

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::with_ip(64, bytes, 0x1234_5678_9ABC_DEF0, DecoderOptions::NONE);
let instructions1: Vec<_> = decoder.into_iter().collect();

// je short $
let bytes = b"\x75\xFE";
let mut decoder = Decoder::with_ip(64, bytes, 0x1234_5678, DecoderOptions::NONE);
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!(result.len(), 2);
        assert_eq!(result[0].code_buffer, vec![0x75, 0xF4, 0x00, 0xCE, 0x41, 0x19, 0xD9]);
        assert_eq!(result[1].code_buffer, vec![0x75, 0xFE]);
    }
};