Struct 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 duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryOperand

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 Eq for MemoryOperand

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MemoryOperand

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MemoryOperand