Struct iced_x86::IntelFormatter

pub struct IntelFormatter { /* private fields */ }

Intel formatter (same as Intel XED)

Examples

use iced_x86::*;

let bytes = b"\x62\xF2\x4F\xDD\x72\x50\x01";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

let mut output = String::new();
let mut formatter = IntelFormatter::new();
formatter.options_mut().set_uppercase_mnemonics(true);
formatter.format(&instr, &mut output);
assert_eq!("VCVTNE2PS2BF16 zmm2{k5}{z},zmm6,[rax+4]{1to16}", output);

Using a symbol resolver

use iced_x86::*;
use std::collections::HashMap;

let bytes = b"\x48\x8B\x8A\xA5\x5A\xA5\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

struct MySymbolResolver { map: HashMap<u64, String> }
impl SymbolResolver for MySymbolResolver {
    fn symbol(&mut self, _instruction: &Instruction, _operand: u32, _instruction_operand: Option<u32>,
         address: u64, _address_size: u32) -> Option<SymbolResult> {
        if let Some(symbol_string) = self.map.get(&address) {
            // The 'address' arg is the address of the symbol and doesn't have to be identical
            // to the 'address' arg passed to symbol(). If it's different from the input
            // address, the formatter will add +N or -N, eg. '[rax+symbol+123]'
            Some(SymbolResult::with_str(address, symbol_string.as_str()))
        } else {
            None
        }
    }
}

// Hard code the symbols, it's just an example!😄
let mut sym_map: HashMap<u64, String> = HashMap::new();
sym_map.insert(0x5AA55AA5, String::from("my_data"));

let mut output = String::new();
let resolver = Box::new(MySymbolResolver { map: sym_map });
let mut formatter = IntelFormatter::with_options(Some(resolver), None);
formatter.format(&instr, &mut output);
assert_eq!("mov rcx,[rdx+my_data]", output);

Implementations

impl IntelFormatter

pub fn new() -> Self

Creates an Intel (XED) formatter

pub fn with_options( symbol_resolver: Option<Box<dyn SymbolResolver>>, options_provider: Option<Box<dyn FormatterOptionsProvider>> ) -> Self

Creates an Intel (XED) formatter

Arguments

• symbol_resolver: Symbol resolver or None
• options_provider: Operand options provider or None

Trait Implementations

impl Default for IntelFormatter

fn default() -> Self

Returns the “default value” for a type.

impl Formatter for IntelFormatter

fn options(&self) -> &FormatterOptions

Gets the formatter options (immutable)

fn options_mut(&mut self) -> &mut FormatterOptions

Gets the formatter options (mutable)

fn format_mnemonic_options( &mut self, instruction: &Instruction, output: &mut dyn FormatterOutput, options: u32 )

Formats the mnemonic and/or any prefixes

fn operand_count(&mut self, instruction: &Instruction) -> u32

Gets the number of operands that will be formatted. A formatter can add and remove operands

fn op_access( &mut self, instruction: &Instruction, operand: u32 ) -> Result<Option<OpAccess>, IcedError>

Returns the operand access but only if it’s an operand added by the formatter. If it’s an operand that is part of Instruction, you should call eg. InstructionInfoFactory::info().

fn get_instruction_operand( &mut self, instruction: &Instruction, operand: u32 ) -> Result<Option<u32>, IcedError>

Converts a formatter operand index to an instruction operand index. Returns None if it’s an operand added by the formatter

fn get_formatter_operand( &mut self, instruction: &Instruction, instruction_operand: u32 ) -> Result<Option<u32>, IcedError>

Converts an instruction operand index to a formatter operand index. Returns None if the instruction operand isn’t used by the formatter

fn format_operand( &mut self, instruction: &Instruction, output: &mut dyn FormatterOutput, operand: u32 ) -> Result<(), IcedError>

Formats an operand. This is a formatter operand and not necessarily a real instruction operand. A formatter can add and remove operands.

fn format_operand_separator( &mut self, _instruction: &Instruction, output: &mut dyn FormatterOutput )

Formats an operand separator

fn format_all_operands( &mut self, instruction: &Instruction, output: &mut dyn FormatterOutput )

Formats all operands

fn format( &mut self, instruction: &Instruction, output: &mut dyn FormatterOutput )

Formats the whole instruction: prefixes, mnemonic, operands

fn format_register(&mut self, register: Register) -> &str

Formats a register

fn format_i8(&mut self, value: i8) -> &str

Formats a i8

fn format_i16(&mut self, value: i16) -> &str

Formats a i16

fn format_i32(&mut self, value: i32) -> &str

Formats a i32

fn format_i64(&mut self, value: i64) -> &str

Formats a i64

fn format_u8(&mut self, value: u8) -> &str

Formats a u8

fn format_u16(&mut self, value: u16) -> &str

Formats a u16

fn format_u32(&mut self, value: u32) -> &str

Formats a u32

fn format_u64(&mut self, value: u64) -> &str

Formats a u64

fn format_i8_options( &mut self, value: i8, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a i8

fn format_i16_options( &mut self, value: i16, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a i16

fn format_i32_options( &mut self, value: i32, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a i32

fn format_i64_options( &mut self, value: i64, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a i64

fn format_u8_options( &mut self, value: u8, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a u8

fn format_u16_options( &mut self, value: u16, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a u16

fn format_u32_options( &mut self, value: u32, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a u32

fn format_u64_options( &mut self, value: u64, number_options: &NumberFormattingOptions<'_> ) -> &str

Formats a u64

fn format_mnemonic( &mut self, instruction: &Instruction, output: &mut dyn FormatterOutput )

Formats the mnemonic and any prefixes