contrib/llvm/tools/clang/include/clang/Serialization/Module.h

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