1 //===- PDBTypes.h - Defines enums for various fields contained in PDB ----====//
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 #ifndef LLVM_DEBUGINFO_PDB_PDBTYPES_H
11 #define LLVM_DEBUGINFO_PDB_PDBTYPES_H
12 
13 #include "llvm/DebugInfo/CodeView/CodeView.h"
14 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
15 #include "llvm/DebugInfo/PDB/IPDBFrameData.h"
16 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
17 #include <cctype>
18 #include <cstddef>
19 #include <cstdint>
20 #include <cstring>
21 #include <functional>
22 
23 namespace llvm {
24 namespace pdb {
25 
26 typedef uint32_t SymIndexId;
27 
28 class IPDBDataStream;
29 class IPDBInjectedSource;
30 class IPDBLineNumber;
31 class IPDBSectionContrib;
32 class IPDBSourceFile;
33 class IPDBTable;
34 class PDBSymDumper;
35 class PDBSymbol;
36 class PDBSymbolExe;
37 class PDBSymbolCompiland;
38 class PDBSymbolCompilandDetails;
39 class PDBSymbolCompilandEnv;
40 class PDBSymbolFunc;
41 class PDBSymbolBlock;
42 class PDBSymbolData;
43 class PDBSymbolAnnotation;
44 class PDBSymbolLabel;
45 class PDBSymbolPublicSymbol;
46 class PDBSymbolTypeUDT;
47 class PDBSymbolTypeEnum;
48 class PDBSymbolTypeFunctionSig;
49 class PDBSymbolTypePointer;
50 class PDBSymbolTypeArray;
51 class PDBSymbolTypeBuiltin;
52 class PDBSymbolTypeTypedef;
53 class PDBSymbolTypeBaseClass;
54 class PDBSymbolTypeFriend;
55 class PDBSymbolTypeFunctionArg;
56 class PDBSymbolFuncDebugStart;
57 class PDBSymbolFuncDebugEnd;
58 class PDBSymbolUsingNamespace;
59 class PDBSymbolTypeVTableShape;
60 class PDBSymbolTypeVTable;
61 class PDBSymbolCustom;
62 class PDBSymbolThunk;
63 class PDBSymbolTypeCustom;
64 class PDBSymbolTypeManaged;
65 class PDBSymbolTypeDimension;
66 class PDBSymbolUnknown;
67 
68 using IPDBEnumSymbols = IPDBEnumChildren<PDBSymbol>;
69 using IPDBEnumSourceFiles = IPDBEnumChildren<IPDBSourceFile>;
70 using IPDBEnumDataStreams = IPDBEnumChildren<IPDBDataStream>;
71 using IPDBEnumLineNumbers = IPDBEnumChildren<IPDBLineNumber>;
72 using IPDBEnumTables = IPDBEnumChildren<IPDBTable>;
73 using IPDBEnumInjectedSources = IPDBEnumChildren<IPDBInjectedSource>;
74 using IPDBEnumSectionContribs = IPDBEnumChildren<IPDBSectionContrib>;
75 using IPDBEnumFrameData = IPDBEnumChildren<IPDBFrameData>;
76 
77 /// Specifies which PDB reader implementation is to be used.  Only a value
78 /// of PDB_ReaderType::DIA is currently supported, but Native is in the works.
79 enum class PDB_ReaderType {
80   DIA = 0,
81   Native = 1,
82 };
83 
84 /// An enumeration indicating the type of data contained in this table.
85 enum class PDB_TableType {
86   TableInvalid = 0,
87   Symbols,
88   SourceFiles,
89   LineNumbers,
90   SectionContribs,
91   Segments,
92   InjectedSources,
93   FrameData,
94   InputAssemblyFiles,
95   Dbg
96 };
97 
98 /// Defines flags used for enumerating child symbols.  This corresponds to the
99 /// NameSearchOptions enumeration which is documented here:
100 /// https://msdn.microsoft.com/en-us/library/yat28ads.aspx
101 enum PDB_NameSearchFlags {
102   NS_Default = 0x0,
103   NS_CaseSensitive = 0x1,
104   NS_CaseInsensitive = 0x2,
105   NS_FileNameExtMatch = 0x4,
106   NS_Regex = 0x8,
107   NS_UndecoratedName = 0x10,
108 
109   // For backward compatibility.
110   NS_CaseInFileNameExt = NS_CaseInsensitive | NS_FileNameExtMatch,
111   NS_CaseRegex = NS_Regex | NS_CaseSensitive,
112   NS_CaseInRex = NS_Regex | NS_CaseInsensitive
113 };
114 
115 /// Specifies the hash algorithm that a source file from a PDB was hashed with.
116 /// This corresponds to the CV_SourceChksum_t enumeration and are documented
117 /// here: https://msdn.microsoft.com/en-us/library/e96az21x.aspx
118 enum class PDB_Checksum { None = 0, MD5 = 1, SHA1 = 2, SHA256 = 3 };
119 
120 /// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented
121 /// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
122 using PDB_Cpu = codeview::CPUType;
123 
124 enum class PDB_Machine {
125   Invalid = 0xffff,
126   Unknown = 0x0,
127   Am33 = 0x13,
128   Amd64 = 0x8664,
129   Arm = 0x1C0,
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 enum class PDB_SourceCompression {
150   None,
151   RunLengthEncoded,
152   Huffman,
153   LZ,
154 };
155 
156 /// These values correspond to the CV_call_e enumeration, and are documented
157 /// at the following locations:
158 ///   https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
159 ///   https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
160 using PDB_CallingConv = codeview::CallingConvention;
161 
162 /// These values correspond to the CV_CFL_LANG enumeration, and are documented
163 /// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
164 using PDB_Lang = codeview::SourceLanguage;
165 
166 /// These values correspond to the DataKind enumeration, and are documented
167 /// here: https://msdn.microsoft.com/en-us/library/b2x2t313.aspx
168 enum class PDB_DataKind {
169   Unknown,
170   Local,
171   StaticLocal,
172   Param,
173   ObjectPtr,
174   FileStatic,
175   Global,
176   Member,
177   StaticMember,
178   Constant
179 };
180 
181 /// These values correspond to the SymTagEnum enumeration, and are documented
182 /// here: https://msdn.microsoft.com/en-us/library/bkedss5f.aspx
183 enum class PDB_SymType {
184   None,
185   Exe,
186   Compiland,
187   CompilandDetails,
188   CompilandEnv,
189   Function,
190   Block,
191   Data,
192   Annotation,
193   Label,
194   PublicSymbol,
195   UDT,
196   Enum,
197   FunctionSig,
198   PointerType,
199   ArrayType,
200   BuiltinType,
201   Typedef,
202   BaseClass,
203   Friend,
204   FunctionArg,
205   FuncDebugStart,
206   FuncDebugEnd,
207   UsingNamespace,
208   VTableShape,
209   VTable,
210   Custom,
211   Thunk,
212   CustomType,
213   ManagedType,
214   Dimension,
215   CallSite,
216   InlineSite,
217   BaseInterface,
218   VectorType,
219   MatrixType,
220   HLSLType,
221   Caller,
222   Callee,
223   Export,
224   HeapAllocationSite,
225   CoffGroup,
226   Inlinee,
227   Max
228 };
229 
230 /// These values correspond to the LocationType enumeration, and are documented
231 /// here: https://msdn.microsoft.com/en-us/library/f57kaez3.aspx
232 enum class PDB_LocType {
233   Null,
234   Static,
235   TLS,
236   RegRel,
237   ThisRel,
238   Enregistered,
239   BitField,
240   Slot,
241   IlRel,
242   MetaData,
243   Constant,
244   RegRelAliasIndir,
245   Max
246 };
247 
248 /// These values correspond to the UdtKind enumeration, and are documented
249 /// here: https://msdn.microsoft.com/en-us/library/wcstk66t.aspx
250 enum class PDB_UdtType { Struct, Class, Union, Interface };
251 
252 /// These values correspond to the StackFrameTypeEnum enumeration, and are
253 /// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
254 enum class PDB_StackFrameType : uint16_t {
255   FPO,
256   KernelTrap,
257   KernelTSS,
258   EBP,
259   FrameData,
260   Unknown = 0xffff
261 };
262 
263 /// These values correspond to the MemoryTypeEnum enumeration, and are
264 /// documented here: https://msdn.microsoft.com/en-us/library/ms165609.aspx.
265 enum class PDB_MemoryType : uint16_t {
266   Code,
267   Data,
268   Stack,
269   HeapCode,
270   Any = 0xffff
271 };
272 
273 /// These values correspond to the Basictype enumeration, and are documented
274 /// here: https://msdn.microsoft.com/en-us/library/4szdtzc3.aspx
275 enum class PDB_BuiltinType {
276   None = 0,
277   Void = 1,
278   Char = 2,
279   WCharT = 3,
280   Int = 6,
281   UInt = 7,
282   Float = 8,
283   BCD = 9,
284   Bool = 10,
285   Long = 13,
286   ULong = 14,
287   Currency = 25,
288   Date = 26,
289   Variant = 27,
290   Complex = 28,
291   Bitfield = 29,
292   BSTR = 30,
293   HResult = 31,
294   Char16 = 32,
295   Char32 = 33
296 };
297 
298 /// These values correspond to the flags that can be combined to control the
299 /// return of an undecorated name for a C++ decorated name, and are documented
300 /// here: https://msdn.microsoft.com/en-us/library/kszfk0fs.aspx
301 enum PDB_UndnameFlags : uint32_t {
302   Undname_Complete = 0x0,
303   Undname_NoLeadingUnderscores = 0x1,
304   Undname_NoMsKeywords = 0x2,
305   Undname_NoFuncReturns = 0x4,
306   Undname_NoAllocModel = 0x8,
307   Undname_NoAllocLang = 0x10,
308   Undname_Reserved1 = 0x20,
309   Undname_Reserved2 = 0x40,
310   Undname_NoThisType = 0x60,
311   Undname_NoAccessSpec = 0x80,
312   Undname_NoThrowSig = 0x100,
313   Undname_NoMemberType = 0x200,
314   Undname_NoReturnUDTModel = 0x400,
315   Undname_32BitDecode = 0x800,
316   Undname_NameOnly = 0x1000,
317   Undname_TypeOnly = 0x2000,
318   Undname_HaveParams = 0x4000,
319   Undname_NoECSU = 0x8000,
320   Undname_NoIdentCharCheck = 0x10000,
321   Undname_NoPTR64 = 0x20000
322 };
323 
324 enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 };
325 
326 struct VersionInfo {
327   uint32_t Major;
328   uint32_t Minor;
329   uint32_t Build;
330   uint32_t QFE;
331 };
332 
333 enum PDB_VariantType {
334   Empty,
335   Unknown,
336   Int8,
337   Int16,
338   Int32,
339   Int64,
340   Single,
341   Double,
342   UInt8,
343   UInt16,
344   UInt32,
345   UInt64,
346   Bool,
347   String
348 };
349 
350 struct Variant {
351   Variant() = default;
352 
VariantVariant353   explicit Variant(bool V) : Type(PDB_VariantType::Bool) { Value.Bool = V; }
VariantVariant354   explicit Variant(int8_t V) : Type(PDB_VariantType::Int8) { Value.Int8 = V; }
VariantVariant355   explicit Variant(int16_t V) : Type(PDB_VariantType::Int16) {
356     Value.Int16 = V;
357   }
VariantVariant358   explicit Variant(int32_t V) : Type(PDB_VariantType::Int32) {
359     Value.Int32 = V;
360   }
VariantVariant361   explicit Variant(int64_t V) : Type(PDB_VariantType::Int64) {
362     Value.Int64 = V;
363   }
VariantVariant364   explicit Variant(float V) : Type(PDB_VariantType::Single) {
365     Value.Single = V;
366   }
VariantVariant367   explicit Variant(double V) : Type(PDB_VariantType::Double) {
368     Value.Double = V;
369   }
VariantVariant370   explicit Variant(uint8_t V) : Type(PDB_VariantType::UInt8) {
371     Value.UInt8 = V;
372   }
VariantVariant373   explicit Variant(uint16_t V) : Type(PDB_VariantType::UInt16) {
374     Value.UInt16 = V;
375   }
VariantVariant376   explicit Variant(uint32_t V) : Type(PDB_VariantType::UInt32) {
377     Value.UInt32 = V;
378   }
VariantVariant379   explicit Variant(uint64_t V) : Type(PDB_VariantType::UInt64) {
380     Value.UInt64 = V;
381   }
382 
VariantVariant383   Variant(const Variant &Other) {
384     *this = Other;
385   }
386 
~VariantVariant387   ~Variant() {
388     if (Type == PDB_VariantType::String)
389       delete[] Value.String;
390   }
391 
392   PDB_VariantType Type = PDB_VariantType::Empty;
393   union {
394     bool Bool;
395     int8_t Int8;
396     int16_t Int16;
397     int32_t Int32;
398     int64_t Int64;
399     float Single;
400     double Double;
401     uint8_t UInt8;
402     uint16_t UInt16;
403     uint32_t UInt32;
404     uint64_t UInt64;
405     char *String;
406   } Value;
407 
408 #define VARIANT_EQUAL_CASE(Enum)                                               \
409   case PDB_VariantType::Enum:                                                  \
410     return Value.Enum == Other.Value.Enum;
411 
412   bool operator==(const Variant &Other) const {
413     if (Type != Other.Type)
414       return false;
415     switch (Type) {
416       VARIANT_EQUAL_CASE(Bool)
417       VARIANT_EQUAL_CASE(Int8)
418       VARIANT_EQUAL_CASE(Int16)
419       VARIANT_EQUAL_CASE(Int32)
420       VARIANT_EQUAL_CASE(Int64)
421       VARIANT_EQUAL_CASE(Single)
422       VARIANT_EQUAL_CASE(Double)
423       VARIANT_EQUAL_CASE(UInt8)
424       VARIANT_EQUAL_CASE(UInt16)
425       VARIANT_EQUAL_CASE(UInt32)
426       VARIANT_EQUAL_CASE(UInt64)
427       VARIANT_EQUAL_CASE(String)
428     default:
429       return true;
430     }
431   }
432 
433 #undef VARIANT_EQUAL_CASE
434 
435   bool operator!=(const Variant &Other) const { return !(*this == Other); }
436   Variant &operator=(const Variant &Other) {
437     if (this == &Other)
438       return *this;
439     if (Type == PDB_VariantType::String)
440       delete[] Value.String;
441     Type = Other.Type;
442     Value = Other.Value;
443     if (Other.Type == PDB_VariantType::String &&
444         Other.Value.String != nullptr) {
445       Value.String = new char[strlen(Other.Value.String) + 1];
446       ::strcpy(Value.String, Other.Value.String);
447     }
448     return *this;
449   }
450 };
451 
452 } // end namespace pdb
453 } // end namespace llvm
454 
455 namespace std {
456 
457 template <> struct hash<llvm::pdb::PDB_SymType> {
458   using argument_type = llvm::pdb::PDB_SymType;
459   using result_type = std::size_t;
460 
461   result_type operator()(const argument_type &Arg) const {
462     return std::hash<int>()(static_cast<int>(Arg));
463   }
464 };
465 
466 } // end namespace std
467 
468 #endif // LLVM_DEBUGINFO_PDB_PDBTYPES_H
469