Coverage Report

Created: 2018-09-25 17:16

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/DebugInfo/CodeView/CodeView.h
Line
Count
Source
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
3.12k
  inline Class operator|(Class a, Class b) {                                   \
55
3.12k
    return static_cast<Class>(                                                 \
56
3.12k
        static_cast<std::underlying_type<Class>::type>(a) |                    \
57
3.12k
        static_cast<std::underlying_type<Class>::type>(b));                    \
58
3.12k
  }                                                                            \
llvm::codeview::operator|(llvm::codeview::ModifierOptions, llvm::codeview::ModifierOptions)
Line
Count
Source
54
106
  inline Class operator|(Class a, Class b) {                                   \
55
106
    return static_cast<Class>(                                                 \
56
106
        static_cast<std::underlying_type<Class>::type>(a) |                    \
57
106
        static_cast<std::underlying_type<Class>::type>(b));                    \
58
106
  }                                                                            \
llvm::codeview::operator|(llvm::codeview::PointerOptions, llvm::codeview::PointerOptions)
Line
Count
Source
54
31
  inline Class operator|(Class a, Class b) {                                   \
55
31
    return static_cast<Class>(                                                 \
56
31
        static_cast<std::underlying_type<Class>::type>(a) |                    \
57
31
        static_cast<std::underlying_type<Class>::type>(b));                    \
58
31
  }                                                                            \
llvm::codeview::operator|(llvm::codeview::ClassOptions, llvm::codeview::ClassOptions)
Line
Count
Source
54
1.77k
  inline Class operator|(Class a, Class b) {                                   \
55
1.77k
    return static_cast<Class>(                                                 \
56
1.77k
        static_cast<std::underlying_type<Class>::type>(a) |                    \
57
1.77k
        static_cast<std::underlying_type<Class>::type>(b));                    \
58
1.77k
  }                                                                            \
llvm::codeview::operator|(llvm::codeview::LocalSymFlags, llvm::codeview::LocalSymFlags)
Line
Count
Source
54
167
  inline Class operator|(Class a, Class b) {                                   \
55
167
    return static_cast<Class>(                                                 \
56
167
        static_cast<std::underlying_type<Class>::type>(a) |                    \
57
167
        static_cast<std::underlying_type<Class>::type>(b));                    \
58
167
  }                                                                            \
llvm::codeview::operator|(llvm::codeview::MethodOptions, llvm::codeview::MethodOptions)
Line
Count
Source
54
1.05k
  inline Class operator|(Class a, Class b) {                                   \
55
1.05k
    return static_cast<Class>(                                                 \
56
1.05k
        static_cast<std::underlying_type<Class>::type>(a) |                    \
57
1.05k
        static_cast<std::underlying_type<Class>::type>(b));                    \
58
1.05k
  }                                                                            \
Unexecuted instantiation: llvm::codeview::operator|(llvm::codeview::PublicSymFlags, llvm::codeview::PublicSymFlags)
Unexecuted instantiation: llvm::codeview::operator|(llvm::codeview::CompileSym2Flags, llvm::codeview::CompileSym2Flags)
Unexecuted instantiation: llvm::codeview::operator|(llvm::codeview::ExportFlags, llvm::codeview::ExportFlags)
59
16.1k
  inline Class operator&(Class a, Class b) {                                   \
60
16.1k
    return static_cast<Class>(                                                 \
61
16.1k
        static_cast<std::underlying_type<Class>::type>(a) &                    \
62
16.1k
        static_cast<std::underlying_type<Class>::type>(b));                    \
63
16.1k
  }                                                                            \
llvm::codeview::operator&(llvm::codeview::ClassOptions, llvm::codeview::ClassOptions)
Line
Count
Source
59
16.1k
  inline Class operator&(Class a, Class b) {                                   \
60
16.1k
    return static_cast<Class>(                                                 \
61
16.1k
        static_cast<std::underlying_type<Class>::type>(a) &                    \
62
16.1k
        static_cast<std::underlying_type<Class>::type>(b));                    \
63
16.1k
  }                                                                            \
Unexecuted instantiation: llvm::codeview::operator&(llvm::codeview::CompileSym2Flags, llvm::codeview::CompileSym2Flags)
Unexecuted instantiation: llvm::codeview::operator&(llvm::codeview::ExportFlags, llvm::codeview::ExportFlags)
64
  inline Class operator~(Class a) {                                            \
65
    return static_cast<Class>(                                                 \
66
        ~static_cast<std::underlying_type<Class>::type>(a));                   \
67
  }                                                                            \
68
364
  inline Class &operator|=(Class &a, Class b) {                                \
69
364
    a = a | b;                                                                 \
70
364
    return a;                                                                  \
71
364
  }                                                                            \
llvm::codeview::operator|=(llvm::codeview::ClassOptions&, llvm::codeview::ClassOptions)
Line
Count
Source
68
167
  inline Class &operator|=(Class &a, Class b) {                                \
69
167
    a = a | b;                                                                 \
70
167
    return a;                                                                  \
71
167
  }                                                                            \
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::FrameProcedureOptions&, llvm::codeview::FrameProcedureOptions)
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::FunctionOptions&, llvm::codeview::FunctionOptions)
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::MethodOptions&, llvm::codeview::MethodOptions)
llvm::codeview::operator|=(llvm::codeview::ModifierOptions&, llvm::codeview::ModifierOptions)
Line
Count
Source
68
24
  inline Class &operator|=(Class &a, Class b) {                                \
69
24
    a = a | b;                                                                 \
70
24
    return a;                                                                  \
71
24
  }                                                                            \
llvm::codeview::operator|=(llvm::codeview::PointerOptions&, llvm::codeview::PointerOptions)
Line
Count
Source
68
31
  inline Class &operator|=(Class &a, Class b) {                                \
69
31
    a = a | b;                                                                 \
70
31
    return a;                                                                  \
71
31
  }                                                                            \
llvm::codeview::operator|=(llvm::codeview::LocalSymFlags&, llvm::codeview::LocalSymFlags)
Line
Count
Source
68
142
  inline Class &operator|=(Class &a, Class b) {                                \
69
142
    a = a | b;                                                                 \
70
142
    return a;                                                                  \
71
142
  }                                                                            \
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::PublicSymFlags&, llvm::codeview::PublicSymFlags)
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::ProcSymFlags&, llvm::codeview::ProcSymFlags)
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::CompileSym2Flags&, llvm::codeview::CompileSym2Flags)
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::CompileSym3Flags&, llvm::codeview::CompileSym3Flags)
Unexecuted instantiation: llvm::codeview::operator|=(llvm::codeview::ExportFlags&, llvm::codeview::ExportFlags)
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
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
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
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
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
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
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
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
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
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
/// These values correspond to the THUNK_ORDINAL enumeration.
516
enum class ThunkOrdinal : uint8_t {
517
  Standard,
518
  ThisAdjustor,
519
  Vcall,
520
  Pcode,
521
  UnknownLoad,
522
  TrampIncremental,
523
  BranchIsland
524
};
525
526
enum class TrampolineType : uint16_t { TrampIncremental, BranchIsland };
527
528
// These values correspond to the CV_SourceChksum_t enumeration.
529
enum class FileChecksumKind : uint8_t { None, MD5, SHA1, SHA256 };
530
531
enum LineFlags : uint16_t {
532
  LF_None = 0,
533
  LF_HaveColumns = 1, // CV_LINES_HAVE_COLUMNS
534
};
535
536
/// Data in the SUBSEC_FRAMEDATA subection.
537
struct FrameData {
538
  support::ulittle32_t RvaStart;
539
  support::ulittle32_t CodeSize;
540
  support::ulittle32_t LocalSize;
541
  support::ulittle32_t ParamsSize;
542
  support::ulittle32_t MaxStackSize;
543
  support::ulittle32_t FrameFunc;
544
  support::ulittle16_t PrologSize;
545
  support::ulittle16_t SavedRegsSize;
546
  support::ulittle32_t Flags;
547
  enum : uint32_t {
548
    HasSEH = 1 << 0,
549
    HasEH = 1 << 1,
550
    IsFunctionStart = 1 << 2,
551
  };
552
};
553
554
// Corresponds to LocalIdAndGlobalIdPair structure.
555
// This structure information allows cross-referencing between PDBs.  For
556
// example, when a PDB is being built during compilation it is not yet known
557
// what other modules may end up in the PDB at link time.  So certain types of
558
// IDs may clash between the various compile time PDBs.  For each affected
559
// module, a subsection would be put into the PDB containing a mapping from its
560
// local IDs to a single ID namespace for all items in the PDB file.
561
struct CrossModuleExport {
562
  support::ulittle32_t Local;
563
  support::ulittle32_t Global;
564
};
565
566
struct CrossModuleImport {
567
  support::ulittle32_t ModuleNameOffset;
568
  support::ulittle32_t Count; // Number of elements
569
  // support::ulittle32_t ids[Count]; // id from referenced module
570
};
571
572
enum class CodeViewContainer { ObjectFile, Pdb };
573
574
4.35k
inline uint32_t alignOf(CodeViewContainer Container) {
575
4.35k
  if (Container == CodeViewContainer::ObjectFile)
576
2.63k
    return 1;
577
1.72k
  return 4;
578
1.72k
}
579
}
580
}
581
582
#endif