Struct iced_x86::MasmFormatter

pub struct MasmFormatter { /* private fields */ }

Masm formatter

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 = MasmFormatter::new();
formatter.options_mut().set_uppercase_mnemonics(true);
formatter.format(&instr, &mut output);
assert_eq!("VCVTNE2PS2BF16 zmm2{k5}{z},zmm6,dword bcst [rax+4]", 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 = MasmFormatter::with_options(Some(resolver), None);
formatter.format(&instr, &mut output);
assert_eq!("mov rcx,[rdx+my_data]", output);

Implementations

impl MasmFormatter

pub fn new() -> Self

Creates a masm formatter

Examples found in repository

src/formatter/masm.rs (line 96)

	fn default() -> Self {
		MasmFormatter::new()
	}

src/instruction.rs (line 3774)

	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		//
		// if the order of #[cfg()] checks gets updated, also update the `display_trait()` test method
		//
		#[cfg(any(feature = "gas", feature = "intel", feature = "masm", feature = "nasm"))]
		{
			#[cfg(feature = "masm")]
			let mut formatter = MasmFormatter::new();

			#[cfg(all(not(feature = "masm"), feature = "nasm"))]
			let mut formatter = NasmFormatter::new();

			#[cfg(all(not(feature = "masm"), not(feature = "nasm"), feature = "intel"))]
			let mut formatter = IntelFormatter::new();

			#[cfg(all(not(feature = "masm"), not(feature = "nasm"), not(feature = "intel"), feature = "gas"))]
			let mut formatter = GasFormatter::new();

			let mut output = FmtFormatterOutput::new(f);
			formatter.format(self, &mut output);
			output.result
		}
		#[cfg(not(any(feature = "gas", feature = "intel", feature = "masm", feature = "nasm")))]
		{
			let mut formatter = FastFormatter::new();

			let mut output = alloc::string::String::new();
			formatter.format(self, &mut output);
			f.write_str(&output)
		}
	}

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

Creates a masm formatter

Arguments

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

Examples found in repository

src/formatter/masm.rs (line 115)

	pub fn new() -> Self {
		MasmFormatter::with_options(None, None)
	}

Trait Implementations

impl Default for MasmFormatter

fn default() -> Self

Returns the “default value” for a type.

impl Formatter for MasmFormatter

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