//===- Minidump.h - Minidump constants and structures -----------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This header constants and data structures pertaining to the Windows Minidump
// core file format.
//
// Reference:
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms679293(v=vs.85).aspx
// https://chromium.googlesource.com/breakpad/breakpad/
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_BINARYFORMAT_MINIDUMP_H
#define LLVM_BINARYFORMAT_MINIDUMP_H

#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/Support/Endian.h"

namespace llvm {
namespace minidump {

LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();

/// The minidump header is the first part of a minidump file. It identifies the
/// file as a minidump file, and gives the location of the stream directory.
struct Header {
  static constexpr uint32_t MagicSignature = 0x504d444d; // PMDM
  static constexpr uint16_t MagicVersion = 0xa793;

  support::ulittle32_t Signature;
  // The high 16 bits of version field are implementation specific. The low 16
  // bits should be MagicVersion.
  support::ulittle32_t Version;
  support::ulittle32_t NumberOfStreams;
  support::ulittle32_t StreamDirectoryRVA;
  support::ulittle32_t Checksum;
  support::ulittle32_t TimeDateStamp;
  support::ulittle64_t Flags;
};
static_assert(sizeof(Header) == 32);

/// The type of a minidump stream identifies its contents. Streams numbers after
/// LastReserved are for application-defined data streams.
enum class StreamType : uint32_t {
#define HANDLE_MDMP_STREAM_TYPE(CODE, NAME) NAME = CODE,
#include "llvm/BinaryFormat/MinidumpConstants.def"
  Unused = 0,
  LastReserved = 0x0000ffff,
};

/// Specifies the location (and size) of various objects in the minidump file.
/// The location is relative to the start of the file.
struct LocationDescriptor {
  support::ulittle32_t DataSize;
  support::ulittle32_t RVA;
};
static_assert(sizeof(LocationDescriptor) == 8);

/// Describes a single memory range (both its VM address and where to find it in
/// the file) of the process from which this minidump file was generated.
struct MemoryDescriptor {
  support::ulittle64_t StartOfMemoryRange;
  LocationDescriptor Memory;
};
static_assert(sizeof(MemoryDescriptor) == 16);

struct MemoryDescriptor_64 {
  support::ulittle64_t StartOfMemoryRange;
  support::ulittle64_t DataSize;
};
static_assert(sizeof(MemoryDescriptor_64) == 16);

struct MemoryListHeader {
  support::ulittle32_t NumberOfMemoryRanges;
};
static_assert(sizeof(MemoryListHeader) == 4);

struct Memory64ListHeader {
  support::ulittle64_t NumberOfMemoryRanges;
  support::ulittle64_t BaseRVA;
};
static_assert(sizeof(Memory64ListHeader) == 16);

struct MemoryInfoListHeader {
  support::ulittle32_t SizeOfHeader;
  support::ulittle32_t SizeOfEntry;
  support::ulittle64_t NumberOfEntries;

  MemoryInfoListHeader() = default;
  MemoryInfoListHeader(uint32_t SizeOfHeader, uint32_t SizeOfEntry,
                       uint64_t NumberOfEntries)
      : SizeOfHeader(SizeOfHeader), SizeOfEntry(SizeOfEntry),
        NumberOfEntries(NumberOfEntries) {}
};
static_assert(sizeof(MemoryInfoListHeader) == 16);

enum class MemoryProtection : uint32_t {
#define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME) NAME = CODE,
#include "llvm/BinaryFormat/MinidumpConstants.def"
  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu),
};

enum class MemoryState : uint32_t {
#define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME) NAME = CODE,
#include "llvm/BinaryFormat/MinidumpConstants.def"
  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu),
};

enum class MemoryType : uint32_t {
#define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME) NAME = CODE,
#include "llvm/BinaryFormat/MinidumpConstants.def"
  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xffffffffu),
};

struct MemoryInfo {
  support::ulittle64_t BaseAddress;
  support::ulittle64_t AllocationBase;
  support::little_t<MemoryProtection> AllocationProtect;
  support::ulittle32_t Reserved0;
  support::ulittle64_t RegionSize;
  support::little_t<MemoryState> State;
  support::little_t<MemoryProtection> Protect;
  support::little_t<MemoryType> Type;
  support::ulittle32_t Reserved1;
};
static_assert(sizeof(MemoryInfo) == 48);

/// Specifies the location and type of a single stream in the minidump file. The
/// minidump stream directory is an array of entries of this type, with its size
/// given by Header.NumberOfStreams.
struct Directory {
  support::little_t<StreamType> Type;
  LocationDescriptor Location;
};
static_assert(sizeof(Directory) == 12);

/// The processor architecture of the system that generated this minidump. Used
/// in the ProcessorArch field of the SystemInfo stream.
enum class ProcessorArchitecture : uint16_t {
#define HANDLE_MDMP_ARCH(CODE, NAME) NAME = CODE,
#include "llvm/BinaryFormat/MinidumpConstants.def"
};

/// The OS Platform of the system that generated this minidump. Used in the
/// PlatformId field of the SystemInfo stream.
enum class OSPlatform : uint32_t {
#define HANDLE_MDMP_PLATFORM(CODE, NAME) NAME = CODE,
#include "llvm/BinaryFormat/MinidumpConstants.def"
};

/// Detailed information about the processor of the system that generated this
/// minidump. Its interpretation depends on the ProcessorArchitecture enum.
union CPUInfo {
  struct X86Info {
    char VendorID[12];                        // cpuid 0: ebx, edx, ecx
    support::ulittle32_t VersionInfo;         // cpuid 1: eax
    support::ulittle32_t FeatureInfo;         // cpuid 1: edx
    support::ulittle32_t AMDExtendedFeatures; // cpuid 0x80000001, ebx
  } X86;
  struct ArmInfo {
    support::ulittle32_t CPUID;
    support::ulittle32_t ElfHWCaps; // linux specific, 0 otherwise
  } Arm;
  struct OtherInfo {
    uint8_t ProcessorFeatures[16];
  } Other;
};
static_assert(sizeof(CPUInfo) == 24);

/// The SystemInfo stream, containing various information about the system where
/// this minidump was generated.
struct SystemInfo {
  support::little_t<ProcessorArchitecture> ProcessorArch;
  support::ulittle16_t ProcessorLevel;
  support::ulittle16_t ProcessorRevision;

  uint8_t NumberOfProcessors;
  uint8_t ProductType;

  support::ulittle32_t MajorVersion;
  support::ulittle32_t MinorVersion;
  support::ulittle32_t BuildNumber;
  support::little_t<OSPlatform> PlatformId;
  support::ulittle32_t CSDVersionRVA;

  support::ulittle16_t SuiteMask;
  support::ulittle16_t Reserved;

  CPUInfo CPU;
};
static_assert(sizeof(SystemInfo) == 56);

struct VSFixedFileInfo {
  support::ulittle32_t Signature;
  support::ulittle32_t StructVersion;
  support::ulittle32_t FileVersionHigh;
  support::ulittle32_t FileVersionLow;
  support::ulittle32_t ProductVersionHigh;
  support::ulittle32_t ProductVersionLow;
  support::ulittle32_t FileFlagsMask;
  support::ulittle32_t FileFlags;
  support::ulittle32_t FileOS;
  support::ulittle32_t FileType;
  support::ulittle32_t FileSubtype;
  support::ulittle32_t FileDateHigh;
  support::ulittle32_t FileDateLow;
};
static_assert(sizeof(VSFixedFileInfo) == 52);

inline bool operator==(const VSFixedFileInfo &LHS, const VSFixedFileInfo &RHS) {
  return memcmp(&LHS, &RHS, sizeof(VSFixedFileInfo)) == 0;
}

struct Module {
  support::ulittle64_t BaseOfImage;
  support::ulittle32_t SizeOfImage;
  support::ulittle32_t Checksum;
  support::ulittle32_t TimeDateStamp;
  support::ulittle32_t ModuleNameRVA;
  VSFixedFileInfo VersionInfo;
  LocationDescriptor CvRecord;
  LocationDescriptor MiscRecord;
  support::ulittle64_t Reserved0;
  support::ulittle64_t Reserved1;
};
static_assert(sizeof(Module) == 108);

/// Describes a single thread in the minidump file. Part of the ThreadList
/// stream.
struct Thread {
  support::ulittle32_t ThreadId;
  support::ulittle32_t SuspendCount;
  support::ulittle32_t PriorityClass;
  support::ulittle32_t Priority;
  support::ulittle64_t EnvironmentBlock;
  MemoryDescriptor Stack;
  LocationDescriptor Context;
};
static_assert(sizeof(Thread) == 48);

struct Exception {
  static constexpr size_t MaxParameters = 15;
  static constexpr size_t MaxParameterBytes = MaxParameters * sizeof(uint64_t);
  static const uint32_t LLDB_FLAG = 0x4C4C4442; // ASCII for 'LLDB'

  support::ulittle32_t ExceptionCode;
  support::ulittle32_t ExceptionFlags;
  support::ulittle64_t ExceptionRecord;
  support::ulittle64_t ExceptionAddress;
  support::ulittle32_t NumberParameters;
  support::ulittle32_t UnusedAlignment;
  support::ulittle64_t ExceptionInformation[MaxParameters];
};
static_assert(sizeof(Exception) == 152);

struct ExceptionStream {
  support::ulittle32_t ThreadId;
  support::ulittle32_t UnusedAlignment;
  Exception ExceptionRecord;
  LocationDescriptor ThreadContext;
};
static_assert(sizeof(ExceptionStream) == 168);

} // namespace minidump

template <> struct DenseMapInfo<minidump::StreamType> {
  static minidump::StreamType getEmptyKey() { return minidump::StreamType(-1); }

  static minidump::StreamType getTombstoneKey() {
    return minidump::StreamType(-2);
  }

  static unsigned getHashValue(minidump::StreamType Val) {
    return DenseMapInfo<uint32_t>::getHashValue(static_cast<uint32_t>(Val));
  }

  static bool isEqual(minidump::StreamType LHS, minidump::StreamType RHS) {
    return LHS == RHS;
  }
};

} // namespace llvm

#endif // LLVM_BINARYFORMAT_MINIDUMP_H
