contrib/llvm/include/llvm/DebugInfo/CodeView/CodeView.h

   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   Omni = 0x70,
 128   Ia64 = 0x80,
 129   Ia64_2 = 0x81,
 130   CEE = 0x90,
 131   AM33 = 0xa0,
 132   M32R = 0xb0,
 133   TriCore = 0xc0,
 134   X64 = 0xd0,
 135   EBC = 0xe0,
 136   Thumb = 0xf0,
 137   ARMNT = 0xf4,
 138   D3D11_Shader = 0x100,
 139 };
 140
 141 /// These values correspond to the CV_CFL_LANG enumeration, and are documented
 142 /// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
 143 enum SourceLanguage : uint8_t {
 144   C = 0x00,
 145   Cpp = 0x01,
 146   Fortran = 0x02,
 147   Masm = 0x03,
 148   Pascal = 0x04,
 149   Basic = 0x05,
 150   Cobol = 0x06,
 151   Link = 0x07,
 152   Cvtres = 0x08,
 153   Cvtpgd = 0x09,
 154   CSharp = 0x0a,
 155   VB = 0x0b,
 156   ILAsm = 0x0c,
 157   Java = 0x0d,
 158   JScript = 0x0e,
 159   MSIL = 0x0f,
 160   HLSL = 0x10
 161 };
 162
 163 /// These values correspond to the CV_call_e enumeration, and are documented
 164 /// at the following locations:
 165 ///   https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
 166 ///   https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
 167 ///
 168 enum class CallingConvention : uint8_t {
 169   NearC = 0x00,       // near right to left push, caller pops stack
 170   FarC = 0x01,        // far right to left push, caller pops stack
 171   NearPascal = 0x02,  // near left to right push, callee pops stack
 172   FarPascal = 0x03,   // far left to right push, callee pops stack
 173   NearFast = 0x04,    // near left to right push with regs, callee pops stack
 174   FarFast = 0x05,     // far left to right push with regs, callee pops stack
 175   NearStdCall = 0x07, // near standard call
 176   FarStdCall = 0x08,  // far standard call
 177   NearSysCall = 0x09, // near sys call
 178   FarSysCall = 0x0a,  // far sys call
 179   ThisCall = 0x0b,    // this call (this passed in register)
 180   MipsCall = 0x0c,    // Mips call
 181   Generic = 0x0d,     // Generic call sequence
 182   AlphaCall = 0x0e,   // Alpha call
 183   PpcCall = 0x0f,     // PPC call
 184   SHCall = 0x10,      // Hitachi SuperH call
 185   ArmCall = 0x11,     // ARM call
 186   AM33Call = 0x12,    // AM33 call
 187   TriCall = 0x13,     // TriCore Call
 188   SH5Call = 0x14,     // Hitachi SuperH-5 call
 189   M32RCall = 0x15,    // M32R Call
 190   ClrCall = 0x16,     // clr call
 191   Inline =
 192       0x17, // Marker for routines always inlined and thus lacking a convention
 193   NearVector = 0x18 // near left to right push with regs, callee pops stack
 194 };
 195
 196 enum class ClassOptions : uint16_t {
 197   None = 0x0000,
 198   Packed = 0x0001,
 199   HasConstructorOrDestructor = 0x0002,
 200   HasOverloadedOperator = 0x0004,
 201   Nested = 0x0008,
 202   ContainsNestedClass = 0x0010,
 203   HasOverloadedAssignmentOperator = 0x0020,
 204   HasConversionOperator = 0x0040,
 205   ForwardReference = 0x0080,
 206   Scoped = 0x0100,
 207   HasUniqueName = 0x0200,
 208   Sealed = 0x0400,
 209   Intrinsic = 0x2000
 210 };
 211 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ClassOptions)
 212
 213 enum class FrameProcedureOptions : uint32_t {
 214   None = 0x00000000,
 215   HasAlloca = 0x00000001,
 216   HasSetJmp = 0x00000002,
 217   HasLongJmp = 0x00000004,
 218   HasInlineAssembly = 0x00000008,
 219   HasExceptionHandling = 0x00000010,
 220   MarkedInline = 0x00000020,
 221   HasStructuredExceptionHandling = 0x00000040,
 222   Naked = 0x00000080,
 223   SecurityChecks = 0x00000100,
 224   AsynchronousExceptionHandling = 0x00000200,
 225   NoStackOrderingForSecurityChecks = 0x00000400,
 226   Inlined = 0x00000800,
 227   StrictSecurityChecks = 0x00001000,
 228   SafeBuffers = 0x00002000,
 229   ProfileGuidedOptimization = 0x00040000,
 230   ValidProfileCounts = 0x00080000,
 231   OptimizedForSpeed = 0x00100000,
 232   GuardCfg = 0x00200000,
 233   GuardCfw = 0x00400000
 234 };
 235 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FrameProcedureOptions)
 236
 237 enum class FunctionOptions : uint8_t {
 238   None = 0x00,
 239   CxxReturnUdt = 0x01,
 240   Constructor = 0x02,
 241   ConstructorWithVirtualBases = 0x04
 242 };
 243 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FunctionOptions)
 244
 245 enum class HfaKind : uint8_t {
 246   None = 0x00,
 247   Float = 0x01,
 248   Double = 0x02,
 249   Other = 0x03
 250 };
 251
 252 /// Source-level access specifier. (CV_access_e)
 253 enum class MemberAccess : uint8_t {
 254   None = 0,
 255   Private = 1,
 256   Protected = 2,
 257   Public = 3
 258 };
 259
 260 /// Part of member attribute flags. (CV_methodprop_e)
 261 enum class MethodKind : uint8_t {
 262   Vanilla = 0x00,
 263   Virtual = 0x01,
 264   Static = 0x02,
 265   Friend = 0x03,
 266   IntroducingVirtual = 0x04,
 267   PureVirtual = 0x05,
 268   PureIntroducingVirtual = 0x06
 269 };
 270
 271 /// Equivalent to CV_fldattr_t bitfield.
 272 enum class MethodOptions : uint16_t {
 273   None = 0x0000,
 274   AccessMask = 0x0003,
 275   MethodKindMask = 0x001c,
 276   Pseudo = 0x0020,
 277   NoInherit = 0x0040,
 278   NoConstruct = 0x0080,
 279   CompilerGenerated = 0x0100,
 280   Sealed = 0x0200
 281 };
 282 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(MethodOptions)
 283
 284 /// Equivalent to CV_LABEL_TYPE_e.
 285 enum class LabelType : uint16_t {
 286   Near = 0x0,
 287   Far = 0x4,
 288 };
 289
 290 /// Equivalent to CV_modifier_t.
 291 /// TODO: Add flag for _Atomic modifier
 292 enum class ModifierOptions : uint16_t {
 293   None = 0x0000,
 294   Const = 0x0001,
 295   Volatile = 0x0002,
 296   Unaligned = 0x0004
 297 };
 298 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
 299
 300 enum class DebugSubsectionKind : uint32_t {
 301   None = 0,
 302   Symbols = 0xf1,
 303   Lines = 0xf2,
 304   StringTable = 0xf3,
 305   FileChecksums = 0xf4,
 306   FrameData = 0xf5,
 307   InlineeLines = 0xf6,
 308   CrossScopeImports = 0xf7,
 309   CrossScopeExports = 0xf8,
 310
 311   // These appear to relate to .Net assembly info.
 312   ILLines = 0xf9,
 313   FuncMDTokenMap = 0xfa,
 314   TypeMDTokenMap = 0xfb,
 315   MergedAssemblyInput = 0xfc,
 316
 317   CoffSymbolRVA = 0xfd,
 318 };
 319
 320 /// Equivalent to CV_ptrtype_e.
 321 enum class PointerKind : uint8_t {
 322   Near16 = 0x00,                // 16 bit pointer
 323   Far16 = 0x01,                 // 16:16 far pointer
 324   Huge16 = 0x02,                // 16:16 huge pointer
 325   BasedOnSegment = 0x03,        // based on segment
 326   BasedOnValue = 0x04,          // based on value of base
 327   BasedOnSegmentValue = 0x05,   // based on segment value of base
 328   BasedOnAddress = 0x06,        // based on address of base
 329   BasedOnSegmentAddress = 0x07, // based on segment address of base
 330   BasedOnType = 0x08,           // based on type
 331   BasedOnSelf = 0x09,           // based on self
 332   Near32 = 0x0a,                // 32 bit pointer
 333   Far32 = 0x0b,                 // 16:32 pointer
 334   Near64 = 0x0c                 // 64 bit pointer
 335 };
 336
 337 /// Equivalent to CV_ptrmode_e.
 338 enum class PointerMode : uint8_t {
 339   Pointer = 0x00,                 // "normal" pointer
 340   LValueReference = 0x01,         // "old" reference
 341   PointerToDataMember = 0x02,     // pointer to data member
 342   PointerToMemberFunction = 0x03, // pointer to member function
 343   RValueReference = 0x04          // r-value reference
 344 };
 345
 346 /// Equivalent to misc lfPointerAttr bitfields.
 347 enum class PointerOptions : uint32_t {
 348   None = 0x00000000,
 349   Flat32 = 0x00000100,
 350   Volatile = 0x00000200,
 351   Const = 0x00000400,
 352   Unaligned = 0x00000800,
 353   Restrict = 0x00001000,
 354   WinRTSmartPointer = 0x00080000
 355 };
 356 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions)
 357
 358 /// Equivalent to CV_pmtype_e.
 359 enum class PointerToMemberRepresentation : uint16_t {
 360   Unknown = 0x00,                     // not specified (pre VC8)
 361   SingleInheritanceData = 0x01,       // member data, single inheritance
 362   MultipleInheritanceData = 0x02,     // member data, multiple inheritance
 363   VirtualInheritanceData = 0x03,      // member data, virtual inheritance
 364   GeneralData = 0x04,                 // member data, most general
 365   SingleInheritanceFunction = 0x05,   // member function, single inheritance
 366   MultipleInheritanceFunction = 0x06, // member function, multiple inheritance
 367   VirtualInheritanceFunction = 0x07,  // member function, virtual inheritance
 368   GeneralFunction = 0x08              // member function, most general
 369 };
 370
 371 enum class VFTableSlotKind : uint8_t {
 372   Near16 = 0x00,
 373   Far16 = 0x01,
 374   This = 0x02,
 375   Outer = 0x03,
 376   Meta = 0x04,
 377   Near = 0x05,
 378   Far = 0x06
 379 };
 380
 381 enum class WindowsRTClassKind : uint8_t {
 382   None = 0x00,
 383   RefClass = 0x01,
 384   ValueClass = 0x02,
 385   Interface = 0x03
 386 };
 387
 388 /// Corresponds to CV_LVARFLAGS bitfield.
 389 enum class LocalSymFlags : uint16_t {
 390   None = 0,
 391   IsParameter = 1 << 0,
 392   IsAddressTaken = 1 << 1,
 393   IsCompilerGenerated = 1 << 2,
 394   IsAggregate = 1 << 3,
 395   IsAggregated = 1 << 4,
 396   IsAliased = 1 << 5,
 397   IsAlias = 1 << 6,
 398   IsReturnValue = 1 << 7,
 399   IsOptimizedOut = 1 << 8,
 400   IsEnregisteredGlobal = 1 << 9,
 401   IsEnregisteredStatic = 1 << 10,
 402 };
 403 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(LocalSymFlags)
 404
 405 /// Corresponds to the CV_PROCFLAGS bitfield.
 406 enum class ProcSymFlags : uint8_t {
 407   None = 0,
 408   HasFP = 1 << 0,
 409   HasIRET = 1 << 1,
 410   HasFRET = 1 << 2,
 411   IsNoReturn = 1 << 3,
 412   IsUnreachable = 1 << 4,
 413   HasCustomCallingConv = 1 << 5,
 414   IsNoInline = 1 << 6,
 415   HasOptimizedDebugInfo = 1 << 7,
 416 };
 417 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ProcSymFlags)
 418
 419 /// Corresponds to COMPILESYM2::Flags bitfield.
 420 enum class CompileSym2Flags : uint32_t {
 421   None = 0,
 422   SourceLanguageMask = 0xFF,
 423   EC = 1 << 8,
 424   NoDbgInfo = 1 << 9,
 425   LTCG = 1 << 10,
 426   NoDataAlign = 1 << 11,
 427   ManagedPresent = 1 << 12,
 428   SecurityChecks = 1 << 13,
 429   HotPatch = 1 << 14,
 430   CVTCIL = 1 << 15,
 431   MSILModule = 1 << 16,
 432 };
 433 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym2Flags)
 434
 435 /// Corresponds to COMPILESYM3::Flags bitfield.
 436 enum class CompileSym3Flags : uint32_t {
 437   None = 0,
 438   SourceLanguageMask = 0xFF,
 439   EC = 1 << 8,
 440   NoDbgInfo = 1 << 9,
 441   LTCG = 1 << 10,
 442   NoDataAlign = 1 << 11,
 443   ManagedPresent = 1 << 12,
 444   SecurityChecks = 1 << 13,
 445   HotPatch = 1 << 14,
 446   CVTCIL = 1 << 15,
 447   MSILModule = 1 << 16,
 448   Sdl = 1 << 17,
 449   PGO = 1 << 18,
 450   Exp = 1 << 19,
 451 };
 452 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym3Flags)
 453
 454 enum class ExportFlags : uint16_t {
 455   None = 0,
 456   IsConstant = 1 << 0,
 457   IsData = 1 << 1,
 458   IsPrivate = 1 << 2,
 459   HasNoName = 1 << 3,
 460   HasExplicitOrdinal = 1 << 4,
 461   IsForwarder = 1 << 5
 462 };
 463 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ExportFlags)
 464
 465 // Corresponds to BinaryAnnotationOpcode enum.
 466 enum class BinaryAnnotationsOpCode : uint32_t {
 467   Invalid,
 468   CodeOffset,
 469   ChangeCodeOffsetBase,
 470   ChangeCodeOffset,
 471   ChangeCodeLength,
 472   ChangeFile,
 473   ChangeLineOffset,
 474   ChangeLineEndDelta,
 475   ChangeRangeKind,
 476   ChangeColumnStart,
 477   ChangeColumnEndDelta,
 478   ChangeCodeOffsetAndLineOffset,
 479   ChangeCodeLengthAndCodeOffset,
 480   ChangeColumnEnd,
 481 };
 482
 483 // Corresponds to CV_cookietype_e enum.
 484 enum class FrameCookieKind : uint8_t {
 485   Copy,
 486   XorStackPointer,
 487   XorFramePointer,
 488   XorR13,
 489 };
 490
 491 // Corresponds to CV_HREG_e enum.
 492 enum class RegisterId : uint16_t {
 493   Unknown = 0,
 494   VFrame = 30006,
 495   AL = 1,
 496   CL = 2,
 497   DL = 3,
 498   BL = 4,
 499   AH = 5,
 500   CH = 6,
 501   DH = 7,
 502   BH = 8,
 503   AX = 9,
 504   CX = 10,
 505   DX = 11,
 506   BX = 12,
 507   SP = 13,
 508   BP = 14,
 509   SI = 15,
 510   DI = 16,
 511   EAX = 17,
 512   ECX = 18,
 513   EDX = 19,
 514   EBX = 20,
 515   ESP = 21,
 516   EBP = 22,
 517   ESI = 23,
 518   EDI = 24,
 519   ES = 25,
 520   CS = 26,
 521   SS = 27,
 522   DS = 28,
 523   FS = 29,
 524   GS = 30,
 525   IP = 31,
 526   RAX = 328,
 527   RBX = 329,
 528   RCX = 330,
 529   RDX = 331,
 530   RSI = 332,
 531   RDI = 333,
 532   RBP = 334,
 533   RSP = 335,
 534   R8 = 336,
 535   R9 = 337,
 536   R10 = 338,
 537   R11 = 339,
 538   R12 = 340,
 539   R13 = 341,
 540   R14 = 342,
 541   R15 = 343,
 542 };
 543
 544 /// These values correspond to the THUNK_ORDINAL enumeration.
 545 enum class ThunkOrdinal : uint8_t {
 546   Standard,
 547   ThisAdjustor,
 548   Vcall,
 549   Pcode,
 550   UnknownLoad,
 551   TrampIncremental,
 552   BranchIsland
 553 };
 554
 555 enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland };
 556
 557 // These values correspond to the CV_SourceChksum_t enumeration.
 558 enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };
 559
 560 enum LineFlags : uint16_t {
 561   LF_None = 0,
 562   LF_HaveColumns = 1, // CV_LINES_HAVE_COLUMNS
 563 };
 564
 565 /// Data in the the SUBSEC_FRAMEDATA subection.
 566 struct FrameData {
 567   support::ulittle32_t RvaStart;
 568   support::ulittle32_t CodeSize;
 569   support::ulittle32_t LocalSize;
 570   support::ulittle32_t ParamsSize;
 571   support::ulittle32_t MaxStackSize;
 572   support::ulittle32_t FrameFunc;
 573   support::ulittle16_t PrologSize;
 574   support::ulittle16_t SavedRegsSize;
 575   support::ulittle32_t Flags;
 576   enum : uint32_t {
 577     HasSEH = 1 << 0,
 578     HasEH = 1 << 1,
 579     IsFunctionStart = 1 << 2,
 580   };
 581 };
 582
 583 // Corresponds to LocalIdAndGlobalIdPair structure.
 584 // This structure information allows cross-referencing between PDBs.  For
 585 // example, when a PDB is being built during compilation it is not yet known
 586 // what other modules may end up in the PDB at link time.  So certain types of
 587 // IDs may clash between the various compile time PDBs.  For each affected
 588 // module, a subsection would be put into the PDB containing a mapping from its
 589 // local IDs to a single ID namespace for all items in the PDB file.
 590 struct CrossModuleExport {
 591   support::ulittle32_t Local;
 592   support::ulittle32_t Global;
 593 };
 594
 595 struct CrossModuleImport {
 596   support::ulittle32_t ModuleNameOffset;
 597   support::ulittle32_t Count; // Number of elements
 598   // support::ulittle32_t ids[Count]; // id from referenced module
 599 };
 600
 601 enum class CodeViewContainer { ObjectFile, Pdb };
 602
 603 inline uint32_t alignOf(CodeViewContainer Container) {
 604   if (Container == CodeViewContainer::ObjectFile)
 605     return 1;
 606   return 4;
 607 }
 608 }
 609 }
 610
 611 #endif