1 //===- CodeView.h -----------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Defines constants and basic types describing CodeView debug information. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_DEBUGINFO_CODEVIEW_CODEVIEW_H 14 #define LLVM_DEBUGINFO_CODEVIEW_CODEVIEW_H 15 16 #include <cinttypes> 17 #include <type_traits> 18 19 #include "llvm/Support/Endian.h" 20 21 namespace llvm { 22 namespace codeview { 23 24 /// Distinguishes individual records in .debug$T or .debug$P section or PDB type 25 /// stream. The documentation and headers talk about this as the "leaf" type. 26 enum class TypeRecordKind : uint16_t { 27 #define TYPE_RECORD(lf_ename, value, name) name = value, 28 #include "CodeViewTypes.def" 29 }; 30 31 /// Duplicate copy of the above enum, but using the official CV names. Useful 32 /// for reference purposes and when dealing with unknown record types. 33 enum TypeLeafKind : uint16_t { 34 #define CV_TYPE(name, val) name = val, 35 #include "CodeViewTypes.def" 36 }; 37 38 /// Distinguishes individual records in the Symbols subsection of a .debug$S 39 /// section. Equivalent to SYM_ENUM_e in cvinfo.h. 40 enum class SymbolRecordKind : uint16_t { 41 #define SYMBOL_RECORD(lf_ename, value, name) name = value, 42 #include "CodeViewSymbols.def" 43 }; 44 45 /// Duplicate copy of the above enum, but using the official CV names. Useful 46 /// for reference purposes and when dealing with unknown record types. 47 enum SymbolKind : uint16_t { 48 #define CV_SYMBOL(name, val) name = val, 49 #include "CodeViewSymbols.def" 50 }; 51 52 #define CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(Class) \ 53 inline Class operator|(Class a, Class b) { \ 54 return static_cast<Class>( \ 55 static_cast<std::underlying_type<Class>::type>(a) | \ 56 static_cast<std::underlying_type<Class>::type>(b)); \ 57 } \ 58 inline Class operator&(Class a, Class b) { \ 59 return static_cast<Class>( \ 60 static_cast<std::underlying_type<Class>::type>(a) & \ 61 static_cast<std::underlying_type<Class>::type>(b)); \ 62 } \ 63 inline Class operator~(Class a) { \ 64 return static_cast<Class>( \ 65 ~static_cast<std::underlying_type<Class>::type>(a)); \ 66 } \ 67 inline Class &operator|=(Class &a, Class b) { \ 68 a = a | b; \ 69 return a; \ 70 } \ 71 inline Class &operator&=(Class &a, Class b) { \ 72 a = a & b; \ 73 return a; \ 74 } 75 76 /// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented 77 /// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx 78 enum class CPUType : uint16_t { 79 Intel8080 = 0x0, 80 Intel8086 = 0x1, 81 Intel80286 = 0x2, 82 Intel80386 = 0x3, 83 Intel80486 = 0x4, 84 Pentium = 0x5, 85 PentiumPro = 0x6, 86 Pentium3 = 0x7, 87 MIPS = 0x10, 88 MIPS16 = 0x11, 89 MIPS32 = 0x12, 90 MIPS64 = 0x13, 91 MIPSI = 0x14, 92 MIPSII = 0x15, 93 MIPSIII = 0x16, 94 MIPSIV = 0x17, 95 MIPSV = 0x18, 96 M68000 = 0x20, 97 M68010 = 0x21, 98 M68020 = 0x22, 99 M68030 = 0x23, 100 M68040 = 0x24, 101 Alpha = 0x30, 102 Alpha21164 = 0x31, 103 Alpha21164A = 0x32, 104 Alpha21264 = 0x33, 105 Alpha21364 = 0x34, 106 PPC601 = 0x40, 107 PPC603 = 0x41, 108 PPC604 = 0x42, 109 PPC620 = 0x43, 110 PPCFP = 0x44, 111 PPCBE = 0x45, 112 SH3 = 0x50, 113 SH3E = 0x51, 114 SH3DSP = 0x52, 115 SH4 = 0x53, 116 SHMedia = 0x54, 117 ARM3 = 0x60, 118 ARM4 = 0x61, 119 ARM4T = 0x62, 120 ARM5 = 0x63, 121 ARM5T = 0x64, 122 ARM6 = 0x65, 123 ARM_XMAC = 0x66, 124 ARM_WMMX = 0x67, 125 ARM7 = 0x68, 126 Omni = 0x70, 127 Ia64 = 0x80, 128 Ia64_2 = 0x81, 129 CEE = 0x90, 130 AM33 = 0xa0, 131 M32R = 0xb0, 132 TriCore = 0xc0, 133 X64 = 0xd0, 134 EBC = 0xe0, 135 Thumb = 0xf0, 136 ARMNT = 0xf4, 137 ARM64 = 0xf6, 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 /// The DMD & Swift compilers emit 'D' and 'S', respectively, for the CV 163 /// source language. Microsoft does not have enumerators for them yet. 164 D = 'D', 165 Swift = 'S', 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 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 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 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 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 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions) 306 307 // If the subsection kind has this bit set, then the linker should ignore it. 308 enum : uint32_t { SubsectionIgnoreFlag = 0x80000000 }; 309 310 enum class DebugSubsectionKind : uint32_t { 311 None = 0, 312 Symbols = 0xf1, 313 Lines = 0xf2, 314 StringTable = 0xf3, 315 FileChecksums = 0xf4, 316 FrameData = 0xf5, 317 InlineeLines = 0xf6, 318 CrossScopeImports = 0xf7, 319 CrossScopeExports = 0xf8, 320 321 // These appear to relate to .Net assembly info. 322 ILLines = 0xf9, 323 FuncMDTokenMap = 0xfa, 324 TypeMDTokenMap = 0xfb, 325 MergedAssemblyInput = 0xfc, 326 327 CoffSymbolRVA = 0xfd, 328 }; 329 330 /// Equivalent to CV_ptrtype_e. 331 enum class PointerKind : uint8_t { 332 Near16 = 0x00, // 16 bit pointer 333 Far16 = 0x01, // 16:16 far pointer 334 Huge16 = 0x02, // 16:16 huge pointer 335 BasedOnSegment = 0x03, // based on segment 336 BasedOnValue = 0x04, // based on value of base 337 BasedOnSegmentValue = 0x05, // based on segment value of base 338 BasedOnAddress = 0x06, // based on address of base 339 BasedOnSegmentAddress = 0x07, // based on segment address of base 340 BasedOnType = 0x08, // based on type 341 BasedOnSelf = 0x09, // based on self 342 Near32 = 0x0a, // 32 bit pointer 343 Far32 = 0x0b, // 16:32 pointer 344 Near64 = 0x0c // 64 bit pointer 345 }; 346 347 /// Equivalent to CV_ptrmode_e. 348 enum class PointerMode : uint8_t { 349 Pointer = 0x00, // "normal" pointer 350 LValueReference = 0x01, // "old" reference 351 PointerToDataMember = 0x02, // pointer to data member 352 PointerToMemberFunction = 0x03, // pointer to member function 353 RValueReference = 0x04 // r-value reference 354 }; 355 356 /// Equivalent to misc lfPointerAttr bitfields. 357 enum class PointerOptions : uint32_t { 358 None = 0x00000000, 359 Flat32 = 0x00000100, 360 Volatile = 0x00000200, 361 Const = 0x00000400, 362 Unaligned = 0x00000800, 363 Restrict = 0x00001000, 364 WinRTSmartPointer = 0x00080000, 365 LValueRefThisPointer = 0x00100000, 366 RValueRefThisPointer = 0x00200000 367 }; 368 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions) 369 370 /// Equivalent to CV_pmtype_e. 371 enum class PointerToMemberRepresentation : uint16_t { 372 Unknown = 0x00, // not specified (pre VC8) 373 SingleInheritanceData = 0x01, // member data, single inheritance 374 MultipleInheritanceData = 0x02, // member data, multiple inheritance 375 VirtualInheritanceData = 0x03, // member data, virtual inheritance 376 GeneralData = 0x04, // member data, most general 377 SingleInheritanceFunction = 0x05, // member function, single inheritance 378 MultipleInheritanceFunction = 0x06, // member function, multiple inheritance 379 VirtualInheritanceFunction = 0x07, // member function, virtual inheritance 380 GeneralFunction = 0x08 // member function, most general 381 }; 382 383 enum class VFTableSlotKind : uint8_t { 384 Near16 = 0x00, 385 Far16 = 0x01, 386 This = 0x02, 387 Outer = 0x03, 388 Meta = 0x04, 389 Near = 0x05, 390 Far = 0x06 391 }; 392 393 enum class WindowsRTClassKind : uint8_t { 394 None = 0x00, 395 RefClass = 0x01, 396 ValueClass = 0x02, 397 Interface = 0x03 398 }; 399 400 /// Corresponds to CV_LVARFLAGS bitfield. 401 enum class LocalSymFlags : uint16_t { 402 None = 0, 403 IsParameter = 1 << 0, 404 IsAddressTaken = 1 << 1, 405 IsCompilerGenerated = 1 << 2, 406 IsAggregate = 1 << 3, 407 IsAggregated = 1 << 4, 408 IsAliased = 1 << 5, 409 IsAlias = 1 << 6, 410 IsReturnValue = 1 << 7, 411 IsOptimizedOut = 1 << 8, 412 IsEnregisteredGlobal = 1 << 9, 413 IsEnregisteredStatic = 1 << 10, 414 }; 415 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(LocalSymFlags) 416 417 /// Corresponds to the CV_PUBSYMFLAGS bitfield. 418 enum class PublicSymFlags : uint32_t { 419 None = 0, 420 Code = 1 << 0, 421 Function = 1 << 1, 422 Managed = 1 << 2, 423 MSIL = 1 << 3, 424 }; 425 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PublicSymFlags) 426 427 /// Corresponds to the CV_PROCFLAGS bitfield. 428 enum class ProcSymFlags : uint8_t { 429 None = 0, 430 HasFP = 1 << 0, 431 HasIRET = 1 << 1, 432 HasFRET = 1 << 2, 433 IsNoReturn = 1 << 3, 434 IsUnreachable = 1 << 4, 435 HasCustomCallingConv = 1 << 5, 436 IsNoInline = 1 << 6, 437 HasOptimizedDebugInfo = 1 << 7, 438 }; 439 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ProcSymFlags) 440 441 /// Corresponds to COMPILESYM2::Flags bitfield. 442 enum class CompileSym2Flags : uint32_t { 443 None = 0, 444 SourceLanguageMask = 0xFF, 445 EC = 1 << 8, 446 NoDbgInfo = 1 << 9, 447 LTCG = 1 << 10, 448 NoDataAlign = 1 << 11, 449 ManagedPresent = 1 << 12, 450 SecurityChecks = 1 << 13, 451 HotPatch = 1 << 14, 452 CVTCIL = 1 << 15, 453 MSILModule = 1 << 16, 454 }; 455 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym2Flags) 456 457 /// Corresponds to COMPILESYM3::Flags bitfield. 458 enum class CompileSym3Flags : uint32_t { 459 None = 0, 460 SourceLanguageMask = 0xFF, 461 EC = 1 << 8, 462 NoDbgInfo = 1 << 9, 463 LTCG = 1 << 10, 464 NoDataAlign = 1 << 11, 465 ManagedPresent = 1 << 12, 466 SecurityChecks = 1 << 13, 467 HotPatch = 1 << 14, 468 CVTCIL = 1 << 15, 469 MSILModule = 1 << 16, 470 Sdl = 1 << 17, 471 PGO = 1 << 18, 472 Exp = 1 << 19, 473 }; 474 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym3Flags) 475 476 enum class ExportFlags : uint16_t { 477 None = 0, 478 IsConstant = 1 << 0, 479 IsData = 1 << 1, 480 IsPrivate = 1 << 2, 481 HasNoName = 1 << 3, 482 HasExplicitOrdinal = 1 << 4, 483 IsForwarder = 1 << 5 484 }; 485 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ExportFlags) 486 487 // Corresponds to BinaryAnnotationOpcode enum. 488 enum class BinaryAnnotationsOpCode : uint32_t { 489 Invalid, 490 CodeOffset, 491 ChangeCodeOffsetBase, 492 ChangeCodeOffset, 493 ChangeCodeLength, 494 ChangeFile, 495 ChangeLineOffset, 496 ChangeLineEndDelta, 497 ChangeRangeKind, 498 ChangeColumnStart, 499 ChangeColumnEndDelta, 500 ChangeCodeOffsetAndLineOffset, 501 ChangeCodeLengthAndCodeOffset, 502 ChangeColumnEnd, 503 }; 504 505 // Corresponds to CV_cookietype_e enum. 506 enum class FrameCookieKind : uint8_t { 507 Copy, 508 XorStackPointer, 509 XorFramePointer, 510 XorR13, 511 }; 512 513 // Corresponds to CV_HREG_e enum. 514 enum class RegisterId : uint16_t { 515 #define CV_REGISTERS_ALL 516 #define CV_REGISTER(name, value) name = value, 517 #include "CodeViewRegisters.def" 518 #undef CV_REGISTER 519 #undef CV_REGISTERS_ALL 520 }; 521 522 // Register Ids are shared between architectures in CodeView. CPUType is needed 523 // to map register Id to name. 524 struct CPURegister { 525 CPURegister() = delete; 526 CPURegister(CPUType Cpu, codeview::RegisterId Reg) { 527 this->Cpu = Cpu; 528 this->Reg = Reg; 529 } 530 CPUType Cpu; 531 RegisterId Reg; 532 }; 533 534 /// Two-bit value indicating which register is the designated frame pointer 535 /// register. Appears in the S_FRAMEPROC record flags. 536 enum class EncodedFramePtrReg : uint8_t { 537 None = 0, 538 StackPtr = 1, 539 FramePtr = 2, 540 BasePtr = 3, 541 }; 542 543 RegisterId decodeFramePtrReg(EncodedFramePtrReg EncodedReg, CPUType CPU); 544 545 EncodedFramePtrReg encodeFramePtrReg(RegisterId Reg, CPUType CPU); 546 547 /// These values correspond to the THUNK_ORDINAL enumeration. 548 enum class ThunkOrdinal : uint8_t { 549 Standard, 550 ThisAdjustor, 551 Vcall, 552 Pcode, 553 UnknownLoad, 554 TrampIncremental, 555 BranchIsland 556 }; 557 558 enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland }; 559 560 // These values correspond to the CV_SourceChksum_t enumeration. 561 enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 }; 562 563 enum LineFlags : uint16_t { 564 LF_None = 0, 565 LF_HaveColumns = 1, // CV_LINES_HAVE_COLUMNS 566 }; 567 568 /// Data in the SUBSEC_FRAMEDATA subection. 569 struct FrameData { 570 support::ulittle32_t RvaStart; 571 support::ulittle32_t CodeSize; 572 support::ulittle32_t LocalSize; 573 support::ulittle32_t ParamsSize; 574 support::ulittle32_t MaxStackSize; 575 support::ulittle32_t FrameFunc; 576 support::ulittle16_t PrologSize; 577 support::ulittle16_t SavedRegsSize; 578 support::ulittle32_t Flags; 579 enum : uint32_t { 580 HasSEH = 1 << 0, 581 HasEH = 1 << 1, 582 IsFunctionStart = 1 << 2, 583 }; 584 }; 585 586 // Corresponds to LocalIdAndGlobalIdPair structure. 587 // This structure information allows cross-referencing between PDBs. For 588 // example, when a PDB is being built during compilation it is not yet known 589 // what other modules may end up in the PDB at link time. So certain types of 590 // IDs may clash between the various compile time PDBs. For each affected 591 // module, a subsection would be put into the PDB containing a mapping from its 592 // local IDs to a single ID namespace for all items in the PDB file. 593 struct CrossModuleExport { 594 support::ulittle32_t Local; 595 support::ulittle32_t Global; 596 }; 597 598 struct CrossModuleImport { 599 support::ulittle32_t ModuleNameOffset; 600 support::ulittle32_t Count; // Number of elements 601 // support::ulittle32_t ids[Count]; // id from referenced module 602 }; 603 604 enum class CodeViewContainer { ObjectFile, Pdb }; 605 606 inline uint32_t alignOf(CodeViewContainer Container) { 607 if (Container == CodeViewContainer::ObjectFile) 608 return 1; 609 return 4; 610 } 611 } 612 } 613 614 #endif 615
Indexes created Tue Feb 24 08:35:24 UTC 2026