• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- RawTypes.h -----------------------------------------------*- C++ -*-===//
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_RAW_RAWTYPES_H
10 #define LLVM_DEBUGINFO_PDB_RAW_RAWTYPES_H
11 
12 #include "llvm/DebugInfo/CodeView/GUID.h"
13 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
14 #include "llvm/Support/Endian.h"
15 
16 namespace llvm {
17 namespace pdb {
18 // This struct is defined as "SO" in langapi/include/pdb.h.
19 struct SectionOffset {
20   support::ulittle32_t Off;
21   support::ulittle16_t Isect;
22   char Padding[2];
23 };
24 
25 /// Header of the hash tables found in the globals and publics sections.
26 /// Based on GSIHashHdr in
27 /// https://github.com/Microsoft/microsoft-pdb/blob/master/PDB/dbi/gsi.h
28 struct GSIHashHeader {
29   enum : unsigned {
30     HdrSignature = ~0U,
31     HdrVersion = 0xeffe0000 + 19990810,
32   };
33   support::ulittle32_t VerSignature;
34   support::ulittle32_t VerHdr;
35   support::ulittle32_t HrSize;
36   support::ulittle32_t NumBuckets;
37 };
38 
39 // This is HRFile.
40 struct PSHashRecord {
41   support::ulittle32_t Off; // Offset in the symbol record stream
42   support::ulittle32_t CRef;
43 };
44 
45 // This struct is defined as `SC` in include/dbicommon.h
46 struct SectionContrib {
47   support::ulittle16_t ISect;
48   char Padding[2];
49   support::little32_t Off;
50   support::little32_t Size;
51   support::ulittle32_t Characteristics;
52   support::ulittle16_t Imod;
53   char Padding2[2];
54   support::ulittle32_t DataCrc;
55   support::ulittle32_t RelocCrc;
56 };
57 
58 // This struct is defined as `SC2` in include/dbicommon.h
59 struct SectionContrib2 {
60   // To guarantee SectionContrib2 is standard layout, we cannot use inheritance.
61   SectionContrib Base;
62   support::ulittle32_t ISectCoff;
63 };
64 
65 // This corresponds to the `OMFSegMap` structure.
66 struct SecMapHeader {
67   support::ulittle16_t SecCount;    // Number of segment descriptors in table
68   support::ulittle16_t SecCountLog; // Number of logical segment descriptors
69 };
70 
71 // This corresponds to the `OMFSegMapDesc` structure.  The definition is not
72 // present in the reference implementation, but the layout is derived from
73 // code that accesses the fields.
74 struct SecMapEntry {
75   support::ulittle16_t Flags; // Descriptor flags.  See OMFSegDescFlags
76   support::ulittle16_t Ovl;   // Logical overlay number.
77   support::ulittle16_t Group; // Group index into descriptor array.
78   support::ulittle16_t Frame;
79   support::ulittle16_t SecName;       // Byte index of the segment or group name
80                                       // in the sstSegName table, or 0xFFFF.
81   support::ulittle16_t ClassName;     // Byte index of the class name in the
82                                       // sstSegName table, or 0xFFFF.
83   support::ulittle32_t Offset;        // Byte offset of the logical segment
84                                       // within the specified physical segment.
85                                       // If group is set in flags, offset is the
86                                       // offset of the group.
87   support::ulittle32_t SecByteLength; // Byte count of the segment or group.
88 };
89 
90 /// Some of the values are stored in bitfields.  Since this needs to be portable
91 /// across compilers and architectures (big / little endian in particular) we
92 /// can't use the actual structures below, but must instead do the shifting
93 /// and masking ourselves.  The struct definitions are provided for reference.
94 struct DbiFlags {
95   ///  uint16_t IncrementalLinking : 1; // True if linked incrementally
96   ///  uint16_t IsStripped : 1;         // True if private symbols were
97   ///  stripped.
98   ///  uint16_t HasCTypes : 1;          // True if linked with /debug:ctypes.
99   ///  uint16_t Reserved : 13;
100   static const uint16_t FlagIncrementalMask = 0x0001;
101   static const uint16_t FlagStrippedMask = 0x0002;
102   static const uint16_t FlagHasCTypesMask = 0x0004;
103 };
104 
105 struct DbiBuildNo {
106   ///  uint16_t MinorVersion : 8;
107   ///  uint16_t MajorVersion : 7;
108   ///  uint16_t NewVersionFormat : 1;
109   static const uint16_t BuildMinorMask = 0x00FF;
110   static const uint16_t BuildMinorShift = 0;
111 
112   static const uint16_t BuildMajorMask = 0x7F00;
113   static const uint16_t BuildMajorShift = 8;
114 
115   static const uint16_t NewVersionFormatMask = 0x8000;
116 };
117 
118 /// The fixed size header that appears at the beginning of the DBI Stream.
119 struct DbiStreamHeader {
120   support::little32_t VersionSignature;
121   support::ulittle32_t VersionHeader;
122 
123   /// How "old" is this DBI Stream. Should match the age of the PDB InfoStream.
124   support::ulittle32_t Age;
125 
126   /// Global symbol stream #
127   support::ulittle16_t GlobalSymbolStreamIndex;
128 
129   /// See DbiBuildNo structure.
130   support::ulittle16_t BuildNumber;
131 
132   /// Public symbols stream #
133   support::ulittle16_t PublicSymbolStreamIndex;
134 
135   /// version of mspdbNNN.dll
136   support::ulittle16_t PdbDllVersion;
137 
138   /// Symbol records stream #
139   support::ulittle16_t SymRecordStreamIndex;
140 
141   /// rbld number of mspdbNNN.dll
142   support::ulittle16_t PdbDllRbld;
143 
144   /// Size of module info stream
145   support::little32_t ModiSubstreamSize;
146 
147   /// Size of sec. contrib stream
148   support::little32_t SecContrSubstreamSize;
149 
150   /// Size of sec. map substream
151   support::little32_t SectionMapSize;
152 
153   /// Size of file info substream
154   support::little32_t FileInfoSize;
155 
156   /// Size of type server map
157   support::little32_t TypeServerSize;
158 
159   /// Index of MFC Type Server
160   support::ulittle32_t MFCTypeServerIndex;
161 
162   /// Size of DbgHeader info
163   support::little32_t OptionalDbgHdrSize;
164 
165   /// Size of EC stream (what is EC?)
166   support::little32_t ECSubstreamSize;
167 
168   /// See DbiFlags enum.
169   support::ulittle16_t Flags;
170 
171   /// See PDB_MachineType enum.
172   support::ulittle16_t MachineType;
173 
174   /// Pad to 64 bytes
175   support::ulittle32_t Reserved;
176 };
177 static_assert(sizeof(DbiStreamHeader) == 64, "Invalid DbiStreamHeader size!");
178 
179 /// The header preceding the File Info Substream of the DBI stream.
180 struct FileInfoSubstreamHeader {
181   /// Total # of modules, should match number of records in the ModuleInfo
182   /// substream.
183   support::ulittle16_t NumModules;
184 
185   /// Total # of source files. This value is not accurate because PDB actually
186   /// supports more than 64k source files, so we ignore it and compute the value
187   /// from other stream fields.
188   support::ulittle16_t NumSourceFiles;
189 
190   /// Following this header the File Info Substream is laid out as follows:
191   ///   ulittle16_t ModIndices[NumModules];
192   ///   ulittle16_t ModFileCounts[NumModules];
193   ///   ulittle32_t FileNameOffsets[NumSourceFiles];
194   ///   char Names[][NumSourceFiles];
195   /// with the caveat that `NumSourceFiles` cannot be trusted, so
196   /// it is computed by summing the `ModFileCounts` array.
197 };
198 
199 struct ModInfoFlags {
200   ///  uint16_t fWritten : 1;   // True if DbiModuleDescriptor is dirty
201   ///  uint16_t fECEnabled : 1; // Is EC symbolic info present?  (What is EC?)
202   ///  uint16_t unused : 6;     // Reserved
203   ///  uint16_t iTSM : 8;       // Type Server Index for this module
204   static const uint16_t HasECFlagMask = 0x2;
205 
206   static const uint16_t TypeServerIndexMask = 0xFF00;
207   static const uint16_t TypeServerIndexShift = 8;
208 };
209 
210 /// The header preceding each entry in the Module Info substream of the DBI
211 /// stream.  Corresponds to the type MODI in the reference implementation.
212 struct ModuleInfoHeader {
213   /// Currently opened module. This field is a pointer in the reference
214   /// implementation, but that won't work on 64-bit systems, and anyway it
215   /// doesn't make sense to read a pointer from a file. For now it is unused,
216   /// so just ignore it.
217   support::ulittle32_t Mod;
218 
219   /// First section contribution of this module.
220   SectionContrib SC;
221 
222   /// See ModInfoFlags definition.
223   support::ulittle16_t Flags;
224 
225   /// Stream Number of module debug info
226   support::ulittle16_t ModDiStream;
227 
228   /// Size of local symbol debug info in above stream
229   support::ulittle32_t SymBytes;
230 
231   /// Size of C11 line number info in above stream
232   support::ulittle32_t C11Bytes;
233 
234   /// Size of C13 line number info in above stream
235   support::ulittle32_t C13Bytes;
236 
237   /// Number of files contributing to this module
238   support::ulittle16_t NumFiles;
239 
240   /// Padding so the next field is 4-byte aligned.
241   char Padding1[2];
242 
243   /// Array of [0..NumFiles) DBI name buffer offsets.  In the reference
244   /// implementation this field is a pointer.  But since you can't portably
245   /// serialize a pointer, on 64-bit platforms they copy all the values except
246   /// this one into the 32-bit version of the struct and use that for
247   /// serialization.  Regardless, this field is unused, it is only there to
248   /// store a pointer that can be accessed at runtime.
249   support::ulittle32_t FileNameOffs;
250 
251   /// Name Index for src file name
252   support::ulittle32_t SrcFileNameNI;
253 
254   /// Name Index for path to compiler PDB
255   support::ulittle32_t PdbFilePathNI;
256 
257   /// Following this header are two zero terminated strings.
258   /// char ModuleName[];
259   /// char ObjFileName[];
260 };
261 
262 // This is PSGSIHDR struct defined in
263 // https://github.com/Microsoft/microsoft-pdb/blob/master/PDB/dbi/gsi.h
264 struct PublicsStreamHeader {
265   support::ulittle32_t SymHash;
266   support::ulittle32_t AddrMap;
267   support::ulittle32_t NumThunks;
268   support::ulittle32_t SizeOfThunk;
269   support::ulittle16_t ISectThunkTable;
270   char Padding[2];
271   support::ulittle32_t OffThunkTable;
272   support::ulittle32_t NumSections;
273 };
274 
275 // The header preceding the global TPI stream.
276 // This corresponds to `HDR` in PDB/dbi/tpi.h.
277 struct TpiStreamHeader {
278   struct EmbeddedBuf {
279     support::little32_t Off;
280     support::ulittle32_t Length;
281   };
282 
283   support::ulittle32_t Version;
284   support::ulittle32_t HeaderSize;
285   support::ulittle32_t TypeIndexBegin;
286   support::ulittle32_t TypeIndexEnd;
287   support::ulittle32_t TypeRecordBytes;
288 
289   // The following members correspond to `TpiHash` in PDB/dbi/tpi.h.
290   support::ulittle16_t HashStreamIndex;
291   support::ulittle16_t HashAuxStreamIndex;
292   support::ulittle32_t HashKeySize;
293   support::ulittle32_t NumHashBuckets;
294 
295   EmbeddedBuf HashValueBuffer;
296   EmbeddedBuf IndexOffsetBuffer;
297   EmbeddedBuf HashAdjBuffer;
298 };
299 
300 const uint32_t MinTpiHashBuckets = 0x1000;
301 const uint32_t MaxTpiHashBuckets = 0x40000;
302 
303 /// The header preceding the global PDB Stream (Stream 1)
304 struct InfoStreamHeader {
305   support::ulittle32_t Version;
306   support::ulittle32_t Signature;
307   support::ulittle32_t Age;
308   codeview::GUID Guid;
309 };
310 
311 /// The header preceding the /names stream.
312 struct PDBStringTableHeader {
313   support::ulittle32_t Signature;   // PDBStringTableSignature
314   support::ulittle32_t HashVersion; // 1 or 2
315   support::ulittle32_t ByteSize;    // Number of bytes of names buffer.
316 };
317 
318 const uint32_t PDBStringTableSignature = 0xEFFEEFFE;
319 
320 /// The header preceding the /src/headerblock stream.
321 struct SrcHeaderBlockHeader {
322   support::ulittle32_t Version; // PdbRaw_SrcHeaderBlockVer enumeration.
323   support::ulittle32_t Size;    // Size of entire stream.
324   uint64_t FileTime;            // Time stamp (Windows FILETIME format).
325   support::ulittle32_t Age;     // Age
326   uint8_t Padding[44];          // Pad to 64 bytes.
327 };
328 static_assert(sizeof(SrcHeaderBlockHeader) == 64, "Incorrect struct size!");
329 
330 /// A single file record entry within the /src/headerblock stream.
331 struct SrcHeaderBlockEntry {
332   support::ulittle32_t Size;     // Record Length.
333   support::ulittle32_t Version;  // PdbRaw_SrcHeaderBlockVer enumeration.
334   support::ulittle32_t CRC;      // CRC of the original file contents.
335   support::ulittle32_t FileSize; // Size of original source file.
336   support::ulittle32_t FileNI;   // String table index of file name.
337   support::ulittle32_t ObjNI;    // String table index of object name.
338   support::ulittle32_t VFileNI;  // String table index of virtual file name.
339   uint8_t Compression;           // PDB_SourceCompression enumeration.
340   uint8_t IsVirtual;             // Is this a virtual file (injected)?
341   short Padding;                 // Pad to 4 bytes.
342   char Reserved[8];
343 };
344 static_assert(sizeof(SrcHeaderBlockEntry) == 40, "Incorrect struct size!");
345 
346 } // namespace pdb
347 } // namespace llvm
348 
349 #endif
350