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