mirror of
https://github.com/chromium/crashpad.git
synced 2025-03-17 16:43:53 +00:00
doc/support/crashpad.doxy is updated with: ``` % doxygen -u doc/support/crashpad.doxy […] % doxygen -v 1.13.2 ``` Additional updates to doc/support/crashpad.doxy are made: - The settings for `DISABLE_INDEX` and `GENERATE_TREEVIEW` are updated, as Doxygen’s defaults have changed. This switches from the top-of-page index to the side-of-page tree view. - The TODO and Deprecated sections have become more prominent under the side-of-page tree view than they were with the top-of-page index, and they’re not very useful in Crashpad documentation, so they’re disabled by setting `GENERATE_TODOLIST` and `GENERATE_DEPRECATEDLIST` appropriately. The similar (but unused in Crashpad) `GENERATE_TESTLIST` and `GENERATE_BUGLIST` are also disabled. - `USE_DOT` is now set, to use `dot` from GraphViz to generate SVG diagrams. These look better than the PNGs that Doxygen generated without `dot`. `DOT_COMMON_ATTR` and `DOT_EDGE_ATTR` are set to make the fonts used in GraphViz-generated SVGs match those used in Doxygen-generated HTML/CSS. - `EXCLUDE` has been updated to drop directories that no longer exist (compat/non_cxx11_lib) and add ones that now do (compat/android, compat/ios, and compat/linux). - Some values that were otherwise unused in doc/support/crashpad.doxy are set back to their default values. The differences from the default configuration are shown with `doxygen -x doc/support/crashpad.doxy`, and a configuration template with default values can be generated for inspection with `doxygen -g /tmp/template.doxy`. The tags affected are: - `MATHJAX_RELPATH`, unused since `USE_MATHJAX` is `NO`. - `LATEX_CMD_NAME` and `LATEX_BIB_STYLE`, unused since `USE_LATEX` is `NO`). - `EXCLUDE_PATTERNS`, unused since `EXCLUDE_PATH` is empty. doc/support/doxygen_crashpad.css is updated to change the non-monospaced font from Open Sans to Noto Sans. It is also updated to use the CSS properties Doxygen defines for the purpose, rather than monkeying around with custom selectors. The properties can be discovered by running `doxygen -w html header.html footer.html customdoxygen.css doc/support/crashpad.doxy` and reviewing customdoxygen.css. doc/support/generate.sh is updated to further execute doc/support/generate_doxygen.py by invoking directly and relying on its `#!/usr/bin/env python3` line rather than invoking via `python`, which is no longer available on many systems. doc/support/generate_doxygen.py has already been Python 3-compatible since f88a116c0e2e (https://chromium-review.googlesource.com/c/3542572, 2022-03-23). Finally, there are a number of changes to fix Doxygen warnings produced by the new Doxygen version or because of new code that has not yet been run through Doxygen during a test run. Change-Id: I436688b16530cb0a07dbf89d32601fff689ac2f2 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/6180234 Reviewed-by: Justin Cohen <justincohen@chromium.org> Reviewed-by: Joshua Peraza <jperaza@chromium.org> Commit-Queue: Mark Mentovai <mark@chromium.org>
692 lines
23 KiB
C++
692 lines
23 KiB
C++
// Copyright 2014 The Crashpad Authors
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// http://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
|
||
#ifndef CRASHPAD_MINIDUMP_MINIDUMP_CONTEXT_H_
|
||
#define CRASHPAD_MINIDUMP_MINIDUMP_CONTEXT_H_
|
||
|
||
#include <stdint.h>
|
||
|
||
#include "base/compiler_specific.h"
|
||
#include "snapshot/cpu_context.h"
|
||
#include "util/numeric/int128.h"
|
||
|
||
namespace crashpad {
|
||
|
||
//! \brief Architecture-independent flags for `context_flags` fields in Minidump
|
||
//! context structures.
|
||
//
|
||
// https://zachsaw.blogspot.com/2010/11/wow64-bug-getthreadcontext-may-return.html#c5639760895973344002
|
||
enum MinidumpContextFlags : uint32_t {
|
||
//! \brief The thread was executing a trap handler in kernel mode
|
||
//! (`CONTEXT_EXCEPTION_ACTIVE`).
|
||
//!
|
||
//! If this bit is set, it indicates that the context is from a thread that
|
||
//! was executing a trap handler in the kernel. This bit is only valid when
|
||
//! ::kMinidumpContextExceptionReporting is also set. This bit is only used on
|
||
//! Windows.
|
||
kMinidumpContextExceptionActive = 0x08000000,
|
||
|
||
//! \brief The thread was executing a system call in kernel mode
|
||
//! (`CONTEXT_SERVICE_ACTIVE`).
|
||
//!
|
||
//! If this bit is set, it indicates that the context is from a thread that
|
||
//! was executing a system call in the kernel. This bit is only valid when
|
||
//! ::kMinidumpContextExceptionReporting is also set. This bit is only used on
|
||
//! Windows.
|
||
kMinidumpContextServiceActive = 0x10000000,
|
||
|
||
//! \brief Kernel-mode state reporting is desired
|
||
//! (`CONTEXT_EXCEPTION_REQUEST`).
|
||
//!
|
||
//! This bit is not used in context structures containing snapshots of thread
|
||
//! CPU context. It used when calling `GetThreadContext()` on Windows to
|
||
//! specify that kernel-mode state reporting
|
||
//! (::kMinidumpContextExceptionReporting) is desired in the returned context
|
||
//! structure.
|
||
kMinidumpContextExceptionRequest = 0x40000000,
|
||
|
||
//! \brief Kernel-mode state reporting is provided
|
||
//! (`CONTEXT_EXCEPTION_REPORTING`).
|
||
//!
|
||
//! If this bit is set, it indicates that the bits indicating how the thread
|
||
//! had entered kernel mode (::kMinidumpContextExceptionActive and
|
||
//! ::kMinidumpContextServiceActive) are valid. This bit is only used on
|
||
//! Windows.
|
||
kMinidumpContextExceptionReporting = 0x80000000,
|
||
};
|
||
|
||
//! \brief 32-bit x86-specifc flags for MinidumpContextX86::context_flags.
|
||
enum MinidumpContextX86Flags : uint32_t {
|
||
//! \brief Identifies the context structure as 32-bit x86. This is the same as
|
||
//! `CONTEXT_i386` and `CONTEXT_i486` on Windows for this architecture.
|
||
kMinidumpContextX86 = 0x00010000,
|
||
|
||
//! \brief Indicates the validity of control registers (`CONTEXT_CONTROL`).
|
||
//!
|
||
//! The `ebp`, `eip`, `cs`, `eflags`, `esp`, and `ss` fields are valid.
|
||
kMinidumpContextX86Control = kMinidumpContextX86 | 0x00000001,
|
||
|
||
//! \brief Indicates the validity of non-control integer registers
|
||
//! (`CONTEXT_INTEGER`).
|
||
//!
|
||
//! The `edi`, `esi`, `ebx`, `edx`, `ecx`, and `eax` fields are valid.
|
||
kMinidumpContextX86Integer = kMinidumpContextX86 | 0x00000002,
|
||
|
||
//! \brief Indicates the validity of non-control segment registers
|
||
//! (`CONTEXT_SEGMENTS`).
|
||
//!
|
||
//! The `gs`, `fs`, `es`, and `ds` fields are valid.
|
||
kMinidumpContextX86Segment = kMinidumpContextX86 | 0x00000004,
|
||
|
||
//! \brief Indicates the validity of floating-point state
|
||
//! (`CONTEXT_FLOATING_POINT`).
|
||
//!
|
||
//! The `fsave` field is valid. The `float_save` field is included in this
|
||
//! definition, but its members have no practical use asdie from `fsave`.
|
||
kMinidumpContextX86FloatingPoint = kMinidumpContextX86 | 0x00000008,
|
||
|
||
//! \brief Indicates the validity of debug registers
|
||
//! (`CONTEXT_DEBUG_REGISTERS`).
|
||
//!
|
||
//! The `dr0` through `dr3`, `dr6`, and `dr7` fields are valid.
|
||
kMinidumpContextX86Debug = kMinidumpContextX86 | 0x00000010,
|
||
|
||
//! \brief Indicates the validity of extended registers in `fxsave` format
|
||
//! (`CONTEXT_EXTENDED_REGISTERS`).
|
||
//!
|
||
//! The `extended_registers` field is valid and contains `fxsave` data.
|
||
kMinidumpContextX86Extended = kMinidumpContextX86 | 0x00000020,
|
||
|
||
//! \brief Indicates the validity of `xsave` data (`CONTEXT_XSTATE`).
|
||
//!
|
||
//! The context contains `xsave` data. This is used with an extended context
|
||
//! structure not currently defined here.
|
||
kMinidumpContextX86Xstate = kMinidumpContextX86 | 0x00000040,
|
||
|
||
//! \brief Indicates the validity of control, integer, and segment registers.
|
||
//! (`CONTEXT_FULL`).
|
||
kMinidumpContextX86Full = kMinidumpContextX86Control |
|
||
kMinidumpContextX86Integer |
|
||
kMinidumpContextX86Segment,
|
||
|
||
//! \brief Indicates the validity of all registers except `xsave` data.
|
||
//! (`CONTEXT_ALL`).
|
||
kMinidumpContextX86All =
|
||
kMinidumpContextX86Full | kMinidumpContextX86FloatingPoint |
|
||
kMinidumpContextX86Debug | kMinidumpContextX86Extended,
|
||
};
|
||
|
||
//! \brief A 32-bit x86 CPU context (register state) carried in a minidump file.
|
||
//!
|
||
//! This is analogous to the `CONTEXT` structure on Windows when targeting
|
||
//! 32-bit x86, and the `WOW64_CONTEXT` structure when targeting an x86-family
|
||
//! CPU, either 32- or 64-bit. This structure is used instead of `CONTEXT` or
|
||
//! `WOW64_CONTEXT` to make it available when targeting other architectures.
|
||
//!
|
||
//! \note This structure doesn’t carry `dr4` or `dr5`, which are obsolete and
|
||
//! normally alias `dr6` and `dr7`, respectively. See Intel Software
|
||
//! Developer’s Manual, Volume 3B: System Programming, Part 2 (253669-052),
|
||
//! 17.2.2 “Debug Registers DR4 and DR5”.
|
||
struct MinidumpContextX86 {
|
||
//! \brief A bitfield composed of values of #MinidumpContextFlags and
|
||
//! #MinidumpContextX86Flags.
|
||
//!
|
||
//! This field identifies the context structure as a 32-bit x86 CPU context,
|
||
//! and indicates which other fields in the structure are valid.
|
||
uint32_t context_flags;
|
||
|
||
uint32_t dr0;
|
||
uint32_t dr1;
|
||
uint32_t dr2;
|
||
uint32_t dr3;
|
||
uint32_t dr6;
|
||
uint32_t dr7;
|
||
|
||
// CPUContextX86::Fsave has identical layout to what the x86 CONTEXT structure
|
||
// places here.
|
||
CPUContextX86::Fsave fsave;
|
||
union {
|
||
uint32_t spare_0; // As in the native x86 CONTEXT structure since Windows 8
|
||
uint32_t cr0_npx_state; // As in WOW64_CONTEXT and older SDKs’ x86 CONTEXT
|
||
} float_save;
|
||
|
||
uint32_t gs;
|
||
uint32_t fs;
|
||
uint32_t es;
|
||
uint32_t ds;
|
||
|
||
uint32_t edi;
|
||
uint32_t esi;
|
||
uint32_t ebx;
|
||
uint32_t edx;
|
||
uint32_t ecx;
|
||
uint32_t eax;
|
||
|
||
uint32_t ebp;
|
||
uint32_t eip;
|
||
uint32_t cs;
|
||
uint32_t eflags;
|
||
uint32_t esp;
|
||
uint32_t ss;
|
||
|
||
// CPUContextX86::Fxsave has identical layout to what the x86 CONTEXT
|
||
// structure places here.
|
||
CPUContextX86::Fxsave fxsave;
|
||
};
|
||
|
||
//! \brief x86_64-specific flags for MinidumpContextAMD64::context_flags.
|
||
enum MinidumpContextAMD64Flags : uint32_t {
|
||
//! \brief Identifies the context structure as x86_64. This is the same as
|
||
//! `CONTEXT_AMD64` on Windows for this architecture.
|
||
kMinidumpContextAMD64 = 0x00100000,
|
||
|
||
//! \brief Indicates the validity of control registers (`CONTEXT_CONTROL`).
|
||
//!
|
||
//! The `cs`, `ss`, `eflags`, `rsp`, and `rip` fields are valid.
|
||
kMinidumpContextAMD64Control = kMinidumpContextAMD64 | 0x00000001,
|
||
|
||
//! \brief Indicates the validity of non-control integer registers
|
||
//! (`CONTEXT_INTEGER`).
|
||
//!
|
||
//! The `rax`, `rcx`, `rdx`, `rbx`, `rbp`, `rsi`, `rdi`, and `r8` through
|
||
//! `r15` fields are valid.
|
||
kMinidumpContextAMD64Integer = kMinidumpContextAMD64 | 0x00000002,
|
||
|
||
//! \brief Indicates the validity of non-control segment registers
|
||
//! (`CONTEXT_SEGMENTS`).
|
||
//!
|
||
//! The `ds`, `es`, `fs`, and `gs` fields are valid.
|
||
kMinidumpContextAMD64Segment = kMinidumpContextAMD64 | 0x00000004,
|
||
|
||
//! \brief Indicates the validity of floating-point state
|
||
//! (`CONTEXT_FLOATING_POINT`).
|
||
//!
|
||
//! The `xmm0` through `xmm15` fields are valid.
|
||
kMinidumpContextAMD64FloatingPoint = kMinidumpContextAMD64 | 0x00000008,
|
||
|
||
//! \brief Indicates the validity of debug registers
|
||
//! (`CONTEXT_DEBUG_REGISTERS`).
|
||
//!
|
||
//! The `dr0` through `dr3`, `dr6`, and `dr7` fields are valid.
|
||
kMinidumpContextAMD64Debug = kMinidumpContextAMD64 | 0x00000010,
|
||
|
||
//! \brief Indicates the validity of `xsave` data (`CONTEXT_XSTATE`).
|
||
//!
|
||
//! The context contains `xsave` data. This is used with an extended context
|
||
//! structure which is partly implemented for CET state only.
|
||
kMinidumpContextAMD64Xstate = kMinidumpContextAMD64 | 0x00000040,
|
||
|
||
//! \brief Indicates the validity of control, integer, and floating-point
|
||
//! registers (`CONTEXT_FULL`).
|
||
kMinidumpContextAMD64Full = kMinidumpContextAMD64Control |
|
||
kMinidumpContextAMD64Integer |
|
||
kMinidumpContextAMD64FloatingPoint,
|
||
|
||
//! \brief Indicates the validity of all registers except `xsave` data
|
||
//! (`CONTEXT_ALL`).
|
||
kMinidumpContextAMD64All = kMinidumpContextAMD64Full |
|
||
kMinidumpContextAMD64Segment |
|
||
kMinidumpContextAMD64Debug,
|
||
};
|
||
|
||
//! \brief An x86_64 (AMD64) CPU context (register state) carried in a minidump
|
||
//! file.
|
||
//!
|
||
//! This is analogous to the `CONTEXT` structure on Windows when targeting
|
||
//! x86_64. This structure is used instead of `CONTEXT` to make it available
|
||
//! when targeting other architectures.
|
||
//!
|
||
//! \note This structure doesn’t carry `dr4` or `dr5`, which are obsolete and
|
||
//! normally alias `dr6` and `dr7`, respectively. See Intel Software
|
||
//! Developer’s Manual, Volume 3B: System Programming, Part 2 (253669-052),
|
||
//! 17.2.2 “Debug Registers DR4 and DR5”.
|
||
struct alignas(16) MinidumpContextAMD64 {
|
||
//! \brief Register parameter home address.
|
||
//!
|
||
//! On Windows, this field may contain the “home” address (on-stack, in the
|
||
//! shadow area) of a parameter passed by register. This field is present for
|
||
//! convenience but is not necessarily populated, even if a corresponding
|
||
//! parameter was passed by register.
|
||
//!
|
||
//! \{
|
||
uint64_t p1_home;
|
||
uint64_t p2_home;
|
||
uint64_t p3_home;
|
||
uint64_t p4_home;
|
||
uint64_t p5_home;
|
||
uint64_t p6_home;
|
||
//! \}
|
||
|
||
//! \brief A bitfield composed of values of #MinidumpContextFlags and
|
||
//! #MinidumpContextAMD64Flags.
|
||
//!
|
||
//! This field identifies the context structure as an x86_64 CPU context, and
|
||
//! indicates which other fields in the structure are valid.
|
||
uint32_t context_flags;
|
||
|
||
uint32_t mx_csr;
|
||
|
||
uint16_t cs;
|
||
uint16_t ds;
|
||
uint16_t es;
|
||
uint16_t fs;
|
||
uint16_t gs;
|
||
uint16_t ss;
|
||
|
||
uint32_t eflags;
|
||
|
||
uint64_t dr0;
|
||
uint64_t dr1;
|
||
uint64_t dr2;
|
||
uint64_t dr3;
|
||
uint64_t dr6;
|
||
uint64_t dr7;
|
||
|
||
uint64_t rax;
|
||
uint64_t rcx;
|
||
uint64_t rdx;
|
||
uint64_t rbx;
|
||
uint64_t rsp;
|
||
uint64_t rbp;
|
||
uint64_t rsi;
|
||
uint64_t rdi;
|
||
uint64_t r8;
|
||
uint64_t r9;
|
||
uint64_t r10;
|
||
uint64_t r11;
|
||
uint64_t r12;
|
||
uint64_t r13;
|
||
uint64_t r14;
|
||
uint64_t r15;
|
||
|
||
uint64_t rip;
|
||
|
||
// CPUContextX86_64::Fxsave has identical layout to what the x86_64 CONTEXT
|
||
// structure places here.
|
||
CPUContextX86_64::Fxsave fxsave;
|
||
|
||
uint128_struct vector_register[26];
|
||
uint64_t vector_control;
|
||
|
||
//! \brief Model-specific debug extension register.
|
||
//!
|
||
//! See Intel Software Developer’s Manual, Volume 3B: System Programming, Part
|
||
//! 2 (253669-051), 17.4 “Last Branch, Interrupt, and Exception Recording
|
||
//! Overview”, and AMD Architecture Programmer’s Manual, Volume 2: System
|
||
//! Programming (24593-3.24), 13.1.6 “Control-Transfer Breakpoint Features”.
|
||
//!
|
||
//! \{
|
||
uint64_t debug_control;
|
||
uint64_t last_branch_to_rip;
|
||
uint64_t last_branch_from_rip;
|
||
uint64_t last_exception_to_rip;
|
||
uint64_t last_exception_from_rip;
|
||
//! \}
|
||
};
|
||
|
||
//! \brief 32-bit ARM-specifc flags for MinidumpContextARM::context_flags.
|
||
enum MinidumpContextARMFlags : uint32_t {
|
||
//! \brief Identifies the context structure as 32-bit ARM.
|
||
kMinidumpContextARM = 0x40000000,
|
||
|
||
//! \brief Indicates the validity of integer regsiters.
|
||
//!
|
||
//! Regsiters `r0`-`r15` and `cpsr` are valid.
|
||
kMinidumpContextARMInteger = kMinidumpContextARM | 0x00000002,
|
||
|
||
//! \brief Inidicates the validity of VFP regsiters.
|
||
//!
|
||
//! Registers `d0`-`d31` and `fpscr` are valid.
|
||
kMinidumpContextARMVFP = kMinidumpContextARM | 0x00000004,
|
||
|
||
//! \brief Indicates the validity of all registers.
|
||
kMinidumpContextARMAll = kMinidumpContextARMInteger | kMinidumpContextARMVFP,
|
||
};
|
||
|
||
//! \brief A 32-bit ARM CPU context (register state) carried in a minidump file.
|
||
struct MinidumpContextARM {
|
||
//! \brief A bitfield composed of values of #MinidumpContextFlags and
|
||
//! #MinidumpContextARMFlags.
|
||
//!
|
||
//! This field identifies the context structure as a 32-bit ARM CPU context,
|
||
//! and indicates which other fields in the structure are valid.
|
||
uint32_t context_flags;
|
||
|
||
//! \brief General-purpose registers `r0`-`r15`.
|
||
uint32_t regs[11];
|
||
uint32_t fp; // r11
|
||
uint32_t ip; // r12
|
||
uint32_t sp; // r13
|
||
uint32_t lr; // r14
|
||
uint32_t pc; // r15
|
||
|
||
//! \brief Current program status register.
|
||
uint32_t cpsr;
|
||
|
||
//! \brief Floating-point status and control register.
|
||
uint32_t fpscr;
|
||
|
||
//! \brief VFP registers `d0`-`d31`.
|
||
uint64_t vfp[32];
|
||
|
||
//! \brief This space is unused. It is included for compatibility with
|
||
//! breakpad (which also doesn't use it).
|
||
uint32_t extra[8];
|
||
};
|
||
|
||
//! \brief CONTEXT_CHUNK
|
||
struct MinidumpContextChunk {
|
||
int32_t offset;
|
||
uint32_t size;
|
||
};
|
||
|
||
//! \brief CONTEXT_EX
|
||
struct MinidumpContextExHeader {
|
||
MinidumpContextChunk all;
|
||
MinidumpContextChunk legacy;
|
||
MinidumpContextChunk xstate;
|
||
};
|
||
|
||
//! \brief XSAVE_AREA_HEADER
|
||
struct MinidumpXSaveAreaHeader {
|
||
uint64_t mask;
|
||
uint64_t compaction_mask;
|
||
uint64_t xsave_header_reserved[6];
|
||
};
|
||
|
||
//! \brief Offset of first xsave feature in the full extended context.
|
||
//!
|
||
//! This is used to calculate the final size of the extended context, and
|
||
//! can be validated by calling InitializeContext2 with one XSTATE feature,
|
||
//! and LocateXStateFeature to determine the first offset.
|
||
//! Also see “MANAGING STATE USING THE XSAVE FEATURE SET”, Ch. 13, Intel SDM.
|
||
constexpr uint32_t kMinidumpAMD64XSaveOffset = 0x550;
|
||
|
||
//! \brief Offset of first xsave feature within the extended context area.
|
||
//!
|
||
//! 0x240 is the size of the legacy area (512) + the xsave header(64 bytes)
|
||
//! Intel SDM 13.4.1. This is not where the item is in the extended compacted
|
||
//! context, but is the offset recorded in the minidump. It needs to be correct
|
||
//! there. See https://windows-internals.com/cet-on-windows/ for some discussion
|
||
//! “CONTEXT_XSTATE: Extended processor state chunk. The state is stored in the
|
||
//! same format the XSAVE operation stores it with exception of the first 512
|
||
//! bytes, i.e. starting from XSAVE_AREA_HEADER.” This may vary by cpuid.
|
||
constexpr uint32_t kXSaveAreaFirstOffset = 0x240;
|
||
|
||
//! \brief XSAVE_CET_U_FORMAT
|
||
struct MinidumpAMD64XSaveFormatCetU {
|
||
uint64_t cetmsr;
|
||
uint64_t ssp;
|
||
};
|
||
|
||
//! \brief 64-bit ARM-specifc flags for MinidumpContextARM64::context_flags.
|
||
enum MinidumpContextARM64Flags : uint32_t {
|
||
//! \brief Identifies the context structure as 64-bit ARM.
|
||
kMinidumpContextARM64 = 0x00400000,
|
||
|
||
//! \brief Indicates the validity of control registers.
|
||
//!
|
||
//! Registers `fp`, `lr`, `sp`, `pc`, and `cpsr`.
|
||
kMinidumpContextARM64Control = kMinidumpContextARM64 | 0x00000001,
|
||
|
||
//! \brief Indicates the validty of integer registers.
|
||
//!
|
||
//! Registers `x0`-`x28`.
|
||
kMinidumpContextARM64Integer = kMinidumpContextARM64 | 0x00000002,
|
||
|
||
//! \brief Indicates the validity of fpsimd registers.
|
||
//!
|
||
//! Registers `v0`-`v31`, `fpsr`, and `fpcr` are valid.
|
||
kMinidumpContextARM64Fpsimd = kMinidumpContextARM64 | 0x00000004,
|
||
|
||
//! \brief Indicates the validity of debug registers.
|
||
//!
|
||
//! `bcr`, `bvr`, `wcr`, and `wvr` are valid.
|
||
kMinidumpContextARM64Debug = kMinidumpContextARM64 | 0x00000008,
|
||
|
||
//! \brief Indicates the validity of control, integer and floating point
|
||
//! registers.
|
||
kMinidumpContextARM64Full = kMinidumpContextARM64Control |
|
||
kMinidumpContextARM64Integer |
|
||
kMinidumpContextARM64Fpsimd,
|
||
|
||
//! \brief Indicates the validity of all registers.
|
||
kMinidumpContextARM64All =
|
||
kMinidumpContextARM64Full | kMinidumpContextARM64Debug,
|
||
};
|
||
|
||
//! \brief A 64-bit ARM CPU context (register state) carried in a minidump file.
|
||
struct MinidumpContextARM64 {
|
||
uint32_t context_flags;
|
||
|
||
//! \brief Current program status register.
|
||
uint32_t cpsr;
|
||
|
||
//! \brief General-purpose registers `x0`-`x28`.
|
||
uint64_t regs[29];
|
||
|
||
//! \brief Frame pointer or `x29`.
|
||
uint64_t fp;
|
||
|
||
//! \brief Link register or `x30`.
|
||
uint64_t lr;
|
||
|
||
//! \brief Stack pointer or `x31`.
|
||
uint64_t sp;
|
||
|
||
//! \brief Program counter.
|
||
uint64_t pc;
|
||
|
||
//! \brief NEON registers `v0`-`v31`.
|
||
uint128_struct fpsimd[32];
|
||
|
||
//! \brief Floating-point control register.
|
||
uint32_t fpcr;
|
||
|
||
//! \brief Floating-point status register.
|
||
uint32_t fpsr;
|
||
|
||
//! \brief Debug registers.
|
||
uint32_t bcr[8];
|
||
uint64_t bvr[8];
|
||
uint32_t wcr[2];
|
||
uint64_t wvr[2];
|
||
};
|
||
|
||
//! \brief 32bit MIPS-specifc flags for MinidumpContextMIPS::context_flags.
|
||
//! Based on minidump_cpu_mips.h from breakpad
|
||
enum MinidumpContextMIPSFlags : uint32_t {
|
||
//! \brief Identifies the context structure as MIPSEL.
|
||
kMinidumpContextMIPS = 0x00040000,
|
||
|
||
//! \brief Indicates the validity of integer registers.
|
||
//!
|
||
//! Registers `0`-`31`, `mdhi`, `mdlo`, `epc`, `badvaddr`, `status` and
|
||
//! `cause` are valid.
|
||
kMinidumpContextMIPSInteger = kMinidumpContextMIPS | 0x00000002,
|
||
|
||
//! \brief Indicates the validity of floating point registers.
|
||
//!
|
||
//! Floating point registers `0`-`31`, `fpcsr` and `fir` are valid
|
||
kMinidumpContextMIPSFloatingPoint = kMinidumpContextMIPS | 0x00000004,
|
||
|
||
//! \brief Indicates the validity of DSP registers.
|
||
//!
|
||
//! Registers `hi0`-`hi2`, `lo0`-`lo2` and `dsp_control` are valid
|
||
kMinidumpContextMIPSDSP = kMinidumpContextMIPS | 0x00000008,
|
||
|
||
//! \brief Indicates the validity of all registers.
|
||
kMinidumpContextMIPSAll = kMinidumpContextMIPSInteger |
|
||
kMinidumpContextMIPSFloatingPoint |
|
||
kMinidumpContextMIPSDSP,
|
||
};
|
||
|
||
//! \brief A 32bit MIPS CPU context (register state) carried in a minidump file.
|
||
struct MinidumpContextMIPS {
|
||
uint32_t context_flags;
|
||
|
||
//! \brief This padding field is included for breakpad compatibility.
|
||
uint32_t _pad0;
|
||
//! \brief General purpose registers `0`-`31`.
|
||
uint64_t regs[32];
|
||
|
||
//! \brief Multiply/divide result.
|
||
uint64_t mdhi, mdlo;
|
||
|
||
//! \brief DSP registers.
|
||
uint32_t hi[3];
|
||
uint32_t lo[3];
|
||
uint32_t dsp_control;
|
||
//! \brief This padding field is included for breakpad compatibility.
|
||
uint32_t _pad1;
|
||
|
||
// \brief cp0 registers.
|
||
uint64_t epc;
|
||
uint64_t badvaddr;
|
||
uint32_t status;
|
||
uint32_t cause;
|
||
|
||
//! \brief FPU registers.
|
||
union {
|
||
struct {
|
||
float _fp_fregs;
|
||
uint32_t _fp_pad;
|
||
} fregs[32];
|
||
double dregs[32];
|
||
} fpregs;
|
||
|
||
//! \brief FPU status register.
|
||
uint32_t fpcsr;
|
||
//! \brief FPU implementation register.
|
||
uint32_t fir;
|
||
};
|
||
|
||
//! \brief 64bit MIPS-specifc flags for MinidumpContextMIPS64::context_flags.
|
||
//! Based on minidump_cpu_mips.h from breakpad
|
||
enum MinidumpContextMIPS64Flags : uint32_t {
|
||
//! \brief Identifies the context structure as MIPS64EL.
|
||
kMinidumpContextMIPS64 = 0x00080000,
|
||
|
||
//! \brief Indicates the validity of integer registers.
|
||
//!
|
||
//! Registers `0`-`31`, `mdhi`, `mdlo`, `epc`, `badvaddr`, `status` and
|
||
//! `cause` are valid.
|
||
kMinidumpContextMIPS64Integer = kMinidumpContextMIPS64 | 0x00000002,
|
||
|
||
//! \brief Indicates the validity of floating point registers.
|
||
//!
|
||
//! Floating point registers `0`-`31`, `fpcsr` and `fir` are valid
|
||
kMinidumpContextMIPS64FloatingPoint = kMinidumpContextMIPS64 | 0x00000004,
|
||
|
||
//! \brief Indicates the validity of DSP registers.
|
||
//!
|
||
//! Registers `hi0`-`hi2`, `lo0`-`lo2` and `dsp_control` are valid.
|
||
kMinidumpContextMIPS64DSP = kMinidumpContextMIPS64 | 0x00000008,
|
||
|
||
//! \brief Indicates the validity of all registers.
|
||
kMinidumpContextMIPS64All = kMinidumpContextMIPS64Integer |
|
||
kMinidumpContextMIPS64FloatingPoint |
|
||
kMinidumpContextMIPS64DSP,
|
||
};
|
||
|
||
//! \brief A 32bit MIPS CPU context (register state) carried in a minidump file.
|
||
struct MinidumpContextMIPS64 {
|
||
uint64_t context_flags;
|
||
|
||
//! \brief General purpose registers.
|
||
uint64_t regs[32];
|
||
|
||
//! \brief Multiply/divide result.
|
||
uint64_t mdhi, mdlo;
|
||
|
||
//! \brief DSP registers.
|
||
uint64_t hi[3];
|
||
uint64_t lo[3];
|
||
uint64_t dsp_control;
|
||
|
||
//! \brief cp0 registers.
|
||
uint64_t epc;
|
||
uint64_t badvaddr;
|
||
uint64_t status;
|
||
uint64_t cause;
|
||
|
||
//! \brief FPU registers.
|
||
union {
|
||
struct {
|
||
float _fp_fregs;
|
||
uint32_t _fp_pad;
|
||
} fregs[32];
|
||
double dregs[32];
|
||
} fpregs;
|
||
|
||
//! \brief FPU status register.
|
||
uint64_t fpcsr;
|
||
//! \brief FPU implementation register.
|
||
uint64_t fir;
|
||
};
|
||
|
||
//! \brief 64-bit RISCV-specific flags for
|
||
//! MinidumpContextRISCV64::context_flags.
|
||
enum MinidumpContextRISCV64Flags : uint32_t {
|
||
//! \brief Identifies the context structure as RISCV64.
|
||
kMinidumpContextRISCV64 = 0x08000000,
|
||
|
||
//! \brief Indicates the validity of integer registers.
|
||
//!
|
||
//! Registers 'pc' and `x1`-`x31` are valid.
|
||
kMinidumpContextRISCV64Integer = kMinidumpContextRISCV64 | 0x00000001,
|
||
|
||
//! \brief Indicates the validity of floating point registers.
|
||
//!
|
||
//! Floating point registers `f0`-`f31` are valid.
|
||
kMinidumpContextRISCV64FloatingPoint = kMinidumpContextRISCV64 | 0x00000002,
|
||
|
||
//! \brief Indicates the validity of all registers.
|
||
kMinidumpContextRISCV64All = kMinidumpContextRISCV64Integer |
|
||
kMinidumpContextRISCV64FloatingPoint,
|
||
};
|
||
|
||
//! \brief A 64-bit RISC-V CPU context (register state) carried in a minidump
|
||
//! file.
|
||
//!
|
||
//! This structure is versioned. Increment |kVersion| when changing this
|
||
//! structure.
|
||
struct MinidumpContextRISCV64 {
|
||
|
||
//! \brief The structure’s currently-defined version number.
|
||
static constexpr uint32_t kVersion = 1;
|
||
|
||
//! \brief Indicates the validity of fields in this structure.
|
||
uint32_t context_flags;
|
||
|
||
//! \brief The structure’s version number.
|
||
uint32_t version;
|
||
|
||
//! \brief The program counter register.
|
||
uint64_t pc;
|
||
|
||
//! \brief The integer registers, x1 through x31.
|
||
uint64_t regs[31];
|
||
|
||
//! \brief The floating point registers.
|
||
uint64_t fpregs[32];
|
||
|
||
//! \brief The floating point control and status register.
|
||
uint32_t fcsr;
|
||
};
|
||
|
||
} // namespace crashpad
|
||
|
||
#endif // CRASHPAD_MINIDUMP_MINIDUMP_CONTEXT_H_
|