• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/Config/llvm-config.h"
14 #include "llvm/DebugInfo/CodeView/CodeView.h"
15 #include <functional>
16 #include <cstdint>
17 #include <cstring>
18 
19 namespace llvm {
20 namespace pdb {
21 
22 class PDBSymDumper;
23 class PDBSymbol;
24 
25 class IPDBDataStream;
26 template <class T> class IPDBEnumChildren;
27 class IPDBLineNumber;
28 class IPDBRawSymbol;
29 class IPDBSession;
30 class IPDBSourceFile;
31 
32 typedef IPDBEnumChildren<PDBSymbol> IPDBEnumSymbols;
33 typedef IPDBEnumChildren<IPDBSourceFile> IPDBEnumSourceFiles;
34 typedef IPDBEnumChildren<IPDBDataStream> IPDBEnumDataStreams;
35 typedef IPDBEnumChildren<IPDBLineNumber> IPDBEnumLineNumbers;
36 
37 class PDBSymbolExe;
38 class PDBSymbolCompiland;
39 class PDBSymbolCompilandDetails;
40 class PDBSymbolCompilandEnv;
41 class PDBSymbolFunc;
42 class PDBSymbolBlock;
43 class PDBSymbolData;
44 class PDBSymbolAnnotation;
45 class PDBSymbolLabel;
46 class PDBSymbolPublicSymbol;
47 class PDBSymbolTypeUDT;
48 class PDBSymbolTypeEnum;
49 class PDBSymbolTypeFunctionSig;
50 class PDBSymbolTypePointer;
51 class PDBSymbolTypeArray;
52 class PDBSymbolTypeBuiltin;
53 class PDBSymbolTypeTypedef;
54 class PDBSymbolTypeBaseClass;
55 class PDBSymbolTypeFriend;
56 class PDBSymbolTypeFunctionArg;
57 class PDBSymbolFuncDebugStart;
58 class PDBSymbolFuncDebugEnd;
59 class PDBSymbolUsingNamespace;
60 class PDBSymbolTypeVTableShape;
61 class PDBSymbolTypeVTable;
62 class PDBSymbolCustom;
63 class PDBSymbolThunk;
64 class PDBSymbolTypeCustom;
65 class PDBSymbolTypeManaged;
66 class PDBSymbolTypeDimension;
67 class PDBSymbolUnknown;
68 
69 /// Specifies which PDB reader implementation is to be used.  Only a value
70 /// of PDB_ReaderType::DIA is supported.
71 enum class PDB_ReaderType {
72   DIA = 0,
73   Raw = 1,
74 };
75 
76 /// Defines a 128-bit unique identifier.  This maps to a GUID on Windows, but
77 /// is abstracted here for the purposes of non-Windows platforms that don't have
78 /// the GUID structure defined.
79 struct PDB_UniqueId {
80   char Guid[16];
81 };
82 
83 /// An enumeration indicating the type of data contained in this table.
84 enum class PDB_TableType {
85   Symbols,
86   SourceFiles,
87   LineNumbers,
88   SectionContribs,
89   Segments,
90   InjectedSources,
91   FrameData
92 };
93 
94 /// Defines flags used for enumerating child symbols.  This corresponds to the
95 /// NameSearchOptions enumeration which is documented here:
96 /// https://msdn.microsoft.com/en-us/library/yat28ads.aspx
97 enum PDB_NameSearchFlags {
98   NS_Default = 0x0,
99   NS_CaseSensitive = 0x1,
100   NS_CaseInsensitive = 0x2,
101   NS_FileNameExtMatch = 0x4,
102   NS_Regex = 0x8,
103   NS_UndecoratedName = 0x10
104 };
105 
106 /// Specifies the hash algorithm that a source file from a PDB was hashed with.
107 /// This corresponds to the CV_SourceChksum_t enumeration and are documented
108 /// here: https://msdn.microsoft.com/en-us/library/e96az21x.aspx
109 enum class PDB_Checksum { None = 0, MD5 = 1, SHA1 = 2 };
110 
111 /// These values correspond to the CV_CPU_TYPE_e enumeration, and are documented
112 /// here: https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
113 typedef codeview::CPUType PDB_Cpu;
114 
115 enum class PDB_Machine {
116   Invalid = 0xffff,
117   Unknown = 0x0,
118   Am33 = 0x13,
119   Amd64 = 0x8664,
120   Arm = 0x1C0,
121   ArmNT = 0x1C4,
122   Ebc = 0xEBC,
123   x86 = 0x14C,
124   Ia64 = 0x200,
125   M32R = 0x9041,
126   Mips16 = 0x266,
127   MipsFpu = 0x366,
128   MipsFpu16 = 0x466,
129   PowerPC = 0x1F0,
130   PowerPCFP = 0x1F1,
131   R4000 = 0x166,
132   SH3 = 0x1A2,
133   SH3DSP = 0x1A3,
134   SH4 = 0x1A6,
135   SH5 = 0x1A8,
136   Thumb = 0x1C2,
137   WceMipsV2 = 0x169
138 };
139 
140 /// These values correspond to the CV_call_e enumeration, and are documented
141 /// at the following locations:
142 ///   https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
143 ///   https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
144 ///
145 typedef codeview::CallingConvention PDB_CallingConv;
146 
147 /// These values correspond to the CV_CFL_LANG enumeration, and are documented
148 /// here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx
149 typedef codeview::SourceLanguage PDB_Lang;
150 
151 /// These values correspond to the DataKind enumeration, and are documented
152 /// here: https://msdn.microsoft.com/en-us/library/b2x2t313.aspx
153 enum class PDB_DataKind {
154   Unknown,
155   Local,
156   StaticLocal,
157   Param,
158   ObjectPtr,
159   FileStatic,
160   Global,
161   Member,
162   StaticMember,
163   Constant
164 };
165 
166 /// These values correspond to the SymTagEnum enumeration, and are documented
167 /// here: https://msdn.microsoft.com/en-us/library/bkedss5f.aspx
168 enum class PDB_SymType {
169   None,
170   Exe,
171   Compiland,
172   CompilandDetails,
173   CompilandEnv,
174   Function,
175   Block,
176   Data,
177   Annotation,
178   Label,
179   PublicSymbol,
180   UDT,
181   Enum,
182   FunctionSig,
183   PointerType,
184   ArrayType,
185   BuiltinType,
186   Typedef,
187   BaseClass,
188   Friend,
189   FunctionArg,
190   FuncDebugStart,
191   FuncDebugEnd,
192   UsingNamespace,
193   VTableShape,
194   VTable,
195   Custom,
196   Thunk,
197   CustomType,
198   ManagedType,
199   Dimension,
200   Max
201 };
202 
203 /// These values correspond to the LocationType enumeration, and are documented
204 /// here: https://msdn.microsoft.com/en-us/library/f57kaez3.aspx
205 enum class PDB_LocType {
206   Null,
207   Static,
208   TLS,
209   RegRel,
210   ThisRel,
211   Enregistered,
212   BitField,
213   Slot,
214   IlRel,
215   MetaData,
216   Constant,
217   Max
218 };
219 
220 /// These values correspond to the UdtKind enumeration, and are documented
221 /// here: https://msdn.microsoft.com/en-us/library/wcstk66t.aspx
222 enum class PDB_UdtType { Struct, Class, Union, Interface };
223 
224 /// These values correspond to the StackFrameTypeEnum enumeration, and are
225 /// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
226 enum class PDB_StackFrameType { FPO, KernelTrap, KernelTSS, EBP, FrameData };
227 
228 /// These values correspond to the StackFrameTypeEnum enumeration, and are
229 /// documented here: https://msdn.microsoft.com/en-us/library/bc5207xw.aspx.
230 enum class PDB_MemoryType { Code, Data, Stack, HeapCode };
231 
232 /// These values correspond to the Basictype enumeration, and are documented
233 /// here: https://msdn.microsoft.com/en-us/library/4szdtzc3.aspx
234 enum class PDB_BuiltinType {
235   None = 0,
236   Void = 1,
237   Char = 2,
238   WCharT = 3,
239   Int = 6,
240   UInt = 7,
241   Float = 8,
242   BCD = 9,
243   Bool = 10,
244   Long = 13,
245   ULong = 14,
246   Currency = 25,
247   Date = 26,
248   Variant = 27,
249   Complex = 28,
250   Bitfield = 29,
251   BSTR = 30,
252   HResult = 31
253 };
254 
255 enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 };
256 
257 struct VersionInfo {
258   uint32_t Major;
259   uint32_t Minor;
260   uint32_t Build;
261   uint32_t QFE;
262 };
263 
264 enum PDB_VariantType {
265   Empty,
266   Unknown,
267   Int8,
268   Int16,
269   Int32,
270   Int64,
271   Single,
272   Double,
273   UInt8,
274   UInt16,
275   UInt32,
276   UInt64,
277   Bool,
278   String
279 };
280 
281 struct Variant {
VariantVariant282   Variant() : Type(PDB_VariantType::Empty) {}
283 
VariantVariant284   Variant(const Variant &Other) : Type(PDB_VariantType::Empty) {
285     *this = Other;
286   }
287 
~VariantVariant288   ~Variant() {
289     if (Type == PDB_VariantType::String)
290       delete[] Value.String;
291   }
292 
293   PDB_VariantType Type;
294   union {
295     bool Bool;
296     int8_t Int8;
297     int16_t Int16;
298     int32_t Int32;
299     int64_t Int64;
300     float Single;
301     double Double;
302     uint8_t UInt8;
303     uint16_t UInt16;
304     uint32_t UInt32;
305     uint64_t UInt64;
306     char *String;
307   } Value;
308 
309 #define VARIANT_EQUAL_CASE(Enum)                                               \
310   case PDB_VariantType::Enum:                                                  \
311     return Value.Enum == Other.Value.Enum;
312 
313   bool operator==(const Variant &Other) const {
314     if (Type != Other.Type)
315       return false;
316     switch (Type) {
317       VARIANT_EQUAL_CASE(Bool)
318       VARIANT_EQUAL_CASE(Int8)
319       VARIANT_EQUAL_CASE(Int16)
320       VARIANT_EQUAL_CASE(Int32)
321       VARIANT_EQUAL_CASE(Int64)
322       VARIANT_EQUAL_CASE(Single)
323       VARIANT_EQUAL_CASE(Double)
324       VARIANT_EQUAL_CASE(UInt8)
325       VARIANT_EQUAL_CASE(UInt16)
326       VARIANT_EQUAL_CASE(UInt32)
327       VARIANT_EQUAL_CASE(UInt64)
328       VARIANT_EQUAL_CASE(String)
329     default:
330       return true;
331     }
332   }
333 
334 #undef VARIANT_EQUAL_CASE
335 
336   bool operator!=(const Variant &Other) const { return !(*this == Other); }
337   Variant &operator=(const Variant &Other) {
338     if (this == &Other)
339       return *this;
340     if (Type == PDB_VariantType::String)
341       delete[] Value.String;
342     Type = Other.Type;
343     Value = Other.Value;
344     if (Other.Type == PDB_VariantType::String &&
345         Other.Value.String != nullptr) {
346       Value.String = new char[strlen(Other.Value.String) + 1];
347       ::strcpy(Value.String, Other.Value.String);
348     }
349     return *this;
350   }
351 };
352 
353 } // end namespace llvm
354 }
355 
356 namespace std {
357 template <> struct hash<llvm::pdb::PDB_SymType> {
358   typedef llvm::pdb::PDB_SymType argument_type;
359   typedef std::size_t result_type;
360 
361   result_type operator()(const argument_type &Arg) const {
362     return std::hash<int>()(static_cast<int>(Arg));
363   }
364 };
365 } // end namespace std
366 
367 #endif // LLVM_DEBUGINFO_PDB_PDBTYPES_H
368