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