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
21namespace llvm {
22namespace 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.
26enum 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.
33enum 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.
40enum 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.
47enum 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
78enum 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  ARM64 = 0x69,
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
143enum 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///
173enum 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
201enum 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};
216CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ClassOptions)
217
218enum 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};
242CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FrameProcedureOptions)
243
244enum class FunctionOptions : uint8_t {
245  None = 0x00,
246  CxxReturnUdt = 0x01,
247  Constructor = 0x02,
248  ConstructorWithVirtualBases = 0x04
249};
250CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FunctionOptions)
251
252enum 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)
260enum 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)
268enum 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.
279enum 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};
289CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(MethodOptions)
290
291/// Equivalent to CV_LABEL_TYPE_e.
292enum 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
299enum class ModifierOptions : uint16_t {
300  None = 0x0000,
301  Const = 0x0001,
302  Volatile = 0x0002,
303  Unaligned = 0x0004
304};
305CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
306
307// If the subsection kind has this bit set, then the linker should ignore it.
308enum : uint32_t { SubsectionIgnoreFlag = 0x80000000 };
309
310enum 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.
331enum 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.
348enum 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.
357enum 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};
368CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions)
369
370/// Equivalent to CV_pmtype_e.
371enum 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
383enum 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
393enum class WindowsRTClassKind : uint8_t {
394  None = 0x00,
395  RefClass = 0x01,
396  ValueClass = 0x02,
397  Interface = 0x03
398};
399
400/// Corresponds to CV_LVARFLAGS bitfield.
401enum 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};
415CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(LocalSymFlags)
416
417/// Corresponds to the CV_PUBSYMFLAGS bitfield.
418enum class PublicSymFlags : uint32_t {
419  None = 0,
420  Code = 1 << 0,
421  Function = 1 << 1,
422  Managed = 1 << 2,
423  MSIL = 1 << 3,
424};
425CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PublicSymFlags)
426
427/// Corresponds to the CV_PROCFLAGS bitfield.
428enum 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};
439CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ProcSymFlags)
440
441/// Corresponds to COMPILESYM2::Flags bitfield.
442enum 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};
455CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym2Flags)
456
457/// Corresponds to COMPILESYM3::Flags bitfield.
458enum 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};
474CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(CompileSym3Flags)
475
476enum 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};
485CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ExportFlags)
486
487// Corresponds to BinaryAnnotationOpcode enum.
488enum 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.
506enum class FrameCookieKind : uint8_t {
507  Copy,
508  XorStackPointer,
509  XorFramePointer,
510  XorR13,
511};
512
513// Corresponds to CV_HREG_e enum.
514enum 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.
524struct 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.
536enum class EncodedFramePtrReg : uint8_t {
537  None = 0,
538  StackPtr = 1,
539  FramePtr = 2,
540  BasePtr = 3,
541};
542
543RegisterId decodeFramePtrReg(EncodedFramePtrReg EncodedReg, CPUType CPU);
544
545EncodedFramePtrReg encodeFramePtrReg(RegisterId Reg, CPUType CPU);
546
547/// These values correspond to the THUNK_ORDINAL enumeration.
548enum class ThunkOrdinal : uint8_t {
549  Standard,
550  ThisAdjustor,
551  Vcall,
552  Pcode,
553  UnknownLoad,
554  TrampIncremental,
555  BranchIsland
556};
557
558enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland };
559
560// These values correspond to the CV_SourceChksum_t enumeration.
561enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };
562
563enum LineFlags : uint16_t {
564  LF_None = 0,
565  LF_HaveColumns = 1, // CV_LINES_HAVE_COLUMNS
566};
567
568/// Data in the SUBSEC_FRAMEDATA subection.
569struct 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.
593struct CrossModuleExport {
594  support::ulittle32_t Local;
595  support::ulittle32_t Global;
596};
597
598struct 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
604enum class CodeViewContainer { ObjectFile, Pdb };
605
606inline uint32_t alignOf(CodeViewContainer Container) {
607  if (Container == CodeViewContainer::ObjectFile)
608    return 1;
609  return 4;
610}
611}
612}
613
614#endif
615