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: 2018-10-20 13:21:21 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 or .debug$P section or PDB type
      26             : /// stream. The 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       13533 : 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             :   EncodedLocalBasePointerMask = 0x0000C000,
     235             :   EncodedParamBasePointerMask = 0x00030000,
     236             :   ProfileGuidedOptimization = 0x00040000,
     237             :   ValidProfileCounts = 0x00080000,
     238             :   OptimizedForSpeed = 0x00100000,
     239             :   GuardCfg = 0x00200000,
     240             :   GuardCfw = 0x00400000
     241             : };
     242        1007 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FrameProcedureOptions)
     243             : 
     244             : enum class FunctionOptions : uint8_t {
     245             :   None = 0x00,
     246             :   CxxReturnUdt = 0x01,
     247             :   Constructor = 0x02,
     248             :   ConstructorWithVirtualBases = 0x04
     249             : };
     250        2452 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FunctionOptions)
     251             : 
     252             : enum class HfaKind : uint8_t {
     253             :   None = 0x00,
     254             :   Float = 0x01,
     255             :   Double = 0x02,
     256             :   Other = 0x03
     257             : };
     258             : 
     259             : /// Source-level access specifier. (CV_access_e)
     260             : enum class MemberAccess : uint8_t {
     261             :   None = 0,
     262             :   Private = 1,
     263             :   Protected = 2,
     264             :   Public = 3
     265             : };
     266             : 
     267             : /// Part of member attribute flags. (CV_methodprop_e)
     268             : enum class MethodKind : uint8_t {
     269             :   Vanilla = 0x00,
     270             :   Virtual = 0x01,
     271             :   Static = 0x02,
     272             :   Friend = 0x03,
     273             :   IntroducingVirtual = 0x04,
     274             :   PureVirtual = 0x05,
     275             :   PureIntroducingVirtual = 0x06
     276             : };
     277             : 
     278             : /// Equivalent to CV_fldattr_t bitfield.
     279             : enum class MethodOptions : uint16_t {
     280             :   None = 0x0000,
     281             :   AccessMask = 0x0003,
     282             :   MethodKindMask = 0x001c,
     283             :   Pseudo = 0x0020,
     284             :   NoInherit = 0x0040,
     285             :   NoConstruct = 0x0080,
     286             :   CompilerGenerated = 0x0100,
     287             :   Sealed = 0x0200
     288             : };
     289         686 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(MethodOptions)
     290             : 
     291             : /// Equivalent to CV_LABEL_TYPE_e.
     292             : enum class LabelType : uint16_t {
     293             :   Near = 0x0,
     294             :   Far = 0x4,
     295             : };
     296             : 
     297             : /// Equivalent to CV_modifier_t.
     298             : /// TODO: Add flag for _Atomic modifier
     299             : enum class ModifierOptions : uint16_t {
     300             :   None = 0x0000,
     301             :   Const = 0x0001,
     302             :   Volatile = 0x0002,
     303             :   Unaligned = 0x0004
     304             : };
     305         568 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
     306             : 
     307             : enum class DebugSubsectionKind : uint32_t {
     308             :   None = 0,
     309             :   Symbols = 0xf1,
     310             :   Lines = 0xf2,
     311             :   StringTable = 0xf3,
     312             :   FileChecksums = 0xf4,
     313             :   FrameData = 0xf5,
     314             :   InlineeLines = 0xf6,
     315             :   CrossScopeImports = 0xf7,
     316             :   CrossScopeExports = 0xf8,
     317             : 
     318             :   // These appear to relate to .Net assembly info.
     319             :   ILLines = 0xf9,
     320             :   FuncMDTokenMap = 0xfa,
     321             :   TypeMDTokenMap = 0xfb,
     322             :   MergedAssemblyInput = 0xfc,
     323             : 
     324             :   CoffSymbolRVA = 0xfd,
     325             : };
     326             : 
     327             : /// Equivalent to CV_ptrtype_e.
     328             : enum class PointerKind : uint8_t {
     329             :   Near16 = 0x00,                // 16 bit pointer
     330             :   Far16 = 0x01,                 // 16:16 far pointer
     331             :   Huge16 = 0x02,                // 16:16 huge pointer
     332             :   BasedOnSegment = 0x03,        // based on segment
     333             :   BasedOnValue = 0x04,          // based on value of base
     334             :   BasedOnSegmentValue = 0x05,   // based on segment value of base
     335             :   BasedOnAddress = 0x06,        // based on address of base
     336             :   BasedOnSegmentAddress = 0x07, // based on segment address of base
     337             :   BasedOnType = 0x08,           // based on type
     338             :   BasedOnSelf = 0x09,           // based on self
     339             :   Near32 = 0x0a,                // 32 bit pointer
     340             :   Far32 = 0x0b,                 // 16:32 pointer
     341             :   Near64 = 0x0c                 // 64 bit pointer
     342             : };
     343             : 
     344             : /// Equivalent to CV_ptrmode_e.
     345             : enum class PointerMode : uint8_t {
     346             :   Pointer = 0x00,                 // "normal" pointer
     347             :   LValueReference = 0x01,         // "old" reference
     348             :   PointerToDataMember = 0x02,     // pointer to data member
     349             :   PointerToMemberFunction = 0x03, // pointer to member function
     350             :   RValueReference = 0x04          // r-value reference
     351             : };
     352             : 
     353             : /// Equivalent to misc lfPointerAttr bitfields.
     354             : enum class PointerOptions : uint32_t {
     355             :   None = 0x00000000,
     356             :   Flat32 = 0x00000100,
     357             :   Volatile = 0x00000200,
     358             :   Const = 0x00000400,
     359             :   Unaligned = 0x00000800,
     360             :   Restrict = 0x00001000,
     361             :   WinRTSmartPointer = 0x00080000
     362             : };
     363         632 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions)
     364             : 
     365             : /// Equivalent to CV_pmtype_e.
     366             : enum class PointerToMemberRepresentation : uint16_t {
     367             :   Unknown = 0x00,                     // not specified (pre VC8)
     368             :   SingleInheritanceData = 0x01,       // member data, single inheritance
     369             :   MultipleInheritanceData = 0x02,     // member data, multiple inheritance
     370             :   VirtualInheritanceData = 0x03,      // member data, virtual inheritance
     371             :   GeneralData = 0x04,                 // member data, most general
     372             :   SingleInheritanceFunction = 0x05,   // member function, single inheritance
     373             :   MultipleInheritanceFunction = 0x06, // member function, multiple inheritance
     374             :   VirtualInheritanceFunction = 0x07,  // member function, virtual inheritance
     375             :   GeneralFunction = 0x08              // member function, most general
     376             : };
     377             : 
     378             : enum class VFTableSlotKind : uint8_t {
     379             :   Near16 = 0x00,
     380             :   Far16 = 0x01,
     381             :   This = 0x02,
     382             :   Outer = 0x03,
     383             :   Meta = 0x04,
     384             :   Near = 0x05,
     385             :   Far = 0x06
     386             : };
     387             : 
     388             : enum class WindowsRTClassKind : uint8_t {
     389             :   None = 0x00,
     390             :   RefClass = 0x01,
     391             :   ValueClass = 0x02,
     392             :   Interface = 0x03
     393             : };
     394             : 
     395             : /// Corresponds to CV_LVARFLAGS bitfield.
     396             : enum class LocalSymFlags : uint16_t {
     397             :   None = 0,
     398             :   IsParameter = 1 << 0,
     399             :   IsAddressTaken = 1 << 1,
     400             :   IsCompilerGenerated = 1 << 2,
     401             :   IsAggregate = 1 << 3,
     402             :   IsAggregated = 1 << 4,
     403             :   IsAliased = 1 << 5,
     404             :   IsAlias = 1 << 6,
     405             :   IsReturnValue = 1 << 7,
     406             :   IsOptimizedOut = 1 << 8,
     407             :   IsEnregisteredGlobal = 1 << 9,
     408             :   IsEnregisteredStatic = 1 << 10,
     409             : };
     410         371 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(LocalSymFlags)
     411             : 
     412             : /// Corresponds to the CV_PUBSYMFLAGS bitfield.
     413             : enum class PublicSymFlags : uint32_t {
     414             :   None = 0,
     415             :   Code = 1 << 0,
     416             :   Function = 1 << 1,
     417             :   Managed = 1 << 2,
     418             :   MSIL = 1 << 3,
     419             : };
     420          12 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PublicSymFlags)
     421             : 
     422             : /// Corresponds to the CV_PROCFLAGS bitfield.
     423             : enum class ProcSymFlags : uint8_t {
     424             :   None = 0,
     425             :   HasFP = 1 << 0,
     426             :   HasIRET = 1 << 1,
     427             :   HasFRET = 1 << 2,
     428             :   IsNoReturn = 1 << 3,
     429             :   IsUnreachable = 1 << 4,
     430             :   HasCustomCallingConv = 1 << 5,
     431             :   IsNoInline = 1 << 6,
     432             :   HasOptimizedDebugInfo = 1 << 7,
     433             : };
     434         123 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ProcSymFlags)
     435             : 
     436             : /// Corresponds to COMPILESYM2::Flags bitfield.
     437             : enum class CompileSym2Flags : uint32_t {
     438             :   None = 0,
     439             :   SourceLanguageMask = 0xFF,
     440             :   EC = 1 << 8,
     441             :   NoDbgInfo = 1 << 9,
     442             :   LTCG = 1 << 10,
     443             :   NoDataAlign = 1 << 11,
     444             :   ManagedPresent = 1 << 12,
     445             :   SecurityChecks = 1 << 13,
     446             :   HotPatch = 1 << 14,
     447             :   CVTCIL = 1 << 15,
     448             :   MSILModule = 1 << 16,
     449             : };
     450           0 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym2Flags)
     451             : 
     452             : /// Corresponds to COMPILESYM3::Flags bitfield.
     453             : enum class CompileSym3Flags : uint32_t {
     454             :   None = 0,
     455             :   SourceLanguageMask = 0xFF,
     456             :   EC = 1 << 8,
     457             :   NoDbgInfo = 1 << 9,
     458             :   LTCG = 1 << 10,
     459             :   NoDataAlign = 1 << 11,
     460             :   ManagedPresent = 1 << 12,
     461             :   SecurityChecks = 1 << 13,
     462             :   HotPatch = 1 << 14,
     463             :   CVTCIL = 1 << 15,
     464             :   MSILModule = 1 << 16,
     465             :   Sdl = 1 << 17,
     466             :   PGO = 1 << 18,
     467             :   Exp = 1 << 19,
     468             : };
     469         383 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym3Flags)
     470             : 
     471             : enum class ExportFlags : uint16_t {
     472             :   None = 0,
     473             :   IsConstant = 1 << 0,
     474             :   IsData = 1 << 1,
     475             :   IsPrivate = 1 << 2,
     476             :   HasNoName = 1 << 3,
     477             :   HasExplicitOrdinal = 1 << 4,
     478             :   IsForwarder = 1 << 5
     479             : };
     480           0 : CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ExportFlags)
     481             : 
     482             : // Corresponds to BinaryAnnotationOpcode enum.
     483             : enum class BinaryAnnotationsOpCode : uint32_t {
     484             :   Invalid,
     485             :   CodeOffset,
     486             :   ChangeCodeOffsetBase,
     487             :   ChangeCodeOffset,
     488             :   ChangeCodeLength,
     489             :   ChangeFile,
     490             :   ChangeLineOffset,
     491             :   ChangeLineEndDelta,
     492             :   ChangeRangeKind,
     493             :   ChangeColumnStart,
     494             :   ChangeColumnEndDelta,
     495             :   ChangeCodeOffsetAndLineOffset,
     496             :   ChangeCodeLengthAndCodeOffset,
     497             :   ChangeColumnEnd,
     498             : };
     499             : 
     500             : // Corresponds to CV_cookietype_e enum.
     501             : enum class FrameCookieKind : uint8_t {
     502             :   Copy,
     503             :   XorStackPointer,
     504             :   XorFramePointer,
     505             :   XorR13,
     506             : };
     507             : 
     508             : // Corresponds to CV_HREG_e enum.
     509             : enum class RegisterId : uint16_t {
     510             : #define CV_REGISTER(name, value) name = value,
     511             : #include "CodeViewRegisters.def"
     512             : #undef CV_REGISTER
     513             : };
     514             : 
     515             : /// Two-bit value indicating which register is the designated frame pointer
     516             : /// register. Appears in the S_FRAMEPROC record flags.
     517             : enum class EncodedFramePtrReg : uint8_t {
     518             :   None = 0,
     519             :   StackPtr = 1,
     520             :   FramePtr = 2,
     521             :   BasePtr = 3,
     522             : };
     523             : 
     524             : RegisterId decodeFramePtrReg(EncodedFramePtrReg EncodedReg, CPUType CPU);
     525             : 
     526             : EncodedFramePtrReg encodeFramePtrReg(RegisterId Reg, CPUType CPU);
     527             : 
     528             : /// These values correspond to the THUNK_ORDINAL enumeration.
     529             : enum class ThunkOrdinal : uint8_t {
     530             :   Standard,
     531             :   ThisAdjustor,
     532             :   Vcall,
     533             :   Pcode,
     534             :   UnknownLoad,
     535             :   TrampIncremental,
     536             :   BranchIsland
     537             : };
     538             : 
     539             : enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland };
     540             : 
     541             : // These values correspond to the CV_SourceChksum_t enumeration.
     542             : enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };
     543             : 
     544             : enum LineFlags : uint16_t {
     545             :   LF_None = 0,
     546             :   LF_HaveColumns = 1, // CV_LINES_HAVE_COLUMNS
     547             : };
     548             : 
     549             : /// Data in the SUBSEC_FRAMEDATA subection.
     550             : struct FrameData {
     551             :   support::ulittle32_t RvaStart;
     552             :   support::ulittle32_t CodeSize;
     553             :   support::ulittle32_t LocalSize;
     554             :   support::ulittle32_t ParamsSize;
     555             :   support::ulittle32_t MaxStackSize;
     556             :   support::ulittle32_t FrameFunc;
     557             :   support::ulittle16_t PrologSize;
     558             :   support::ulittle16_t SavedRegsSize;
     559             :   support::ulittle32_t Flags;
     560             :   enum : uint32_t {
     561             :     HasSEH = 1 << 0,
     562             :     HasEH = 1 << 1,
     563             :     IsFunctionStart = 1 << 2,
     564             :   };
     565             : };
     566             : 
     567             : // Corresponds to LocalIdAndGlobalIdPair structure.
     568             : // This structure information allows cross-referencing between PDBs.  For
     569             : // example, when a PDB is being built during compilation it is not yet known
     570             : // what other modules may end up in the PDB at link time.  So certain types of
     571             : // IDs may clash between the various compile time PDBs.  For each affected
     572             : // module, a subsection would be put into the PDB containing a mapping from its
     573             : // local IDs to a single ID namespace for all items in the PDB file.
     574             : struct CrossModuleExport {
     575             :   support::ulittle32_t Local;
     576             :   support::ulittle32_t Global;
     577             : };
     578             : 
     579             : struct CrossModuleImport {
     580             :   support::ulittle32_t ModuleNameOffset;
     581             :   support::ulittle32_t Count; // Number of elements
     582             :   // support::ulittle32_t ids[Count]; // id from referenced module
     583             : };
     584             : 
     585             : enum class CodeViewContainer { ObjectFile, Pdb };
     586             : 
     587             : inline uint32_t alignOf(CodeViewContainer Container) {
     588        4342 :   if (Container == CodeViewContainer::ObjectFile)
     589             :     return 1;
     590             :   return 4;
     591             : }
     592             : }
     593             : }
     594             : 
     595             : #endif

Generated by: LCOV version 1.13