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
|
