LCOV - code coverage report
Current view: top level - include/llvm/DebugInfo/CodeView - CodeView.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 11 13 84.6 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- CodeView.h -----------------------------------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // Defines constants and basic types describing CodeView debug information.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_DEBUGINFO_CODEVIEW_CODEVIEW_H
      15             : #define LLVM_DEBUGINFO_CODEVIEW_CODEVIEW_H
      16             : 
      17             : #include <cinttypes>
      18             : #include <type_traits>
      19             : 
      20             : #include "llvm/Support/Endian.h"
      21             : 
      22             : namespace llvm {
      23             : namespace codeview {
      24             : 
      25             : /// Distinguishes individual records in .debug$T section or PDB type stream. The
      26             : /// documentation and headers talk about this as the "leaf" type.
      27             : enum class TypeRecordKind : uint16_t {
      28             : #define TYPE_RECORD(lf_ename, value, name) name = value,
      29             : #include "CodeViewTypes.def"
      30             : };
      31             : 
      32             : /// Duplicate copy of the above enum, but using the official CV names. Useful
      33             : /// for reference purposes and when dealing with unknown record types.
      34             : enum TypeLeafKind : uint16_t {
      35             : #define CV_TYPE(name, val) name = val,
      36             : #include "CodeViewTypes.def"
      37             : };
      38             : 
      39             : /// Distinguishes individual records in the Symbols subsection of a .debug$S
      40             : /// section. Equivalent to SYM_ENUM_e in cvinfo.h.
      41             : enum class SymbolRecordKind : uint16_t {
      42             : #define SYMBOL_RECORD(lf_ename, value, name) name = value,
      43             : #include "CodeViewSymbols.def"
      44             : };
      45             : 
      46             : /// Duplicate copy of the above enum, but using the official CV names. Useful
      47             : /// for reference purposes and when dealing with unknown record types.
      48             : enum SymbolKind : uint16_t {
      49             : #define CV_SYMBOL(name, val) name = val,
      50             : #include "CodeViewSymbols.def"
      51             : };
      52             : 
      53             : #define CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(Class)                            \
      54             :   inline Class operator|(Class a, Class b) {                                   \
      55             :     return static_cast<Class>(                                                 \
      56             :         static_cast<std::underlying_type<Class>::type>(a) |                    \
      57             :         static_cast<std::underlying_type<Class>::type>(b));                    \
      58             :   }                                                                            \
      59             :   inline Class operator&(Class a, Class b) {                                   \
      60             :     return static_cast<Class>(                                                 \
      61             :         static_cast<std::underlying_type<Class>::type>(a) &                    \
      62             :         static_cast<std::underlying_type<Class>::type>(b));                    \
      63             :   }                                                                            \
      64             :   inline Class operator~(Class a) {                                            \
      65             :     return static_cast<Class>(                                                 \
      66             :         ~static_cast<std::underlying_type<Class>::type>(a));                   \
      67             :   }                                                                            \
      68             :   inline Class &operator|=(Class &a, Class b) {                                \
      69             :     a = a | b;                                                                 \
      70             :     return a;                                                                  \
      71             :   }                                                                            \
      72             :   inline Class &operator&=(Class &a, Class b) {                                \
      73             :     a = a & b;                                                                 \
      74             :     return a;                                                                  \
      75             :   }
      76             : 
      77             : /// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented
      78             : /// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
      79             : enum class CPUType : uint16_t {
      80             :   Intel8080 = 0x0,
      81             :   Intel8086 = 0x1,
      82             :   Intel80286 = 0x2,
      83             :   Intel80386 = 0x3,
      84             :   Intel80486 = 0x4,
      85             :   Pentium = 0x5,
      86             :   PentiumPro = 0x6,
      87             :   Pentium3 = 0x7,
      88             :   MIPS = 0x10,
      89             :   MIPS16 = 0x11,
      90             :   MIPS32 = 0x12,
      91             :   MIPS64 = 0x13,
      92             :   MIPSI = 0x14,
      93             :   MIPSII = 0x15,
      94             :   MIPSIII = 0x16,
      95             :   MIPSIV = 0x17,
      96             :   MIPSV = 0x18,
      97             :   M68000 = 0x20,
      98             :   M68010 = 0x21,
      99             :   M68020 = 0x22,
     100             :   M68030 = 0x23,
     101             :   M68040 = 0x24,
     102             :   Alpha = 0x30,
     103             :   Alpha21164 = 0x31,
     104             :   Alpha21164A = 0x32,
     105             :   Alpha21264 = 0x33,
     106             :   Alpha21364 = 0x34,
     107             :   PPC601 = 0x40,
     108             :   PPC603 = 0x41,
     109             :   PPC604 = 0x42,
     110             :   PPC620 = 0x43,
     111             :   PPCFP = 0x44,
     112             :   PPCBE = 0x45,
     113             :   SH3 = 0x50,
     114             :   SH3E = 0x51,
     115             :   SH3DSP = 0x52,
     116             :   SH4 = 0x53,
     117             :   SHMedia = 0x54,
     118             :   ARM3 = 0x60,
     119             :   ARM4 = 0x61,
     120             :   ARM4T = 0x62,
     121             :   ARM5 = 0x63,
     122             :   ARM5T = 0x64,
     123             :   ARM6 = 0x65,
     124             :   ARM_XMAC = 0x66,
     125             :   ARM_WMMX = 0x67,
     126             :   ARM7 = 0x68,
     127             :   ARM64 = 0x69,
     128             :   Omni = 0x70,
     129             :   Ia64 = 0x80,
     130             :   Ia64_2 = 0x81,
     131             :   CEE = 0x90,
     132             :   AM33 = 0xa0,
     133             :   M32R = 0xb0,
     134             :   TriCore = 0xc0,
     135             :   X64 = 0xd0,
     136             :   EBC = 0xe0,
     137             :   Thumb = 0xf0,
     138             :   ARMNT = 0xf4,
     139             :   D3D11_Shader = 0x100,
     140             : };
     141             : 
     142             : /// These values correspond to the CV_CFL_LANG enumeration, and are documented
     143             : /// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
     144             : enum SourceLanguage : uint8_t {
     145             :   C = 0x00,
     146             :   Cpp = 0x01,
     147             :   Fortran = 0x02,
     148             :   Masm = 0x03,
     149             :   Pascal = 0x04,
     150             :   Basic = 0x05,
     151             :   Cobol = 0x06,
     152             :   Link = 0x07,
     153             :   Cvtres = 0x08,
     154             :   Cvtpgd = 0x09,
     155             :   CSharp = 0x0a,
     156             :   VB = 0x0b,
     157             :   ILAsm = 0x0c,
     158             :   Java = 0x0d,
     159             :   JScript = 0x0e,
     160             :   MSIL = 0x0f,
     161             :   HLSL = 0x10,
     162             : 
     163             :   /// The DMD compiler emits 'D' for the CV source language. Microsoft doesn't
     164             :   /// have an enumerator for it yet.
     165             :   D = 'D',
     166             : };
     167             : 
     168             : /// These values correspond to the CV_call_e enumeration, and are documented
     169             : /// at the following locations:
     170             : ///   https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
     171             : ///   https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
     172             : ///
     173             : enum class CallingConvention : uint8_t {
     174             :   NearC = 0x00,       // near right to left push, caller pops stack
     175             :   FarC = 0x01,        // far right to left push, caller pops stack
     176             :   NearPascal = 0x02,  // near left to right push, callee pops stack
     177             :   FarPascal = 0x03,   // far left to right push, callee pops stack
     178             :   NearFast = 0x04,    // near left to right push with regs, callee pops stack
     179             :   FarFast = 0x05,     // far left to right push with regs, callee pops stack
     180             :   NearStdCall = 0x07, // near standard call
     181             :   FarStdCall = 0x08,  // far standard call
     182             :   NearSysCall = 0x09, // near sys call
     183             :   FarSysCall = 0x0a,  // far sys call
     184             :   ThisCall = 0x0b,    // this call (this passed in register)
     185             :   MipsCall = 0x0c,    // Mips call
     186             :   Generic = 0x0d,     // Generic call sequence
     187             :   AlphaCall = 0x0e,   // Alpha call
     188             :   PpcCall = 0x0f,     // PPC call
     189             :   SHCall = 0x10,      // Hitachi SuperH call
     190             :   ArmCall = 0x11,     // ARM call
     191             :   AM33Call = 0x12,    // AM33 call
     192             :   TriCall = 0x13,     // TriCore Call
     193             :   SH5Call = 0x14,     // Hitachi SuperH-5 call
     194             :   M32RCall = 0x15,    // M32R Call
     195             :   ClrCall = 0x16,     // clr call
     196             :   Inline =
     197             :       0x17, // Marker for routines always inlined and thus lacking a convention
     198             :   NearVector = 0x18 // near left to right push with regs, callee pops stack
     199             : };
     200             : 
     201             : enum class ClassOptions : uint16_t {
     202             :   None = 0x0000,
     203             :   Packed = 0x0001,
     204             :   HasConstructorOrDestructor = 0x0002,
     205             :   HasOverloadedOperator = 0x0004,
     206             :   Nested = 0x0008,
     207             :   ContainsNestedClass = 0x0010,
     208             :   HasOverloadedAssignmentOperator = 0x0020,
     209             :   HasConversionOperator = 0x0040,
     210             :   ForwardReference = 0x0080,
     211             :   Scoped = 0x0100,
     212             :   HasUniqueName = 0x0200,
     213             :   Sealed = 0x0400,
     214             :   Intrinsic = 0x2000
     215             : };
     216        4859 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ClassOptions)
     217             : 
     218             : enum class FrameProcedureOptions : uint32_t {
     219             :   None = 0x00000000,
     220             :   HasAlloca = 0x00000001,
     221             :   HasSetJmp = 0x00000002,
     222             :   HasLongJmp = 0x00000004,
     223             :   HasInlineAssembly = 0x00000008,
     224             :   HasExceptionHandling = 0x00000010,
     225             :   MarkedInline = 0x00000020,
     226             :   HasStructuredExceptionHandling = 0x00000040,
     227             :   Naked = 0x00000080,
     228             :   SecurityChecks = 0x00000100,
     229             :   AsynchronousExceptionHandling = 0x00000200,
     230             :   NoStackOrderingForSecurityChecks = 0x00000400,
     231             :   Inlined = 0x00000800,
     232             :   StrictSecurityChecks = 0x00001000,
     233             :   SafeBuffers = 0x00002000,
     234             :   ProfileGuidedOptimization = 0x00040000,
     235             :   ValidProfileCounts = 0x00080000,
     236             :   OptimizedForSpeed = 0x00100000,
     237             :   GuardCfg = 0x00200000,
     238             :   GuardCfw = 0x00400000
     239             : };
     240         401 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FrameProcedureOptions)
     241             : 
     242             : enum class FunctionOptions : uint8_t {
     243             :   None = 0x00,
     244             :   CxxReturnUdt = 0x01,
     245             :   Constructor = 0x02,
     246             :   ConstructorWithVirtualBases = 0x04
     247             : };
     248         887 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FunctionOptions)
     249             : 
     250             : enum class HfaKind : uint8_t {
     251             :   None = 0x00,
     252             :   Float = 0x01,
     253             :   Double = 0x02,
     254             :   Other = 0x03
     255             : };
     256             : 
     257             : /// Source-level access specifier. (CV_access_e)
     258             : enum class MemberAccess : uint8_t {
     259             :   None = 0,
     260             :   Private = 1,
     261             :   Protected = 2,
     262             :   Public = 3
     263             : };
     264             : 
     265             : /// Part of member attribute flags. (CV_methodprop_e)
     266             : enum class MethodKind : uint8_t {
     267             :   Vanilla = 0x00,
     268             :   Virtual = 0x01,
     269             :   Static = 0x02,
     270             :   Friend = 0x03,
     271             :   IntroducingVirtual = 0x04,
     272             :   PureVirtual = 0x05,
     273             :   PureIntroducingVirtual = 0x06
     274             : };
     275             : 
     276             : /// Equivalent to CV_fldattr_t bitfield.
     277             : enum class MethodOptions : uint16_t {
     278             :   None = 0x0000,
     279             :   AccessMask = 0x0003,
     280             :   MethodKindMask = 0x001c,
     281             :   Pseudo = 0x0020,
     282             :   NoInherit = 0x0040,
     283             :   NoConstruct = 0x0080,
     284             :   CompilerGenerated = 0x0100,
     285             :   Sealed = 0x0200
     286             : };
     287         860 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(MethodOptions)
     288             : 
     289             : /// Equivalent to CV_LABEL_TYPE_e.
     290             : enum class LabelType : uint16_t {
     291             :   Near = 0x0,
     292             :   Far = 0x4,
     293             : };
     294             : 
     295             : /// Equivalent to CV_modifier_t.
     296             : /// TODO: Add flag for _Atomic modifier
     297             : enum class ModifierOptions : uint16_t {
     298             :   None = 0x0000,
     299             :   Const = 0x0001,
     300             :   Volatile = 0x0002,
     301             :   Unaligned = 0x0004
     302             : };
     303         109 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
     304             : 
     305             : enum class DebugSubsectionKind : uint32_t {
     306             :   None = 0,
     307             :   Symbols = 0xf1,
     308             :   Lines = 0xf2,
     309             :   StringTable = 0xf3,
     310             :   FileChecksums = 0xf4,
     311             :   FrameData = 0xf5,
     312             :   InlineeLines = 0xf6,
     313             :   CrossScopeImports = 0xf7,
     314             :   CrossScopeExports = 0xf8,
     315             : 
     316             :   // These appear to relate to .Net assembly info.
     317             :   ILLines = 0xf9,
     318             :   FuncMDTokenMap = 0xfa,
     319             :   TypeMDTokenMap = 0xfb,
     320             :   MergedAssemblyInput = 0xfc,
     321             : 
     322             :   CoffSymbolRVA = 0xfd,
     323             : };
     324             : 
     325             : /// Equivalent to CV_ptrtype_e.
     326             : enum class PointerKind : uint8_t {
     327             :   Near16 = 0x00,                // 16 bit pointer
     328             :   Far16 = 0x01,                 // 16:16 far pointer
     329             :   Huge16 = 0x02,                // 16:16 huge pointer
     330             :   BasedOnSegment = 0x03,        // based on segment
     331             :   BasedOnValue = 0x04,          // based on value of base
     332             :   BasedOnSegmentValue = 0x05,   // based on segment value of base
     333             :   BasedOnAddress = 0x06,        // based on address of base
     334             :   BasedOnSegmentAddress = 0x07, // based on segment address of base
     335             :   BasedOnType = 0x08,           // based on type
     336             :   BasedOnSelf = 0x09,           // based on self
     337             :   Near32 = 0x0a,                // 32 bit pointer
     338             :   Far32 = 0x0b,                 // 16:32 pointer
     339             :   Near64 = 0x0c                 // 64 bit pointer
     340             : };
     341             : 
     342             : /// Equivalent to CV_ptrmode_e.
     343             : enum class PointerMode : uint8_t {
     344             :   Pointer = 0x00,                 // "normal" pointer
     345             :   LValueReference = 0x01,         // "old" reference
     346             :   PointerToDataMember = 0x02,     // pointer to data member
     347             :   PointerToMemberFunction = 0x03, // pointer to member function
     348             :   RValueReference = 0x04          // r-value reference
     349             : };
     350             : 
     351             : /// Equivalent to misc lfPointerAttr bitfields.
     352             : enum class PointerOptions : uint32_t {
     353             :   None = 0x00000000,
     354             :   Flat32 = 0x00000100,
     355             :   Volatile = 0x00000200,
     356             :   Const = 0x00000400,
     357             :   Unaligned = 0x00000800,
     358             :   Restrict = 0x00001000,
     359             :   WinRTSmartPointer = 0x00080000
     360             : };
     361         384 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions)
     362             : 
     363             : /// Equivalent to CV_pmtype_e.
     364             : enum class PointerToMemberRepresentation : uint16_t {
     365             :   Unknown = 0x00,                     // not specified (pre VC8)
     366             :   SingleInheritanceData = 0x01,       // member data, single inheritance
     367             :   MultipleInheritanceData = 0x02,     // member data, multiple inheritance
     368             :   VirtualInheritanceData = 0x03,      // member data, virtual inheritance
     369             :   GeneralData = 0x04,                 // member data, most general
     370             :   SingleInheritanceFunction = 0x05,   // member function, single inheritance
     371             :   MultipleInheritanceFunction = 0x06, // member function, multiple inheritance
     372             :   VirtualInheritanceFunction = 0x07,  // member function, virtual inheritance
     373             :   GeneralFunction = 0x08              // member function, most general
     374             : };
     375             : 
     376             : enum class VFTableSlotKind : uint8_t {
     377             :   Near16 = 0x00,
     378             :   Far16 = 0x01,
     379             :   This = 0x02,
     380             :   Outer = 0x03,
     381             :   Meta = 0x04,
     382             :   Near = 0x05,
     383             :   Far = 0x06
     384             : };
     385             : 
     386             : enum class WindowsRTClassKind : uint8_t {
     387             :   None = 0x00,
     388             :   RefClass = 0x01,
     389             :   ValueClass = 0x02,
     390             :   Interface = 0x03
     391             : };
     392             : 
     393             : /// Corresponds to CV_LVARFLAGS bitfield.
     394             : enum class LocalSymFlags : uint16_t {
     395             :   None = 0,
     396             :   IsParameter = 1 << 0,
     397             :   IsAddressTaken = 1 << 1,
     398             :   IsCompilerGenerated = 1 << 2,
     399             :   IsAggregate = 1 << 3,
     400             :   IsAggregated = 1 << 4,
     401             :   IsAliased = 1 << 5,
     402             :   IsAlias = 1 << 6,
     403             :   IsReturnValue = 1 << 7,
     404             :   IsOptimizedOut = 1 << 8,
     405             :   IsEnregisteredGlobal = 1 << 9,
     406             :   IsEnregisteredStatic = 1 << 10,
     407             : };
     408         108 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(LocalSymFlags)
     409             : 
     410             : /// Corresponds to the CV_PUBSYMFLAGS bitfield.
     411             : enum class PublicSymFlags : uint32_t {
     412             :   None = 0,
     413             :   Code = 1 << 0,
     414             :   Function = 1 << 1,
     415             :   Managed = 1 << 2,
     416             :   MSIL = 1 << 3,
     417             : };
     418          24 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PublicSymFlags)
     419             : 
     420             : /// Corresponds to the CV_PROCFLAGS bitfield.
     421             : enum class ProcSymFlags : uint8_t {
     422             :   None = 0,
     423             :   HasFP = 1 << 0,
     424             :   HasIRET = 1 << 1,
     425             :   HasFRET = 1 << 2,
     426             :   IsNoReturn = 1 << 3,
     427             :   IsUnreachable = 1 << 4,
     428             :   HasCustomCallingConv = 1 << 5,
     429             :   IsNoInline = 1 << 6,
     430             :   HasOptimizedDebugInfo = 1 << 7,
     431             : };
     432          47 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ProcSymFlags)
     433             : 
     434             : /// Corresponds to COMPILESYM2::Flags bitfield.
     435             : enum class CompileSym2Flags : uint32_t {
     436             :   None = 0,
     437             :   SourceLanguageMask = 0xFF,
     438             :   EC = 1 << 8,
     439             :   NoDbgInfo = 1 << 9,
     440             :   LTCG = 1 << 10,
     441             :   NoDataAlign = 1 << 11,
     442             :   ManagedPresent = 1 << 12,
     443             :   SecurityChecks = 1 << 13,
     444             :   HotPatch = 1 << 14,
     445             :   CVTCIL = 1 << 15,
     446             :   MSILModule = 1 << 16,
     447             : };
     448           0 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym2Flags)
     449             : 
     450             : /// Corresponds to COMPILESYM3::Flags bitfield.
     451             : enum class CompileSym3Flags : uint32_t {
     452             :   None = 0,
     453             :   SourceLanguageMask = 0xFF,
     454             :   EC = 1 << 8,
     455             :   NoDbgInfo = 1 << 9,
     456             :   LTCG = 1 << 10,
     457             :   NoDataAlign = 1 << 11,
     458             :   ManagedPresent = 1 << 12,
     459             :   SecurityChecks = 1 << 13,
     460             :   HotPatch = 1 << 14,
     461             :   CVTCIL = 1 << 15,
     462             :   MSILModule = 1 << 16,
     463             :   Sdl = 1 << 17,
     464             :   PGO = 1 << 18,
     465             :   Exp = 1 << 19,
     466             : };
     467         331 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym3Flags)
     468             : 
     469             : enum class ExportFlags : uint16_t {
     470             :   None = 0,
     471             :   IsConstant = 1 << 0,
     472             :   IsData = 1 << 1,
     473             :   IsPrivate = 1 << 2,
     474             :   HasNoName = 1 << 3,
     475             :   HasExplicitOrdinal = 1 << 4,
     476             :   IsForwarder = 1 << 5
     477             : };
     478           0 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ExportFlags)
     479             : 
     480             : // Corresponds to BinaryAnnotationOpcode enum.
     481             : enum class BinaryAnnotationsOpCode : uint32_t {
     482             :   Invalid,
     483             :   CodeOffset,
     484             :   ChangeCodeOffsetBase,
     485             :   ChangeCodeOffset,
     486             :   ChangeCodeLength,
     487             :   ChangeFile,
     488             :   ChangeLineOffset,
     489             :   ChangeLineEndDelta,
     490             :   ChangeRangeKind,
     491             :   ChangeColumnStart,
     492             :   ChangeColumnEndDelta,
     493             :   ChangeCodeOffsetAndLineOffset,
     494             :   ChangeCodeLengthAndCodeOffset,
     495             :   ChangeColumnEnd,
     496             : };
     497             : 
     498             : // Corresponds to CV_cookietype_e enum.
     499             : enum class FrameCookieKind : uint8_t {
     500             :   Copy,
     501             :   XorStackPointer,
     502             :   XorFramePointer,
     503             :   XorR13,
     504             : };
     505             : 
     506             : // Corresponds to CV_HREG_e enum.
     507             : enum class RegisterId : uint16_t {
     508             :   Unknown = 0,
     509             :   VFrame = 30006,
     510             :   AL = 1,
     511             :   CL = 2,
     512             :   DL = 3,
     513             :   BL = 4,
     514             :   AH = 5,
     515             :   CH = 6,
     516             :   DH = 7,
     517             :   BH = 8,
     518             :   AX = 9,
     519             :   CX = 10,
     520             :   DX = 11,
     521             :   BX = 12,
     522             :   SP = 13,
     523             :   BP = 14,
     524             :   SI = 15,
     525             :   DI = 16,
     526             :   EAX = 17,
     527             :   ECX = 18,
     528             :   EDX = 19,
     529             :   EBX = 20,
     530             :   ESP = 21,
     531             :   EBP = 22,
     532             :   ESI = 23,
     533             :   EDI = 24,
     534             :   ES = 25,
     535             :   CS = 26,
     536             :   SS = 27,
     537             :   DS = 28,
     538             :   FS = 29,
     539             :   GS = 30,
     540             :   IP = 31,
     541             :   RAX = 328,
     542             :   RBX = 329,
     543             :   RCX = 330,
     544             :   RDX = 331,
     545             :   RSI = 332,
     546             :   RDI = 333,
     547             :   RBP = 334,
     548             :   RSP = 335,
     549             :   R8 = 336,
     550             :   R9 = 337,
     551             :   R10 = 338,
     552             :   R11 = 339,
     553             :   R12 = 340,
     554             :   R13 = 341,
     555             :   R14 = 342,
     556             :   R15 = 343,
     557             : };
     558             : 
     559             : /// These values correspond to the THUNK_ORDINAL enumeration.
     560             : enum class ThunkOrdinal : uint8_t {
     561             :   Standard,
     562             :   ThisAdjustor,
     563             :   Vcall,
     564             :   Pcode,
     565             :   UnknownLoad,
     566             :   TrampIncremental,
     567             :   BranchIsland
     568             : };
     569             : 
     570             : enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland };
     571             : 
     572             : // These values correspond to the CV_SourceChksum_t enumeration.
     573             : enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };
     574             : 
     575             : enum LineFlags : uint16_t {
     576             :   LF_None = 0,
     577             :   LF_HaveColumns = 1, // CV_LINES_HAVE_COLUMNS
     578             : };
     579             : 
     580             : /// Data in the the SUBSEC_FRAMEDATA subection.
     581             : struct FrameData {
     582             :   support::ulittle32_t RvaStart;
     583             :   support::ulittle32_t CodeSize;
     584             :   support::ulittle32_t LocalSize;
     585             :   support::ulittle32_t ParamsSize;
     586             :   support::ulittle32_t MaxStackSize;
     587             :   support::ulittle32_t FrameFunc;
     588             :   support::ulittle16_t PrologSize;
     589             :   support::ulittle16_t SavedRegsSize;
     590             :   support::ulittle32_t Flags;
     591             :   enum : uint32_t {
     592             :     HasSEH = 1 << 0,
     593             :     HasEH = 1 << 1,
     594             :     IsFunctionStart = 1 << 2,
     595             :   };
     596             : };
     597             : 
     598             : // Corresponds to LocalIdAndGlobalIdPair structure.
     599             : // This structure information allows cross-referencing between PDBs.  For
     600             : // example, when a PDB is being built during compilation it is not yet known
     601             : // what other modules may end up in the PDB at link time.  So certain types of
     602             : // IDs may clash between the various compile time PDBs.  For each affected
     603             : // module, a subsection would be put into the PDB containing a mapping from its
     604             : // local IDs to a single ID namespace for all items in the PDB file.
     605             : struct CrossModuleExport {
     606             :   support::ulittle32_t Local;
     607             :   support::ulittle32_t Global;
     608             : };
     609             : 
     610             : struct CrossModuleImport {
     611             :   support::ulittle32_t ModuleNameOffset;
     612             :   support::ulittle32_t Count; // Number of elements
     613             :   // support::ulittle32_t ids[Count]; // id from referenced module
     614             : };
     615             : 
     616             : enum class CodeViewContainer { ObjectFile, Pdb };
     617             : 
     618             : inline uint32_t alignOf(CodeViewContainer Container) {
     619        2233 :   if (Container == CodeViewContainer::ObjectFile)
     620             :     return 1;
     621             :   return 4;
     622             : }
     623             : }
     624             : }
     625             : 
     626             : #endif

Generated by: LCOV version 1.13