Struct iced_x86::MemoryOperand

pub struct MemoryOperand {
    pub segment_prefix: Register,
    pub base: Register,
    pub index: Register,
    pub scale: u32,
    pub displacement: i32,
    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: i32

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 broadcasted memory (EVEX instructions)

Implementations

impl MemoryOperand

#[must_use]pub fn new(
    base: Register,
    index: Register,
    scale: u32,
    displacement: i32,
    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 broadcasted memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

#[must_use]pub 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 broadcasted memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

#[must_use]pub fn with_base_displ_size_bcst_seg(
    base: Register,
    displacement: i32,
    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 broadcasted memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

#[must_use]pub fn with_index_scale_displ_size_bcst_seg(
    index: Register,
    scale: u32,
    displacement: i32,
    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 broadcasted memory (EVEX instructions)
• segment_prefix: Segment override or Register::None

#[must_use]pub fn with_base_displ_bcst_seg(
    base: Register,
    displacement: i32,
    is_broadcast: bool,
    segment_prefix: Register
) -> Self

Constructor

Arguments

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

#[must_use]pub fn with_base_index_scale_displ_size(
    base: Register,
    index: Register,
    scale: u32,
    displacement: i32,
    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)

#[must_use]pub 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)

#[must_use]pub fn with_base_index(base: Register, index: Register) -> Self

Constructor

Arguments

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

#[must_use]pub fn with_base_displ_size(
    base: Register,
    displacement: i32,
    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)

#[must_use]pub fn with_index_scale_displ_size(
    index: Register,
    scale: u32,
    displacement: i32,
    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)

#[must_use]pub fn with_base_displ(base: Register, displacement: i32) -> Self

Constructor

Arguments

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

#[must_use]pub fn with_base(base: Register) -> Self

Constructor

Arguments

• base: Base register or Register::None

Trait Implementations

impl Clone for MemoryOperand

pub fn clone(&self) -> MemoryOperand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryOperand

impl Debug for MemoryOperand

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

Formats the value using the given formatter.

impl Default for MemoryOperand

pub fn default() -> MemoryOperand

Returns the "default value" for a type.

impl Eq for MemoryOperand

impl Hash for MemoryOperand

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

Feeds this value into the given Hasher.

pub 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

pub fn eq(&self, other: &MemoryOperand) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &MemoryOperand) -> bool

This method tests for !=.

impl StructuralEq for MemoryOperand

impl StructuralPartialEq for MemoryOperand