Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/DebugInfo/PDB/PDBTypes.h
Line
Count
Source (jump to first uncovered line)
1
//===- PDBTypes.h - Defines enums for various fields contained in PDB ----====//
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
#ifndef LLVM_DEBUGINFO_PDB_PDBTYPES_H
10
#define LLVM_DEBUGINFO_PDB_PDBTYPES_H
11
12
#include "llvm/DebugInfo/CodeView/CodeView.h"
13
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
14
#include "llvm/DebugInfo/PDB/IPDBFrameData.h"
15
#include "llvm/DebugInfo/PDB/Native/RawTypes.h"
16
#include <cctype>
17
#include <cstddef>
18
#include <cstdint>
19
#include <cstring>
20
#include <functional>
21
22
namespace llvm {
23
namespace pdb {
24
25
typedef uint32_t SymIndexId;
26
27
class IPDBDataStream;
28
class IPDBInjectedSource;
29
class IPDBLineNumber;
30
class IPDBSectionContrib;
31
class IPDBSourceFile;
32
class IPDBTable;
33
class PDBSymDumper;
34
class PDBSymbol;
35
class PDBSymbolExe;
36
class PDBSymbolCompiland;
37
class PDBSymbolCompilandDetails;
38
class PDBSymbolCompilandEnv;
39
class PDBSymbolFunc;
40
class PDBSymbolBlock;
41
class PDBSymbolData;
42
class PDBSymbolAnnotation;
43
class PDBSymbolLabel;
44
class PDBSymbolPublicSymbol;
45
class PDBSymbolTypeUDT;
46
class PDBSymbolTypeEnum;
47
class PDBSymbolTypeFunctionSig;
48
class PDBSymbolTypePointer;
49
class PDBSymbolTypeArray;
50
class PDBSymbolTypeBuiltin;
51
class PDBSymbolTypeTypedef;
52
class PDBSymbolTypeBaseClass;
53
class PDBSymbolTypeFriend;
54
class PDBSymbolTypeFunctionArg;
55
class PDBSymbolFuncDebugStart;
56
class PDBSymbolFuncDebugEnd;
57
class PDBSymbolUsingNamespace;
58
class PDBSymbolTypeVTableShape;
59
class PDBSymbolTypeVTable;
60
class PDBSymbolCustom;
61
class PDBSymbolThunk;
62
class PDBSymbolTypeCustom;
63
class PDBSymbolTypeManaged;
64
class PDBSymbolTypeDimension;
65
class PDBSymbolUnknown;
66
67
using IPDBEnumSymbols = IPDBEnumChildren<PDBSymbol>;
68
using IPDBEnumSourceFiles = IPDBEnumChildren<IPDBSourceFile>;
69
using IPDBEnumDataStreams = IPDBEnumChildren<IPDBDataStream>;
70
using IPDBEnumLineNumbers = IPDBEnumChildren<IPDBLineNumber>;
71
using IPDBEnumTables = IPDBEnumChildren<IPDBTable>;
72
using IPDBEnumInjectedSources = IPDBEnumChildren<IPDBInjectedSource>;
73
using IPDBEnumSectionContribs = IPDBEnumChildren<IPDBSectionContrib>;
74
using IPDBEnumFrameData = IPDBEnumChildren<IPDBFrameData>;
75
76
/// Specifies which PDB reader implementation is to be used.  Only a value
77
/// of PDB_ReaderType::DIA is currently supported, but Native is in the works.
78
enum class PDB_ReaderType {
79
  DIA = 0,
80
  Native = 1,
81
};
82
83
/// An enumeration indicating the type of data contained in this table.
84
enum class PDB_TableType {
85
  TableInvalid = 0,
86
  Symbols,
87
  SourceFiles,
88
  LineNumbers,
89
  SectionContribs,
90
  Segments,
91
  InjectedSources,
92
  FrameData,
93
  InputAssemblyFiles,
94
  Dbg
95
};
96
97
/// Defines flags used for enumerating child symbols.  This corresponds to the
98
/// NameSearchOptions enumeration which is documented here:
99
/// https://msdn.microsoft.com/en-us/library/yat28ads.aspx
100
enum PDB_NameSearchFlags {
101
  NS_Default = 0x0,
102
  NS_CaseSensitive = 0x1,
103
  NS_CaseInsensitive = 0x2,
104
  NS_FileNameExtMatch = 0x4,
105
  NS_Regex = 0x8,
106
  NS_UndecoratedName = 0x10,
107
108
  // For backward compatibility.
109
  NS_CaseInFileNameExt = NS_CaseInsensitive | NS_FileNameExtMatch,
110
  NS_CaseRegex = NS_Regex | NS_CaseSensitive,
111
  NS_CaseInRex = NS_Regex | NS_CaseInsensitive
112
};
113
114
/// Specifies the hash algorithm that a source file from a PDB was hashed with.
115
/// This corresponds to the CV_SourceChksum_t enumeration and are documented
116
/// here: https://msdn.microsoft.com/en-us/library/e96az21x.aspx
117
enum class PDB_Checksum { None = 0, MD5 = 1, SHA1 = 2, SHA256 = 3 };
118
119
/// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented
120
/// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
121
using PDB_Cpu = codeview::CPUType;
122
123
enum class PDB_Machine {
124
  Invalid = 0xffff,
125
  Unknown = 0x0,
126
  Am33 = 0x13,
127
  Amd64 = 0x8664,
128
  Arm = 0x1C0,
129
  Arm64 = 0xaa64,
130
  ArmNT = 0x1C4,
131
  Ebc = 0xEBC,
132
  x86 = 0x14C,
133
  Ia64 = 0x200,
134
  M32R = 0x9041,
135
  Mips16 = 0x266,
136
  MipsFpu = 0x366,
137
  MipsFpu16 = 0x466,
138
  PowerPC = 0x1F0,
139
  PowerPCFP = 0x1F1,
140
  R4000 = 0x166,
141
  SH3 = 0x1A2,
142
  SH3DSP = 0x1A3,
143
  SH4 = 0x1A6,
144
  SH5 = 0x1A8,
145
  Thumb = 0x1C2,
146
  WceMipsV2 = 0x169
147
};
148
149
// A struct with an inner unnamed enum with explicit underlying type resuls
150
// in an enum class that can implicitly convert to the underlying type, which
151
// is convenient for this enum.
152
struct PDB_SourceCompression {
153
  enum : uint32_t {
154
    // No compression. Produced e.g. by `link.exe /natvis:foo.natvis`.
155
    None,
156
    // Not known what produces this.
157
    RunLengthEncoded,
158
    // Not known what produces this.
159
    Huffman,
160
    // Not known what produces this.
161
    LZ,
162
    // Produced e.g. by `csc /debug`. The encoded data is its own mini-stream
163
    // with the following layout (in little endian):
164
    //   GUID LanguageTypeGuid;
165
    //   GUID LanguageVendorGuid;
166
    //   GUID DocumentTypeGuid;
167
    //   GUID HashFunctionGuid;
168
    //   uint32_t HashDataSize;
169
    //   uint32_t CompressedDataSize;
170
    // Followed by HashDataSize bytes containing a hash checksum,
171
    // followed by CompressedDataSize bytes containing source contents.
172
    //
173
    // CompressedDataSize can be 0, in this case only the hash data is present.
174
    // (CompressedDataSize is != 0 e.g. if `/embed` is passed to csc.exe.)
175
    // The compressed data format is:
176
    //   uint32_t UncompressedDataSize;
177
    // If UncompressedDataSize is 0, the data is stored uncompressed and
178
    // CompressedDataSize stores the uncompressed size.
179
    // If UncompressedDataSize is != 0, then the data is in raw deflate
180
    // encoding as described in rfc1951.
181
    //
182
    // A GUID is 16 bytes, stored in the usual
183
    //   uint32_t
184
    //   uint16_t
185
    //   uint16_t
186
    //   uint8_t[24]
187
    // layout.
188
    //
189
    // Well-known GUIDs for LanguageTypeGuid are:
190
    //   63a08714-fc37-11d2-904c-00c04fa302a1 C
191
    //   3a12d0b7-c26c-11d0-b442-00a0244a1dd2 C++
192
    //   3f5162f8-07c6-11d3-9053-00c04fa302a1 C#
193
    //   af046cd1-d0e1-11d2-977c-00a0c9b4d50c Cobol
194
    //   ab4f38c9-b6e6-43ba-be3b-58080b2ccce3 F#
195
    //   3a12d0b4-c26c-11d0-b442-00a0244a1dd2 Java
196
    //   3a12d0b6-c26c-11d0-b442-00a0244a1dd2 JScript
197
    //   af046cd2-d0e1-11d2-977c-00a0c9b4d50c Pascal
198
    //   3a12d0b8-c26c-11d0-b442-00a0244a1dd2 Visual Basic
199
    //
200
    // Well-known GUIDs for LanguageVendorGuid are:
201
    //   994b45c4-e6e9-11d2-903f-00c04fa302a1 Microsoft
202
    //
203
    // Well-known GUIDs for DocumentTypeGuid are:
204
    //   5a869d0b-6611-11d3-bd2a-0000f80849bd Text
205
    //
206
    // Well-known GUIDs for HashFunctionGuid are:
207
    //   406ea660-64cf-4c82-b6f0-42d48172a799 MD5    (HashDataSize is 16)
208
    //   ff1816ec-aa5e-4d10-87f7-6f4963833460 SHA1   (HashDataSize is 20)
209
    //   8829d00f-11b8-4213-878b-770e8597ac16 SHA256 (HashDataSize is 32)
210
    DotNet = 101,
211
  };
212
};
213
214
/// These values correspond to the CV_call_e enumeration, and are documented
215
/// at the following locations:
216
///   https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
217
///   https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
218
using PDB_CallingConv = codeview::CallingConvention;
219
220
/// These values correspond to the CV_CFL_LANG enumeration, and are documented
221
/// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
222
using PDB_Lang = codeview::SourceLanguage;
223
224
/// These values correspond to the DataKind enumeration, and are documented
225
/// here: https://msdn.microsoft.com/en-us/library/b2x2t313.aspx
226
enum class PDB_DataKind {
227
  Unknown,
228
  Local,
229
  StaticLocal,
230
  Param,
231
  ObjectPtr,
232
  FileStatic,
233
  Global,
234
  Member,
235
  StaticMember,
236
  Constant
237
};
238
239
/// These values correspond to the SymTagEnum enumeration, and are documented
240
/// here: https://msdn.microsoft.com/en-us/library/bkedss5f.aspx
241
enum class PDB_SymType {
242
  None,
243
  Exe,
244
  Compiland,
245
  CompilandDetails,
246
  CompilandEnv,
247
  Function,
248
  Block,
249
  Data,
250
  Annotation,
251
  Label,
252
  PublicSymbol,
253
  UDT,
254
  Enum,
255
  FunctionSig,
256
  PointerType,
257
  ArrayType,
258
  BuiltinType,
259
  Typedef,
260
  BaseClass,
261
  Friend,
262
  FunctionArg,
263
  FuncDebugStart,
264
  FuncDebugEnd,
265
  UsingNamespace,
266
  VTableShape,
267
  VTable,
268
  Custom,
269
  Thunk,
270
  CustomType,
271
  ManagedType,
272
  Dimension,
273
  CallSite,
274
  InlineSite,
275
  BaseInterface,
276
  VectorType,
277
  MatrixType,
278
  HLSLType,
279
  Caller,
280
  Callee,
281
  Export,
282
  HeapAllocationSite,
283
  CoffGroup,
284
  Inlinee,
285
  Max
286
};
287
288
/// These values correspond to the LocationType enumeration, and are documented
289
/// here: https://msdn.microsoft.com/en-us/library/f57kaez3.aspx
290
enum class PDB_LocType {
291
  Null,
292
  Static,
293
  TLS,
294
  RegRel,
295
  ThisRel,
296
  Enregistered,
297
  BitField,
298
  Slot,
299
  IlRel,
300
  MetaData,
301
  Constant,
302
  RegRelAliasIndir,
303
  Max
304
};
305
306
/// These values correspond to the UdtKind enumeration, and are documented
307
/// here: https://msdn.microsoft.com/en-us/library/wcstk66t.aspx
308
enum class PDB_UdtType { Struct, Class, Union, Interface };
309
310
/// These values correspond to the StackFrameTypeEnum enumeration, and are
311
/// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
312
enum class PDB_StackFrameType : uint16_t {
313
  FPO,
314
  KernelTrap,
315
  KernelTSS,
316
  EBP,
317
  FrameData,
318
  Unknown = 0xffff
319
};
320
321
/// These values correspond to the MemoryTypeEnum enumeration, and are
322
/// documented here: https://msdn.microsoft.com/en-us/library/ms165609.aspx.
323
enum class PDB_MemoryType : uint16_t {
324
  Code,
325
  Data,
326
  Stack,
327
  HeapCode,
328
  Any = 0xffff
329
};
330
331
/// These values correspond to the Basictype enumeration, and are documented
332
/// here: https://msdn.microsoft.com/en-us/library/4szdtzc3.aspx
333
enum class PDB_BuiltinType {
334
  None = 0,
335
  Void = 1,
336
  Char = 2,
337
  WCharT = 3,
338
  Int = 6,
339
  UInt = 7,
340
  Float = 8,
341
  BCD = 9,
342
  Bool = 10,
343
  Long = 13,
344
  ULong = 14,
345
  Currency = 25,
346
  Date = 26,
347
  Variant = 27,
348
  Complex = 28,
349
  Bitfield = 29,
350
  BSTR = 30,
351
  HResult = 31,
352
  Char16 = 32,
353
  Char32 = 33
354
};
355
356
/// These values correspond to the flags that can be combined to control the
357
/// return of an undecorated name for a C++ decorated name, and are documented
358
/// here: https://msdn.microsoft.com/en-us/library/kszfk0fs.aspx
359
enum PDB_UndnameFlags : uint32_t {
360
  Undname_Complete = 0x0,
361
  Undname_NoLeadingUnderscores = 0x1,
362
  Undname_NoMsKeywords = 0x2,
363
  Undname_NoFuncReturns = 0x4,
364
  Undname_NoAllocModel = 0x8,
365
  Undname_NoAllocLang = 0x10,
366
  Undname_Reserved1 = 0x20,
367
  Undname_Reserved2 = 0x40,
368
  Undname_NoThisType = 0x60,
369
  Undname_NoAccessSpec = 0x80,
370
  Undname_NoThrowSig = 0x100,
371
  Undname_NoMemberType = 0x200,
372
  Undname_NoReturnUDTModel = 0x400,
373
  Undname_32BitDecode = 0x800,
374
  Undname_NameOnly = 0x1000,
375
  Undname_TypeOnly = 0x2000,
376
  Undname_HaveParams = 0x4000,
377
  Undname_NoECSU = 0x8000,
378
  Undname_NoIdentCharCheck = 0x10000,
379
  Undname_NoPTR64 = 0x20000
380
};
381
382
enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 };
383
384
struct VersionInfo {
385
  uint32_t Major;
386
  uint32_t Minor;
387
  uint32_t Build;
388
  uint32_t QFE;
389
};
390
391
enum PDB_VariantType {
392
  Empty,
393
  Unknown,
394
  Int8,
395
  Int16,
396
  Int32,
397
  Int64,
398
  Single,
399
  Double,
400
  UInt8,
401
  UInt16,
402
  UInt32,
403
  UInt64,
404
  Bool,
405
  String
406
};
407
408
struct Variant {
409
0
  Variant() = default;
410
411
4
  explicit Variant(bool V) : Type(PDB_VariantType::Bool) { Value.Bool = V; }
412
6
  explicit Variant(int8_t V) : Type(PDB_VariantType::Int8) { Value.Int8 = V; }
413
6
  explicit Variant(int16_t V) : Type(PDB_VariantType::Int16) {
414
6
    Value.Int16 = V;
415
6
  }
416
128
  explicit Variant(int32_t V) : Type(PDB_VariantType::Int32) {
417
128
    Value.Int32 = V;
418
128
  }
419
6
  explicit Variant(int64_t V) : Type(PDB_VariantType::Int64) {
420
6
    Value.Int64 = V;
421
6
  }
422
0
  explicit Variant(float V) : Type(PDB_VariantType::Single) {
423
0
    Value.Single = V;
424
0
  }
425
0
  explicit Variant(double V) : Type(PDB_VariantType::Double) {
426
0
    Value.Double = V;
427
0
  }
428
4
  explicit Variant(uint8_t V) : Type(PDB_VariantType::UInt8) {
429
4
    Value.UInt8 = V;
430
4
  }
431
12
  explicit Variant(uint16_t V) : Type(PDB_VariantType::UInt16) {
432
12
    Value.UInt16 = V;
433
12
  }
434
8
  explicit Variant(uint32_t V) : Type(PDB_VariantType::UInt32) {
435
8
    Value.UInt32 = V;
436
8
  }
437
4
  explicit Variant(uint64_t V) : Type(PDB_VariantType::UInt64) {
438
4
    Value.UInt64 = V;
439
4
  }
440
441
0
  Variant(const Variant &Other) {
442
0
    *this = Other;
443
0
  }
444
445
178
  ~Variant() {
446
178
    if (Type == PDB_VariantType::String)
447
0
      delete[] Value.String;
448
178
  }
449
450
  PDB_VariantType Type = PDB_VariantType::Empty;
451
  union {
452
    bool Bool;
453
    int8_t Int8;
454
    int16_t Int16;
455
    int32_t Int32;
456
    int64_t Int64;
457
    float Single;
458
    double Double;
459
    uint8_t UInt8;
460
    uint16_t UInt16;
461
    uint32_t UInt32;
462
    uint64_t UInt64;
463
    char *String;
464
  } Value;
465
466
#define VARIANT_EQUAL_CASE(Enum)                                               \
467
  case PDB_VariantType::Enum:                                                  \
468
    return Value.Enum == Other.Value.Enum;
469
470
0
  bool operator==(const Variant &Other) const {
471
0
    if (Type != Other.Type)
472
0
      return false;
473
0
    switch (Type) {
474
0
      VARIANT_EQUAL_CASE(Bool)
475
0
      VARIANT_EQUAL_CASE(Int8)
476
0
      VARIANT_EQUAL_CASE(Int16)
477
0
      VARIANT_EQUAL_CASE(Int32)
478
0
      VARIANT_EQUAL_CASE(Int64)
479
0
      VARIANT_EQUAL_CASE(Single)
480
0
      VARIANT_EQUAL_CASE(Double)
481
0
      VARIANT_EQUAL_CASE(UInt8)
482
0
      VARIANT_EQUAL_CASE(UInt16)
483
0
      VARIANT_EQUAL_CASE(UInt32)
484
0
      VARIANT_EQUAL_CASE(UInt64)
485
0
      VARIANT_EQUAL_CASE(String)
486
0
    default:
487
0
      return true;
488
0
    }
489
0
  }
490
491
#undef VARIANT_EQUAL_CASE
492
493
0
  bool operator!=(const Variant &Other) const { return !(*this == Other); }
494
0
  Variant &operator=(const Variant &Other) {
495
0
    if (this == &Other)
496
0
      return *this;
497
0
    if (Type == PDB_VariantType::String)
498
0
      delete[] Value.String;
499
0
    Type = Other.Type;
500
0
    Value = Other.Value;
501
0
    if (Other.Type == PDB_VariantType::String &&
502
0
        Other.Value.String != nullptr) {
503
0
      Value.String = new char[strlen(Other.Value.String) + 1];
504
0
      ::strcpy(Value.String, Other.Value.String);
505
0
    }
506
0
    return *this;
507
0
  }
508
};
509
510
} // end namespace pdb
511
} // end namespace llvm
512
513
namespace std {
514
515
template <> struct hash<llvm::pdb::PDB_SymType> {
516
  using argument_type = llvm::pdb::PDB_SymType;
517
  using result_type = std::size_t;
518
519
32
  result_type operator()(const argument_type &Arg) const {
520
32
    return std::hash<int>()(static_cast<int>(Arg));
521
32
  }
522
};
523
524
} // end namespace std
525
526
#endif // LLVM_DEBUGINFO_PDB_PDBTYPES_H