Enum CpuFamily

#[non_exhaustive]
#[repr(u32)]
pub enum CpuFamily {
    Unknown = 0,
    Intel32 = 1,
    Amd64 = 2,
    Arm32 = 3,
    Arm64 = 4,
    Ppc32 = 5,
    Ppc64 = 6,
    Mips32 = 7,
    Mips64 = 8,
    Arm64_32 = 9,
    Wasm32 = 10,
}

Represents a family of CPUs.

This is strongly connected to the Arch type, but reduces the selection to a range of families with distinct properties, such as a generally common instruction set and pointer size.

This enumeration is represented as u32 for C-bindings and lowlevel APIs.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unknown = 0

Any other CPU family that is not explicitly supported.

Intel32 = 1

32-bit little-endian CPUs using the Intel 8086 instruction set, also known as x86.

Amd64 = 2

64-bit little-endian, also known as x86_64, now widely used by Intel and AMD.

Arm32 = 3

32-bit ARM.

Arm64 = 4

64-bit ARM (e.g. ARMv8-A).

Ppc32 = 5

32-bit big-endian PowerPC.

Ppc64 = 6

64-bit big-endian PowerPC.

Mips32 = 7

32-bit MIPS.

Mips64 = 8

64-bit MIPS.

Arm64_32 = 9

ILP32 ABI on 64-bit ARM.

Wasm32 = 10

Virtual WASM 32-bit architecture.

Implementations

impl CpuFamily

pub fn pointer_size(self) -> Option<usize>

Returns the native pointer size.

This commonly defines the size of CPU registers including the instruction pointer, and the size of all pointers on the platform.

This function returns None if the CPU family is unknown.

Examples

use symbolic_common::CpuFamily;

assert_eq!(CpuFamily::Amd64.pointer_size(), Some(8));
assert_eq!(CpuFamily::Intel32.pointer_size(), Some(4));

pub fn instruction_alignment(self) -> Option<u64>

Returns instruction alignment if fixed.

Some instruction sets, such as Intel’s x86, use variable length instruction encoding. Others, such as ARM, have fixed length instructions. This method returns Some for fixed size instructions and None for variable-length instruction sizes.

Examples

use symbolic_common::CpuFamily;

// variable length on x86_64:
assert_eq!(CpuFamily::Amd64.instruction_alignment(), None);

// 4-byte alignment on all 64-bit ARM variants:
assert_eq!(CpuFamily::Arm64.instruction_alignment(), Some(4));

pub fn ip_register_name(self) -> Option<&'static str>

Returns the name of the instruction pointer register.

The instruction pointer register holds a pointer to currrent code execution at all times. This is a differrent register on each CPU family. The size of the value in this register is specified by pointer_size.

Returns None if the CPU family is unknown.

Examples

use symbolic_common::CpuFamily;

assert_eq!(CpuFamily::Amd64.ip_register_name(), Some("rip"));

Trait Implementations

impl Clone for CpuFamily

fn clone(&self) -> CpuFamily

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CpuFamily

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

Formats the value using the given formatter.

impl Default for CpuFamily

fn default() -> CpuFamily

Returns the “default value” for a type.

impl Hash for CpuFamily

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 CpuFamily

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

Restrict a value to a certain interval.

impl PartialEq for CpuFamily

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

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

impl Eq for CpuFamily

impl StructuralPartialEq for CpuFamily