diff options
Diffstat (limited to 'src/google_breakpad')
19 files changed, 419 insertions, 417 deletions
diff --git a/src/google_breakpad/common/breakpad_types.h b/src/google_breakpad/common/breakpad_types.h index 926b47f2..a6545be5 100644 --- a/src/google_breakpad/common/breakpad_types.h +++ b/src/google_breakpad/common/breakpad_types.h @@ -31,7 +31,7 @@ * * (This is C99 source, please don't corrupt it with C++.) * - * This file ensures that types u_intN_t are defined for N = 8, 16, 32, and + * This file ensures that types uintN_t are defined for N = 8, 16, 32, and * 64. Types of precise widths are crucial to the task of writing data * structures on one platform and reading them on another. * @@ -42,36 +42,38 @@ #ifndef _WIN32 -#include <sys/types.h> #ifndef __STDC_FORMAT_MACROS #define __STDC_FORMAT_MACROS #endif /* __STDC_FORMAT_MACROS */ #include <inttypes.h> -#if defined(__SUNPRO_CC) || (defined(__GNUC__) && defined(__sun__)) -typedef uint8_t u_int8_t; -typedef uint16_t u_int16_t; -typedef uint32_t u_int32_t; -typedef uint64_t u_int64_t; -#endif - #else /* !_WIN32 */ +#if _MSC_VER >= 1600 +#include <stdint.h> +#elif defined(BREAKPAD_CUSTOM_STDINT_H) +/* Visual C++ Pre-2010 did not ship a stdint.h, so allow + * consumers of this library to provide their own because + * there are often subtle type incompatibilities. + */ +#include BREAKPAD_CUSTOM_STDINT_H +#else #include <WTypes.h> -typedef unsigned __int8 u_int8_t; -typedef unsigned __int16 u_int16_t; -typedef unsigned __int32 u_int32_t; -typedef unsigned __int64 u_int64_t; +typedef unsigned __int8 uint8_t; +typedef unsigned __int16 uint16_t; +typedef unsigned __int32 uint32_t; +typedef unsigned __int64 uint64_t; +#endif #endif /* !_WIN32 */ typedef struct { - u_int64_t high; - u_int64_t low; -} u_int128_t; + uint64_t high; + uint64_t low; +} uint128_struct; -typedef u_int64_t breakpad_time_t; +typedef uint64_t breakpad_time_t; /* Try to get PRIx64 from inttypes.h, but if it's not defined, fall back to * llx, which is the format string for "long long" - this is a 64-bit diff --git a/src/google_breakpad/common/minidump_cpu_amd64.h b/src/google_breakpad/common/minidump_cpu_amd64.h index fa6a9961..4256706d 100644 --- a/src/google_breakpad/common/minidump_cpu_amd64.h +++ b/src/google_breakpad/common/minidump_cpu_amd64.h @@ -67,7 +67,7 @@ * equivalent types and values in the Windows Platform SDK are given in * comments. * - * Author: Mark Mentovai + * Author: Mark Mentovai * Change to split into its own file: Neal Sidhwaney */ #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_AMD64_H__ @@ -79,22 +79,22 @@ */ typedef struct { - u_int16_t control_word; - u_int16_t status_word; - u_int8_t tag_word; - u_int8_t reserved1; - u_int16_t error_opcode; - u_int32_t error_offset; - u_int16_t error_selector; - u_int16_t reserved2; - u_int32_t data_offset; - u_int16_t data_selector; - u_int16_t reserved3; - u_int32_t mx_csr; - u_int32_t mx_csr_mask; - u_int128_t float_registers[8]; - u_int128_t xmm_registers[16]; - u_int8_t reserved4[96]; + uint16_t control_word; + uint16_t status_word; + uint8_t tag_word; + uint8_t reserved1; + uint16_t error_opcode; + uint32_t error_offset; + uint16_t error_selector; + uint16_t reserved2; + uint32_t data_offset; + uint16_t data_selector; + uint16_t reserved3; + uint32_t mx_csr; + uint32_t mx_csr_mask; + uint128_struct float_registers[8]; + uint128_struct xmm_registers[16]; + uint8_t reserved4[96]; } MDXmmSaveArea32AMD64; /* XMM_SAVE_AREA32 */ #define MD_CONTEXT_AMD64_VR_COUNT 26 @@ -103,63 +103,63 @@ typedef struct { /* * Register parameter home addresses. */ - u_int64_t p1_home; - u_int64_t p2_home; - u_int64_t p3_home; - u_int64_t p4_home; - u_int64_t p5_home; - u_int64_t p6_home; + uint64_t p1_home; + uint64_t p2_home; + uint64_t p3_home; + uint64_t p4_home; + uint64_t p5_home; + uint64_t p6_home; /* The next field determines the layout of the structure, and which parts * of it are populated */ - u_int32_t context_flags; - u_int32_t mx_csr; + uint32_t context_flags; + uint32_t mx_csr; /* The next register is included with MD_CONTEXT_AMD64_CONTROL */ - u_int16_t cs; + uint16_t cs; /* The next 4 registers are included with MD_CONTEXT_AMD64_SEGMENTS */ - u_int16_t ds; - u_int16_t es; - u_int16_t fs; - u_int16_t gs; + uint16_t ds; + uint16_t es; + uint16_t fs; + uint16_t gs; /* The next 2 registers are included with MD_CONTEXT_AMD64_CONTROL */ - u_int16_t ss; - u_int32_t eflags; - + uint16_t ss; + uint32_t eflags; + /* The next 6 registers are included with MD_CONTEXT_AMD64_DEBUG_REGISTERS */ - u_int64_t dr0; - u_int64_t dr1; - u_int64_t dr2; - u_int64_t dr3; - u_int64_t dr6; - u_int64_t dr7; + uint64_t dr0; + uint64_t dr1; + uint64_t dr2; + uint64_t dr3; + uint64_t dr6; + uint64_t dr7; /* The next 4 registers are included with MD_CONTEXT_AMD64_INTEGER */ - u_int64_t rax; - u_int64_t rcx; - u_int64_t rdx; - u_int64_t rbx; + uint64_t rax; + uint64_t rcx; + uint64_t rdx; + uint64_t rbx; /* The next register is included with MD_CONTEXT_AMD64_CONTROL */ - u_int64_t rsp; + uint64_t rsp; /* The next 11 registers are included with MD_CONTEXT_AMD64_INTEGER */ - u_int64_t rbp; - u_int64_t rsi; - u_int64_t rdi; - u_int64_t r8; - u_int64_t r9; - u_int64_t r10; - u_int64_t r11; - u_int64_t r12; - u_int64_t r13; - u_int64_t r14; - u_int64_t r15; + 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; /* The next register is included with MD_CONTEXT_AMD64_CONTROL */ - u_int64_t rip; + uint64_t rip; /* The next set of registers are included with * MD_CONTEXT_AMD64_FLOATING_POINT @@ -167,37 +167,37 @@ typedef struct { union { MDXmmSaveArea32AMD64 flt_save; struct { - u_int128_t header[2]; - u_int128_t legacy[8]; - u_int128_t xmm0; - u_int128_t xmm1; - u_int128_t xmm2; - u_int128_t xmm3; - u_int128_t xmm4; - u_int128_t xmm5; - u_int128_t xmm6; - u_int128_t xmm7; - u_int128_t xmm8; - u_int128_t xmm9; - u_int128_t xmm10; - u_int128_t xmm11; - u_int128_t xmm12; - u_int128_t xmm13; - u_int128_t xmm14; - u_int128_t xmm15; + uint128_struct header[2]; + uint128_struct legacy[8]; + uint128_struct xmm0; + uint128_struct xmm1; + uint128_struct xmm2; + uint128_struct xmm3; + uint128_struct xmm4; + uint128_struct xmm5; + uint128_struct xmm6; + uint128_struct xmm7; + uint128_struct xmm8; + uint128_struct xmm9; + uint128_struct xmm10; + uint128_struct xmm11; + uint128_struct xmm12; + uint128_struct xmm13; + uint128_struct xmm14; + uint128_struct xmm15; } sse_registers; }; - u_int128_t vector_register[MD_CONTEXT_AMD64_VR_COUNT]; - u_int64_t vector_control; + uint128_struct vector_register[MD_CONTEXT_AMD64_VR_COUNT]; + uint64_t vector_control; /* The next 5 registers are included with MD_CONTEXT_AMD64_DEBUG_REGISTERS */ - u_int64_t debug_control; - u_int64_t last_branch_to_rip; - u_int64_t last_branch_from_rip; - u_int64_t last_exception_to_rip; - u_int64_t last_exception_from_rip; - + 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; + } MDRawContextAMD64; /* CONTEXT */ /* For (MDRawContextAMD64).context_flags. These values indicate the type of diff --git a/src/google_breakpad/common/minidump_cpu_arm.h b/src/google_breakpad/common/minidump_cpu_arm.h index dd071293..6a711383 100644 --- a/src/google_breakpad/common/minidump_cpu_arm.h +++ b/src/google_breakpad/common/minidump_cpu_arm.h @@ -77,13 +77,13 @@ * are not exactly minidumps. */ typedef struct { - u_int64_t fpscr; /* FPU status register */ + uint64_t fpscr; /* FPU status register */ /* 32 64-bit floating point registers, d0 .. d31. */ - u_int64_t regs[MD_FLOATINGSAVEAREA_ARM_FPR_COUNT]; + uint64_t regs[MD_FLOATINGSAVEAREA_ARM_FPR_COUNT]; /* Miscellaneous control words */ - u_int32_t extra[MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT]; + uint32_t extra[MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT]; } MDFloatingSaveAreaARM; #define MD_CONTEXT_ARM_GPR_COUNT 16 @@ -92,7 +92,7 @@ typedef struct { /* The next field determines the layout of the structure, and which parts * of it are populated */ - u_int32_t context_flags; + uint32_t context_flags; /* 16 32-bit integer registers, r0 .. r15 * Note the following fixed uses: @@ -100,7 +100,7 @@ typedef struct { * r14 is the link register * r15 is the program counter */ - u_int32_t iregs[MD_CONTEXT_ARM_GPR_COUNT]; + uint32_t iregs[MD_CONTEXT_ARM_GPR_COUNT]; /* CPSR (flags, basically): 32 bits: bit 31 - N (negative) @@ -109,14 +109,14 @@ typedef struct { bit 28 - V (overflow) bit 27 - Q (saturation flag, sticky) All other fields -- ignore */ - u_int32_t cpsr; + uint32_t cpsr; /* The next field is included with MD_CONTEXT_ARM_FLOATING_POINT */ MDFloatingSaveAreaARM float_save; } MDRawContextARM; -/* Indices into iregs for registers with a dedicated or conventional +/* Indices into iregs for registers with a dedicated or conventional * purpose. */ enum MDARMRegisterNumbers { diff --git a/src/google_breakpad/common/minidump_cpu_ppc.h b/src/google_breakpad/common/minidump_cpu_ppc.h index 038e921a..02ac3220 100644 --- a/src/google_breakpad/common/minidump_cpu_ppc.h +++ b/src/google_breakpad/common/minidump_cpu_ppc.h @@ -81,11 +81,11 @@ #define MD_FLOATINGSAVEAREA_PPC_FPR_COUNT 32 typedef struct { - /* fpregs is a double[32] in mach/ppc/_types.h, but a u_int64_t is used + /* fpregs is a double[32] in mach/ppc/_types.h, but a uint64_t is used * here for precise sizing. */ - u_int64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT]; - u_int32_t fpscr_pad; - u_int32_t fpscr; /* Status/control */ + uint64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT]; + uint32_t fpscr_pad; + uint32_t fpscr; /* Status/control */ } MDFloatingSaveAreaPPC; /* Based on ppc_float_state */ @@ -94,11 +94,11 @@ typedef struct { typedef struct { /* Vector registers (including vscr) are 128 bits, but mach/ppc/_types.h * exposes them as four 32-bit quantities. */ - u_int128_t save_vr[MD_VECTORSAVEAREA_PPC_VR_COUNT]; - u_int128_t save_vscr; /* Status/control */ - u_int32_t save_pad5[4]; - u_int32_t save_vrvalid; /* Identifies which vector registers are saved */ - u_int32_t save_pad6[7]; + uint128_struct save_vr[MD_VECTORSAVEAREA_PPC_VR_COUNT]; + uint128_struct save_vscr; /* Status/control */ + uint32_t save_pad5[4]; + uint32_t save_vrvalid; /* Indicates which vector registers are saved */ + uint32_t save_pad6[7]; } MDVectorSaveAreaPPC; /* ppc_vector_state */ @@ -117,21 +117,21 @@ typedef struct { /* context_flags is not present in ppc_thread_state, but it aids * identification of MDRawContextPPC among other raw context types, * and it guarantees alignment when we get to float_save. */ - u_int32_t context_flags; + uint32_t context_flags; - u_int32_t srr0; /* Machine status save/restore: stores pc + uint32_t srr0; /* Machine status save/restore: stores pc * (instruction) */ - u_int32_t srr1; /* Machine status save/restore: stores msr + uint32_t srr1; /* Machine status save/restore: stores msr * (ps, program/machine state) */ /* ppc_thread_state contains 32 fields, r0 .. r31. Here, an array is * used for brevity. */ - u_int32_t gpr[MD_CONTEXT_PPC_GPR_COUNT]; - u_int32_t cr; /* Condition */ - u_int32_t xer; /* Integer (fiXed-point) exception */ - u_int32_t lr; /* Link */ - u_int32_t ctr; /* Count */ - u_int32_t mq; /* Multiply/Quotient (PPC 601, POWER only) */ - u_int32_t vrsave; /* Vector save */ + uint32_t gpr[MD_CONTEXT_PPC_GPR_COUNT]; + uint32_t cr; /* Condition */ + uint32_t xer; /* Integer (fiXed-point) exception */ + uint32_t lr; /* Link */ + uint32_t ctr; /* Count */ + uint32_t mq; /* Multiply/Quotient (PPC 601, POWER only) */ + uint32_t vrsave; /* Vector save */ /* float_save and vector_save aren't present in ppc_thread_state, but * are represented in separate structures that still define a thread's diff --git a/src/google_breakpad/common/minidump_cpu_ppc64.h b/src/google_breakpad/common/minidump_cpu_ppc64.h index a788e5d1..da4f8723 100644 --- a/src/google_breakpad/common/minidump_cpu_ppc64.h +++ b/src/google_breakpad/common/minidump_cpu_ppc64.h @@ -90,20 +90,20 @@ typedef struct { /* context_flags is not present in ppc_thread_state, but it aids * identification of MDRawContextPPC among other raw context types, * and it guarantees alignment when we get to float_save. */ - u_int64_t context_flags; + uint64_t context_flags; - u_int64_t srr0; /* Machine status save/restore: stores pc + uint64_t srr0; /* Machine status save/restore: stores pc * (instruction) */ - u_int64_t srr1; /* Machine status save/restore: stores msr + uint64_t srr1; /* Machine status save/restore: stores msr * (ps, program/machine state) */ /* ppc_thread_state contains 32 fields, r0 .. r31. Here, an array is * used for brevity. */ - u_int64_t gpr[MD_CONTEXT_PPC64_GPR_COUNT]; - u_int64_t cr; /* Condition */ - u_int64_t xer; /* Integer (fiXed-point) exception */ - u_int64_t lr; /* Link */ - u_int64_t ctr; /* Count */ - u_int64_t vrsave; /* Vector save */ + uint64_t gpr[MD_CONTEXT_PPC64_GPR_COUNT]; + uint64_t cr; /* Condition */ + uint64_t xer; /* Integer (fiXed-point) exception */ + uint64_t lr; /* Link */ + uint64_t ctr; /* Count */ + uint64_t vrsave; /* Vector save */ /* float_save and vector_save aren't present in ppc_thread_state, but * are represented in separate structures that still define a thread's diff --git a/src/google_breakpad/common/minidump_cpu_sparc.h b/src/google_breakpad/common/minidump_cpu_sparc.h index ee95b64e..ddc4c759 100644 --- a/src/google_breakpad/common/minidump_cpu_sparc.h +++ b/src/google_breakpad/common/minidump_cpu_sparc.h @@ -82,10 +82,10 @@ typedef struct { /* FPU floating point regs */ - u_int64_t regs[MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT]; + uint64_t regs[MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT]; - u_int64_t filler; - u_int64_t fsr; /* FPU status register */ + uint64_t filler; + uint64_t fsr; /* FPU status register */ } MDFloatingSaveAreaSPARC; /* FLOATING_SAVE_AREA */ #define MD_CONTEXT_SPARC_GPR_COUNT 32 @@ -94,8 +94,8 @@ typedef struct { /* The next field determines the layout of the structure, and which parts * of it are populated */ - u_int32_t context_flags; - u_int32_t flag_pad; + uint32_t context_flags; + uint32_t flag_pad; /* * General register access (SPARC). * Don't confuse definitions here with definitions in <sys/regset.h>. @@ -110,28 +110,28 @@ typedef struct { * g_r[16-23] local registers(l0-l7) * g_r[24-31] in registers(i0-i7) */ - u_int64_t g_r[MD_CONTEXT_SPARC_GPR_COUNT]; + uint64_t g_r[MD_CONTEXT_SPARC_GPR_COUNT]; /* several control registers */ /* Processor State register(PSR) for SPARC V7/V8 * Condition Code register (CCR) for SPARC V9 */ - u_int64_t ccr; + uint64_t ccr; - u_int64_t pc; /* Program Counter register (PC) */ - u_int64_t npc; /* Next Program Counter register (nPC) */ - u_int64_t y; /* Y register (Y) */ + uint64_t pc; /* Program Counter register (PC) */ + uint64_t npc; /* Next Program Counter register (nPC) */ + uint64_t y; /* Y register (Y) */ /* Address Space Identifier register (ASI) for SPARC V9 * WIM for SPARC V7/V8 */ - u_int64_t asi; + uint64_t asi; /* Floating-Point Registers State register (FPRS) for SPARC V9 * TBR for for SPARC V7/V8 */ - u_int64_t fprs; + uint64_t fprs; /* The next field is included with MD_CONTEXT_SPARC_FLOATING_POINT */ MDFloatingSaveAreaSPARC float_save; diff --git a/src/google_breakpad/common/minidump_cpu_x86.h b/src/google_breakpad/common/minidump_cpu_x86.h index 32aff8a7..e09cb7cb 100644 --- a/src/google_breakpad/common/minidump_cpu_x86.h +++ b/src/google_breakpad/common/minidump_cpu_x86.h @@ -76,18 +76,18 @@ /* SIZE_OF_80387_REGISTERS */ typedef struct { - u_int32_t control_word; - u_int32_t status_word; - u_int32_t tag_word; - u_int32_t error_offset; - u_int32_t error_selector; - u_int32_t data_offset; - u_int32_t data_selector; + uint32_t control_word; + uint32_t status_word; + uint32_t tag_word; + uint32_t error_offset; + uint32_t error_selector; + uint32_t data_offset; + uint32_t data_selector; /* register_area contains eight 80-bit (x87 "long double") quantities for * floating-point registers %st0 (%mm0) through %st7 (%mm7). */ - u_int8_t register_area[MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE]; - u_int32_t cr0_npx_state; + uint8_t register_area[MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE]; + uint32_t cr0_npx_state; } MDFloatingSaveAreaX86; /* FLOATING_SAVE_AREA */ @@ -97,46 +97,46 @@ typedef struct { typedef struct { /* The next field determines the layout of the structure, and which parts * of it are populated */ - u_int32_t context_flags; + uint32_t context_flags; /* The next 6 registers are included with MD_CONTEXT_X86_DEBUG_REGISTERS */ - u_int32_t dr0; - u_int32_t dr1; - u_int32_t dr2; - u_int32_t dr3; - u_int32_t dr6; - u_int32_t dr7; + uint32_t dr0; + uint32_t dr1; + uint32_t dr2; + uint32_t dr3; + uint32_t dr6; + uint32_t dr7; /* The next field is included with MD_CONTEXT_X86_FLOATING_POINT */ MDFloatingSaveAreaX86 float_save; /* The next 4 registers are included with MD_CONTEXT_X86_SEGMENTS */ - u_int32_t gs; - u_int32_t fs; - u_int32_t es; - u_int32_t ds; + uint32_t gs; + uint32_t fs; + uint32_t es; + uint32_t ds; /* The next 6 registers are included with MD_CONTEXT_X86_INTEGER */ - u_int32_t edi; - u_int32_t esi; - u_int32_t ebx; - u_int32_t edx; - u_int32_t ecx; - u_int32_t eax; + uint32_t edi; + uint32_t esi; + uint32_t ebx; + uint32_t edx; + uint32_t ecx; + uint32_t eax; /* The next 6 registers are included with MD_CONTEXT_X86_CONTROL */ - u_int32_t ebp; - u_int32_t eip; - u_int32_t cs; /* WinNT.h says "must be sanitized" */ - u_int32_t eflags; /* WinNT.h says "must be sanitized" */ - u_int32_t esp; - u_int32_t ss; + uint32_t ebp; + uint32_t eip; + uint32_t cs; /* WinNT.h says "must be sanitized" */ + uint32_t eflags; /* WinNT.h says "must be sanitized" */ + uint32_t esp; + uint32_t ss; /* The next field is included with MD_CONTEXT_X86_EXTENDED_REGISTERS. * It contains vector (MMX/SSE) registers. It it laid out in the * format used by the fxsave and fsrstor instructions, so it includes * a copy of the x87 floating-point registers as well. See FXSAVE in * "Intel Architecture Software Developer's Manual, Volume 2." */ - u_int8_t extended_registers[ + uint8_t extended_registers[ MD_CONTEXT_X86_EXTENDED_REGISTERS_SIZE]; } MDRawContextX86; /* CONTEXT */ diff --git a/src/google_breakpad/common/minidump_format.h b/src/google_breakpad/common/minidump_format.h index 28a81d41..af8cab0a 100644 --- a/src/google_breakpad/common/minidump_format.h +++ b/src/google_breakpad/common/minidump_format.h @@ -79,10 +79,10 @@ */ typedef struct { - u_int32_t data1; - u_int16_t data2; - u_int16_t data3; - u_int8_t data4[8]; + uint32_t data1; + uint16_t data2; + uint16_t data3; + uint8_t data4[8]; } MDGUID; /* GUID */ @@ -110,7 +110,7 @@ typedef struct { * structure should never be allocated directly. The actual structure type * can be determined by examining the context_flags field. */ typedef struct { - u_int32_t context_flags; + uint32_t context_flags; } MDRawContextBase; #include "minidump_cpu_amd64.h" @@ -126,19 +126,19 @@ typedef struct { typedef struct { - u_int32_t signature; - u_int32_t struct_version; - u_int32_t file_version_hi; - u_int32_t file_version_lo; - u_int32_t product_version_hi; - u_int32_t product_version_lo; - u_int32_t file_flags_mask; /* Identifies valid bits in fileFlags */ - u_int32_t file_flags; - u_int32_t file_os; - u_int32_t file_type; - u_int32_t file_subtype; - u_int32_t file_date_hi; - u_int32_t file_date_lo; + uint32_t signature; + uint32_t struct_version; + uint32_t file_version_hi; + uint32_t file_version_lo; + uint32_t product_version_hi; + uint32_t product_version_lo; + uint32_t file_flags_mask; /* Identifies valid bits in fileFlags */ + uint32_t file_flags; + uint32_t file_os; + uint32_t file_type; + uint32_t file_subtype; + uint32_t file_date_hi; + uint32_t file_date_lo; } MDVSFixedFileInfo; /* VS_FIXEDFILEINFO */ /* For (MDVSFixedFileInfo).signature */ @@ -231,10 +231,10 @@ typedef struct { /* An MDRVA is an offset into the minidump file. The beginning of the * MDRawHeader is at offset 0. */ -typedef u_int32_t MDRVA; /* RVA */ +typedef uint32_t MDRVA; /* RVA */ typedef struct { - u_int32_t data_size; + uint32_t data_size; MDRVA rva; } MDLocationDescriptor; /* MINIDUMP_LOCATION_DESCRIPTOR */ @@ -242,22 +242,22 @@ typedef struct { typedef struct { /* The base address of the memory range on the host that produced the * minidump. */ - u_int64_t start_of_memory_range; + uint64_t start_of_memory_range; MDLocationDescriptor memory; } MDMemoryDescriptor; /* MINIDUMP_MEMORY_DESCRIPTOR */ typedef struct { - u_int32_t signature; - u_int32_t version; - u_int32_t stream_count; + uint32_t signature; + uint32_t version; + uint32_t stream_count; MDRVA stream_directory_rva; /* A |stream_count|-sized array of * MDRawDirectory structures. */ - u_int32_t checksum; /* Can be 0. In fact, that's all that's + uint32_t checksum; /* Can be 0. In fact, that's all that's * been found in minidump files. */ - u_int32_t time_date_stamp; /* time_t */ - u_int64_t flags; + uint32_t time_date_stamp; /* time_t */ + uint64_t flags; } MDRawHeader; /* MINIDUMP_HEADER */ /* For (MDRawHeader).signature and (MDRawHeader).version. Note that only the @@ -302,7 +302,7 @@ typedef enum { typedef struct { - u_int32_t stream_type; + uint32_t stream_type; MDLocationDescriptor location; } MDRawDirectory; /* MINIDUMP_DIRECTORY */ @@ -346,27 +346,27 @@ typedef enum { typedef struct { - u_int32_t length; /* Length of buffer in bytes (not characters), + uint32_t length; /* Length of buffer in bytes (not characters), * excluding 0-terminator */ - u_int16_t buffer[1]; /* UTF-16-encoded, 0-terminated */ + uint16_t buffer[1]; /* UTF-16-encoded, 0-terminated */ } MDString; /* MINIDUMP_STRING */ static const size_t MDString_minsize = offsetof(MDString, buffer[0]); typedef struct { - u_int32_t thread_id; - u_int32_t suspend_count; - u_int32_t priority_class; - u_int32_t priority; - u_int64_t teb; /* Thread environment block */ + uint32_t thread_id; + uint32_t suspend_count; + uint32_t priority_class; + uint32_t priority; + uint64_t teb; /* Thread environment block */ MDMemoryDescriptor stack; MDLocationDescriptor thread_context; /* MDRawContext[CPU] */ } MDRawThread; /* MINIDUMP_THREAD */ typedef struct { - u_int32_t number_of_threads; + uint32_t number_of_threads; MDRawThread threads[1]; } MDRawThreadList; /* MINIDUMP_THREAD_LIST */ @@ -375,10 +375,10 @@ static const size_t MDRawThreadList_minsize = offsetof(MDRawThreadList, typedef struct { - u_int64_t base_of_image; - u_int32_t size_of_image; - u_int32_t checksum; /* 0 if unknown */ - u_int32_t time_date_stamp; /* time_t */ + uint64_t base_of_image; + uint32_t size_of_image; + uint32_t checksum; /* 0 if unknown */ + uint32_t time_date_stamp; /* time_t */ MDRVA module_name_rva; /* MDString, pathname or filename */ MDVSFixedFileInfo version_info; @@ -402,8 +402,8 @@ typedef struct { * As a workaround, reserved0 and reserved1 are instead defined here as * four 32-bit quantities. This should be harmless, as there are * currently no known uses for these fields. */ - u_int32_t reserved0[2]; - u_int32_t reserved1[2]; + uint32_t reserved0[2]; + uint32_t reserved1[2]; } MDRawModule; /* MINIDUMP_MODULE */ /* The inclusion of a 64-bit type in MINIDUMP_MODULE forces the struct to @@ -419,15 +419,15 @@ typedef struct { * MDCVInfoPDB70 is the expected structure type with recent toolchains. */ typedef struct { - u_int32_t signature; - u_int32_t offset; /* Offset to debug data (expect 0 in minidump) */ + uint32_t signature; + uint32_t offset; /* Offset to debug data (expect 0 in minidump) */ } MDCVHeader; typedef struct { MDCVHeader cv_header; - u_int32_t signature; /* time_t debug information created */ - u_int32_t age; /* revision of PDB file */ - u_int8_t pdb_file_name[1]; /* Pathname or filename of PDB file */ + uint32_t signature; /* time_t debug information created */ + uint32_t age; /* revision of PDB file */ + uint8_t pdb_file_name[1]; /* Pathname or filename of PDB file */ } MDCVInfoPDB20; static const size_t MDCVInfoPDB20_minsize = offsetof(MDCVInfoPDB20, @@ -436,10 +436,10 @@ static const size_t MDCVInfoPDB20_minsize = offsetof(MDCVInfoPDB20, #define MD_CVINFOPDB20_SIGNATURE 0x3031424e /* cvHeader.signature = '01BN' */ typedef struct { - u_int32_t cv_signature; + uint32_t cv_signature; MDGUID signature; /* GUID, identifies PDB file */ - u_int32_t age; /* Identifies incremental changes to PDB file */ - u_int8_t pdb_file_name[1]; /* Pathname or filename of PDB file, + uint32_t age; /* Identifies incremental changes to PDB file */ + uint8_t pdb_file_name[1]; /* Pathname or filename of PDB file, * 0-terminated 8-bit character data (UTF-8?) */ } MDCVInfoPDB70; @@ -449,12 +449,12 @@ static const size_t MDCVInfoPDB70_minsize = offsetof(MDCVInfoPDB70, #define MD_CVINFOPDB70_SIGNATURE 0x53445352 /* cvSignature = 'SDSR' */ typedef struct { - u_int32_t data1[2]; - u_int32_t data2; - u_int32_t data3; - u_int32_t data4; - u_int32_t data5[3]; - u_int8_t extra[2]; + uint32_t data1[2]; + uint32_t data2; + uint32_t data3; + uint32_t data4; + uint32_t data5[3]; + uint8_t extra[2]; } MDCVInfoELF; /* In addition to the two CodeView record formats above, used for linking @@ -479,12 +479,12 @@ typedef struct { * obsolete with modules built by recent toolchains. */ typedef struct { - u_int32_t data_type; /* IMAGE_DEBUG_TYPE_*, not defined here because + uint32_t data_type; /* IMAGE_DEBUG_TYPE_*, not defined here because * this debug record type is mostly obsolete. */ - u_int32_t length; /* Length of entire MDImageDebugMisc structure */ - u_int8_t unicode; /* True if data is multibyte */ - u_int8_t reserved[3]; - u_int8_t data[1]; + uint32_t length; /* Length of entire MDImageDebugMisc structure */ + uint8_t unicode; /* True if data is multibyte */ + uint8_t reserved[3]; + uint8_t data[1]; } MDImageDebugMisc; /* IMAGE_DEBUG_MISC */ static const size_t MDImageDebugMisc_minsize = offsetof(MDImageDebugMisc, @@ -492,7 +492,7 @@ static const size_t MDImageDebugMisc_minsize = offsetof(MDImageDebugMisc, typedef struct { - u_int32_t number_of_modules; + uint32_t number_of_modules; MDRawModule modules[1]; } MDRawModuleList; /* MINIDUMP_MODULE_LIST */ @@ -501,7 +501,7 @@ static const size_t MDRawModuleList_minsize = offsetof(MDRawModuleList, typedef struct { - u_int32_t number_of_memory_ranges; + uint32_t number_of_memory_ranges; MDMemoryDescriptor memory_ranges[1]; } MDRawMemoryList; /* MINIDUMP_MEMORY_LIST */ @@ -512,21 +512,21 @@ static const size_t MDRawMemoryList_minsize = offsetof(MDRawMemoryList, #define MD_EXCEPTION_MAXIMUM_PARAMETERS 15 typedef struct { - u_int32_t exception_code; /* Windows: MDExceptionCodeWin, + uint32_t exception_code; /* Windows: MDExceptionCodeWin, * Mac OS X: MDExceptionMac, * Linux: MDExceptionCodeLinux. */ - u_int32_t exception_flags; /* Windows: 1 if noncontinuable, + uint32_t exception_flags; /* Windows: 1 if noncontinuable, Mac OS X: MDExceptionCodeMac. */ - u_int64_t exception_record; /* Address (in the minidump-producing host's + uint64_t exception_record; /* Address (in the minidump-producing host's * memory) of another MDException, for * nested exceptions. */ - u_int64_t exception_address; /* The address that caused the exception. + uint64_t exception_address; /* The address that caused the exception. * Mac OS X: exception subcode (which is * typically the address). */ - u_int32_t number_parameters; /* Number of valid elements in + uint32_t number_parameters; /* Number of valid elements in * exception_information. */ - u_int32_t __align; - u_int64_t exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS]; + uint32_t __align; + uint64_t exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS]; } MDException; /* MINIDUMP_EXCEPTION */ #include "minidump_exception_win32.h" @@ -535,10 +535,10 @@ typedef struct { #include "minidump_exception_solaris.h" typedef struct { - u_int32_t thread_id; /* Thread in which the exception + uint32_t thread_id; /* Thread in which the exception * occurred. Corresponds to * (MDRawThread).thread_id. */ - u_int32_t __align; + uint32_t __align; MDException exception_record; MDLocationDescriptor thread_context; /* MDRawContext[CPU] */ } MDRawExceptionStream; /* MINIDUMP_EXCEPTION_STREAM */ @@ -546,13 +546,13 @@ typedef struct { typedef union { struct { - u_int32_t vendor_id[3]; /* cpuid 0: ebx, edx, ecx */ - u_int32_t version_information; /* cpuid 1: eax */ - u_int32_t feature_information; /* cpuid 1: edx */ - u_int32_t amd_extended_cpu_features; /* cpuid 0x80000001, ebx */ + uint32_t vendor_id[3]; /* cpuid 0: ebx, edx, ecx */ + uint32_t version_information; /* cpuid 1: eax */ + uint32_t feature_information; /* cpuid 1: edx */ + uint32_t amd_extended_cpu_features; /* cpuid 0x80000001, ebx */ } x86_cpu_info; struct { - u_int64_t processor_features[2]; + uint64_t processor_features[2]; } other_cpu_info; } MDCPUInformation; /* CPU_INFORMATION */ @@ -560,20 +560,20 @@ typedef union { typedef struct { /* The next 3 fields and numberOfProcessors are from the SYSTEM_INFO * structure as returned by GetSystemInfo */ - u_int16_t processor_architecture; - u_int16_t processor_level; /* x86: 5 = 586, 6 = 686, ... */ - u_int16_t processor_revision; /* x86: 0xMMSS, where MM=model, + uint16_t processor_architecture; + uint16_t processor_level; /* x86: 5 = 586, 6 = 686, ... */ + uint16_t processor_revision; /* x86: 0xMMSS, where MM=model, * SS=stepping */ - u_int8_t number_of_processors; - u_int8_t product_type; /* Windows: VER_NT_* from WinNT.h */ + uint8_t number_of_processors; + uint8_t product_type; /* Windows: VER_NT_* from WinNT.h */ /* The next 5 fields are from the OSVERSIONINFO structure as returned * by GetVersionEx */ - u_int32_t major_version; - u_int32_t minor_version; - u_int32_t build_number; - u_int32_t platform_id; + uint32_t major_version; + uint32_t minor_version; + uint32_t build_number; + uint32_t platform_id; MDRVA csd_version_rva; /* MDString further identifying the * host OS. * Windows: name of the installed OS @@ -582,8 +582,8 @@ typedef struct { * (sw_vers -buildVersion). * Linux: uname -srvmo */ - u_int16_t suite_mask; /* Windows: VER_SUITE_* from WinNT.h */ - u_int16_t reserved2; + uint16_t suite_mask; /* Windows: VER_SUITE_* from WinNT.h */ + uint16_t reserved2; MDCPUInformation cpu; } MDRawSystemInfo; /* MINIDUMP_SYSTEM_INFO */ @@ -627,29 +627,29 @@ typedef enum { typedef struct { - u_int32_t size_of_info; /* Length of entire MDRawMiscInfo structure. */ - u_int32_t flags1; + uint32_t size_of_info; /* Length of entire MDRawMiscInfo structure. */ + uint32_t flags1; /* The next field is only valid if flags1 contains * MD_MISCINFO_FLAGS1_PROCESS_ID. */ - u_int32_t process_id; + uint32_t process_id; /* The next 3 fields are only valid if flags1 contains * MD_MISCINFO_FLAGS1_PROCESS_TIMES. */ - u_int32_t process_create_time; /* time_t process started */ - u_int32_t process_user_time; /* seconds of user CPU time */ - u_int32_t process_kernel_time; /* seconds of kernel CPU time */ + uint32_t process_create_time; /* time_t process started */ + uint32_t process_user_time; /* seconds of user CPU time */ + uint32_t process_kernel_time; /* seconds of kernel CPU time */ /* The following fields are not present in MINIDUMP_MISC_INFO but are * in MINIDUMP_MISC_INFO_2. When this struct is populated, these values * may not be set. Use flags1 or sizeOfInfo to determine whether these * values are present. These are only valid when flags1 contains * MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO. */ - u_int32_t processor_max_mhz; - u_int32_t processor_current_mhz; - u_int32_t processor_mhz_limit; - u_int32_t processor_max_idle_state; - u_int32_t processor_current_idle_state; + uint32_t processor_max_mhz; + uint32_t processor_current_mhz; + uint32_t processor_mhz_limit; + uint32_t processor_max_idle_state; + uint32_t processor_current_idle_state; } MDRawMiscInfo; /* MINIDUMP_MISC_INFO, MINIDUMP_MISC_INFO2 */ #define MD_MISCINFO_SIZE 24 @@ -666,7 +666,7 @@ typedef enum { /* MINIDUMP_MISC1_PROCESSOR_POWER_INFO */ } MDMiscInfoFlags1; -/* +/* * Around DbgHelp version 6.0, the style of new LIST structures changed * from including an array of length 1 at the end of the struct to * represent the variable-length data to including explicit @@ -677,24 +677,24 @@ typedef enum { */ typedef struct { - u_int32_t size_of_header; /* sizeof(MDRawMemoryInfoList) */ - u_int32_t size_of_entry; /* sizeof(MDRawMemoryInfo) */ - u_int64_t number_of_entries; + uint32_t size_of_header; /* sizeof(MDRawMemoryInfoList) */ + uint32_t size_of_entry; /* sizeof(MDRawMemoryInfo) */ + uint64_t number_of_entries; } MDRawMemoryInfoList; /* MINIDUMP_MEMORY_INFO_LIST */ typedef struct { - u_int64_t base_address; /* Base address of a region of pages */ - u_int64_t allocation_base; /* Base address of a range of pages + uint64_t base_address; /* Base address of a region of pages */ + uint64_t allocation_base; /* Base address of a range of pages * within this region. */ - u_int32_t allocation_protection; /* Memory protection when this region + uint32_t allocation_protection; /* Memory protection when this region * was originally allocated: * MDMemoryProtection */ - u_int32_t __alignment1; - u_int64_t region_size; - u_int32_t state; /* MDMemoryState */ - u_int32_t protection; /* MDMemoryProtection */ - u_int32_t type; /* MDMemoryType */ - u_int32_t __alignment2; + uint32_t __alignment1; + uint64_t region_size; + uint32_t state; /* MDMemoryState */ + uint32_t protection; /* MDMemoryProtection */ + uint32_t type; /* MDMemoryType */ + uint32_t __alignment2; } MDRawMemoryInfo; /* MINIDUMP_MEMORY_INFO */ /* For (MDRawMemoryInfo).state */ @@ -721,7 +721,7 @@ typedef enum { } MDMemoryProtection; /* Used to mask the mutually exclusive options from the combinable flags. */ -const u_int32_t MD_MEMORY_PROTECTION_ACCESS_MASK = 0xFF; +const uint32_t MD_MEMORY_PROTECTION_ACCESS_MASK = 0xFF; /* For (MDRawMemoryInfo).type */ typedef enum { @@ -738,7 +738,7 @@ typedef enum { typedef struct { /* validity is a bitmask with values from MDBreakpadInfoValidity, indicating * which of the other fields in the structure are valid. */ - u_int32_t validity; + uint32_t validity; /* Thread ID of the handler thread. dump_thread_id should correspond to * the thread_id of an MDRawThread in the minidump's MDRawThreadList if @@ -746,7 +746,7 @@ typedef struct { * the MDRawThreadList does not contain a dedicated thread used to produce * the minidump, this field should be set to 0 and the validity field * must not contain MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID. */ - u_int32_t dump_thread_id; + uint32_t dump_thread_id; /* Thread ID of the thread that requested the minidump be produced. As * with dump_thread_id, requesting_thread_id should correspond to the @@ -759,7 +759,7 @@ typedef struct { * other than a thread in the MDRawThreadList, this field should be set * to 0 and the validity field must not contain * MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID. */ - u_int32_t requesting_thread_id; + uint32_t requesting_thread_id; } MDRawBreakpadInfo; /* For (MDRawBreakpadInfo).validity: */ @@ -777,11 +777,11 @@ typedef struct { * written to a file. * Fixed-length strings are used because MiniDumpWriteDump doesn't offer * a way for user streams to point to arbitrary RVAs for strings. */ - u_int16_t expression[128]; /* Assertion that failed... */ - u_int16_t function[128]; /* ...within this function... */ - u_int16_t file[128]; /* ...in this file... */ - u_int32_t line; /* ...at this line. */ - u_int32_t type; + uint16_t expression[128]; /* Assertion that failed... */ + uint16_t function[128]; /* ...within this function... */ + uint16_t file[128]; /* ...in this file... */ + uint32_t line; /* ...at this line. */ + uint32_t type; } MDRawAssertionInfo; /* For (MDRawAssertionInfo).type: */ @@ -806,9 +806,9 @@ typedef struct { } MDRawLinkMap; typedef struct { - u_int32_t version; + uint32_t version; MDRVA map; - u_int32_t dso_count; + uint32_t dso_count; void* brk; void* ldbase; void* dynamic; diff --git a/src/google_breakpad/processor/code_module.h b/src/google_breakpad/processor/code_module.h index 24b88fba..4e892824 100644 --- a/src/google_breakpad/processor/code_module.h +++ b/src/google_breakpad/processor/code_module.h @@ -47,11 +47,11 @@ class CodeModule { virtual ~CodeModule() {} // The base address of this code module as it was loaded by the process. - // (u_int64_t)-1 on error. - virtual u_int64_t base_address() const = 0; + // (uint64_t)-1 on error. + virtual uint64_t base_address() const = 0; // The size of the code module. 0 on error. - virtual u_int64_t size() const = 0; + virtual uint64_t size() const = 0; // The path or file name that the code module was loaded from. Empty on // error. diff --git a/src/google_breakpad/processor/code_modules.h b/src/google_breakpad/processor/code_modules.h index 29c55d4e..a38579af 100644 --- a/src/google_breakpad/processor/code_modules.h +++ b/src/google_breakpad/processor/code_modules.h @@ -53,7 +53,7 @@ class CodeModules { // address, returns NULL. Ownership of the returned CodeModule is retained // by the CodeModules object; pointers returned by this method are valid for // comparison with pointers returned by the other Get methods. - virtual const CodeModule* GetModuleForAddress(u_int64_t address) const = 0; + virtual const CodeModule* GetModuleForAddress(uint64_t address) const = 0; // Returns the module corresponding to the main executable. If there is // no main executable, returns NULL. Ownership of the returned CodeModule diff --git a/src/google_breakpad/processor/exploitability.h b/src/google_breakpad/processor/exploitability.h index 225206d7..67255a3a 100644 --- a/src/google_breakpad/processor/exploitability.h +++ b/src/google_breakpad/processor/exploitability.h @@ -54,7 +54,7 @@ class Exploitability { ProcessState *process_state); ExploitabilityRating CheckExploitability(); - bool AddressIsAscii(u_int64_t); + bool AddressIsAscii(uint64_t); protected: Exploitability(Minidump *dump, diff --git a/src/google_breakpad/processor/memory_region.h b/src/google_breakpad/processor/memory_region.h index 15e23ddc..bd9755f5 100644 --- a/src/google_breakpad/processor/memory_region.h +++ b/src/google_breakpad/processor/memory_region.h @@ -50,10 +50,10 @@ class MemoryRegion { virtual ~MemoryRegion() {} // The base address of this memory region. - virtual u_int64_t GetBase() const = 0; + virtual uint64_t GetBase() const = 0; // The size of this memory region. - virtual u_int32_t GetSize() const = 0; + virtual uint32_t GetSize() const = 0; // Access to data of various sizes within the memory region. address // is a pointer to read, and it must lie within the memory region as @@ -63,10 +63,10 @@ class MemoryRegion { // program. Returns true on success. Fails and returns false if address // is out of the region's bounds (after considering the width of value), // or for other types of errors. - virtual bool GetMemoryAtAddress(u_int64_t address, u_int8_t* value) const =0; - virtual bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) const =0; - virtual bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) const =0; - virtual bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) const =0; + virtual bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const = 0; + virtual bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const = 0; + virtual bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const = 0; + virtual bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const = 0; }; diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h index 0fe78443..18097714 100644 --- a/src/google_breakpad/processor/minidump.h +++ b/src/google_breakpad/processor/minidump.h @@ -154,7 +154,7 @@ class MinidumpStream : public MinidumpObject { // the MDRawDirectory record or other identifying record. A class // that implements MinidumpStream can compare expected_size to a // known size as an integrity check. - virtual bool Read(u_int32_t expected_size) = 0; + virtual bool Read(uint32_t expected_size) = 0; }; @@ -176,11 +176,11 @@ class MinidumpContext : public MinidumpStream { // identifying the CPU type that the context was collected from. The // returned value will identify the CPU only, and will have any other // MD_CONTEXT_* bits masked out. Returns 0 on failure. - u_int32_t GetContextCPU() const; + uint32_t GetContextCPU() const; // A convenience method to get the instruction pointer out of the // MDRawContext, since it varies per-CPU architecture. - bool GetInstructionPointer(u_int64_t* ip) const; + bool GetInstructionPointer(uint64_t* ip) const; // Returns raw CPU-specific context data for the named CPU type. If the // context data does not match the CPU type or does not exist, returns @@ -210,13 +210,13 @@ class MinidumpContext : public MinidumpStream { } context_; // Store this separately because of the weirdo AMD64 context - u_int32_t context_flags_; + uint32_t context_flags_; private: friend class MinidumpThread; friend class MinidumpException; - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); // Free the CPU-specific context structure. void FreeContext(); @@ -226,7 +226,7 @@ class MinidumpContext : public MinidumpStream { // CPU type in context_cpu_type. Returns false if the CPU type does not // match. Returns true if the CPU type matches or if the minidump does // not contain a system info stream. - bool CheckAgainstSystemInfo(u_int32_t context_cpu_type); + bool CheckAgainstSystemInfo(uint32_t context_cpu_type); }; @@ -243,28 +243,28 @@ class MinidumpMemoryRegion : public MinidumpObject, public: virtual ~MinidumpMemoryRegion(); - static void set_max_bytes(u_int32_t max_bytes) { max_bytes_ = max_bytes; } - static u_int32_t max_bytes() { return max_bytes_; } + static void set_max_bytes(uint32_t max_bytes) { max_bytes_ = max_bytes; } + static uint32_t max_bytes() { return max_bytes_; } // Returns a pointer to the base of the memory region. Returns the // cached value if available, otherwise, reads the minidump file and // caches the memory region. - const u_int8_t* GetMemory() const; + const uint8_t* GetMemory() const; // The address of the base of the memory region. - u_int64_t GetBase() const; + uint64_t GetBase() const; // The size, in bytes, of the memory region. - u_int32_t GetSize() const; + uint32_t GetSize() const; // Frees the cached memory region, if cached. void FreeMemory(); // Obtains the value of memory at the pointer specified by address. - bool GetMemoryAtAddress(u_int64_t address, u_int8_t* value) const; - bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) const; - bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) const; - bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) const; + bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const; + bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const; + bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const; + bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const; // Print a human-readable representation of the object to stdout. void Print(); @@ -281,19 +281,19 @@ class MinidumpMemoryRegion : public MinidumpObject, void SetDescriptor(MDMemoryDescriptor* descriptor); // Implementation for GetMemoryAtAddress - template<typename T> bool GetMemoryAtAddressInternal(u_int64_t address, + template<typename T> bool GetMemoryAtAddressInternal(uint64_t address, T* value) const; // The largest memory region that will be read from a minidump. The // default is 1MB. - static u_int32_t max_bytes_; + static uint32_t max_bytes_; // Base address and size of the memory region, and its position in the // minidump file. MDMemoryDescriptor* descriptor_; // Cached memory. - mutable vector<u_int8_t>* memory_; + mutable vector<uint8_t>* memory_; }; @@ -319,7 +319,7 @@ class MinidumpThread : public MinidumpObject { // so a special getter is provided to retrieve this data from the // MDRawThread structure. Returns false if the thread ID cannot be // determined. - virtual bool GetThreadID(u_int32_t *thread_id) const; + virtual bool GetThreadID(uint32_t *thread_id) const; // Print a human-readable representation of the object to stdout. void Print(); @@ -348,10 +348,10 @@ class MinidumpThreadList : public MinidumpStream { public: virtual ~MinidumpThreadList(); - static void set_max_threads(u_int32_t max_threads) { + static void set_max_threads(uint32_t max_threads) { max_threads_ = max_threads; } - static u_int32_t max_threads() { return max_threads_; } + static uint32_t max_threads() { return max_threads_; } virtual unsigned int thread_count() const { return valid_ ? thread_count_ : 0; @@ -361,7 +361,7 @@ class MinidumpThreadList : public MinidumpStream { virtual MinidumpThread* GetThreadAtIndex(unsigned int index) const; // Random access to threads. - MinidumpThread* GetThreadByID(u_int32_t thread_id); + MinidumpThread* GetThreadByID(uint32_t thread_id); // Print a human-readable representation of the object to stdout. void Print(); @@ -372,23 +372,23 @@ class MinidumpThreadList : public MinidumpStream { private: friend class Minidump; - typedef map<u_int32_t, MinidumpThread*> IDToThreadMap; + typedef map<uint32_t, MinidumpThread*> IDToThreadMap; typedef vector<MinidumpThread> MinidumpThreads; - static const u_int32_t kStreamType = MD_THREAD_LIST_STREAM; + static const uint32_t kStreamType = MD_THREAD_LIST_STREAM; - bool Read(u_int32_t aExpectedSize); + bool Read(uint32_t aExpectedSize); // The largest number of threads that will be read from a minidump. The // default is 256. - static u_int32_t max_threads_; + static uint32_t max_threads_; // Access to threads using the thread ID as the key. IDToThreadMap id_to_thread_map_; // The list of threads. MinidumpThreads* threads_; - u_int32_t thread_count_; + uint32_t thread_count_; }; @@ -401,23 +401,23 @@ class MinidumpModule : public MinidumpObject, public: virtual ~MinidumpModule(); - static void set_max_cv_bytes(u_int32_t max_cv_bytes) { + static void set_max_cv_bytes(uint32_t max_cv_bytes) { max_cv_bytes_ = max_cv_bytes; } - static u_int32_t max_cv_bytes() { return max_cv_bytes_; } + static uint32_t max_cv_bytes() { return max_cv_bytes_; } - static void set_max_misc_bytes(u_int32_t max_misc_bytes) { + static void set_max_misc_bytes(uint32_t max_misc_bytes) { max_misc_bytes_ = max_misc_bytes; } - static u_int32_t max_misc_bytes() { return max_misc_bytes_; } + static uint32_t max_misc_bytes() { return max_misc_bytes_; } const MDRawModule* module() const { return valid_ ? &module_ : NULL; } // CodeModule implementation - virtual u_int64_t base_address() const { - return valid_ ? module_.base_of_image : static_cast<u_int64_t>(-1); + virtual uint64_t base_address() const { + return valid_ ? module_.base_of_image : static_cast<uint64_t>(-1); } - virtual u_int64_t size() const { return valid_ ? module_.size_of_image : 0; } + virtual uint64_t size() const { return valid_ ? module_.size_of_image : 0; } virtual string code_file() const; virtual string code_identifier() const; virtual string debug_file() const; @@ -426,7 +426,7 @@ class MinidumpModule : public MinidumpObject, virtual const CodeModule* Copy() const; // The CodeView record, which contains information to locate the module's - // debugging information (pdb). This is returned as u_int8_t* because + // debugging information (pdb). This is returned as uint8_t* because // the data can be of types MDCVInfoPDB20* or MDCVInfoPDB70*, or it may be // of a type unknown to Breakpad, in which case the raw data will still be // returned but no byte-swapping will have been performed. Check the @@ -435,14 +435,14 @@ class MinidumpModule : public MinidumpObject, // MDCVInfoPDB70 by default. Returns a pointer to the CodeView record on // success, and NULL on failure. On success, the optional |size| argument // is set to the size of the CodeView record. - const u_int8_t* GetCVRecord(u_int32_t* size); + const uint8_t* GetCVRecord(uint32_t* size); // The miscellaneous debug record, which is obsolete. Current toolchains // do not generate this type of debugging information (dbg), and this // field is not expected to be present. Returns a pointer to the debugging // record on success, and NULL on failure. On success, the optional |size| // argument is set to the size of the debugging record. - const MDImageDebugMisc* GetMiscRecord(u_int32_t* size); + const MDImageDebugMisc* GetMiscRecord(uint32_t* size); // Print a human-readable representation of the object to stdout. void Print(); @@ -469,8 +469,8 @@ class MinidumpModule : public MinidumpObject, // The largest number of bytes that will be read from a minidump for a // CodeView record or miscellaneous debugging record, respectively. The // default for each is 1024. - static u_int32_t max_cv_bytes_; - static u_int32_t max_misc_bytes_; + static uint32_t max_cv_bytes_; + static uint32_t max_misc_bytes_; // True after a successful Read. This is different from valid_, which is // not set true until ReadAuxiliaryData also completes successfully. @@ -490,20 +490,20 @@ class MinidumpModule : public MinidumpObject, const string* name_; // Cached CodeView record - this is MDCVInfoPDB20 or (likely) - // MDCVInfoPDB70, or possibly something else entirely. Stored as a u_int8_t + // MDCVInfoPDB70, or possibly something else entirely. Stored as a uint8_t // because the structure contains a variable-sized string and its exact // size cannot be known until it is processed. - vector<u_int8_t>* cv_record_; + vector<uint8_t>* cv_record_; // If cv_record_ is present, cv_record_signature_ contains a copy of the // CodeView record's first four bytes, for ease of determinining the // type of structure that cv_record_ contains. - u_int32_t cv_record_signature_; + uint32_t cv_record_signature_; - // Cached MDImageDebugMisc (usually not present), stored as u_int8_t + // Cached MDImageDebugMisc (usually not present), stored as uint8_t // because the structure contains a variable-sized string and its exact // size cannot be known until it is processed. - vector<u_int8_t>* misc_record_; + vector<uint8_t>* misc_record_; }; @@ -516,16 +516,16 @@ class MinidumpModuleList : public MinidumpStream, public: virtual ~MinidumpModuleList(); - static void set_max_modules(u_int32_t max_modules) { + static void set_max_modules(uint32_t max_modules) { max_modules_ = max_modules; } - static u_int32_t max_modules() { return max_modules_; } + static uint32_t max_modules() { return max_modules_; } // CodeModules implementation. virtual unsigned int module_count() const { return valid_ ? module_count_ : 0; } - virtual const MinidumpModule* GetModuleForAddress(u_int64_t address) const; + virtual const MinidumpModule* GetModuleForAddress(uint64_t address) const; virtual const MinidumpModule* GetMainModule() const; virtual const MinidumpModule* GetModuleAtSequence( unsigned int sequence) const; @@ -543,19 +543,19 @@ class MinidumpModuleList : public MinidumpStream, typedef vector<MinidumpModule> MinidumpModules; - static const u_int32_t kStreamType = MD_MODULE_LIST_STREAM; + static const uint32_t kStreamType = MD_MODULE_LIST_STREAM; - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); // The largest number of modules that will be read from a minidump. The // default is 1024. - static u_int32_t max_modules_; + static uint32_t max_modules_; // Access to modules using addresses as the key. - RangeMap<u_int64_t, unsigned int> *range_map_; + RangeMap<uint64_t, unsigned int> *range_map_; MinidumpModules *modules_; - u_int32_t module_count_; + uint32_t module_count_; }; @@ -572,10 +572,10 @@ class MinidumpMemoryList : public MinidumpStream { public: virtual ~MinidumpMemoryList(); - static void set_max_regions(u_int32_t max_regions) { + static void set_max_regions(uint32_t max_regions) { max_regions_ = max_regions; } - static u_int32_t max_regions() { return max_regions_; } + static uint32_t max_regions() { return max_regions_; } unsigned int region_count() const { return valid_ ? region_count_ : 0; } @@ -584,7 +584,7 @@ class MinidumpMemoryList : public MinidumpStream { // Random access to memory regions. Returns the region encompassing // the address identified by address. - MinidumpMemoryRegion* GetMemoryRegionForAddress(u_int64_t address); + MinidumpMemoryRegion* GetMemoryRegionForAddress(uint64_t address); // Print a human-readable representation of the object to stdout. void Print(); @@ -595,18 +595,18 @@ class MinidumpMemoryList : public MinidumpStream { typedef vector<MDMemoryDescriptor> MemoryDescriptors; typedef vector<MinidumpMemoryRegion> MemoryRegions; - static const u_int32_t kStreamType = MD_MEMORY_LIST_STREAM; + static const uint32_t kStreamType = MD_MEMORY_LIST_STREAM; explicit MinidumpMemoryList(Minidump* minidump); - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); // The largest number of memory regions that will be read from a minidump. // The default is 256. - static u_int32_t max_regions_; + static uint32_t max_regions_; // Access to memory regions using addresses as the key. - RangeMap<u_int64_t, unsigned int> *range_map_; + RangeMap<uint64_t, unsigned int> *range_map_; // The list of descriptors. This is maintained separately from the list // of regions, because MemoryRegion doesn't own its MemoryDescriptor, it @@ -616,7 +616,7 @@ class MinidumpMemoryList : public MinidumpStream { // The list of regions. MemoryRegions *regions_; - u_int32_t region_count_; + uint32_t region_count_; }; @@ -638,7 +638,7 @@ class MinidumpException : public MinidumpStream { // so a special getter is provided to retrieve this data from the // MDRawExceptionStream structure. Returns false if the thread ID cannot // be determined. - bool GetThreadID(u_int32_t *thread_id) const; + bool GetThreadID(uint32_t *thread_id) const; MinidumpContext* GetContext(); @@ -648,11 +648,11 @@ class MinidumpException : public MinidumpStream { private: friend class Minidump; - static const u_int32_t kStreamType = MD_EXCEPTION_STREAM; + static const uint32_t kStreamType = MD_EXCEPTION_STREAM; explicit MinidumpException(Minidump* minidump); - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); MDRawExceptionStream exception_; MinidumpContext* context_; @@ -686,11 +686,11 @@ class MinidumpAssertion : public MinidumpStream { private: friend class Minidump; - static const u_int32_t kStreamType = MD_ASSERTION_INFO_STREAM; + static const uint32_t kStreamType = MD_ASSERTION_INFO_STREAM; explicit MinidumpAssertion(Minidump* minidump); - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); MDRawAssertionInfo assertion_; string expression_; @@ -743,9 +743,9 @@ class MinidumpSystemInfo : public MinidumpStream { private: friend class Minidump; - static const u_int32_t kStreamType = MD_SYSTEM_INFO_STREAM; + static const uint32_t kStreamType = MD_SYSTEM_INFO_STREAM; - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); // A string identifying the CPU vendor, if known. const string* cpu_vendor_; @@ -767,11 +767,11 @@ class MinidumpMiscInfo : public MinidumpStream { private: friend class Minidump; - static const u_int32_t kStreamType = MD_MISC_INFO_STREAM; + static const uint32_t kStreamType = MD_MISC_INFO_STREAM; explicit MinidumpMiscInfo(Minidump* minidump_); - bool Read(u_int32_t expected_size_); + bool Read(uint32_t expected_size_); MDRawMiscInfo misc_info_; }; @@ -790,8 +790,8 @@ class MinidumpBreakpadInfo : public MinidumpStream { // treatment, so special getters are provided to retrieve this data from // the MDRawBreakpadInfo structure. The getters return false if the thread // IDs cannot be determined. - bool GetDumpThreadID(u_int32_t *thread_id) const; - bool GetRequestingThreadID(u_int32_t *thread_id) const; + bool GetDumpThreadID(uint32_t *thread_id) const; + bool GetRequestingThreadID(uint32_t *thread_id) const; // Print a human-readable representation of the object to stdout. void Print(); @@ -799,11 +799,11 @@ class MinidumpBreakpadInfo : public MinidumpStream { private: friend class Minidump; - static const u_int32_t kStreamType = MD_BREAKPAD_INFO_STREAM; + static const uint32_t kStreamType = MD_BREAKPAD_INFO_STREAM; explicit MinidumpBreakpadInfo(Minidump* minidump_); - bool Read(u_int32_t expected_size_); + bool Read(uint32_t expected_size_); MDRawBreakpadInfo breakpad_info_; }; @@ -816,10 +816,10 @@ class MinidumpMemoryInfo : public MinidumpObject { const MDRawMemoryInfo* info() const { return valid_ ? &memory_info_ : NULL; } // The address of the base of the memory region. - u_int64_t GetBase() const { return valid_ ? memory_info_.base_address : 0; } + uint64_t GetBase() const { return valid_ ? memory_info_.base_address : 0; } // The size, in bytes, of the memory region. - u_int32_t GetSize() const { return valid_ ? memory_info_.region_size : 0; } + uint32_t GetSize() const { return valid_ ? memory_info_.region_size : 0; } // Return true if the memory protection allows execution. bool IsExecutable() const; @@ -854,7 +854,7 @@ class MinidumpMemoryInfoList : public MinidumpStream { unsigned int info_count() const { return valid_ ? info_count_ : 0; } - const MinidumpMemoryInfo* GetMemoryInfoForAddress(u_int64_t address) const; + const MinidumpMemoryInfo* GetMemoryInfoForAddress(uint64_t address) const; const MinidumpMemoryInfo* GetMemoryInfoAtIndex(unsigned int index) const; // Print a human-readable representation of the object to stdout. @@ -865,17 +865,17 @@ class MinidumpMemoryInfoList : public MinidumpStream { typedef vector<MinidumpMemoryInfo> MinidumpMemoryInfos; - static const u_int32_t kStreamType = MD_MEMORY_INFO_LIST_STREAM; + static const uint32_t kStreamType = MD_MEMORY_INFO_LIST_STREAM; explicit MinidumpMemoryInfoList(Minidump* minidump); - bool Read(u_int32_t expected_size); + bool Read(uint32_t expected_size); // Access to memory info using addresses as the key. - RangeMap<u_int64_t, unsigned int> *range_map_; + RangeMap<uint64_t, unsigned int> *range_map_; MinidumpMemoryInfos* infos_; - u_int32_t info_count_; + uint32_t info_count_; }; @@ -896,15 +896,15 @@ class Minidump { virtual string path() const { return path_; } - static void set_max_streams(u_int32_t max_streams) { + static void set_max_streams(uint32_t max_streams) { max_streams_ = max_streams; } - static u_int32_t max_streams() { return max_streams_; } + static uint32_t max_streams() { return max_streams_; } - static void set_max_string_length(u_int32_t max_string_length) { + static void set_max_string_length(uint32_t max_string_length) { max_string_length_ = max_string_length; } - static u_int32_t max_string_length() { return max_string_length_; } + static uint32_t max_string_length() { return max_string_length_; } virtual const MDRawHeader* header() const { return valid_ ? &header_ : NULL; } @@ -916,7 +916,7 @@ class Minidump { // Returns true if the current position in the stream was not changed. // Returns false when the current location in the stream was changed and the // attempt to restore the original position failed. - bool GetContextCPUFlagsFromSystemInfo(u_int32_t* context_cpu_flags); + bool GetContextCPUFlagsFromSystemInfo(uint32_t* context_cpu_flags); // Reads the minidump file's header and top-level stream directory. // The minidump is expected to be positioned at the beginning of the @@ -980,7 +980,7 @@ class Minidump { // possibility, and consider using GetDirectoryEntryAtIndex (possibly // with GetDirectoryEntryCount) if expecting multiple streams of the same // type in a single minidump file. - bool SeekToStreamType(u_int32_t stream_type, u_int32_t* stream_length); + bool SeekToStreamType(uint32_t stream_type, uint32_t* stream_length); bool swap() const { return valid_ ? swap_ : false; } @@ -1003,7 +1003,7 @@ class Minidump { }; typedef vector<MDRawDirectory> MinidumpDirectoryEntries; - typedef map<u_int32_t, MinidumpStreamInfo> MinidumpStreamMap; + typedef map<uint32_t, MinidumpStreamInfo> MinidumpStreamMap; template<typename T> T* GetStream(T** stream); @@ -1013,7 +1013,7 @@ class Minidump { // The largest number of top-level streams that will be read from a minidump. // Note that streams are only read (and only consume memory) as needed, // when directed by the caller. The default is 128. - static u_int32_t max_streams_; + static uint32_t max_streams_; // The maximum length of a UTF-16 string that will be read from a minidump // in 16-bit words. The default is 1024. UTF-16 strings are converted diff --git a/src/google_breakpad/processor/minidump_processor.h b/src/google_breakpad/processor/minidump_processor.h index 0e10f40b..33cd0206 100644 --- a/src/google_breakpad/processor/minidump_processor.h +++ b/src/google_breakpad/processor/minidump_processor.h @@ -131,7 +131,7 @@ class MinidumpProcessor { // address when the crash was caused by problems such as illegal // instructions or divisions by zero, or a data address when the crash // was caused by a memory access violation. - static string GetCrashReason(Minidump* dump, u_int64_t* address); + static string GetCrashReason(Minidump* dump, uint64_t* address); // This function returns true if the passed-in error code is // something unrecoverable(i.e. retry should not happen). For diff --git a/src/google_breakpad/processor/process_state.h b/src/google_breakpad/processor/process_state.h index 8d71457b..780cb548 100644 --- a/src/google_breakpad/processor/process_state.h +++ b/src/google_breakpad/processor/process_state.h @@ -94,10 +94,10 @@ class ProcessState { void Clear(); // Accessors. See the data declarations below. - u_int32_t time_date_stamp() const { return time_date_stamp_; } + uint32_t time_date_stamp() const { return time_date_stamp_; } bool crashed() const { return crashed_; } string crash_reason() const { return crash_reason_; } - u_int64_t crash_address() const { return crash_address_; } + uint64_t crash_address() const { return crash_address_; } string assertion() const { return assertion_; } int requesting_thread() const { return requesting_thread_; } const vector<CallStack*>* threads() const { return &threads_; } @@ -113,7 +113,7 @@ class ProcessState { friend class MinidumpProcessor; // The time-date stamp of the minidump (time_t format) - u_int32_t time_date_stamp_; + uint32_t time_date_stamp_; // True if the process crashed, false if the dump was produced outside // of an exception handler. @@ -129,7 +129,7 @@ class ProcessState { // the memory address that caused the crash. For data access errors, // this will be the data address that caused the fault. For code errors, // this will be the address of the instruction that caused the fault. - u_int64_t crash_address_; + uint64_t crash_address_; // If there was an assertion that was hit, a textual representation // of that assertion, possibly including the file and line at which diff --git a/src/google_breakpad/processor/source_line_resolver_interface.h b/src/google_breakpad/processor/source_line_resolver_interface.h index 4e9dd4b7..7b69b0d3 100644 --- a/src/google_breakpad/processor/source_line_resolver_interface.h +++ b/src/google_breakpad/processor/source_line_resolver_interface.h @@ -48,7 +48,7 @@ class CFIFrameInfo; class SourceLineResolverInterface { public: - typedef u_int64_t MemAddr; + typedef uint64_t MemAddr; virtual ~SourceLineResolverInterface() {} diff --git a/src/google_breakpad/processor/stack_frame.h b/src/google_breakpad/processor/stack_frame.h index e8803804..23e69bb4 100644 --- a/src/google_breakpad/processor/stack_frame.h +++ b/src/google_breakpad/processor/stack_frame.h @@ -85,7 +85,7 @@ struct StackFrame { // Return the actual return address, as saved on the stack or in a // register. See the comments for 'instruction', below, for details. - virtual u_int64_t ReturnAddress() const { return instruction; } + virtual uint64_t ReturnAddress() const { return instruction; } // The program counter location as an absolute virtual address. // @@ -108,7 +108,7 @@ struct StackFrame { // a register is fine for looking up the point of the call. On others, it // requires adjustment. ReturnAddress returns the address as saved by the // machine. - u_int64_t instruction; + uint64_t instruction; // The module in which the instruction resides. const CodeModule *module; @@ -118,7 +118,7 @@ struct StackFrame { // The start address of the function, may be omitted if debug symbols // are not available. - u_int64_t function_base; + uint64_t function_base; // The source file name, may be omitted if debug symbols are not available. string source_file_name; @@ -129,7 +129,7 @@ struct StackFrame { // The start address of the source line, may be omitted if debug symbols // are not available. - u_int64_t source_line_base; + uint64_t source_line_base; // Amount of trust the stack walker has in the instruction pointer // of this frame. diff --git a/src/google_breakpad/processor/stack_frame_cpu.h b/src/google_breakpad/processor/stack_frame_cpu.h index 34171f37..a9cf99b7 100644 --- a/src/google_breakpad/processor/stack_frame_cpu.h +++ b/src/google_breakpad/processor/stack_frame_cpu.h @@ -78,7 +78,7 @@ struct StackFrameX86 : public StackFrame { ~StackFrameX86(); // Overriden to return the return address as saved on the stack. - virtual u_int64_t ReturnAddress() const; + virtual uint64_t ReturnAddress() const; // Register state. This is only fully valid for the topmost frame in a // stack. In other frames, the values of nonvolatile registers may be @@ -151,7 +151,7 @@ struct StackFrameAMD64 : public StackFrame { StackFrameAMD64() : context(), context_validity(CONTEXT_VALID_NONE) {} // Overriden to return the return address as saved on the stack. - virtual u_int64_t ReturnAddress() const; + virtual uint64_t ReturnAddress() const; // Register state. This is only fully valid for the topmost frame in a // stack. In other frames, which registers are present depends on what diff --git a/src/google_breakpad/processor/stackwalker.h b/src/google_breakpad/processor/stackwalker.h index 401c2f62..9e678e3c 100644 --- a/src/google_breakpad/processor/stackwalker.h +++ b/src/google_breakpad/processor/stackwalker.h @@ -78,8 +78,8 @@ class Stackwalker { const CodeModules* modules, StackFrameSymbolizer* resolver_helper); - static void set_max_frames(u_int32_t max_frames) { max_frames_ = max_frames; } - static u_int32_t max_frames() { return max_frames_; } + static void set_max_frames(uint32_t max_frames) { max_frames_ = max_frames; } + static uint32_t max_frames() { return max_frames_; } protected: // system_info identifies the operating system, NULL or empty if unknown. @@ -104,7 +104,7 @@ class Stackwalker { // * This address is within a loaded module for which we have symbols, // and falls inside a function in that module. // Returns false otherwise. - bool InstructionAddressSeemsValid(u_int64_t address); + bool InstructionAddressSeemsValid(uint64_t address); // The default number of words to search through on the stack // for a return address. @@ -185,7 +185,7 @@ class Stackwalker { // The maximum number of frames Stackwalker will walk through. // This defaults to 1024 to prevent infinite loops. - static u_int32_t max_frames_; + static uint32_t max_frames_; }; } // namespace google_breakpad |