1//===- Minidump.h - Minidump constants and structures -----------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This header constants and data structures pertaining to the Windows Minidump 10// core file format. 11// 12// Reference: 13// https://msdn.microsoft.com/en-us/library/windows/desktop/ms679293(v=vs.85).aspx 14// https://chromium.googlesource.com/breakpad/breakpad/ 15// 16//===----------------------------------------------------------------------===// 17 18#ifndef LLVM_BINARYFORMAT_MINIDUMP_H 19#define LLVM_BINARYFORMAT_MINIDUMP_H 20 21#include "llvm/ADT/BitmaskEnum.h" 22#include "llvm/ADT/DenseMapInfo.h" 23#include "llvm/Support/Endian.h" 24 25namespace llvm { 26namespace minidump { 27 28LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); 29 30/// The minidump header is the first part of a minidump file. It identifies the 31/// file as a minidump file, and gives the location of the stream directory. 32struct Header { 33 static constexpr uint32_t MagicSignature = 0x504d444d; // PMDM 34 static constexpr uint16_t MagicVersion = 0xa793; 35 36 support::ulittle32_t Signature; 37 // The high 16 bits of version field are implementation specific. The low 16 38 // bits should be MagicVersion. 39 support::ulittle32_t Version; 40 support::ulittle32_t NumberOfStreams; 41 support::ulittle32_t StreamDirectoryRVA; 42 support::ulittle32_t Checksum; 43 support::ulittle32_t TimeDateStamp; 44 support::ulittle64_t Flags; 45}; 46static_assert(sizeof(Header) == 32); 47 48/// The type of a minidump stream identifies its contents. Streams numbers after 49/// LastReserved are for application-defined data streams. 50enum class StreamType : uint32_t { 51#define HANDLE_MDMP_STREAM_TYPE(CODE, NAME) NAME = CODE, 52#include "llvm/BinaryFormat/MinidumpConstants.def" 53 Unused = 0, 54 LastReserved = 0x0000ffff, 55}; 56 57/// Specifies the location (and size) of various objects in the minidump file. 58/// The location is relative to the start of the file. 59struct LocationDescriptor { 60 support::ulittle32_t DataSize; 61 support::ulittle32_t RVA; 62}; 63static_assert(sizeof(LocationDescriptor) == 8); 64 65/// Describes a single memory range (both its VM address and where to find it in 66/// the file) of the process from which this minidump file was generated. 67struct MemoryDescriptor { 68 support::ulittle64_t StartOfMemoryRange; 69 LocationDescriptor Memory; 70}; 71static_assert(sizeof(MemoryDescriptor) == 16); 72 73struct MemoryInfoListHeader { 74 support::ulittle32_t SizeOfHeader; 75 support::ulittle32_t SizeOfEntry; 76 support::ulittle64_t NumberOfEntries; 77 78 MemoryInfoListHeader() = default; 79 MemoryInfoListHeader(uint32_t SizeOfHeader, uint32_t SizeOfEntry, 80 uint64_t NumberOfEntries) 81 : SizeOfHeader(SizeOfHeader), SizeOfEntry(SizeOfEntry), 82 NumberOfEntries(NumberOfEntries) {} 83}; 84static_assert(sizeof(MemoryInfoListHeader) == 16); 85 86enum class MemoryProtection : uint32_t { 87#define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME) NAME = CODE, 88#include "llvm/BinaryFormat/MinidumpConstants.def" 89 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu), 90}; 91 92enum class MemoryState : uint32_t { 93#define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME) NAME = CODE, 94#include "llvm/BinaryFormat/MinidumpConstants.def" 95 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu), 96}; 97 98enum class MemoryType : uint32_t { 99#define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME) NAME = CODE, 100#include "llvm/BinaryFormat/MinidumpConstants.def" 101 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu), 102}; 103 104struct MemoryInfo { 105 support::ulittle64_t BaseAddress; 106 support::ulittle64_t AllocationBase; 107 support::little_t<MemoryProtection> AllocationProtect; 108 support::ulittle32_t Reserved0; 109 support::ulittle64_t RegionSize; 110 support::little_t<MemoryState> State; 111 support::little_t<MemoryProtection> Protect; 112 support::little_t<MemoryType> Type; 113 support::ulittle32_t Reserved1; 114}; 115static_assert(sizeof(MemoryInfo) == 48); 116 117/// Specifies the location and type of a single stream in the minidump file. The 118/// minidump stream directory is an array of entries of this type, with its size 119/// given by Header.NumberOfStreams. 120struct Directory { 121 support::little_t<StreamType> Type; 122 LocationDescriptor Location; 123}; 124static_assert(sizeof(Directory) == 12); 125 126/// The processor architecture of the system that generated this minidump. Used 127/// in the ProcessorArch field of the SystemInfo stream. 128enum class ProcessorArchitecture : uint16_t { 129#define HANDLE_MDMP_ARCH(CODE, NAME) NAME = CODE, 130#include "llvm/BinaryFormat/MinidumpConstants.def" 131}; 132 133/// The OS Platform of the system that generated this minidump. Used in the 134/// PlatformId field of the SystemInfo stream. 135enum class OSPlatform : uint32_t { 136#define HANDLE_MDMP_PLATFORM(CODE, NAME) NAME = CODE, 137#include "llvm/BinaryFormat/MinidumpConstants.def" 138}; 139 140/// Detailed information about the processor of the system that generated this 141/// minidump. Its interpretation depends on the ProcessorArchitecture enum. 142union CPUInfo { 143 struct X86Info { 144 char VendorID[12]; // cpuid 0: ebx, edx, ecx 145 support::ulittle32_t VersionInfo; // cpuid 1: eax 146 support::ulittle32_t FeatureInfo; // cpuid 1: edx 147 support::ulittle32_t AMDExtendedFeatures; // cpuid 0x80000001, ebx 148 } X86; 149 struct ArmInfo { 150 support::ulittle32_t CPUID; 151 support::ulittle32_t ElfHWCaps; // linux specific, 0 otherwise 152 } Arm; 153 struct OtherInfo { 154 uint8_t ProcessorFeatures[16]; 155 } Other; 156}; 157static_assert(sizeof(CPUInfo) == 24); 158 159/// The SystemInfo stream, containing various information about the system where 160/// this minidump was generated. 161struct SystemInfo { 162 support::little_t<ProcessorArchitecture> ProcessorArch; 163 support::ulittle16_t ProcessorLevel; 164 support::ulittle16_t ProcessorRevision; 165 166 uint8_t NumberOfProcessors; 167 uint8_t ProductType; 168 169 support::ulittle32_t MajorVersion; 170 support::ulittle32_t MinorVersion; 171 support::ulittle32_t BuildNumber; 172 support::little_t<OSPlatform> PlatformId; 173 support::ulittle32_t CSDVersionRVA; 174 175 support::ulittle16_t SuiteMask; 176 support::ulittle16_t Reserved; 177 178 CPUInfo CPU; 179}; 180static_assert(sizeof(SystemInfo) == 56); 181 182struct VSFixedFileInfo { 183 support::ulittle32_t Signature; 184 support::ulittle32_t StructVersion; 185 support::ulittle32_t FileVersionHigh; 186 support::ulittle32_t FileVersionLow; 187 support::ulittle32_t ProductVersionHigh; 188 support::ulittle32_t ProductVersionLow; 189 support::ulittle32_t FileFlagsMask; 190 support::ulittle32_t FileFlags; 191 support::ulittle32_t FileOS; 192 support::ulittle32_t FileType; 193 support::ulittle32_t FileSubtype; 194 support::ulittle32_t FileDateHigh; 195 support::ulittle32_t FileDateLow; 196}; 197static_assert(sizeof(VSFixedFileInfo) == 52); 198 199inline bool operator==(const VSFixedFileInfo &LHS, const VSFixedFileInfo &RHS) { 200 return memcmp(&LHS, &RHS, sizeof(VSFixedFileInfo)) == 0; 201} 202 203struct Module { 204 support::ulittle64_t BaseOfImage; 205 support::ulittle32_t SizeOfImage; 206 support::ulittle32_t Checksum; 207 support::ulittle32_t TimeDateStamp; 208 support::ulittle32_t ModuleNameRVA; 209 VSFixedFileInfo VersionInfo; 210 LocationDescriptor CvRecord; 211 LocationDescriptor MiscRecord; 212 support::ulittle64_t Reserved0; 213 support::ulittle64_t Reserved1; 214}; 215static_assert(sizeof(Module) == 108); 216 217/// Describes a single thread in the minidump file. Part of the ThreadList 218/// stream. 219struct Thread { 220 support::ulittle32_t ThreadId; 221 support::ulittle32_t SuspendCount; 222 support::ulittle32_t PriorityClass; 223 support::ulittle32_t Priority; 224 support::ulittle64_t EnvironmentBlock; 225 MemoryDescriptor Stack; 226 LocationDescriptor Context; 227}; 228static_assert(sizeof(Thread) == 48); 229 230struct Exception { 231 static constexpr size_t MaxParameters = 15; 232 233 support::ulittle32_t ExceptionCode; 234 support::ulittle32_t ExceptionFlags; 235 support::ulittle64_t ExceptionRecord; 236 support::ulittle64_t ExceptionAddress; 237 support::ulittle32_t NumberParameters; 238 support::ulittle32_t UnusedAlignment; 239 support::ulittle64_t ExceptionInformation[MaxParameters]; 240}; 241static_assert(sizeof(Exception) == 152); 242 243struct ExceptionStream { 244 support::ulittle32_t ThreadId; 245 support::ulittle32_t UnusedAlignment; 246 Exception ExceptionRecord; 247 LocationDescriptor ThreadContext; 248}; 249static_assert(sizeof(ExceptionStream) == 168); 250 251} // namespace minidump 252 253template <> struct DenseMapInfo<minidump::StreamType> { 254 static minidump::StreamType getEmptyKey() { return minidump::StreamType(-1); } 255 256 static minidump::StreamType getTombstoneKey() { 257 return minidump::StreamType(-2); 258 } 259 260 static unsigned getHashValue(minidump::StreamType Val) { 261 return DenseMapInfo<uint32_t>::getHashValue(static_cast<uint32_t>(Val)); 262 } 263 264 static bool isEqual(minidump::StreamType LHS, minidump::StreamType RHS) { 265 return LHS == RHS; 266 } 267}; 268 269} // namespace llvm 270 271#endif // LLVM_BINARYFORMAT_MINIDUMP_H 272