/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Serialization/ModuleFile.h
Line | Count | Source |
1 | | //===- ModuleFile.h - Module file description -------------------*- 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 | | // This file defines the Module class, which describes a module that has |
10 | | // been loaded from an AST file. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_CLANG_SERIALIZATION_MODULEFILE_H |
15 | | #define LLVM_CLANG_SERIALIZATION_MODULEFILE_H |
16 | | |
17 | | #include "clang/Basic/FileManager.h" |
18 | | #include "clang/Basic/Module.h" |
19 | | #include "clang/Basic/SourceLocation.h" |
20 | | #include "clang/Serialization/ASTBitCodes.h" |
21 | | #include "clang/Serialization/ContinuousRangeMap.h" |
22 | | #include "clang/Serialization/ModuleFileExtension.h" |
23 | | #include "llvm/ADT/DenseMap.h" |
24 | | #include "llvm/ADT/PointerIntPair.h" |
25 | | #include "llvm/ADT/SetVector.h" |
26 | | #include "llvm/ADT/SmallVector.h" |
27 | | #include "llvm/ADT/StringRef.h" |
28 | | #include "llvm/Bitstream/BitstreamReader.h" |
29 | | #include "llvm/Support/Endian.h" |
30 | | #include <cassert> |
31 | | #include <cstdint> |
32 | | #include <memory> |
33 | | #include <string> |
34 | | #include <vector> |
35 | | |
36 | | namespace clang { |
37 | | |
38 | | namespace serialization { |
39 | | |
40 | | /// Specifies the kind of module that has been loaded. |
41 | | enum ModuleKind { |
42 | | /// File is an implicitly-loaded module. |
43 | | MK_ImplicitModule, |
44 | | |
45 | | /// File is an explicitly-loaded module. |
46 | | MK_ExplicitModule, |
47 | | |
48 | | /// File is a PCH file treated as such. |
49 | | MK_PCH, |
50 | | |
51 | | /// File is a PCH file treated as the preamble. |
52 | | MK_Preamble, |
53 | | |
54 | | /// File is a PCH file treated as the actual main file. |
55 | | MK_MainFile, |
56 | | |
57 | | /// File is from a prebuilt module path. |
58 | | MK_PrebuiltModule |
59 | | }; |
60 | | |
61 | | /// The input file that has been loaded from this AST file, along with |
62 | | /// bools indicating whether this was an overridden buffer or if it was |
63 | | /// out-of-date or not-found. |
64 | | class InputFile { |
65 | | enum { |
66 | | Overridden = 1, |
67 | | OutOfDate = 2, |
68 | | NotFound = 3 |
69 | | }; |
70 | | llvm::PointerIntPair<const FileEntryRef::MapEntry *, 2, unsigned> Val; |
71 | | |
72 | | public: |
73 | 1.25M | InputFile() = default; |
74 | | |
75 | | InputFile(FileEntryRef File, bool isOverridden = false, |
76 | 829k | bool isOutOfDate = false) { |
77 | 829k | assert(!(isOverridden && isOutOfDate) && |
78 | 829k | "an overridden cannot be out-of-date"); |
79 | 829k | unsigned intVal = 0; |
80 | 829k | if (isOverridden) |
81 | 658 | intVal = Overridden; |
82 | 829k | else if (isOutOfDate) |
83 | 35 | intVal = OutOfDate; |
84 | 829k | Val.setPointerAndInt(&File.getMapEntry(), intVal); |
85 | 829k | } |
86 | | |
87 | 3 | static InputFile getNotFound() { |
88 | 3 | InputFile File; |
89 | 3 | File.Val.setInt(NotFound); |
90 | 3 | return File; |
91 | 3 | } |
92 | | |
93 | 2.24M | OptionalFileEntryRefDegradesToFileEntryPtr getFile() const { |
94 | 2.24M | if (auto *P = Val.getPointer()) |
95 | 1.41M | return FileEntryRef(*P); |
96 | 830k | return None; |
97 | 830k | } |
98 | 367k | bool isOverridden() const { return Val.getInt() == Overridden; } |
99 | 755k | bool isOutOfDate() const { return Val.getInt() == OutOfDate; } |
100 | 830k | bool isNotFound() const { return Val.getInt() == NotFound; } |
101 | | }; |
102 | | |
103 | | /// Information about a module that has been loaded by the ASTReader. |
104 | | /// |
105 | | /// Each instance of the Module class corresponds to a single AST file, which |
106 | | /// may be a precompiled header, precompiled preamble, a module, or an AST file |
107 | | /// of some sort loaded as the main file, all of which are specific formulations |
108 | | /// of the general notion of a "module". A module may depend on any number of |
109 | | /// other modules. |
110 | | class ModuleFile { |
111 | | public: |
112 | | ModuleFile(ModuleKind Kind, unsigned Generation) |
113 | 18.6k | : Kind(Kind), Generation(Generation) {} |
114 | | ~ModuleFile(); |
115 | | |
116 | | // === General information === |
117 | | |
118 | | /// The index of this module in the list of modules. |
119 | | unsigned Index = 0; |
120 | | |
121 | | /// The type of this module. |
122 | | ModuleKind Kind; |
123 | | |
124 | | /// The file name of the module file. |
125 | | std::string FileName; |
126 | | |
127 | | /// The name of the module. |
128 | | std::string ModuleName; |
129 | | |
130 | | /// The base directory of the module. |
131 | | std::string BaseDirectory; |
132 | | |
133 | 13.3k | std::string getTimestampFilename() const { |
134 | 13.3k | return FileName + ".timestamp"; |
135 | 13.3k | } |
136 | | |
137 | | /// The original source file name that was used to build the |
138 | | /// primary AST file, which may have been modified for |
139 | | /// relocatable-pch support. |
140 | | std::string OriginalSourceFileName; |
141 | | |
142 | | /// The actual original source file name that was used to |
143 | | /// build this AST file. |
144 | | std::string ActualOriginalSourceFileName; |
145 | | |
146 | | /// The file ID for the original source file that was used to |
147 | | /// build this AST file. |
148 | | FileID OriginalSourceFileID; |
149 | | |
150 | | /// The directory that the PCH was originally created in. Used to |
151 | | /// allow resolving headers even after headers+PCH was moved to a new path. |
152 | | std::string OriginalDir; |
153 | | |
154 | | std::string ModuleMapPath; |
155 | | |
156 | | /// Whether this precompiled header is a relocatable PCH file. |
157 | | bool RelocatablePCH = false; |
158 | | |
159 | | /// Whether timestamps are included in this module file. |
160 | | bool HasTimestamps = false; |
161 | | |
162 | | /// Whether the top-level module has been read from the AST file. |
163 | | bool DidReadTopLevelSubmodule = false; |
164 | | |
165 | | /// The file entry for the module file. |
166 | | OptionalFileEntryRefDegradesToFileEntryPtr File; |
167 | | |
168 | | /// The signature of the module file, which may be used instead of the size |
169 | | /// and modification time to identify this particular file. |
170 | | ASTFileSignature Signature; |
171 | | |
172 | | /// The signature of the AST block of the module file, this can be used to |
173 | | /// unique module files based on AST contents. |
174 | | ASTFileSignature ASTBlockHash; |
175 | | |
176 | | /// Whether this module has been directly imported by the |
177 | | /// user. |
178 | | bool DirectlyImported = false; |
179 | | |
180 | | /// The generation of which this module file is a part. |
181 | | unsigned Generation; |
182 | | |
183 | | /// The memory buffer that stores the data associated with |
184 | | /// this AST file, owned by the InMemoryModuleCache. |
185 | | llvm::MemoryBuffer *Buffer; |
186 | | |
187 | | /// The size of this file, in bits. |
188 | | uint64_t SizeInBits = 0; |
189 | | |
190 | | /// The global bit offset (or base) of this module |
191 | | uint64_t GlobalBitOffset = 0; |
192 | | |
193 | | /// The bit offset of the AST block of this module. |
194 | | uint64_t ASTBlockStartOffset = 0; |
195 | | |
196 | | /// The serialized bitstream data for this file. |
197 | | StringRef Data; |
198 | | |
199 | | /// The main bitstream cursor for the main block. |
200 | | llvm::BitstreamCursor Stream; |
201 | | |
202 | | /// The source location where the module was explicitly or implicitly |
203 | | /// imported in the local translation unit. |
204 | | /// |
205 | | /// If module A depends on and imports module B, both modules will have the |
206 | | /// same DirectImportLoc, but different ImportLoc (B's ImportLoc will be a |
207 | | /// source location inside module A). |
208 | | /// |
209 | | /// WARNING: This is largely useless. It doesn't tell you when a module was |
210 | | /// made visible, just when the first submodule of that module was imported. |
211 | | SourceLocation DirectImportLoc; |
212 | | |
213 | | /// The source location where this module was first imported. |
214 | | SourceLocation ImportLoc; |
215 | | |
216 | | /// The first source location in this module. |
217 | | SourceLocation FirstLoc; |
218 | | |
219 | | /// The list of extension readers that are attached to this module |
220 | | /// file. |
221 | | std::vector<std::unique_ptr<ModuleFileExtensionReader>> ExtensionReaders; |
222 | | |
223 | | /// The module offset map data for this file. If non-empty, the various |
224 | | /// ContinuousRangeMaps described below have not yet been populated. |
225 | | StringRef ModuleOffsetMap; |
226 | | |
227 | | // === Input Files === |
228 | | |
229 | | /// The cursor to the start of the input-files block. |
230 | | llvm::BitstreamCursor InputFilesCursor; |
231 | | |
232 | | /// Offsets for all of the input file entries in the AST file. |
233 | | const llvm::support::unaligned_uint64_t *InputFileOffsets = nullptr; |
234 | | |
235 | | /// The input files that have been loaded from this AST file. |
236 | | std::vector<InputFile> InputFilesLoaded; |
237 | | |
238 | | // All user input files reside at the index range [0, NumUserInputFiles), and |
239 | | // system input files reside at [NumUserInputFiles, InputFilesLoaded.size()). |
240 | | unsigned NumUserInputFiles = 0; |
241 | | |
242 | | /// If non-zero, specifies the time when we last validated input |
243 | | /// files. Zero means we never validated them. |
244 | | /// |
245 | | /// The time is specified in seconds since the start of the Epoch. |
246 | | uint64_t InputFilesValidationTimestamp = 0; |
247 | | |
248 | | // === Source Locations === |
249 | | |
250 | | /// Cursor used to read source location entries. |
251 | | llvm::BitstreamCursor SLocEntryCursor; |
252 | | |
253 | | /// The bit offset to the start of the SOURCE_MANAGER_BLOCK. |
254 | | uint64_t SourceManagerBlockStartOffset = 0; |
255 | | |
256 | | /// The number of source location entries in this AST file. |
257 | | unsigned LocalNumSLocEntries = 0; |
258 | | |
259 | | /// The base ID in the source manager's view of this module. |
260 | | int SLocEntryBaseID = 0; |
261 | | |
262 | | /// The base offset in the source manager's view of this module. |
263 | | unsigned SLocEntryBaseOffset = 0; |
264 | | |
265 | | /// Base file offset for the offsets in SLocEntryOffsets. Real file offset |
266 | | /// for the entry is SLocEntryOffsetsBase + SLocEntryOffsets[i]. |
267 | | uint64_t SLocEntryOffsetsBase = 0; |
268 | | |
269 | | /// Offsets for all of the source location entries in the |
270 | | /// AST file. |
271 | | const uint32_t *SLocEntryOffsets = nullptr; |
272 | | |
273 | | /// SLocEntries that we're going to preload. |
274 | | SmallVector<uint64_t, 4> PreloadSLocEntries; |
275 | | |
276 | | /// Remapping table for source locations in this module. |
277 | | ContinuousRangeMap<uint32_t, int, 2> SLocRemap; |
278 | | |
279 | | // === Identifiers === |
280 | | |
281 | | /// The number of identifiers in this AST file. |
282 | | unsigned LocalNumIdentifiers = 0; |
283 | | |
284 | | /// Offsets into the identifier table data. |
285 | | /// |
286 | | /// This array is indexed by the identifier ID (-1), and provides |
287 | | /// the offset into IdentifierTableData where the string data is |
288 | | /// stored. |
289 | | const uint32_t *IdentifierOffsets = nullptr; |
290 | | |
291 | | /// Base identifier ID for identifiers local to this module. |
292 | | serialization::IdentID BaseIdentifierID = 0; |
293 | | |
294 | | /// Remapping table for identifier IDs in this module. |
295 | | ContinuousRangeMap<uint32_t, int, 2> IdentifierRemap; |
296 | | |
297 | | /// Actual data for the on-disk hash table of identifiers. |
298 | | /// |
299 | | /// This pointer points into a memory buffer, where the on-disk hash |
300 | | /// table for identifiers actually lives. |
301 | | const char *IdentifierTableData = nullptr; |
302 | | |
303 | | /// A pointer to an on-disk hash table of opaque type |
304 | | /// IdentifierHashTable. |
305 | | void *IdentifierLookupTable = nullptr; |
306 | | |
307 | | /// Offsets of identifiers that we're going to preload within |
308 | | /// IdentifierTableData. |
309 | | std::vector<unsigned> PreloadIdentifierOffsets; |
310 | | |
311 | | // === Macros === |
312 | | |
313 | | /// The cursor to the start of the preprocessor block, which stores |
314 | | /// all of the macro definitions. |
315 | | llvm::BitstreamCursor MacroCursor; |
316 | | |
317 | | /// The number of macros in this AST file. |
318 | | unsigned LocalNumMacros = 0; |
319 | | |
320 | | /// Base file offset for the offsets in MacroOffsets. Real file offset for |
321 | | /// the entry is MacroOffsetsBase + MacroOffsets[i]. |
322 | | uint64_t MacroOffsetsBase = 0; |
323 | | |
324 | | /// Offsets of macros in the preprocessor block. |
325 | | /// |
326 | | /// This array is indexed by the macro ID (-1), and provides |
327 | | /// the offset into the preprocessor block where macro definitions are |
328 | | /// stored. |
329 | | const uint32_t *MacroOffsets = nullptr; |
330 | | |
331 | | /// Base macro ID for macros local to this module. |
332 | | serialization::MacroID BaseMacroID = 0; |
333 | | |
334 | | /// Remapping table for macro IDs in this module. |
335 | | ContinuousRangeMap<uint32_t, int, 2> MacroRemap; |
336 | | |
337 | | /// The offset of the start of the set of defined macros. |
338 | | uint64_t MacroStartOffset = 0; |
339 | | |
340 | | // === Detailed PreprocessingRecord === |
341 | | |
342 | | /// The cursor to the start of the (optional) detailed preprocessing |
343 | | /// record block. |
344 | | llvm::BitstreamCursor PreprocessorDetailCursor; |
345 | | |
346 | | /// The offset of the start of the preprocessor detail cursor. |
347 | | uint64_t PreprocessorDetailStartOffset = 0; |
348 | | |
349 | | /// Base preprocessed entity ID for preprocessed entities local to |
350 | | /// this module. |
351 | | serialization::PreprocessedEntityID BasePreprocessedEntityID = 0; |
352 | | |
353 | | /// Remapping table for preprocessed entity IDs in this module. |
354 | | ContinuousRangeMap<uint32_t, int, 2> PreprocessedEntityRemap; |
355 | | |
356 | | const PPEntityOffset *PreprocessedEntityOffsets = nullptr; |
357 | | unsigned NumPreprocessedEntities = 0; |
358 | | |
359 | | /// Base ID for preprocessed skipped ranges local to this module. |
360 | | unsigned BasePreprocessedSkippedRangeID = 0; |
361 | | |
362 | | const PPSkippedRange *PreprocessedSkippedRangeOffsets = nullptr; |
363 | | unsigned NumPreprocessedSkippedRanges = 0; |
364 | | |
365 | | // === Header search information === |
366 | | |
367 | | /// The number of local HeaderFileInfo structures. |
368 | | unsigned LocalNumHeaderFileInfos = 0; |
369 | | |
370 | | /// Actual data for the on-disk hash table of header file |
371 | | /// information. |
372 | | /// |
373 | | /// This pointer points into a memory buffer, where the on-disk hash |
374 | | /// table for header file information actually lives. |
375 | | const char *HeaderFileInfoTableData = nullptr; |
376 | | |
377 | | /// The on-disk hash table that contains information about each of |
378 | | /// the header files. |
379 | | void *HeaderFileInfoTable = nullptr; |
380 | | |
381 | | // === Submodule information === |
382 | | |
383 | | /// The number of submodules in this module. |
384 | | unsigned LocalNumSubmodules = 0; |
385 | | |
386 | | /// Base submodule ID for submodules local to this module. |
387 | | serialization::SubmoduleID BaseSubmoduleID = 0; |
388 | | |
389 | | /// Remapping table for submodule IDs in this module. |
390 | | ContinuousRangeMap<uint32_t, int, 2> SubmoduleRemap; |
391 | | |
392 | | // === Selectors === |
393 | | |
394 | | /// The number of selectors new to this file. |
395 | | /// |
396 | | /// This is the number of entries in SelectorOffsets. |
397 | | unsigned LocalNumSelectors = 0; |
398 | | |
399 | | /// Offsets into the selector lookup table's data array |
400 | | /// where each selector resides. |
401 | | const uint32_t *SelectorOffsets = nullptr; |
402 | | |
403 | | /// Base selector ID for selectors local to this module. |
404 | | serialization::SelectorID BaseSelectorID = 0; |
405 | | |
406 | | /// Remapping table for selector IDs in this module. |
407 | | ContinuousRangeMap<uint32_t, int, 2> SelectorRemap; |
408 | | |
409 | | /// A pointer to the character data that comprises the selector table |
410 | | /// |
411 | | /// The SelectorOffsets table refers into this memory. |
412 | | const unsigned char *SelectorLookupTableData = nullptr; |
413 | | |
414 | | /// A pointer to an on-disk hash table of opaque type |
415 | | /// ASTSelectorLookupTable. |
416 | | /// |
417 | | /// This hash table provides the IDs of all selectors, and the associated |
418 | | /// instance and factory methods. |
419 | | void *SelectorLookupTable = nullptr; |
420 | | |
421 | | // === Declarations === |
422 | | |
423 | | /// DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block. |
424 | | /// It has read all the abbreviations at the start of the block and is ready |
425 | | /// to jump around with these in context. |
426 | | llvm::BitstreamCursor DeclsCursor; |
427 | | |
428 | | /// The offset to the start of the DECLTYPES_BLOCK block. |
429 | | uint64_t DeclsBlockStartOffset = 0; |
430 | | |
431 | | /// The number of declarations in this AST file. |
432 | | unsigned LocalNumDecls = 0; |
433 | | |
434 | | /// Offset of each declaration within the bitstream, indexed |
435 | | /// by the declaration ID (-1). |
436 | | const DeclOffset *DeclOffsets = nullptr; |
437 | | |
438 | | /// Base declaration ID for declarations local to this module. |
439 | | serialization::DeclID BaseDeclID = 0; |
440 | | |
441 | | /// Remapping table for declaration IDs in this module. |
442 | | ContinuousRangeMap<uint32_t, int, 2> DeclRemap; |
443 | | |
444 | | /// Mapping from the module files that this module file depends on |
445 | | /// to the base declaration ID for that module as it is understood within this |
446 | | /// module. |
447 | | /// |
448 | | /// This is effectively a reverse global-to-local mapping for declaration |
449 | | /// IDs, so that we can interpret a true global ID (for this translation unit) |
450 | | /// as a local ID (for this module file). |
451 | | llvm::DenseMap<ModuleFile *, serialization::DeclID> GlobalToLocalDeclIDs; |
452 | | |
453 | | /// Array of file-level DeclIDs sorted by file. |
454 | | const serialization::DeclID *FileSortedDecls = nullptr; |
455 | | unsigned NumFileSortedDecls = 0; |
456 | | |
457 | | /// Array of category list location information within this |
458 | | /// module file, sorted by the definition ID. |
459 | | const serialization::ObjCCategoriesInfo *ObjCCategoriesMap = nullptr; |
460 | | |
461 | | /// The number of redeclaration info entries in ObjCCategoriesMap. |
462 | | unsigned LocalNumObjCCategoriesInMap = 0; |
463 | | |
464 | | /// The Objective-C category lists for categories known to this |
465 | | /// module. |
466 | | SmallVector<uint64_t, 1> ObjCCategories; |
467 | | |
468 | | // === Types === |
469 | | |
470 | | /// The number of types in this AST file. |
471 | | unsigned LocalNumTypes = 0; |
472 | | |
473 | | /// Offset of each type within the bitstream, indexed by the |
474 | | /// type ID, or the representation of a Type*. |
475 | | const UnderalignedInt64 *TypeOffsets = nullptr; |
476 | | |
477 | | /// Base type ID for types local to this module as represented in |
478 | | /// the global type ID space. |
479 | | serialization::TypeID BaseTypeIndex = 0; |
480 | | |
481 | | /// Remapping table for type IDs in this module. |
482 | | ContinuousRangeMap<uint32_t, int, 2> TypeRemap; |
483 | | |
484 | | // === Miscellaneous === |
485 | | |
486 | | /// Diagnostic IDs and their mappings that the user changed. |
487 | | SmallVector<uint64_t, 8> PragmaDiagMappings; |
488 | | |
489 | | /// List of modules which depend on this module |
490 | | llvm::SetVector<ModuleFile *> ImportedBy; |
491 | | |
492 | | /// List of modules which this module depends on |
493 | | llvm::SetVector<ModuleFile *> Imports; |
494 | | |
495 | | /// Determine whether this module was directly imported at |
496 | | /// any point during translation. |
497 | 3.61k | bool isDirectlyImported() const { return DirectlyImported; } |
498 | | |
499 | | /// Is this a module file for a module (rather than a PCH or similar). |
500 | 7.53M | bool isModule() const { |
501 | 7.53M | return Kind == MK_ImplicitModule || Kind == MK_ExplicitModule655k || |
502 | 647k | Kind == MK_PrebuiltModule; |
503 | 7.53M | } |
504 | | |
505 | | /// Dump debugging output for this module. |
506 | | void dump(); |
507 | | }; |
508 | | |
509 | | } // namespace serialization |
510 | | |
511 | | } // namespace clang |
512 | | |
513 | | #endif // LLVM_CLANG_SERIALIZATION_MODULEFILE_H |