Enum simics_api_sys::bindings::ppc_mem_instr_origin_t

#[repr(u32)]
pub enum ppc_mem_instr_origin_t {
    Normal_Load_Store = 0,
    Caching_Inhibited = 1,
    Instr_Multiple = 2,
    Instr_String = 3,
    Instr_Altivec_Element = 4,
    Instr_dcbt = 5,
    Instr_dcbst = 6,
    Instr_dcbtst = 7,
    Instr_dcbi = 8,
    Instr_dcbf = 9,
    Instr_dcbfl = 10,
    Instr_dcba = 11,
    Instr_dcbz = 12,
    Instr_icbi = 13,
    Instr_dst = 14,
    Instr_dstt = 15,
    Instr_dstst = 16,
    Instr_dststt = 17,
    Instr_dcblc_l1 = 18,
    Instr_dcblc_l2 = 19,
    Instr_dcbtls_l1 = 20,
    Instr_dcbtls_l2 = 21,
    Instr_dcbtstls_l1 = 22,
    Instr_dcbtstls_l2 = 23,
    Instr_icblc_l1 = 24,
    Instr_icblc_l2 = 25,
    Instr_icbtls_l1 = 26,
    Instr_icbtls_l2 = 27,
    Instr_lwarx = 28,
    Instr_stwcx = 29,
    Instr_ldarx = 30,
    Instr_stdcx = 31,
    Instr_lq = 32,
    Instr_stq = 33,
    Instr_sync = 34,
    Instr_eieio = 35,
    Instr_ecowx = 36,
    Instr_eciwx = 37,
    Instr_tlbie = 38,
    Instr_tlbsync = 39,
    Instr_isync = 40,
    Instr_lfdp = 41,
    Instr_stfdp = 42,
    Instr_spe = 43,
    Instr_dcbal = 44,
    Instr_dcblc_pc = 45,
    Instr_dcbtls_pc = 46,
    Instr_dcbtstls_pc = 47,
    Instr_icblc_pc = 48,
    Instr_icbtls_pc = 49,
    Instr_Fpu = 50,
}

Variants

Normal_Load_Store = 0

Normal load or store instructions

Caching_Inhibited = 1

No data touched by the load/store will be placed in cache

Instr_Multiple = 2

load/store multiple

Instr_String = 3

load/store string

Instr_Altivec_Element = 4

Altivec load/store element

Instr_dcbt = 5

data cache block touch

Instr_dcbst = 6

data cache block store

Instr_dcbtst = 7

data cache block touch for store

Instr_dcbi = 8

data cache block invalidate

Instr_dcbf = 9

data cache block flush

Instr_dcbfl = 10

data cache block flush local

Instr_dcba = 11

data cache block allocate

Instr_dcbz = 12

data cache block to zero

Instr_icbi = 13

instruction cache block invalidate

Instr_dst = 14

data stream touch

Instr_dstt = 15

data stream touch transient

Instr_dstst = 16

data stream touch for store

Instr_dststt = 17

data stream touch for store transient

Instr_dcblc_l1 = 18

data cache block lock clear (L1)

Instr_dcblc_l2 = 19

data cache block lock clear (L2)

Instr_dcbtls_l1 = 20

data cache block touch and lock set (L1)

Instr_dcbtls_l2 = 21

data cache block touch and lock set (L1)

Instr_dcbtstls_l1 = 22

data cache block touch for store and lock set (L1)

Instr_dcbtstls_l2 = 23

data cache block touch for store and lock set (L1)

Instr_icblc_l1 = 24

instruction cache block clear (L1)

Instr_icblc_l2 = 25

instruction cache block clear (L2)

Instr_icbtls_l1 = 26

instruction cache block touch and lock set (L1)

Instr_icbtls_l2 = 27

instruction cache block touch and lock set (L1)

Instr_lwarx = 28

Other loads/stores or cache affecting instructions

Instr_stwcx = 29

Other loads/stores or cache affecting instructions

Instr_ldarx = 30

Other loads/stores or cache affecting instructions

Instr_stdcx = 31

Other loads/stores or cache affecting instructions

Instr_lq = 32

Other loads/stores or cache affecting instructions

Instr_stq = 33

Other loads/stores or cache affecting instructions

Instr_sync = 34

Other cache affecting instructions

Instr_eieio = 35

Other cache affecting instructions

Instr_ecowx = 36

Other cache affecting instructions

Instr_eciwx = 37

Other cache affecting instructions

Instr_tlbie = 38

Other cache affecting instructions

Instr_tlbsync = 39

Other cache affecting instructions

Instr_isync = 40

Other cache affecting instructions

Instr_lfdp = 41

Load Floating point Double Pair

Instr_stfdp = 42

Store Floating point Double Pair

Instr_spe = 43

Instr_dcbal = 44

Obsolete - use Instr_dcba.

Instr_dcblc_pc = 45

data cache block lock clear

Instr_dcbtls_pc = 46

data cache block touch and lock set

Instr_dcbtstls_pc = 47

data cache block touch for store and lock set

Instr_icblc_pc = 48

instruction cache block clear

Instr_icbtls_pc = 49

instruction cache block touch and lock set

Instr_Fpu = 50

Load/store from FPU unit

Trait Implementations

impl Clone for ppc_mem_instr_origin_t

fn clone(&self) -> ppc_mem_instr_origin_t

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ppc_mem_instr_origin_t

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

Formats the value using the given formatter.

impl Hash for ppc_mem_instr_origin_t

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 Ord for ppc_mem_instr_origin_t

fn cmp(&self, other: &ppc_mem_instr_origin_t) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for ppc_mem_instr_origin_t

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

fn partial_cmp(&self, other: &ppc_mem_instr_origin_t) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for ppc_mem_instr_origin_t

impl Eq for ppc_mem_instr_origin_t

impl StructuralPartialEq for ppc_mem_instr_origin_t