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 612
