1//===--- Module.h - Module description --------------------------*- C++ -*-===//
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//  This file defines the Module class, which describes a module that has
11//  been loaded from an AST file.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_SERIALIZATION_MODULE_H
16#define LLVM_CLANG_SERIALIZATION_MODULE_H
17
18#include "clang/Basic/SourceLocation.h"
19#include "clang/Serialization/ASTBitCodes.h"
20#include "clang/Serialization/ContinuousRangeMap.h"
21#include "llvm/ADT/OwningPtr.h"
22#include "llvm/ADT/SetVector.h"
23#include "llvm/Bitcode/BitstreamReader.h"
24#include <string>
25
26namespace clang {
27
28class FileEntry;
29class DeclContext;
30class Module;
31template<typename Info> class OnDiskChainedHashTable;
32
33namespace serialization {
34
35namespace reader {
36  class ASTDeclContextNameLookupTrait;
37}
38
39/// \brief Specifies the kind of module that has been loaded.
40enum ModuleKind {
41  MK_Module,   ///< File is a module proper.
42  MK_PCH,      ///< File is a PCH file treated as such.
43  MK_Preamble, ///< File is a PCH file treated as the preamble.
44  MK_MainFile  ///< File is a PCH file treated as the actual main file.
45};
46
47/// \brief Information about the contents of a DeclContext.
48struct DeclContextInfo {
49  DeclContextInfo()
50    : NameLookupTableData(), LexicalDecls(), NumLexicalDecls() {}
51
52  OnDiskChainedHashTable<reader::ASTDeclContextNameLookupTrait>
53    *NameLookupTableData; // an ASTDeclContextNameLookupTable.
54  const KindDeclIDPair *LexicalDecls;
55  unsigned NumLexicalDecls;
56};
57
58/// \brief The input file that has been loaded from this AST file, along with
59/// bools indicating whether this was an overridden buffer or if it was
60/// out-of-date.
61class InputFile {
62  enum {
63    Overridden = 1,
64    OutOfDate = 2
65  };
66  llvm::PointerIntPair<const FileEntry *, 2, unsigned> Val;
67
68public:
69  InputFile() {}
70  InputFile(const FileEntry *File,
71            bool isOverridden = false, bool isOutOfDate = false) {
72    assert(!(isOverridden && isOutOfDate) &&
73           "an overridden cannot be out-of-date");
74    unsigned intVal = 0;
75    if (isOverridden)
76      intVal = Overridden;
77    else if (isOutOfDate)
78      intVal = OutOfDate;
79    Val.setPointerAndInt(File, intVal);
80  }
81
82  const FileEntry *getFile() const { return Val.getPointer(); }
83  bool isOverridden() const { return Val.getInt() == Overridden; }
84  bool isOutOfDate() const { return Val.getInt() == OutOfDate; }
85};
86
87/// \brief Information about a module that has been loaded by the ASTReader.
88///
89/// Each instance of the Module class corresponds to a single AST file, which
90/// may be a precompiled header, precompiled preamble, a module, or an AST file
91/// of some sort loaded as the main file, all of which are specific formulations
92/// of the general notion of a "module". A module may depend on any number of
93/// other modules.
94class ModuleFile {
95public:
96  ModuleFile(ModuleKind Kind, unsigned Generation);
97  ~ModuleFile();
98
99  // === General information ===
100
101  /// \brief The index of this module in the list of modules.
102  unsigned Index;
103
104  /// \brief The type of this module.
105  ModuleKind Kind;
106
107  /// \brief The file name of the module file.
108  std::string FileName;
109
110  /// \brief The original source file name that was used to build the
111  /// primary AST file, which may have been modified for
112  /// relocatable-pch support.
113  std::string OriginalSourceFileName;
114
115  /// \brief The actual original source file name that was used to
116  /// build this AST file.
117  std::string ActualOriginalSourceFileName;
118
119  /// \brief The file ID for the original source file that was used to
120  /// build this AST file.
121  FileID OriginalSourceFileID;
122
123  /// \brief The directory that the PCH was originally created in. Used to
124  /// allow resolving headers even after headers+PCH was moved to a new path.
125  std::string OriginalDir;
126
127  /// \brief Whether this precompiled header is a relocatable PCH file.
128  bool RelocatablePCH;
129
130  /// \brief The file entry for the module file.
131  const FileEntry *File;
132
133  /// \brief Whether this module has been directly imported by the
134  /// user.
135  bool DirectlyImported;
136
137  /// \brief The generation of which this module file is a part.
138  unsigned Generation;
139
140  /// \brief The memory buffer that stores the data associated with
141  /// this AST file.
142  OwningPtr<llvm::MemoryBuffer> Buffer;
143
144  /// \brief The size of this file, in bits.
145  uint64_t SizeInBits;
146
147  /// \brief The global bit offset (or base) of this module
148  uint64_t GlobalBitOffset;
149
150  /// \brief The bitstream reader from which we'll read the AST file.
151  llvm::BitstreamReader StreamFile;
152
153  /// \brief The main bitstream cursor for the main block.
154  llvm::BitstreamCursor Stream;
155
156  /// \brief The source location where the module was explicitly or implicitly
157  /// imported in the local translation unit.
158  ///
159  /// If module A depends on and imports module B, both modules will have the
160  /// same DirectImportLoc, but different ImportLoc (B's ImportLoc will be a
161  /// source location inside module A).
162  SourceLocation DirectImportLoc;
163
164  /// \brief The source location where this module was first imported.
165  SourceLocation ImportLoc;
166
167  /// \brief The first source location in this module.
168  SourceLocation FirstLoc;
169
170  // === Input Files ===
171  /// \brief The cursor to the start of the input-files block.
172  llvm::BitstreamCursor InputFilesCursor;
173
174  /// \brief Offsets for all of the input file entries in the AST file.
175  const uint32_t *InputFileOffsets;
176
177  /// \brief The input files that have been loaded from this AST file.
178  std::vector<InputFile> InputFilesLoaded;
179
180  // === Source Locations ===
181
182  /// \brief Cursor used to read source location entries.
183  llvm::BitstreamCursor SLocEntryCursor;
184
185  /// \brief The number of source location entries in this AST file.
186  unsigned LocalNumSLocEntries;
187
188  /// \brief The base ID in the source manager's view of this module.
189  int SLocEntryBaseID;
190
191  /// \brief The base offset in the source manager's view of this module.
192  unsigned SLocEntryBaseOffset;
193
194  /// \brief Offsets for all of the source location entries in the
195  /// AST file.
196  const uint32_t *SLocEntryOffsets;
197
198  /// \brief SLocEntries that we're going to preload.
199  SmallVector<uint64_t, 4> PreloadSLocEntries;
200
201  /// \brief Remapping table for source locations in this module.
202  ContinuousRangeMap<uint32_t, int, 2> SLocRemap;
203
204  // === Identifiers ===
205
206  /// \brief The number of identifiers in this AST file.
207  unsigned LocalNumIdentifiers;
208
209  /// \brief Offsets into the identifier table data.
210  ///
211  /// This array is indexed by the identifier ID (-1), and provides
212  /// the offset into IdentifierTableData where the string data is
213  /// stored.
214  const uint32_t *IdentifierOffsets;
215
216  /// \brief Base identifier ID for identifiers local to this module.
217  serialization::IdentID BaseIdentifierID;
218
219  /// \brief Remapping table for identifier IDs in this module.
220  ContinuousRangeMap<uint32_t, int, 2> IdentifierRemap;
221
222  /// \brief Actual data for the on-disk hash table of identifiers.
223  ///
224  /// This pointer points into a memory buffer, where the on-disk hash
225  /// table for identifiers actually lives.
226  const char *IdentifierTableData;
227
228  /// \brief A pointer to an on-disk hash table of opaque type
229  /// IdentifierHashTable.
230  void *IdentifierLookupTable;
231
232  // === Macros ===
233
234  /// \brief The cursor to the start of the preprocessor block, which stores
235  /// all of the macro definitions.
236  llvm::BitstreamCursor MacroCursor;
237
238  /// \brief The number of macros in this AST file.
239  unsigned LocalNumMacros;
240
241  /// \brief Offsets of macros in the preprocessor block.
242  ///
243  /// This array is indexed by the macro ID (-1), and provides
244  /// the offset into the preprocessor block where macro definitions are
245  /// stored.
246  const uint32_t *MacroOffsets;
247
248  /// \brief Base macro ID for macros local to this module.
249  serialization::MacroID BaseMacroID;
250
251  /// \brief Remapping table for macro IDs in this module.
252  ContinuousRangeMap<uint32_t, int, 2> MacroRemap;
253
254  /// \brief The offset of the start of the set of defined macros.
255  uint64_t MacroStartOffset;
256
257  // === Detailed PreprocessingRecord ===
258
259  /// \brief The cursor to the start of the (optional) detailed preprocessing
260  /// record block.
261  llvm::BitstreamCursor PreprocessorDetailCursor;
262
263  /// \brief The offset of the start of the preprocessor detail cursor.
264  uint64_t PreprocessorDetailStartOffset;
265
266  /// \brief Base preprocessed entity ID for preprocessed entities local to
267  /// this module.
268  serialization::PreprocessedEntityID BasePreprocessedEntityID;
269
270  /// \brief Remapping table for preprocessed entity IDs in this module.
271  ContinuousRangeMap<uint32_t, int, 2> PreprocessedEntityRemap;
272
273  const PPEntityOffset *PreprocessedEntityOffsets;
274  unsigned NumPreprocessedEntities;
275
276  // === Header search information ===
277
278  /// \brief The number of local HeaderFileInfo structures.
279  unsigned LocalNumHeaderFileInfos;
280
281  /// \brief Actual data for the on-disk hash table of header file
282  /// information.
283  ///
284  /// This pointer points into a memory buffer, where the on-disk hash
285  /// table for header file information actually lives.
286  const char *HeaderFileInfoTableData;
287
288  /// \brief The on-disk hash table that contains information about each of
289  /// the header files.
290  void *HeaderFileInfoTable;
291
292  // === Submodule information ===
293  /// \brief The number of submodules in this module.
294  unsigned LocalNumSubmodules;
295
296  /// \brief Base submodule ID for submodules local to this module.
297  serialization::SubmoduleID BaseSubmoduleID;
298
299  /// \brief Remapping table for submodule IDs in this module.
300  ContinuousRangeMap<uint32_t, int, 2> SubmoduleRemap;
301
302  // === Selectors ===
303
304  /// \brief The number of selectors new to this file.
305  ///
306  /// This is the number of entries in SelectorOffsets.
307  unsigned LocalNumSelectors;
308
309  /// \brief Offsets into the selector lookup table's data array
310  /// where each selector resides.
311  const uint32_t *SelectorOffsets;
312
313  /// \brief Base selector ID for selectors local to this module.
314  serialization::SelectorID BaseSelectorID;
315
316  /// \brief Remapping table for selector IDs in this module.
317  ContinuousRangeMap<uint32_t, int, 2> SelectorRemap;
318
319  /// \brief A pointer to the character data that comprises the selector table
320  ///
321  /// The SelectorOffsets table refers into this memory.
322  const unsigned char *SelectorLookupTableData;
323
324  /// \brief A pointer to an on-disk hash table of opaque type
325  /// ASTSelectorLookupTable.
326  ///
327  /// This hash table provides the IDs of all selectors, and the associated
328  /// instance and factory methods.
329  void *SelectorLookupTable;
330
331  // === Declarations ===
332
333  /// DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block. It
334  /// has read all the abbreviations at the start of the block and is ready to
335  /// jump around with these in context.
336  llvm::BitstreamCursor DeclsCursor;
337
338  /// \brief The number of declarations in this AST file.
339  unsigned LocalNumDecls;
340
341  /// \brief Offset of each declaration within the bitstream, indexed
342  /// by the declaration ID (-1).
343  const DeclOffset *DeclOffsets;
344
345  /// \brief Base declaration ID for declarations local to this module.
346  serialization::DeclID BaseDeclID;
347
348  /// \brief Remapping table for declaration IDs in this module.
349  ContinuousRangeMap<uint32_t, int, 2> DeclRemap;
350
351  /// \brief Mapping from the module files that this module file depends on
352  /// to the base declaration ID for that module as it is understood within this
353  /// module.
354  ///
355  /// This is effectively a reverse global-to-local mapping for declaration
356  /// IDs, so that we can interpret a true global ID (for this translation unit)
357  /// as a local ID (for this module file).
358  llvm::DenseMap<ModuleFile *, serialization::DeclID> GlobalToLocalDeclIDs;
359
360  /// \brief The number of C++ base specifier sets in this AST file.
361  unsigned LocalNumCXXBaseSpecifiers;
362
363  /// \brief Offset of each C++ base specifier set within the bitstream,
364  /// indexed by the C++ base specifier set ID (-1).
365  const uint32_t *CXXBaseSpecifiersOffsets;
366
367  typedef llvm::DenseMap<const DeclContext *, DeclContextInfo>
368  DeclContextInfosMap;
369
370  /// \brief Information about the lexical and visible declarations
371  /// for each DeclContext.
372  DeclContextInfosMap DeclContextInfos;
373
374  /// \brief Array of file-level DeclIDs sorted by file.
375  const serialization::DeclID *FileSortedDecls;
376  unsigned NumFileSortedDecls;
377
378  /// \brief Array of redeclaration chain location information within this
379  /// module file, sorted by the first declaration ID.
380  const serialization::LocalRedeclarationsInfo *RedeclarationsMap;
381
382  /// \brief The number of redeclaration info entries in RedeclarationsMap.
383  unsigned LocalNumRedeclarationsInMap;
384
385  /// \brief The redeclaration chains for declarations local to this
386  /// module file.
387  SmallVector<uint64_t, 1> RedeclarationChains;
388
389  /// \brief Array of category list location information within this
390  /// module file, sorted by the definition ID.
391  const serialization::ObjCCategoriesInfo *ObjCCategoriesMap;
392
393  /// \brief The number of redeclaration info entries in ObjCCategoriesMap.
394  unsigned LocalNumObjCCategoriesInMap;
395
396  /// \brief The Objective-C category lists for categories known to this
397  /// module.
398  SmallVector<uint64_t, 1> ObjCCategories;
399
400  // === Types ===
401
402  /// \brief The number of types in this AST file.
403  unsigned LocalNumTypes;
404
405  /// \brief Offset of each type within the bitstream, indexed by the
406  /// type ID, or the representation of a Type*.
407  const uint32_t *TypeOffsets;
408
409  /// \brief Base type ID for types local to this module as represented in
410  /// the global type ID space.
411  serialization::TypeID BaseTypeIndex;
412
413  /// \brief Remapping table for type IDs in this module.
414  ContinuousRangeMap<uint32_t, int, 2> TypeRemap;
415
416  // === Miscellaneous ===
417
418  /// \brief Diagnostic IDs and their mappings that the user changed.
419  SmallVector<uint64_t, 8> PragmaDiagMappings;
420
421  /// \brief List of modules which depend on this module
422  llvm::SetVector<ModuleFile *> ImportedBy;
423
424  /// \brief List of modules which this module depends on
425  llvm::SetVector<ModuleFile *> Imports;
426
427  /// \brief Determine whether this module was directly imported at
428  /// any point during translation.
429  bool isDirectlyImported() const { return DirectlyImported; }
430
431  /// \brief Dump debugging output for this module.
432  void dump();
433};
434
435} // end namespace serialization
436
437} // end namespace clang
438
439#endif
440