Struct iced_x86::MemoryOperand

pub struct MemoryOperand {
    pub segment_prefix: Register,
    pub base: Register,
    pub index: Register,
    pub scale: u32,
    pub displacement: i64,
    pub displ_size: u32,
    pub is_broadcast: bool,
}

Memory operand passed to one of Instruction’s with_*() constructor methods

Fields

segment_prefix: Register

Segment override or Register::None

base: Register

Base register or Register::None

index: Register

Index register or Register::None

scale: u32

Index register scale (1, 2, 4, or 8)

displacement: i64

Memory displacement

displ_size: u32

0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)

is_broadcast: bool

true if it’s broadcast memory (EVEX instructions)

Implementations

impl MemoryOperand

pub const fn new(
    base: Register,
    index: Register,
    scale: u32,
    displacement: i64,
    displ_size: u32,
    is_broadcast: bool,
    segment_prefix: Register
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• index: Index register or Register::None
• scale: Index register scale (1, 2, 4, or 8)
• displacement: Memory displacement
• displ_size: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)
• is_broadcast: true if it’s broadcast memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

pub const fn with_base_index_scale_bcst_seg(
    base: Register,
    index: Register,
    scale: u32,
    is_broadcast: bool,
    segment_prefix: Register
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• index: Index register or Register::None
• scale: Index register scale (1, 2, 4, or 8)
• is_broadcast: true if it’s broadcast memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

pub const fn with_base_displ_size_bcst_seg(
    base: Register,
    displacement: i64,
    displ_size: u32,
    is_broadcast: bool,
    segment_prefix: Register
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• displacement: Memory displacement
• displ_size: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)
• is_broadcast: true if it’s broadcast memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

pub const fn with_index_scale_displ_size_bcst_seg(
    index: Register,
    scale: u32,
    displacement: i64,
    displ_size: u32,
    is_broadcast: bool,
    segment_prefix: Register
) -> Self

Constructor

Arguments

• index: Index register or Register::None
• scale: Index register scale (1, 2, 4, or 8)
• displacement: Memory displacement
• displ_size: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)
• is_broadcast: true if it’s broadcast memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

pub const fn with_base_displ_bcst_seg(
    base: Register,
    displacement: i64,
    is_broadcast: bool,
    segment_prefix: Register
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• displacement: Memory displacement
• is_broadcast: true if it’s broadcast memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

pub const fn with_base_index_scale_displ_size(
    base: Register,
    index: Register,
    scale: u32,
    displacement: i64,
    displ_size: u32
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• index: Index register or Register::None
• scale: Index register scale (1, 2, 4, or 8)
• displacement: Memory displacement
• displ_size: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)

pub const fn with_base_index_scale(
    base: Register,
    index: Register,
    scale: u32
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• index: Index register or Register::None
• scale: Index register scale (1, 2, 4, or 8)

pub const fn with_base_index(base: Register, index: Register) -> Self

Constructor

Arguments

• base: Base register or Register::None
• index: Index register or Register::None

pub const fn with_base_displ_size(
    base: Register,
    displacement: i64,
    displ_size: u32
) -> Self

Constructor

Arguments

• base: Base register or Register::None
• displacement: Memory displacement
• displ_size: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)

pub const fn with_index_scale_displ_size(
    index: Register,
    scale: u32,
    displacement: i64,
    displ_size: u32
) -> Self

Constructor

Arguments

• index: Index register or Register::None
• scale: Index register scale (1, 2, 4, or 8)
• displacement: Memory displacement
• displ_size: 0 (no displ), 1 (16/32/64-bit, but use 2/4/8 if it doesn’t fit in a i8), 2 (16-bit), 4 (32-bit) or 8 (64-bit)

pub const fn with_base_displ(base: Register, displacement: i64) -> Self

Constructor

Arguments

• base: Base register or Register::None
• displacement: Memory displacement

pub const fn with_base(base: Register) -> Self

Constructor

Arguments

• base: Base register or Register::None

pub const fn with_displ(displacement: u64, displ_size: u32) -> Self

Constructor

Arguments

• displacement: Memory displacement
• displ_size: 2 (16-bit), 4 (32-bit) or 8 (64-bit)

Trait Implementations

impl Clone for MemoryOperand

fn clone(&self) -> MemoryOperand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryOperand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MemoryOperand

fn default() -> MemoryOperand

Returns the “default value” for a type.

impl Hash for MemoryOperand

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl PartialEq<MemoryOperand> for MemoryOperand

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

impl Eq for MemoryOperand

impl StructuralEq for MemoryOperand

impl StructuralPartialEq for MemoryOperand