Struct minidump::format::CONTEXT_ARM64

pub struct CONTEXT_ARM64 {
    pub context_flags: u32,
    pub cpsr: u32,
    pub iregs: [u64; 31],
    pub sp: u64,
    pub pc: u64,
    pub float_regs: [u128; 32],
    pub fpcr: u32,
    pub fpsr: u32,
    pub bcr: [u32; 8],
    pub bvr: [u64; 8],
    pub wcr: [u32; 2],
    pub wvr: [u64; 2],
}

A (microsoft-style) aarch64 (arm64) CPU context

This matches the layout of how Windows defines this type. Breakpad defines it in an equivalent but more-quirky way that relies more on packing.

For general purpose registers:

• microsoft: make iregs have 31 values and have sp and pc as explicit fields.
• breakpad make iregs have 33 values, no explicit fields.

For float registers:

• microsoft: inline the fields for float_regs, fpcr, fpsr.
• breakpad: wrap them in a struct.

---

Why we went with these definitions:

• ARM64 actually defines x0..x30 register names, but sp and pc aren’t “x31” and “x32”. Breakpad is effectively punning them as such, and that’s kinda weird?

• Microsft’s inlining of the float registers eliminates any need for padding on all platforms (note how there’s always an even number of u32’s before a u64, and an even number of u64’s before a u128!)

NOTE: if you ever decide to try to make this repr(C) and get really clever, note that microsoft aligns this to 16 (and as of this writing, rust does not consistently aling u128 as such).

Fields

context_flags: u32

cpsr: u32

iregs: [u64; 31]

[x0, x1, ..., x28, fp, lr]. See Arm64RegisterNumbers.

sp: u64

pc: u64

float_regs: [u128; 32]

float/NEON registers [d0, d1, ..., d31]

fpcr: u32

FPU control register.

fpsr: u32

FPU status register.

bcr: [u32; 8]

bvr: [u64; 8]

wcr: [u32; 2]

wvr: [u64; 2]

Trait Implementations

impl Clone for CONTEXT_ARM64

fn clone(&self) -> CONTEXT_ARM64

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CpuContext for CONTEXT_ARM64

type Register = u64

The word size of general-purpose registers in the context.

const REGISTERS: &'static [&'static str] = _

General purpose registers in this context type.

fn memoize_register(&self, reg: &str) -> Option<&'static str>

Gets a static version of the given register name, if possible.

fn register_is_valid(&self, reg: &str, valid: &MinidumpContextValidity) -> bool

Gets whether the given register is valid

fn get_register_always(&self, reg: &str) -> u64

Get a register value regardless of whether it is valid.

fn set_register(&mut self, reg: &str, val: Self::Register) -> Option<()>

Set a register value, if that register name it exists.

fn stack_pointer_register_name(&self) -> &'static str

Gets the name of the stack pointer register (for use with get_register/set_register).

fn instruction_pointer_register_name(&self) -> &'static str

Gets the name of the instruction pointer register (for use with get_register/set_register).

fn get_register( &self, reg: &str, valid: &MinidumpContextValidity ) -> Option<Self::Register>

Get a register value if it is valid.

fn format_register(&self, reg: &str) -> String

Return a String containing the value of reg formatted to its natural width.

fn registers(&self) -> CpuRegisters<'_, Self>

An iterator over all registers in this context.

fn valid_registers<'a>( &'a self, valid: &'a MinidumpContextValidity ) -> CpuRegisters<'a, Self>

An iterator over valid registers in this context.

impl Debug for CONTEXT_ARM64

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

Formats the value using the given formatter.

impl Default for CONTEXT_ARM64

fn default() -> CONTEXT_ARM64

Returns the “default value” for a type.

impl SizeWith<Endian> for CONTEXT_ARM64

fn size_with(ctx: &Endian) -> usize

impl<'a> TryFromCtx<'a, Endian> for CONTEXT_ARM64

where CONTEXT_ARM64: 'a,

type Error = Error

fn try_from_ctx( src: &'a [u8], ctx: Endian ) -> Result<(CONTEXT_ARM64, usize), <CONTEXT_ARM64 as TryFromCtx<'a, Endian>>::Error>

impl<'a> TryIntoCtx<Endian> for &'a CONTEXT_ARM64

type Error = Error

fn try_into_ctx( self, dst: &mut [u8], ctx: Endian ) -> Result<usize, <&'a CONTEXT_ARM64 as TryIntoCtx<Endian>>::Error>

impl TryIntoCtx<Endian> for CONTEXT_ARM64

type Error = Error

fn try_into_ctx( self, dst: &mut [u8], ctx: Endian ) -> Result<usize, <CONTEXT_ARM64 as TryIntoCtx<Endian>>::Error>