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/OwningPtr.h"
  22 #include "llvm/ADT/SetVector.h"
  23 #include "llvm/Bitcode/BitstreamReader.h"
  24 #include <string>
  25
  26 namespace clang {
  27
  28 class FileEntry;
  29 class DeclContext;
  30 class Module;
  31 template<typename Info> class OnDiskChainedHashTable;
  32
  33 namespace serialization {
  34
  35 namespace reader {
  36   class ASTDeclContextNameLookupTrait;
  37 }
  38
  39 /// \brief Specifies the kind of module that has been loaded.
  40 enum 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.
  48 struct 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.
  61 class InputFile {
  62   enum {
  63     Overridden = 1,
  64     OutOfDate = 2
  65   };
  66   llvm::PointerIntPair<const FileEntry *, 2, unsigned> Val;
  67
  68 public:
  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.
  94 class ModuleFile {
  95 public:
  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