1 //===- ASTReader.h - AST File Reader ----------------------------*- 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 ASTReader class, which reads AST files. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_SERIALIZATION_ASTREADER_H 14 #define LLVM_CLANG_SERIALIZATION_ASTREADER_H 15 16 #include "clang/AST/Type.h" 17 #include "clang/Basic/Diagnostic.h" 18 #include "clang/Basic/DiagnosticOptions.h" 19 #include "clang/Basic/IdentifierTable.h" 20 #include "clang/Basic/OpenCLOptions.h" 21 #include "clang/Basic/SourceLocation.h" 22 #include "clang/Basic/Version.h" 23 #include "clang/Lex/ExternalPreprocessorSource.h" 24 #include "clang/Lex/HeaderSearch.h" 25 #include "clang/Lex/PreprocessingRecord.h" 26 #include "clang/Lex/PreprocessorOptions.h" 27 #include "clang/Sema/ExternalSemaSource.h" 28 #include "clang/Sema/IdentifierResolver.h" 29 #include "clang/Sema/Sema.h" 30 #include "clang/Serialization/ASTBitCodes.h" 31 #include "clang/Serialization/ContinuousRangeMap.h" 32 #include "clang/Serialization/ModuleFile.h" 33 #include "clang/Serialization/ModuleFileExtension.h" 34 #include "clang/Serialization/ModuleManager.h" 35 #include "llvm/ADT/ArrayRef.h" 36 #include "llvm/ADT/DenseMap.h" 37 #include "llvm/ADT/DenseSet.h" 38 #include "llvm/ADT/IntrusiveRefCntPtr.h" 39 #include "llvm/ADT/MapVector.h" 40 #include "llvm/ADT/Optional.h" 41 #include "llvm/ADT/STLExtras.h" 42 #include "llvm/ADT/SetVector.h" 43 #include "llvm/ADT/SmallPtrSet.h" 44 #include "llvm/ADT/SmallVector.h" 45 #include "llvm/ADT/StringMap.h" 46 #include "llvm/ADT/StringRef.h" 47 #include "llvm/ADT/iterator.h" 48 #include "llvm/ADT/iterator_range.h" 49 #include "llvm/Bitstream/BitstreamReader.h" 50 #include "llvm/Support/MemoryBuffer.h" 51 #include "llvm/Support/Timer.h" 52 #include "llvm/Support/VersionTuple.h" 53 #include <cassert> 54 #include <cstddef> 55 #include <cstdint> 56 #include <ctime> 57 #include <deque> 58 #include <memory> 59 #include <set> 60 #include <string> 61 #include <utility> 62 #include <vector> 63 64 namespace clang { 65 66 class ASTConsumer; 67 class ASTContext; 68 class ASTDeserializationListener; 69 class ASTReader; 70 class ASTRecordReader; 71 class CXXTemporary; 72 class Decl; 73 class DeclarationName; 74 class DeclaratorDecl; 75 class DeclContext; 76 class EnumDecl; 77 class Expr; 78 class FieldDecl; 79 class FileEntry; 80 class FileManager; 81 class FileSystemOptions; 82 class FunctionDecl; 83 class GlobalModuleIndex; 84 struct HeaderFileInfo; 85 class HeaderSearchOptions; 86 class LangOptions; 87 class LazyASTUnresolvedSet; 88 class MacroInfo; 89 class InMemoryModuleCache; 90 class NamedDecl; 91 class NamespaceDecl; 92 class ObjCCategoryDecl; 93 class ObjCInterfaceDecl; 94 class PCHContainerReader; 95 class Preprocessor; 96 class PreprocessorOptions; 97 struct QualifierInfo; 98 class Sema; 99 class SourceManager; 100 class Stmt; 101 class SwitchCase; 102 class TargetOptions; 103 class Token; 104 class TypedefNameDecl; 105 class ValueDecl; 106 class VarDecl; 107 108 /// Abstract interface for callback invocations by the ASTReader. 109 /// 110 /// While reading an AST file, the ASTReader will call the methods of the 111 /// listener to pass on specific information. Some of the listener methods can 112 /// return true to indicate to the ASTReader that the information (and 113 /// consequently the AST file) is invalid. 114 class ASTReaderListener { 115 public: 116 virtual ~ASTReaderListener(); 117 118 /// Receives the full Clang version information. 119 /// 120 /// \returns true to indicate that the version is invalid. Subclasses should 121 /// generally defer to this implementation. 122 virtual bool ReadFullVersionInformation(StringRef FullVersion) { 123 return FullVersion != getClangFullRepositoryVersion(); 124 } 125 126 virtual void ReadModuleName(StringRef ModuleName) {} 127 virtual void ReadModuleMapFile(StringRef ModuleMapPath) {} 128 129 /// Receives the language options. 130 /// 131 /// \returns true to indicate the options are invalid or false otherwise. 132 virtual bool ReadLanguageOptions(const LangOptions &LangOpts, 133 bool Complain, 134 bool AllowCompatibleDifferences) { 135 return false; 136 } 137 138 /// Receives the target options. 139 /// 140 /// \returns true to indicate the target options are invalid, or false 141 /// otherwise. 142 virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, 143 bool AllowCompatibleDifferences) { 144 return false; 145 } 146 147 /// Receives the diagnostic options. 148 /// 149 /// \returns true to indicate the diagnostic options are invalid, or false 150 /// otherwise. 151 virtual bool 152 ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, 153 bool Complain) { 154 return false; 155 } 156 157 /// Receives the file system options. 158 /// 159 /// \returns true to indicate the file system options are invalid, or false 160 /// otherwise. 161 virtual bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, 162 bool Complain) { 163 return false; 164 } 165 166 /// Receives the header search options. 167 /// 168 /// \returns true to indicate the header search options are invalid, or false 169 /// otherwise. 170 virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, 171 StringRef SpecificModuleCachePath, 172 bool Complain) { 173 return false; 174 } 175 176 /// Receives the preprocessor options. 177 /// 178 /// \param SuggestedPredefines Can be filled in with the set of predefines 179 /// that are suggested by the preprocessor options. Typically only used when 180 /// loading a precompiled header. 181 /// 182 /// \returns true to indicate the preprocessor options are invalid, or false 183 /// otherwise. 184 virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 185 bool Complain, 186 std::string &SuggestedPredefines) { 187 return false; 188 } 189 190 /// Receives __COUNTER__ value. 191 virtual void ReadCounter(const serialization::ModuleFile &M, 192 unsigned Value) {} 193 194 /// This is called for each AST file loaded. 195 virtual void visitModuleFile(StringRef Filename, 196 serialization::ModuleKind Kind) {} 197 198 /// Returns true if this \c ASTReaderListener wants to receive the 199 /// input files of the AST file via \c visitInputFile, false otherwise. 200 virtual bool needsInputFileVisitation() { return false; } 201 202 /// Returns true if this \c ASTReaderListener wants to receive the 203 /// system input files of the AST file via \c visitInputFile, false otherwise. 204 virtual bool needsSystemInputFileVisitation() { return false; } 205 206 /// if \c needsInputFileVisitation returns true, this is called for 207 /// each non-system input file of the AST File. If 208 /// \c needsSystemInputFileVisitation is true, then it is called for all 209 /// system input files as well. 210 /// 211 /// \returns true to continue receiving the next input file, false to stop. 212 virtual bool visitInputFile(StringRef Filename, bool isSystem, 213 bool isOverridden, bool isExplicitModule) { 214 return true; 215 } 216 217 /// Returns true if this \c ASTReaderListener wants to receive the 218 /// imports of the AST file via \c visitImport, false otherwise. 219 virtual bool needsImportVisitation() const { return false; } 220 221 /// If needsImportVisitation returns \c true, this is called for each 222 /// AST file imported by this AST file. 223 virtual void visitImport(StringRef ModuleName, StringRef Filename) {} 224 225 /// Indicates that a particular module file extension has been read. 226 virtual void readModuleFileExtension( 227 const ModuleFileExtensionMetadata &Metadata) {} 228 }; 229 230 /// Simple wrapper class for chaining listeners. 231 class ChainedASTReaderListener : public ASTReaderListener { 232 std::unique_ptr<ASTReaderListener> First; 233 std::unique_ptr<ASTReaderListener> Second; 234 235 public: 236 /// Takes ownership of \p First and \p Second. 237 ChainedASTReaderListener(std::unique_ptr<ASTReaderListener> First, 238 std::unique_ptr<ASTReaderListener> Second) 239 : First(std::move(First)), Second(std::move(Second)) {} 240 241 std::unique_ptr<ASTReaderListener> takeFirst() { return std::move(First); } 242 std::unique_ptr<ASTReaderListener> takeSecond() { return std::move(Second); } 243 244 bool ReadFullVersionInformation(StringRef FullVersion) override; 245 void ReadModuleName(StringRef ModuleName) override; 246 void ReadModuleMapFile(StringRef ModuleMapPath) override; 247 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, 248 bool AllowCompatibleDifferences) override; 249 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, 250 bool AllowCompatibleDifferences) override; 251 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, 252 bool Complain) override; 253 bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, 254 bool Complain) override; 255 256 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, 257 StringRef SpecificModuleCachePath, 258 bool Complain) override; 259 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 260 bool Complain, 261 std::string &SuggestedPredefines) override; 262 263 void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override; 264 bool needsInputFileVisitation() override; 265 bool needsSystemInputFileVisitation() override; 266 void visitModuleFile(StringRef Filename, 267 serialization::ModuleKind Kind) override; 268 bool visitInputFile(StringRef Filename, bool isSystem, 269 bool isOverridden, bool isExplicitModule) override; 270 void readModuleFileExtension( 271 const ModuleFileExtensionMetadata &Metadata) override; 272 }; 273 274 /// ASTReaderListener implementation to validate the information of 275 /// the PCH file against an initialized Preprocessor. 276 class PCHValidator : public ASTReaderListener { 277 Preprocessor &PP; 278 ASTReader &Reader; 279 280 public: 281 PCHValidator(Preprocessor &PP, ASTReader &Reader) 282 : PP(PP), Reader(Reader) {} 283 284 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, 285 bool AllowCompatibleDifferences) override; 286 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, 287 bool AllowCompatibleDifferences) override; 288 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, 289 bool Complain) override; 290 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, 291 std::string &SuggestedPredefines) override; 292 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, 293 StringRef SpecificModuleCachePath, 294 bool Complain) override; 295 void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override; 296 297 private: 298 void Error(const char *Msg); 299 }; 300 301 /// ASTReaderListenter implementation to set SuggestedPredefines of 302 /// ASTReader which is required to use a pch file. This is the replacement 303 /// of PCHValidator or SimplePCHValidator when using a pch file without 304 /// validating it. 305 class SimpleASTReaderListener : public ASTReaderListener { 306 Preprocessor &PP; 307 308 public: 309 SimpleASTReaderListener(Preprocessor &PP) : PP(PP) {} 310 311 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, 312 std::string &SuggestedPredefines) override; 313 }; 314 315 namespace serialization { 316 317 class ReadMethodPoolVisitor; 318 319 namespace reader { 320 321 class ASTIdentifierLookupTrait; 322 323 /// The on-disk hash table(s) used for DeclContext name lookup. 324 struct DeclContextLookupTable; 325 326 } // namespace reader 327 328 } // namespace serialization 329 330 /// Reads an AST files chain containing the contents of a translation 331 /// unit. 332 /// 333 /// The ASTReader class reads bitstreams (produced by the ASTWriter 334 /// class) containing the serialized representation of a given 335 /// abstract syntax tree and its supporting data structures. An 336 /// instance of the ASTReader can be attached to an ASTContext object, 337 /// which will provide access to the contents of the AST files. 338 /// 339 /// The AST reader provides lazy de-serialization of declarations, as 340 /// required when traversing the AST. Only those AST nodes that are 341 /// actually required will be de-serialized. 342 class ASTReader 343 : public ExternalPreprocessorSource, 344 public ExternalPreprocessingRecordSource, 345 public ExternalHeaderFileInfoSource, 346 public ExternalSemaSource, 347 public IdentifierInfoLookup, 348 public ExternalSLocEntrySource 349 { 350 public: 351 /// Types of AST files. 352 friend class ASTDeclReader; 353 friend class ASTIdentifierIterator; 354 friend class ASTRecordReader; 355 friend class ASTUnit; // ASTUnit needs to remap source locations. 356 friend class ASTWriter; 357 friend class PCHValidator; 358 friend class serialization::reader::ASTIdentifierLookupTrait; 359 friend class serialization::ReadMethodPoolVisitor; 360 friend class TypeLocReader; 361 362 using RecordData = SmallVector<uint64_t, 64>; 363 using RecordDataImpl = SmallVectorImpl<uint64_t>; 364 365 /// The result of reading the control block of an AST file, which 366 /// can fail for various reasons. 367 enum ASTReadResult { 368 /// The control block was read successfully. Aside from failures, 369 /// the AST file is safe to read into the current context. 370 Success, 371 372 /// The AST file itself appears corrupted. 373 Failure, 374 375 /// The AST file was missing. 376 Missing, 377 378 /// The AST file is out-of-date relative to its input files, 379 /// and needs to be regenerated. 380 OutOfDate, 381 382 /// The AST file was written by a different version of Clang. 383 VersionMismatch, 384 385 /// The AST file was writtten with a different language/target 386 /// configuration. 387 ConfigurationMismatch, 388 389 /// The AST file has errors. 390 HadErrors 391 }; 392 393 using ModuleFile = serialization::ModuleFile; 394 using ModuleKind = serialization::ModuleKind; 395 using ModuleManager = serialization::ModuleManager; 396 using ModuleIterator = ModuleManager::ModuleIterator; 397 using ModuleConstIterator = ModuleManager::ModuleConstIterator; 398 using ModuleReverseIterator = ModuleManager::ModuleReverseIterator; 399 400 private: 401 /// The receiver of some callbacks invoked by ASTReader. 402 std::unique_ptr<ASTReaderListener> Listener; 403 404 /// The receiver of deserialization events. 405 ASTDeserializationListener *DeserializationListener = nullptr; 406 407 bool OwnsDeserializationListener = false; 408 409 SourceManager &SourceMgr; 410 FileManager &FileMgr; 411 const PCHContainerReader &PCHContainerRdr; 412 DiagnosticsEngine &Diags; 413 414 /// The semantic analysis object that will be processing the 415 /// AST files and the translation unit that uses it. 416 Sema *SemaObj = nullptr; 417 418 /// The preprocessor that will be loading the source file. 419 Preprocessor &PP; 420 421 /// The AST context into which we'll read the AST files. 422 ASTContext *ContextObj = nullptr; 423 424 /// The AST consumer. 425 ASTConsumer *Consumer = nullptr; 426 427 /// The module manager which manages modules and their dependencies 428 ModuleManager ModuleMgr; 429 430 /// A dummy identifier resolver used to merge TU-scope declarations in 431 /// C, for the cases where we don't have a Sema object to provide a real 432 /// identifier resolver. 433 IdentifierResolver DummyIdResolver; 434 435 /// A mapping from extension block names to module file extensions. 436 llvm::StringMap<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions; 437 438 /// A timer used to track the time spent deserializing. 439 std::unique_ptr<llvm::Timer> ReadTimer; 440 441 /// The location where the module file will be considered as 442 /// imported from. For non-module AST types it should be invalid. 443 SourceLocation CurrentImportLoc; 444 445 /// The module kind that is currently deserializing. 446 Optional<ModuleKind> CurrentDeserializingModuleKind; 447 448 /// The global module index, if loaded. 449 std::unique_ptr<GlobalModuleIndex> GlobalIndex; 450 451 /// A map of global bit offsets to the module that stores entities 452 /// at those bit offsets. 453 ContinuousRangeMap<uint64_t, ModuleFile*, 4> GlobalBitOffsetsMap; 454 455 /// A map of negated SLocEntryIDs to the modules containing them. 456 ContinuousRangeMap<unsigned, ModuleFile*, 64> GlobalSLocEntryMap; 457 458 using GlobalSLocOffsetMapType = 459 ContinuousRangeMap<unsigned, ModuleFile *, 64>; 460 461 /// A map of reversed (SourceManager::MaxLoadedOffset - SLocOffset) 462 /// SourceLocation offsets to the modules containing them. 463 GlobalSLocOffsetMapType GlobalSLocOffsetMap; 464 465 /// Types that have already been loaded from the chain. 466 /// 467 /// When the pointer at index I is non-NULL, the type with 468 /// ID = (I + 1) << FastQual::Width has already been loaded 469 std::vector<QualType> TypesLoaded; 470 471 using GlobalTypeMapType = 472 ContinuousRangeMap<serialization::TypeID, ModuleFile *, 4>; 473 474 /// Mapping from global type IDs to the module in which the 475 /// type resides along with the offset that should be added to the 476 /// global type ID to produce a local ID. 477 GlobalTypeMapType GlobalTypeMap; 478 479 /// Declarations that have already been loaded from the chain. 480 /// 481 /// When the pointer at index I is non-NULL, the declaration with ID 482 /// = I + 1 has already been loaded. 483 std::vector<Decl *> DeclsLoaded; 484 485 using GlobalDeclMapType = 486 ContinuousRangeMap<serialization::DeclID, ModuleFile *, 4>; 487 488 /// Mapping from global declaration IDs to the module in which the 489 /// declaration resides. 490 GlobalDeclMapType GlobalDeclMap; 491 492 using FileOffset = std::pair<ModuleFile *, uint64_t>; 493 using FileOffsetsTy = SmallVector<FileOffset, 2>; 494 using DeclUpdateOffsetsMap = 495 llvm::DenseMap<serialization::DeclID, FileOffsetsTy>; 496 497 /// Declarations that have modifications residing in a later file 498 /// in the chain. 499 DeclUpdateOffsetsMap DeclUpdateOffsets; 500 501 struct PendingUpdateRecord { 502 Decl *D; 503 serialization::GlobalDeclID ID; 504 505 // Whether the declaration was just deserialized. 506 bool JustLoaded; 507 508 PendingUpdateRecord(serialization::GlobalDeclID ID, Decl *D, 509 bool JustLoaded) 510 : D(D), ID(ID), JustLoaded(JustLoaded) {} 511 }; 512 513 /// Declaration updates for already-loaded declarations that we need 514 /// to apply once we finish processing an import. 515 llvm::SmallVector<PendingUpdateRecord, 16> PendingUpdateRecords; 516 517 enum class PendingFakeDefinitionKind { NotFake, Fake, FakeLoaded }; 518 519 /// The DefinitionData pointers that we faked up for class definitions 520 /// that we needed but hadn't loaded yet. 521 llvm::DenseMap<void *, PendingFakeDefinitionKind> PendingFakeDefinitionData; 522 523 /// Exception specification updates that have been loaded but not yet 524 /// propagated across the relevant redeclaration chain. The map key is the 525 /// canonical declaration (used only for deduplication) and the value is a 526 /// declaration that has an exception specification. 527 llvm::SmallMapVector<Decl *, FunctionDecl *, 4> PendingExceptionSpecUpdates; 528 529 /// Deduced return type updates that have been loaded but not yet propagated 530 /// across the relevant redeclaration chain. The map key is the canonical 531 /// declaration and the value is the deduced return type. 532 llvm::SmallMapVector<FunctionDecl *, QualType, 4> PendingDeducedTypeUpdates; 533 534 /// Declarations that have been imported and have typedef names for 535 /// linkage purposes. 536 llvm::DenseMap<std::pair<DeclContext *, IdentifierInfo *>, NamedDecl *> 537 ImportedTypedefNamesForLinkage; 538 539 /// Mergeable declaration contexts that have anonymous declarations 540 /// within them, and those anonymous declarations. 541 llvm::DenseMap<Decl*, llvm::SmallVector<NamedDecl*, 2>> 542 AnonymousDeclarationsForMerging; 543 544 /// Key used to identify LifetimeExtendedTemporaryDecl for merging, 545 /// containing the lifetime-extending declaration and the mangling number. 546 using LETemporaryKey = std::pair<Decl *, unsigned>; 547 548 /// Map of already deserialiazed temporaries. 549 llvm::DenseMap<LETemporaryKey, LifetimeExtendedTemporaryDecl *> 550 LETemporaryForMerging; 551 552 struct FileDeclsInfo { 553 ModuleFile *Mod = nullptr; 554 ArrayRef<serialization::LocalDeclID> Decls; 555 556 FileDeclsInfo() = default; 557 FileDeclsInfo(ModuleFile *Mod, ArrayRef<serialization::LocalDeclID> Decls) 558 : Mod(Mod), Decls(Decls) {} 559 }; 560 561 /// Map from a FileID to the file-level declarations that it contains. 562 llvm::DenseMap<FileID, FileDeclsInfo> FileDeclIDs; 563 564 /// An array of lexical contents of a declaration context, as a sequence of 565 /// Decl::Kind, DeclID pairs. 566 using LexicalContents = ArrayRef<llvm::support::unaligned_uint32_t>; 567 568 /// Map from a DeclContext to its lexical contents. 569 llvm::DenseMap<const DeclContext*, std::pair<ModuleFile*, LexicalContents>> 570 LexicalDecls; 571 572 /// Map from the TU to its lexical contents from each module file. 573 std::vector<std::pair<ModuleFile*, LexicalContents>> TULexicalDecls; 574 575 /// Map from a DeclContext to its lookup tables. 576 llvm::DenseMap<const DeclContext *, 577 serialization::reader::DeclContextLookupTable> Lookups; 578 579 // Updates for visible decls can occur for other contexts than just the 580 // TU, and when we read those update records, the actual context may not 581 // be available yet, so have this pending map using the ID as a key. It 582 // will be realized when the context is actually loaded. 583 struct PendingVisibleUpdate { 584 ModuleFile *Mod; 585 const unsigned char *Data; 586 }; 587 using DeclContextVisibleUpdates = SmallVector<PendingVisibleUpdate, 1>; 588 589 /// Updates to the visible declarations of declaration contexts that 590 /// haven't been loaded yet. 591 llvm::DenseMap<serialization::DeclID, DeclContextVisibleUpdates> 592 PendingVisibleUpdates; 593 594 /// The set of C++ or Objective-C classes that have forward 595 /// declarations that have not yet been linked to their definitions. 596 llvm::SmallPtrSet<Decl *, 4> PendingDefinitions; 597 598 using PendingBodiesMap = 599 llvm::MapVector<Decl *, uint64_t, 600 llvm::SmallDenseMap<Decl *, unsigned, 4>, 601 SmallVector<std::pair<Decl *, uint64_t>, 4>>; 602 603 /// Functions or methods that have bodies that will be attached. 604 PendingBodiesMap PendingBodies; 605 606 /// Definitions for which we have added merged definitions but not yet 607 /// performed deduplication. 608 llvm::SetVector<NamedDecl *> PendingMergedDefinitionsToDeduplicate; 609 610 /// Read the record that describes the lexical contents of a DC. 611 bool ReadLexicalDeclContextStorage(ModuleFile &M, 612 llvm::BitstreamCursor &Cursor, 613 uint64_t Offset, DeclContext *DC); 614 615 /// Read the record that describes the visible contents of a DC. 616 bool ReadVisibleDeclContextStorage(ModuleFile &M, 617 llvm::BitstreamCursor &Cursor, 618 uint64_t Offset, serialization::DeclID ID); 619 620 /// A vector containing identifiers that have already been 621 /// loaded. 622 /// 623 /// If the pointer at index I is non-NULL, then it refers to the 624 /// IdentifierInfo for the identifier with ID=I+1 that has already 625 /// been loaded. 626 std::vector<IdentifierInfo *> IdentifiersLoaded; 627 628 using GlobalIdentifierMapType = 629 ContinuousRangeMap<serialization::IdentID, ModuleFile *, 4>; 630 631 /// Mapping from global identifier IDs to the module in which the 632 /// identifier resides along with the offset that should be added to the 633 /// global identifier ID to produce a local ID. 634 GlobalIdentifierMapType GlobalIdentifierMap; 635 636 /// A vector containing macros that have already been 637 /// loaded. 638 /// 639 /// If the pointer at index I is non-NULL, then it refers to the 640 /// MacroInfo for the identifier with ID=I+1 that has already 641 /// been loaded. 642 std::vector<MacroInfo *> MacrosLoaded; 643 644 using LoadedMacroInfo = 645 std::pair<IdentifierInfo *, serialization::SubmoduleID>; 646 647 /// A set of #undef directives that we have loaded; used to 648 /// deduplicate the same #undef information coming from multiple module 649 /// files. 650 llvm::DenseSet<LoadedMacroInfo> LoadedUndefs; 651 652 using GlobalMacroMapType = 653 ContinuousRangeMap<serialization::MacroID, ModuleFile *, 4>; 654 655 /// Mapping from global macro IDs to the module in which the 656 /// macro resides along with the offset that should be added to the 657 /// global macro ID to produce a local ID. 658 GlobalMacroMapType GlobalMacroMap; 659 660 /// A vector containing submodules that have already been loaded. 661 /// 662 /// This vector is indexed by the Submodule ID (-1). NULL submodule entries 663 /// indicate that the particular submodule ID has not yet been loaded. 664 SmallVector<Module *, 2> SubmodulesLoaded; 665 666 using GlobalSubmoduleMapType = 667 ContinuousRangeMap<serialization::SubmoduleID, ModuleFile *, 4>; 668 669 /// Mapping from global submodule IDs to the module file in which the 670 /// submodule resides along with the offset that should be added to the 671 /// global submodule ID to produce a local ID. 672 GlobalSubmoduleMapType GlobalSubmoduleMap; 673 674 /// A set of hidden declarations. 675 using HiddenNames = SmallVector<Decl *, 2>; 676 using HiddenNamesMapType = llvm::DenseMap<Module *, HiddenNames>; 677 678 /// A mapping from each of the hidden submodules to the deserialized 679 /// declarations in that submodule that could be made visible. 680 HiddenNamesMapType HiddenNamesMap; 681 682 /// A module import, export, or conflict that hasn't yet been resolved. 683 struct UnresolvedModuleRef { 684 /// The file in which this module resides. 685 ModuleFile *File; 686 687 /// The module that is importing or exporting. 688 Module *Mod; 689 690 /// The kind of module reference. 691 enum { Import, Export, Conflict } Kind; 692 693 /// The local ID of the module that is being exported. 694 unsigned ID; 695 696 /// Whether this is a wildcard export. 697 unsigned IsWildcard : 1; 698 699 /// String data. 700 StringRef String; 701 }; 702 703 /// The set of module imports and exports that still need to be 704 /// resolved. 705 SmallVector<UnresolvedModuleRef, 2> UnresolvedModuleRefs; 706 707 /// A vector containing selectors that have already been loaded. 708 /// 709 /// This vector is indexed by the Selector ID (-1). NULL selector 710 /// entries indicate that the particular selector ID has not yet 711 /// been loaded. 712 SmallVector<Selector, 16> SelectorsLoaded; 713 714 using GlobalSelectorMapType = 715 ContinuousRangeMap<serialization::SelectorID, ModuleFile *, 4>; 716 717 /// Mapping from global selector IDs to the module in which the 718 /// global selector ID to produce a local ID. 719 GlobalSelectorMapType GlobalSelectorMap; 720 721 /// The generation number of the last time we loaded data from the 722 /// global method pool for this selector. 723 llvm::DenseMap<Selector, unsigned> SelectorGeneration; 724 725 /// Whether a selector is out of date. We mark a selector as out of date 726 /// if we load another module after the method pool entry was pulled in. 727 llvm::DenseMap<Selector, bool> SelectorOutOfDate; 728 729 struct PendingMacroInfo { 730 ModuleFile *M; 731 /// Offset relative to ModuleFile::MacroOffsetsBase. 732 uint32_t MacroDirectivesOffset; 733 734 PendingMacroInfo(ModuleFile *M, uint32_t MacroDirectivesOffset) 735 : M(M), MacroDirectivesOffset(MacroDirectivesOffset) {} 736 }; 737 738 using PendingMacroIDsMap = 739 llvm::MapVector<IdentifierInfo *, SmallVector<PendingMacroInfo, 2>>; 740 741 /// Mapping from identifiers that have a macro history to the global 742 /// IDs have not yet been deserialized to the global IDs of those macros. 743 PendingMacroIDsMap PendingMacroIDs; 744 745 using GlobalPreprocessedEntityMapType = 746 ContinuousRangeMap<unsigned, ModuleFile *, 4>; 747 748 /// Mapping from global preprocessing entity IDs to the module in 749 /// which the preprocessed entity resides along with the offset that should be 750 /// added to the global preprocessing entity ID to produce a local ID. 751 GlobalPreprocessedEntityMapType GlobalPreprocessedEntityMap; 752 753 using GlobalSkippedRangeMapType = 754 ContinuousRangeMap<unsigned, ModuleFile *, 4>; 755 756 /// Mapping from global skipped range base IDs to the module in which 757 /// the skipped ranges reside. 758 GlobalSkippedRangeMapType GlobalSkippedRangeMap; 759 760 /// \name CodeGen-relevant special data 761 /// Fields containing data that is relevant to CodeGen. 762 //@{ 763 764 /// The IDs of all declarations that fulfill the criteria of 765 /// "interesting" decls. 766 /// 767 /// This contains the data loaded from all EAGERLY_DESERIALIZED_DECLS blocks 768 /// in the chain. The referenced declarations are deserialized and passed to 769 /// the consumer eagerly. 770 SmallVector<uint64_t, 16> EagerlyDeserializedDecls; 771 772 /// The IDs of all tentative definitions stored in the chain. 773 /// 774 /// Sema keeps track of all tentative definitions in a TU because it has to 775 /// complete them and pass them on to CodeGen. Thus, tentative definitions in 776 /// the PCH chain must be eagerly deserialized. 777 SmallVector<uint64_t, 16> TentativeDefinitions; 778 779 /// The IDs of all CXXRecordDecls stored in the chain whose VTables are 780 /// used. 781 /// 782 /// CodeGen has to emit VTables for these records, so they have to be eagerly 783 /// deserialized. 784 SmallVector<uint64_t, 64> VTableUses; 785 786 /// A snapshot of the pending instantiations in the chain. 787 /// 788 /// This record tracks the instantiations that Sema has to perform at the 789 /// end of the TU. It consists of a pair of values for every pending 790 /// instantiation where the first value is the ID of the decl and the second 791 /// is the instantiation location. 792 SmallVector<uint64_t, 64> PendingInstantiations; 793 794 //@} 795 796 /// \name DiagnosticsEngine-relevant special data 797 /// Fields containing data that is used for generating diagnostics 798 //@{ 799 800 /// A snapshot of Sema's unused file-scoped variable tracking, for 801 /// generating warnings. 802 SmallVector<uint64_t, 16> UnusedFileScopedDecls; 803 804 /// A list of all the delegating constructors we've seen, to diagnose 805 /// cycles. 806 SmallVector<uint64_t, 4> DelegatingCtorDecls; 807 808 /// Method selectors used in a @selector expression. Used for 809 /// implementation of -Wselector. 810 SmallVector<uint64_t, 64> ReferencedSelectorsData; 811 812 /// A snapshot of Sema's weak undeclared identifier tracking, for 813 /// generating warnings. 814 SmallVector<uint64_t, 64> WeakUndeclaredIdentifiers; 815 816 /// The IDs of type aliases for ext_vectors that exist in the chain. 817 /// 818 /// Used by Sema for finding sugared names for ext_vectors in diagnostics. 819 SmallVector<uint64_t, 4> ExtVectorDecls; 820 821 //@} 822 823 /// \name Sema-relevant special data 824 /// Fields containing data that is used for semantic analysis 825 //@{ 826 827 /// The IDs of all potentially unused typedef names in the chain. 828 /// 829 /// Sema tracks these to emit warnings. 830 SmallVector<uint64_t, 16> UnusedLocalTypedefNameCandidates; 831 832 /// Our current depth in #pragma cuda force_host_device begin/end 833 /// macros. 834 unsigned ForceCUDAHostDeviceDepth = 0; 835 836 /// The IDs of the declarations Sema stores directly. 837 /// 838 /// Sema tracks a few important decls, such as namespace std, directly. 839 SmallVector<uint64_t, 4> SemaDeclRefs; 840 841 /// The IDs of the types ASTContext stores directly. 842 /// 843 /// The AST context tracks a few important types, such as va_list, directly. 844 SmallVector<uint64_t, 16> SpecialTypes; 845 846 /// The IDs of CUDA-specific declarations ASTContext stores directly. 847 /// 848 /// The AST context tracks a few important decls, currently cudaConfigureCall, 849 /// directly. 850 SmallVector<uint64_t, 2> CUDASpecialDeclRefs; 851 852 /// The floating point pragma option settings. 853 SmallVector<uint64_t, 1> FPPragmaOptions; 854 855 /// The pragma clang optimize location (if the pragma state is "off"). 856 SourceLocation OptimizeOffPragmaLocation; 857 858 /// The PragmaMSStructKind pragma ms_struct state if set, or -1. 859 int PragmaMSStructState = -1; 860 861 /// The PragmaMSPointersToMembersKind pragma pointers_to_members state. 862 int PragmaMSPointersToMembersState = -1; 863 SourceLocation PointersToMembersPragmaLocation; 864 865 /// The pragma float_control state. 866 Optional<FPOptionsOverride> FpPragmaCurrentValue; 867 SourceLocation FpPragmaCurrentLocation; 868 struct FpPragmaStackEntry { 869 FPOptionsOverride Value; 870 SourceLocation Location; 871 SourceLocation PushLocation; 872 StringRef SlotLabel; 873 }; 874 llvm::SmallVector<FpPragmaStackEntry, 2> FpPragmaStack; 875 llvm::SmallVector<std::string, 2> FpPragmaStrings; 876 877 /// The pragma align/pack state. 878 Optional<Sema::AlignPackInfo> PragmaAlignPackCurrentValue; 879 SourceLocation PragmaAlignPackCurrentLocation; 880 struct PragmaAlignPackStackEntry { 881 Sema::AlignPackInfo Value; 882 SourceLocation Location; 883 SourceLocation PushLocation; 884 StringRef SlotLabel; 885 }; 886 llvm::SmallVector<PragmaAlignPackStackEntry, 2> PragmaAlignPackStack; 887 llvm::SmallVector<std::string, 2> PragmaAlignPackStrings; 888 889 /// The OpenCL extension settings. 890 OpenCLOptions OpenCLExtensions; 891 892 /// Extensions required by an OpenCL type. 893 llvm::DenseMap<const Type *, std::set<std::string>> OpenCLTypeExtMap; 894 895 /// Extensions required by an OpenCL declaration. 896 llvm::DenseMap<const Decl *, std::set<std::string>> OpenCLDeclExtMap; 897 898 /// A list of the namespaces we've seen. 899 SmallVector<uint64_t, 4> KnownNamespaces; 900 901 /// A list of undefined decls with internal linkage followed by the 902 /// SourceLocation of a matching ODR-use. 903 SmallVector<uint64_t, 8> UndefinedButUsed; 904 905 /// Delete expressions to analyze at the end of translation unit. 906 SmallVector<uint64_t, 8> DelayedDeleteExprs; 907 908 // A list of late parsed template function data with their module files. 909 SmallVector<std::pair<ModuleFile *, SmallVector<uint64_t, 1>>, 4> 910 LateParsedTemplates; 911 912 /// The IDs of all decls to be checked for deferred diags. 913 /// 914 /// Sema tracks these to emit deferred diags. 915 SmallVector<uint64_t, 4> DeclsToCheckForDeferredDiags; 916 917 918 public: 919 struct ImportedSubmodule { 920 serialization::SubmoduleID ID; 921 SourceLocation ImportLoc; 922 923 ImportedSubmodule(serialization::SubmoduleID ID, SourceLocation ImportLoc) 924 : ID(ID), ImportLoc(ImportLoc) {} 925 }; 926 927 private: 928 /// A list of modules that were imported by precompiled headers or 929 /// any other non-module AST file. 930 SmallVector<ImportedSubmodule, 2> ImportedModules; 931 //@} 932 933 /// The system include root to be used when loading the 934 /// precompiled header. 935 std::string isysroot; 936 937 /// Whether to disable the normal validation performed on precompiled 938 /// headers and module files when they are loaded. 939 DisableValidationForModuleKind DisableValidationKind; 940 941 /// Whether to accept an AST file with compiler errors. 942 bool AllowASTWithCompilerErrors; 943 944 /// Whether to accept an AST file that has a different configuration 945 /// from the current compiler instance. 946 bool AllowConfigurationMismatch; 947 948 /// Whether validate system input files. 949 bool ValidateSystemInputs; 950 951 /// Whether validate headers and module maps using hash based on contents. 952 bool ValidateASTInputFilesContent; 953 954 /// Whether we are allowed to use the global module index. 955 bool UseGlobalIndex; 956 957 /// Whether we have tried loading the global module index yet. 958 bool TriedLoadingGlobalIndex = false; 959 960 ///Whether we are currently processing update records. 961 bool ProcessingUpdateRecords = false; 962 963 using SwitchCaseMapTy = llvm::DenseMap<unsigned, SwitchCase *>; 964 965 /// Mapping from switch-case IDs in the chain to switch-case statements 966 /// 967 /// Statements usually don't have IDs, but switch cases need them, so that the 968 /// switch statement can refer to them. 969 SwitchCaseMapTy SwitchCaseStmts; 970 971 SwitchCaseMapTy *CurrSwitchCaseStmts; 972 973 /// The number of source location entries de-serialized from 974 /// the PCH file. 975 unsigned NumSLocEntriesRead = 0; 976 977 /// The number of source location entries in the chain. 978 unsigned TotalNumSLocEntries = 0; 979 980 /// The number of statements (and expressions) de-serialized 981 /// from the chain. 982 unsigned NumStatementsRead = 0; 983 984 /// The total number of statements (and expressions) stored 985 /// in the chain. 986 unsigned TotalNumStatements = 0; 987 988 /// The number of macros de-serialized from the chain. 989 unsigned NumMacrosRead = 0; 990 991 /// The total number of macros stored in the chain. 992 unsigned TotalNumMacros = 0; 993 994 /// The number of lookups into identifier tables. 995 unsigned NumIdentifierLookups = 0; 996 997 /// The number of lookups into identifier tables that succeed. 998 unsigned NumIdentifierLookupHits = 0; 999 1000 /// The number of selectors that have been read. 1001 unsigned NumSelectorsRead = 0; 1002 1003 /// The number of method pool entries that have been read. 1004 unsigned NumMethodPoolEntriesRead = 0; 1005 1006 /// The number of times we have looked up a selector in the method 1007 /// pool. 1008 unsigned NumMethodPoolLookups = 0; 1009 1010 /// The number of times we have looked up a selector in the method 1011 /// pool and found something. 1012 unsigned NumMethodPoolHits = 0; 1013 1014 /// The number of times we have looked up a selector in the method 1015 /// pool within a specific module. 1016 unsigned NumMethodPoolTableLookups = 0; 1017 1018 /// The number of times we have looked up a selector in the method 1019 /// pool within a specific module and found something. 1020 unsigned NumMethodPoolTableHits = 0; 1021 1022 /// The total number of method pool entries in the selector table. 1023 unsigned TotalNumMethodPoolEntries = 0; 1024 1025 /// Number of lexical decl contexts read/total. 1026 unsigned NumLexicalDeclContextsRead = 0, TotalLexicalDeclContexts = 0; 1027 1028 /// Number of visible decl contexts read/total. 1029 unsigned NumVisibleDeclContextsRead = 0, TotalVisibleDeclContexts = 0; 1030 1031 /// Total size of modules, in bits, currently loaded 1032 uint64_t TotalModulesSizeInBits = 0; 1033 1034 /// Number of Decl/types that are currently deserializing. 1035 unsigned NumCurrentElementsDeserializing = 0; 1036 1037 /// Set true while we are in the process of passing deserialized 1038 /// "interesting" decls to consumer inside FinishedDeserializing(). 1039 /// This is used as a guard to avoid recursively repeating the process of 1040 /// passing decls to consumer. 1041 bool PassingDeclsToConsumer = false; 1042 1043 /// The set of identifiers that were read while the AST reader was 1044 /// (recursively) loading declarations. 1045 /// 1046 /// The declarations on the identifier chain for these identifiers will be 1047 /// loaded once the recursive loading has completed. 1048 llvm::MapVector<IdentifierInfo *, SmallVector<uint32_t, 4>> 1049 PendingIdentifierInfos; 1050 1051 /// The set of lookup results that we have faked in order to support 1052 /// merging of partially deserialized decls but that we have not yet removed. 1053 llvm::SmallMapVector<IdentifierInfo *, SmallVector<NamedDecl*, 2>, 16> 1054 PendingFakeLookupResults; 1055 1056 /// The generation number of each identifier, which keeps track of 1057 /// the last time we loaded information about this identifier. 1058 llvm::DenseMap<IdentifierInfo *, unsigned> IdentifierGeneration; 1059 1060 class InterestingDecl { 1061 Decl *D; 1062 bool DeclHasPendingBody; 1063 1064 public: 1065 InterestingDecl(Decl *D, bool HasBody) 1066 : D(D), DeclHasPendingBody(HasBody) {} 1067 1068 Decl *getDecl() { return D; } 1069 1070 /// Whether the declaration has a pending body. 1071 bool hasPendingBody() { return DeclHasPendingBody; } 1072 }; 1073 1074 /// Contains declarations and definitions that could be 1075 /// "interesting" to the ASTConsumer, when we get that AST consumer. 1076 /// 1077 /// "Interesting" declarations are those that have data that may 1078 /// need to be emitted, such as inline function definitions or 1079 /// Objective-C protocols. 1080 std::deque<InterestingDecl> PotentiallyInterestingDecls; 1081 1082 /// The list of deduced function types that we have not yet read, because 1083 /// they might contain a deduced return type that refers to a local type 1084 /// declared within the function. 1085 SmallVector<std::pair<FunctionDecl *, serialization::TypeID>, 16> 1086 PendingFunctionTypes; 1087 1088 /// The list of redeclaration chains that still need to be 1089 /// reconstructed, and the local offset to the corresponding list 1090 /// of redeclarations. 1091 SmallVector<std::pair<Decl *, uint64_t>, 16> PendingDeclChains; 1092 1093 /// The list of canonical declarations whose redeclaration chains 1094 /// need to be marked as incomplete once we're done deserializing things. 1095 SmallVector<Decl *, 16> PendingIncompleteDeclChains; 1096 1097 /// The Decl IDs for the Sema/Lexical DeclContext of a Decl that has 1098 /// been loaded but its DeclContext was not set yet. 1099 struct PendingDeclContextInfo { 1100 Decl *D; 1101 serialization::GlobalDeclID SemaDC; 1102 serialization::GlobalDeclID LexicalDC; 1103 }; 1104 1105 /// The set of Decls that have been loaded but their DeclContexts are 1106 /// not set yet. 1107 /// 1108 /// The DeclContexts for these Decls will be set once recursive loading has 1109 /// been completed. 1110 std::deque<PendingDeclContextInfo> PendingDeclContextInfos; 1111 1112 /// The set of NamedDecls that have been loaded, but are members of a 1113 /// context that has been merged into another context where the corresponding 1114 /// declaration is either missing or has not yet been loaded. 1115 /// 1116 /// We will check whether the corresponding declaration is in fact missing 1117 /// once recursing loading has been completed. 1118 llvm::SmallVector<NamedDecl *, 16> PendingOdrMergeChecks; 1119 1120 using DataPointers = 1121 std::pair<CXXRecordDecl *, struct CXXRecordDecl::DefinitionData *>; 1122 1123 /// Record definitions in which we found an ODR violation. 1124 llvm::SmallDenseMap<CXXRecordDecl *, llvm::SmallVector<DataPointers, 2>, 2> 1125 PendingOdrMergeFailures; 1126 1127 /// Function definitions in which we found an ODR violation. 1128 llvm::SmallDenseMap<FunctionDecl *, llvm::SmallVector<FunctionDecl *, 2>, 2> 1129 PendingFunctionOdrMergeFailures; 1130 1131 /// Enum definitions in which we found an ODR violation. 1132 llvm::SmallDenseMap<EnumDecl *, llvm::SmallVector<EnumDecl *, 2>, 2> 1133 PendingEnumOdrMergeFailures; 1134 1135 /// DeclContexts in which we have diagnosed an ODR violation. 1136 llvm::SmallPtrSet<DeclContext*, 2> DiagnosedOdrMergeFailures; 1137 1138 /// The set of Objective-C categories that have been deserialized 1139 /// since the last time the declaration chains were linked. 1140 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> CategoriesDeserialized; 1141 1142 /// The set of Objective-C class definitions that have already been 1143 /// loaded, for which we will need to check for categories whenever a new 1144 /// module is loaded. 1145 SmallVector<ObjCInterfaceDecl *, 16> ObjCClassesLoaded; 1146 1147 using KeyDeclsMap = 1148 llvm::DenseMap<Decl *, SmallVector<serialization::DeclID, 2>>; 1149 1150 /// A mapping from canonical declarations to the set of global 1151 /// declaration IDs for key declaration that have been merged with that 1152 /// canonical declaration. A key declaration is a formerly-canonical 1153 /// declaration whose module did not import any other key declaration for that 1154 /// entity. These are the IDs that we use as keys when finding redecl chains. 1155 KeyDeclsMap KeyDecls; 1156 1157 /// A mapping from DeclContexts to the semantic DeclContext that we 1158 /// are treating as the definition of the entity. This is used, for instance, 1159 /// when merging implicit instantiations of class templates across modules. 1160 llvm::DenseMap<DeclContext *, DeclContext *> MergedDeclContexts; 1161 1162 /// A mapping from canonical declarations of enums to their canonical 1163 /// definitions. Only populated when using modules in C++. 1164 llvm::DenseMap<EnumDecl *, EnumDecl *> EnumDefinitions; 1165 1166 /// When reading a Stmt tree, Stmt operands are placed in this stack. 1167 SmallVector<Stmt *, 16> StmtStack; 1168 1169 /// What kind of records we are reading. 1170 enum ReadingKind { 1171 Read_None, Read_Decl, Read_Type, Read_Stmt 1172 }; 1173 1174 /// What kind of records we are reading. 1175 ReadingKind ReadingKind = Read_None; 1176 1177 /// RAII object to change the reading kind. 1178 class ReadingKindTracker { 1179 ASTReader &Reader; 1180 enum ReadingKind PrevKind; 1181 1182 public: 1183 ReadingKindTracker(enum ReadingKind newKind, ASTReader &reader) 1184 : Reader(reader), PrevKind(Reader.ReadingKind) { 1185 Reader.ReadingKind = newKind; 1186 } 1187 1188 ReadingKindTracker(const ReadingKindTracker &) = delete; 1189 ReadingKindTracker &operator=(const ReadingKindTracker &) = delete; 1190 ~ReadingKindTracker() { Reader.ReadingKind = PrevKind; } 1191 }; 1192 1193 /// RAII object to mark the start of processing updates. 1194 class ProcessingUpdatesRAIIObj { 1195 ASTReader &Reader; 1196 bool PrevState; 1197 1198 public: 1199 ProcessingUpdatesRAIIObj(ASTReader &reader) 1200 : Reader(reader), PrevState(Reader.ProcessingUpdateRecords) { 1201 Reader.ProcessingUpdateRecords = true; 1202 } 1203 1204 ProcessingUpdatesRAIIObj(const ProcessingUpdatesRAIIObj &) = delete; 1205 ProcessingUpdatesRAIIObj & 1206 operator=(const ProcessingUpdatesRAIIObj &) = delete; 1207 ~ProcessingUpdatesRAIIObj() { Reader.ProcessingUpdateRecords = PrevState; } 1208 }; 1209 1210 /// Suggested contents of the predefines buffer, after this 1211 /// PCH file has been processed. 1212 /// 1213 /// In most cases, this string will be empty, because the predefines 1214 /// buffer computed to build the PCH file will be identical to the 1215 /// predefines buffer computed from the command line. However, when 1216 /// there are differences that the PCH reader can work around, this 1217 /// predefines buffer may contain additional definitions. 1218 std::string SuggestedPredefines; 1219 1220 llvm::DenseMap<const Decl *, bool> DefinitionSource; 1221 1222 bool shouldDisableValidationForFile(const serialization::ModuleFile &M) const; 1223 1224 /// Reads a statement from the specified cursor. 1225 Stmt *ReadStmtFromStream(ModuleFile &F); 1226 1227 struct InputFileInfo { 1228 std::string Filename; 1229 uint64_t ContentHash; 1230 off_t StoredSize; 1231 time_t StoredTime; 1232 bool Overridden; 1233 bool Transient; 1234 bool TopLevelModuleMap; 1235 }; 1236 1237 /// Reads the stored information about an input file. 1238 InputFileInfo readInputFileInfo(ModuleFile &F, unsigned ID); 1239 1240 /// Retrieve the file entry and 'overridden' bit for an input 1241 /// file in the given module file. 1242 serialization::InputFile getInputFile(ModuleFile &F, unsigned ID, 1243 bool Complain = true); 1244 1245 public: 1246 void ResolveImportedPath(ModuleFile &M, std::string &Filename); 1247 static void ResolveImportedPath(std::string &Filename, StringRef Prefix); 1248 1249 /// Returns the first key declaration for the given declaration. This 1250 /// is one that is formerly-canonical (or still canonical) and whose module 1251 /// did not import any other key declaration of the entity. 1252 Decl *getKeyDeclaration(Decl *D) { 1253 D = D->getCanonicalDecl(); 1254 if (D->isFromASTFile()) 1255 return D; 1256 1257 auto I = KeyDecls.find(D); 1258 if (I == KeyDecls.end() || I->second.empty()) 1259 return D; 1260 return GetExistingDecl(I->second[0]); 1261 } 1262 const Decl *getKeyDeclaration(const Decl *D) { 1263 return getKeyDeclaration(const_cast<Decl*>(D)); 1264 } 1265 1266 /// Run a callback on each imported key declaration of \p D. 1267 template <typename Fn> 1268 void forEachImportedKeyDecl(const Decl *D, Fn Visit) { 1269 D = D->getCanonicalDecl(); 1270 if (D->isFromASTFile()) 1271 Visit(D); 1272 1273 auto It = KeyDecls.find(const_cast<Decl*>(D)); 1274 if (It != KeyDecls.end()) 1275 for (auto ID : It->second) 1276 Visit(GetExistingDecl(ID)); 1277 } 1278 1279 /// Get the loaded lookup tables for \p Primary, if any. 1280 const serialization::reader::DeclContextLookupTable * 1281 getLoadedLookupTables(DeclContext *Primary) const; 1282 1283 private: 1284 struct ImportedModule { 1285 ModuleFile *Mod; 1286 ModuleFile *ImportedBy; 1287 SourceLocation ImportLoc; 1288 1289 ImportedModule(ModuleFile *Mod, 1290 ModuleFile *ImportedBy, 1291 SourceLocation ImportLoc) 1292 : Mod(Mod), ImportedBy(ImportedBy), ImportLoc(ImportLoc) {} 1293 }; 1294 1295 ASTReadResult ReadASTCore(StringRef FileName, ModuleKind Type, 1296 SourceLocation ImportLoc, ModuleFile *ImportedBy, 1297 SmallVectorImpl<ImportedModule> &Loaded, 1298 off_t ExpectedSize, time_t ExpectedModTime, 1299 ASTFileSignature ExpectedSignature, 1300 unsigned ClientLoadCapabilities); 1301 ASTReadResult ReadControlBlock(ModuleFile &F, 1302 SmallVectorImpl<ImportedModule> &Loaded, 1303 const ModuleFile *ImportedBy, 1304 unsigned ClientLoadCapabilities); 1305 static ASTReadResult ReadOptionsBlock( 1306 llvm::BitstreamCursor &Stream, unsigned ClientLoadCapabilities, 1307 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener, 1308 std::string &SuggestedPredefines); 1309 1310 /// Read the unhashed control block. 1311 /// 1312 /// This has no effect on \c F.Stream, instead creating a fresh cursor from 1313 /// \c F.Data and reading ahead. 1314 ASTReadResult readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy, 1315 unsigned ClientLoadCapabilities); 1316 1317 static ASTReadResult 1318 readUnhashedControlBlockImpl(ModuleFile *F, llvm::StringRef StreamData, 1319 unsigned ClientLoadCapabilities, 1320 bool AllowCompatibleConfigurationMismatch, 1321 ASTReaderListener *Listener, 1322 bool ValidateDiagnosticOptions); 1323 1324 ASTReadResult ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities); 1325 ASTReadResult ReadExtensionBlock(ModuleFile &F); 1326 void ReadModuleOffsetMap(ModuleFile &F) const; 1327 bool ParseLineTable(ModuleFile &F, const RecordData &Record); 1328 bool ReadSourceManagerBlock(ModuleFile &F); 1329 llvm::BitstreamCursor &SLocCursorForID(int ID); 1330 SourceLocation getImportLocation(ModuleFile *F); 1331 ASTReadResult ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F, 1332 const ModuleFile *ImportedBy, 1333 unsigned ClientLoadCapabilities); 1334 ASTReadResult ReadSubmoduleBlock(ModuleFile &F, 1335 unsigned ClientLoadCapabilities); 1336 static bool ParseLanguageOptions(const RecordData &Record, bool Complain, 1337 ASTReaderListener &Listener, 1338 bool AllowCompatibleDifferences); 1339 static bool ParseTargetOptions(const RecordData &Record, bool Complain, 1340 ASTReaderListener &Listener, 1341 bool AllowCompatibleDifferences); 1342 static bool ParseDiagnosticOptions(const RecordData &Record, bool Complain, 1343 ASTReaderListener &Listener); 1344 static bool ParseFileSystemOptions(const RecordData &Record, bool Complain, 1345 ASTReaderListener &Listener); 1346 static bool ParseHeaderSearchOptions(const RecordData &Record, bool Complain, 1347 ASTReaderListener &Listener); 1348 static bool ParsePreprocessorOptions(const RecordData &Record, bool Complain, 1349 ASTReaderListener &Listener, 1350 std::string &SuggestedPredefines); 1351 1352 struct RecordLocation { 1353 ModuleFile *F; 1354 uint64_t Offset; 1355 1356 RecordLocation(ModuleFile *M, uint64_t O) : F(M), Offset(O) {} 1357 }; 1358 1359 QualType readTypeRecord(unsigned Index); 1360 RecordLocation TypeCursorForIndex(unsigned Index); 1361 void LoadedDecl(unsigned Index, Decl *D); 1362 Decl *ReadDeclRecord(serialization::DeclID ID); 1363 void markIncompleteDeclChain(Decl *Canon); 1364 1365 /// Returns the most recent declaration of a declaration (which must be 1366 /// of a redeclarable kind) that is either local or has already been loaded 1367 /// merged into its redecl chain. 1368 Decl *getMostRecentExistingDecl(Decl *D); 1369 1370 RecordLocation DeclCursorForID(serialization::DeclID ID, 1371 SourceLocation &Location); 1372 void loadDeclUpdateRecords(PendingUpdateRecord &Record); 1373 void loadPendingDeclChain(Decl *D, uint64_t LocalOffset); 1374 void loadObjCCategories(serialization::GlobalDeclID ID, ObjCInterfaceDecl *D, 1375 unsigned PreviousGeneration = 0); 1376 1377 RecordLocation getLocalBitOffset(uint64_t GlobalOffset); 1378 uint64_t getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset); 1379 1380 /// Returns the first preprocessed entity ID that begins or ends after 1381 /// \arg Loc. 1382 serialization::PreprocessedEntityID 1383 findPreprocessedEntity(SourceLocation Loc, bool EndsAfter) const; 1384 1385 /// Find the next module that contains entities and return the ID 1386 /// of the first entry. 1387 /// 1388 /// \param SLocMapI points at a chunk of a module that contains no 1389 /// preprocessed entities or the entities it contains are not the 1390 /// ones we are looking for. 1391 serialization::PreprocessedEntityID 1392 findNextPreprocessedEntity( 1393 GlobalSLocOffsetMapType::const_iterator SLocMapI) const; 1394 1395 /// Returns (ModuleFile, Local index) pair for \p GlobalIndex of a 1396 /// preprocessed entity. 1397 std::pair<ModuleFile *, unsigned> 1398 getModulePreprocessedEntity(unsigned GlobalIndex); 1399 1400 /// Returns (begin, end) pair for the preprocessed entities of a 1401 /// particular module. 1402 llvm::iterator_range<PreprocessingRecord::iterator> 1403 getModulePreprocessedEntities(ModuleFile &Mod) const; 1404 1405 public: 1406 class ModuleDeclIterator 1407 : public llvm::iterator_adaptor_base< 1408 ModuleDeclIterator, const serialization::LocalDeclID *, 1409 std::random_access_iterator_tag, const Decl *, ptrdiff_t, 1410 const Decl *, const Decl *> { 1411 ASTReader *Reader = nullptr; 1412 ModuleFile *Mod = nullptr; 1413 1414 public: 1415 ModuleDeclIterator() : iterator_adaptor_base(nullptr) {} 1416 1417 ModuleDeclIterator(ASTReader *Reader, ModuleFile *Mod, 1418 const serialization::LocalDeclID *Pos) 1419 : iterator_adaptor_base(Pos), Reader(Reader), Mod(Mod) {} 1420 1421 value_type operator*() const { 1422 return Reader->GetDecl(Reader->getGlobalDeclID(*Mod, *I)); 1423 } 1424 1425 value_type operator->() const { return **this; } 1426 1427 bool operator==(const ModuleDeclIterator &RHS) const { 1428 assert(Reader == RHS.Reader && Mod == RHS.Mod); 1429 return I == RHS.I; 1430 } 1431 }; 1432 1433 llvm::iterator_range<ModuleDeclIterator> 1434 getModuleFileLevelDecls(ModuleFile &Mod); 1435 1436 private: 1437 void PassInterestingDeclsToConsumer(); 1438 void PassInterestingDeclToConsumer(Decl *D); 1439 1440 void finishPendingActions(); 1441 void diagnoseOdrViolations(); 1442 1443 void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name); 1444 1445 void addPendingDeclContextInfo(Decl *D, 1446 serialization::GlobalDeclID SemaDC, 1447 serialization::GlobalDeclID LexicalDC) { 1448 assert(D); 1449 PendingDeclContextInfo Info = { D, SemaDC, LexicalDC }; 1450 PendingDeclContextInfos.push_back(Info); 1451 } 1452 1453 /// Produce an error diagnostic and return true. 1454 /// 1455 /// This routine should only be used for fatal errors that have to 1456 /// do with non-routine failures (e.g., corrupted AST file). 1457 void Error(StringRef Msg) const; 1458 void Error(unsigned DiagID, StringRef Arg1 = StringRef(), 1459 StringRef Arg2 = StringRef(), StringRef Arg3 = StringRef()) const; 1460 void Error(llvm::Error &&Err) const; 1461 1462 public: 1463 /// Load the AST file and validate its contents against the given 1464 /// Preprocessor. 1465 /// 1466 /// \param PP the preprocessor associated with the context in which this 1467 /// precompiled header will be loaded. 1468 /// 1469 /// \param Context the AST context that this precompiled header will be 1470 /// loaded into, if any. 1471 /// 1472 /// \param PCHContainerRdr the PCHContainerOperations to use for loading and 1473 /// creating modules. 1474 /// 1475 /// \param Extensions the list of module file extensions that can be loaded 1476 /// from the AST files. 1477 /// 1478 /// \param isysroot If non-NULL, the system include path specified by the 1479 /// user. This is only used with relocatable PCH files. If non-NULL, 1480 /// a relocatable PCH file will use the default path "/". 1481 /// 1482 /// \param DisableValidationKind If set, the AST reader will suppress most 1483 /// of its regular consistency checking, allowing the use of precompiled 1484 /// headers and module files that cannot be determined to be compatible. 1485 /// 1486 /// \param AllowASTWithCompilerErrors If true, the AST reader will accept an 1487 /// AST file the was created out of an AST with compiler errors, 1488 /// otherwise it will reject it. 1489 /// 1490 /// \param AllowConfigurationMismatch If true, the AST reader will not check 1491 /// for configuration differences between the AST file and the invocation. 1492 /// 1493 /// \param ValidateSystemInputs If true, the AST reader will validate 1494 /// system input files in addition to user input files. This is only 1495 /// meaningful if \p DisableValidation is false. 1496 /// 1497 /// \param UseGlobalIndex If true, the AST reader will try to load and use 1498 /// the global module index. 1499 /// 1500 /// \param ReadTimer If non-null, a timer used to track the time spent 1501 /// deserializing. 1502 ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache, 1503 ASTContext *Context, const PCHContainerReader &PCHContainerRdr, 1504 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions, 1505 StringRef isysroot = "", 1506 DisableValidationForModuleKind DisableValidationKind = 1507 DisableValidationForModuleKind::None, 1508 bool AllowASTWithCompilerErrors = false, 1509 bool AllowConfigurationMismatch = false, 1510 bool ValidateSystemInputs = false, 1511 bool ValidateASTInputFilesContent = false, 1512 bool UseGlobalIndex = true, 1513 std::unique_ptr<llvm::Timer> ReadTimer = {}); 1514 ASTReader(const ASTReader &) = delete; 1515 ASTReader &operator=(const ASTReader &) = delete; 1516 ~ASTReader() override; 1517 1518 SourceManager &getSourceManager() const { return SourceMgr; } 1519 FileManager &getFileManager() const { return FileMgr; } 1520 DiagnosticsEngine &getDiags() const { return Diags; } 1521 1522 /// Flags that indicate what kind of AST loading failures the client 1523 /// of the AST reader can directly handle. 1524 /// 1525 /// When a client states that it can handle a particular kind of failure, 1526 /// the AST reader will not emit errors when producing that kind of failure. 1527 enum LoadFailureCapabilities { 1528 /// The client can't handle any AST loading failures. 1529 ARR_None = 0, 1530 1531 /// The client can handle an AST file that cannot load because it 1532 /// is missing. 1533 ARR_Missing = 0x1, 1534 1535 /// The client can handle an AST file that cannot load because it 1536 /// is out-of-date relative to its input files. 1537 ARR_OutOfDate = 0x2, 1538 1539 /// The client can handle an AST file that cannot load because it 1540 /// was built with a different version of Clang. 1541 ARR_VersionMismatch = 0x4, 1542 1543 /// The client can handle an AST file that cannot load because it's 1544 /// compiled configuration doesn't match that of the context it was 1545 /// loaded into. 1546 ARR_ConfigurationMismatch = 0x8 1547 }; 1548 1549 /// Load the AST file designated by the given file name. 1550 /// 1551 /// \param FileName The name of the AST file to load. 1552 /// 1553 /// \param Type The kind of AST being loaded, e.g., PCH, module, main file, 1554 /// or preamble. 1555 /// 1556 /// \param ImportLoc the location where the module file will be considered as 1557 /// imported from. For non-module AST types it should be invalid. 1558 /// 1559 /// \param ClientLoadCapabilities The set of client load-failure 1560 /// capabilities, represented as a bitset of the enumerators of 1561 /// LoadFailureCapabilities. 1562 /// 1563 /// \param Imported optional out-parameter to append the list of modules 1564 /// that were imported by precompiled headers or any other non-module AST file 1565 ASTReadResult ReadAST(StringRef FileName, ModuleKind Type, 1566 SourceLocation ImportLoc, 1567 unsigned ClientLoadCapabilities, 1568 SmallVectorImpl<ImportedSubmodule> *Imported = nullptr); 1569 1570 /// Make the entities in the given module and any of its (non-explicit) 1571 /// submodules visible to name lookup. 1572 /// 1573 /// \param Mod The module whose names should be made visible. 1574 /// 1575 /// \param NameVisibility The level of visibility to give the names in the 1576 /// module. Visibility can only be increased over time. 1577 /// 1578 /// \param ImportLoc The location at which the import occurs. 1579 void makeModuleVisible(Module *Mod, 1580 Module::NameVisibilityKind NameVisibility, 1581 SourceLocation ImportLoc); 1582 1583 /// Make the names within this set of hidden names visible. 1584 void makeNamesVisible(const HiddenNames &Names, Module *Owner); 1585 1586 /// Note that MergedDef is a redefinition of the canonical definition 1587 /// Def, so Def should be visible whenever MergedDef is. 1588 void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef); 1589 1590 /// Take the AST callbacks listener. 1591 std::unique_ptr<ASTReaderListener> takeListener() { 1592 return std::move(Listener); 1593 } 1594 1595 /// Set the AST callbacks listener. 1596 void setListener(std::unique_ptr<ASTReaderListener> Listener) { 1597 this->Listener = std::move(Listener); 1598 } 1599 1600 /// Add an AST callback listener. 1601 /// 1602 /// Takes ownership of \p L. 1603 void addListener(std::unique_ptr<ASTReaderListener> L) { 1604 if (Listener) 1605 L = std::make_unique<ChainedASTReaderListener>(std::move(L), 1606 std::move(Listener)); 1607 Listener = std::move(L); 1608 } 1609 1610 /// RAII object to temporarily add an AST callback listener. 1611 class ListenerScope { 1612 ASTReader &Reader; 1613 bool Chained = false; 1614 1615 public: 1616 ListenerScope(ASTReader &Reader, std::unique_ptr<ASTReaderListener> L) 1617 : Reader(Reader) { 1618 auto Old = Reader.takeListener(); 1619 if (Old) { 1620 Chained = true; 1621 L = std::make_unique<ChainedASTReaderListener>(std::move(L), 1622 std::move(Old)); 1623 } 1624 Reader.setListener(std::move(L)); 1625 } 1626 1627 ~ListenerScope() { 1628 auto New = Reader.takeListener(); 1629 if (Chained) 1630 Reader.setListener(static_cast<ChainedASTReaderListener *>(New.get()) 1631 ->takeSecond()); 1632 } 1633 }; 1634 1635 /// Set the AST deserialization listener. 1636 void setDeserializationListener(ASTDeserializationListener *Listener, 1637 bool TakeOwnership = false); 1638 1639 /// Get the AST deserialization listener. 1640 ASTDeserializationListener *getDeserializationListener() { 1641 return DeserializationListener; 1642 } 1643 1644 /// Determine whether this AST reader has a global index. 1645 bool hasGlobalIndex() const { return (bool)GlobalIndex; } 1646 1647 /// Return global module index. 1648 GlobalModuleIndex *getGlobalIndex() { return GlobalIndex.get(); } 1649 1650 /// Reset reader for a reload try. 1651 void resetForReload() { TriedLoadingGlobalIndex = false; } 1652 1653 /// Attempts to load the global index. 1654 /// 1655 /// \returns true if loading the global index has failed for any reason. 1656 bool loadGlobalIndex(); 1657 1658 /// Determine whether we tried to load the global index, but failed, 1659 /// e.g., because it is out-of-date or does not exist. 1660 bool isGlobalIndexUnavailable() const; 1661 1662 /// Initializes the ASTContext 1663 void InitializeContext(); 1664 1665 /// Update the state of Sema after loading some additional modules. 1666 void UpdateSema(); 1667 1668 /// Add in-memory (virtual file) buffer. 1669 void addInMemoryBuffer(StringRef &FileName, 1670 std::unique_ptr<llvm::MemoryBuffer> Buffer) { 1671 ModuleMgr.addInMemoryBuffer(FileName, std::move(Buffer)); 1672 } 1673 1674 /// Finalizes the AST reader's state before writing an AST file to 1675 /// disk. 1676 /// 1677 /// This operation may undo temporary state in the AST that should not be 1678 /// emitted. 1679 void finalizeForWriting(); 1680 1681 /// Retrieve the module manager. 1682 ModuleManager &getModuleManager() { return ModuleMgr; } 1683 1684 /// Retrieve the preprocessor. 1685 Preprocessor &getPreprocessor() const { return PP; } 1686 1687 /// Retrieve the name of the original source file name for the primary 1688 /// module file. 1689 StringRef getOriginalSourceFile() { 1690 return ModuleMgr.getPrimaryModule().OriginalSourceFileName; 1691 } 1692 1693 /// Retrieve the name of the original source file name directly from 1694 /// the AST file, without actually loading the AST file. 1695 static std::string 1696 getOriginalSourceFile(const std::string &ASTFileName, FileManager &FileMgr, 1697 const PCHContainerReader &PCHContainerRdr, 1698 DiagnosticsEngine &Diags); 1699 1700 /// Read the control block for the named AST file. 1701 /// 1702 /// \returns true if an error occurred, false otherwise. 1703 static bool 1704 readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, 1705 const PCHContainerReader &PCHContainerRdr, 1706 bool FindModuleFileExtensions, 1707 ASTReaderListener &Listener, 1708 bool ValidateDiagnosticOptions); 1709 1710 /// Determine whether the given AST file is acceptable to load into a 1711 /// translation unit with the given language and target options. 1712 static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr, 1713 const PCHContainerReader &PCHContainerRdr, 1714 const LangOptions &LangOpts, 1715 const TargetOptions &TargetOpts, 1716 const PreprocessorOptions &PPOpts, 1717 StringRef ExistingModuleCachePath); 1718 1719 /// Returns the suggested contents of the predefines buffer, 1720 /// which contains a (typically-empty) subset of the predefines 1721 /// build prior to including the precompiled header. 1722 const std::string &getSuggestedPredefines() { return SuggestedPredefines; } 1723 1724 /// Read a preallocated preprocessed entity from the external source. 1725 /// 1726 /// \returns null if an error occurred that prevented the preprocessed 1727 /// entity from being loaded. 1728 PreprocessedEntity *ReadPreprocessedEntity(unsigned Index) override; 1729 1730 /// Returns a pair of [Begin, End) indices of preallocated 1731 /// preprocessed entities that \p Range encompasses. 1732 std::pair<unsigned, unsigned> 1733 findPreprocessedEntitiesInRange(SourceRange Range) override; 1734 1735 /// Optionally returns true or false if the preallocated preprocessed 1736 /// entity with index \p Index came from file \p FID. 1737 Optional<bool> isPreprocessedEntityInFileID(unsigned Index, 1738 FileID FID) override; 1739 1740 /// Read a preallocated skipped range from the external source. 1741 SourceRange ReadSkippedRange(unsigned Index) override; 1742 1743 /// Read the header file information for the given file entry. 1744 HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE) override; 1745 1746 void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag); 1747 1748 /// Returns the number of source locations found in the chain. 1749 unsigned getTotalNumSLocs() const { 1750 return TotalNumSLocEntries; 1751 } 1752 1753 /// Returns the number of identifiers found in the chain. 1754 unsigned getTotalNumIdentifiers() const { 1755 return static_cast<unsigned>(IdentifiersLoaded.size()); 1756 } 1757 1758 /// Returns the number of macros found in the chain. 1759 unsigned getTotalNumMacros() const { 1760 return static_cast<unsigned>(MacrosLoaded.size()); 1761 } 1762 1763 /// Returns the number of types found in the chain. 1764 unsigned getTotalNumTypes() const { 1765 return static_cast<unsigned>(TypesLoaded.size()); 1766 } 1767 1768 /// Returns the number of declarations found in the chain. 1769 unsigned getTotalNumDecls() const { 1770 return static_cast<unsigned>(DeclsLoaded.size()); 1771 } 1772 1773 /// Returns the number of submodules known. 1774 unsigned getTotalNumSubmodules() const { 1775 return static_cast<unsigned>(SubmodulesLoaded.size()); 1776 } 1777 1778 /// Returns the number of selectors found in the chain. 1779 unsigned getTotalNumSelectors() const { 1780 return static_cast<unsigned>(SelectorsLoaded.size()); 1781 } 1782 1783 /// Returns the number of preprocessed entities known to the AST 1784 /// reader. 1785 unsigned getTotalNumPreprocessedEntities() const { 1786 unsigned Result = 0; 1787 for (const auto &M : ModuleMgr) 1788 Result += M.NumPreprocessedEntities; 1789 return Result; 1790 } 1791 1792 /// Resolve a type ID into a type, potentially building a new 1793 /// type. 1794 QualType GetType(serialization::TypeID ID); 1795 1796 /// Resolve a local type ID within a given AST file into a type. 1797 QualType getLocalType(ModuleFile &F, unsigned LocalID); 1798 1799 /// Map a local type ID within a given AST file into a global type ID. 1800 serialization::TypeID getGlobalTypeID(ModuleFile &F, unsigned LocalID) const; 1801 1802 /// Read a type from the current position in the given record, which 1803 /// was read from the given AST file. 1804 QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx) { 1805 if (Idx >= Record.size()) 1806 return {}; 1807 1808 return getLocalType(F, Record[Idx++]); 1809 } 1810 1811 /// Map from a local declaration ID within a given module to a 1812 /// global declaration ID. 1813 serialization::DeclID getGlobalDeclID(ModuleFile &F, 1814 serialization::LocalDeclID LocalID) const; 1815 1816 /// Returns true if global DeclID \p ID originated from module \p M. 1817 bool isDeclIDFromModule(serialization::GlobalDeclID ID, ModuleFile &M) const; 1818 1819 /// Retrieve the module file that owns the given declaration, or NULL 1820 /// if the declaration is not from a module file. 1821 ModuleFile *getOwningModuleFile(const Decl *D); 1822 1823 /// Get the best name we know for the module that owns the given 1824 /// declaration, or an empty string if the declaration is not from a module. 1825 std::string getOwningModuleNameForDiagnostic(const Decl *D); 1826 1827 /// Returns the source location for the decl \p ID. 1828 SourceLocation getSourceLocationForDeclID(serialization::GlobalDeclID ID); 1829 1830 /// Resolve a declaration ID into a declaration, potentially 1831 /// building a new declaration. 1832 Decl *GetDecl(serialization::DeclID ID); 1833 Decl *GetExternalDecl(uint32_t ID) override; 1834 1835 /// Resolve a declaration ID into a declaration. Return 0 if it's not 1836 /// been loaded yet. 1837 Decl *GetExistingDecl(serialization::DeclID ID); 1838 1839 /// Reads a declaration with the given local ID in the given module. 1840 Decl *GetLocalDecl(ModuleFile &F, uint32_t LocalID) { 1841 return GetDecl(getGlobalDeclID(F, LocalID)); 1842 } 1843 1844 /// Reads a declaration with the given local ID in the given module. 1845 /// 1846 /// \returns The requested declaration, casted to the given return type. 1847 template<typename T> 1848 T *GetLocalDeclAs(ModuleFile &F, uint32_t LocalID) { 1849 return cast_or_null<T>(GetLocalDecl(F, LocalID)); 1850 } 1851 1852 /// Map a global declaration ID into the declaration ID used to 1853 /// refer to this declaration within the given module fule. 1854 /// 1855 /// \returns the global ID of the given declaration as known in the given 1856 /// module file. 1857 serialization::DeclID 1858 mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 1859 serialization::DeclID GlobalID); 1860 1861 /// Reads a declaration ID from the given position in a record in the 1862 /// given module. 1863 /// 1864 /// \returns The declaration ID read from the record, adjusted to a global ID. 1865 serialization::DeclID ReadDeclID(ModuleFile &F, const RecordData &Record, 1866 unsigned &Idx); 1867 1868 /// Reads a declaration from the given position in a record in the 1869 /// given module. 1870 Decl *ReadDecl(ModuleFile &F, const RecordData &R, unsigned &I) { 1871 return GetDecl(ReadDeclID(F, R, I)); 1872 } 1873 1874 /// Reads a declaration from the given position in a record in the 1875 /// given module. 1876 /// 1877 /// \returns The declaration read from this location, casted to the given 1878 /// result type. 1879 template<typename T> 1880 T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) { 1881 return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I))); 1882 } 1883 1884 /// If any redeclarations of \p D have been imported since it was 1885 /// last checked, this digs out those redeclarations and adds them to the 1886 /// redeclaration chain for \p D. 1887 void CompleteRedeclChain(const Decl *D) override; 1888 1889 CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override; 1890 1891 /// Resolve the offset of a statement into a statement. 1892 /// 1893 /// This operation will read a new statement from the external 1894 /// source each time it is called, and is meant to be used via a 1895 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 1896 Stmt *GetExternalDeclStmt(uint64_t Offset) override; 1897 1898 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1899 /// specified cursor. Read the abbreviations that are at the top of the block 1900 /// and then leave the cursor pointing into the block. 1901 static bool ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID, 1902 uint64_t *StartOfBlockOffset = nullptr); 1903 1904 /// Finds all the visible declarations with a given name. 1905 /// The current implementation of this method just loads the entire 1906 /// lookup table as unmaterialized references. 1907 bool FindExternalVisibleDeclsByName(const DeclContext *DC, 1908 DeclarationName Name) override; 1909 1910 /// Read all of the declarations lexically stored in a 1911 /// declaration context. 1912 /// 1913 /// \param DC The declaration context whose declarations will be 1914 /// read. 1915 /// 1916 /// \param IsKindWeWant A predicate indicating which declaration kinds 1917 /// we are interested in. 1918 /// 1919 /// \param Decls Vector that will contain the declarations loaded 1920 /// from the external source. The caller is responsible for merging 1921 /// these declarations with any declarations already stored in the 1922 /// declaration context. 1923 void 1924 FindExternalLexicalDecls(const DeclContext *DC, 1925 llvm::function_ref<bool(Decl::Kind)> IsKindWeWant, 1926 SmallVectorImpl<Decl *> &Decls) override; 1927 1928 /// Get the decls that are contained in a file in the Offset/Length 1929 /// range. \p Length can be 0 to indicate a point at \p Offset instead of 1930 /// a range. 1931 void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, 1932 SmallVectorImpl<Decl *> &Decls) override; 1933 1934 /// Notify ASTReader that we started deserialization of 1935 /// a decl or type so until FinishedDeserializing is called there may be 1936 /// decls that are initializing. Must be paired with FinishedDeserializing. 1937 void StartedDeserializing() override; 1938 1939 /// Notify ASTReader that we finished the deserialization of 1940 /// a decl or type. Must be paired with StartedDeserializing. 1941 void FinishedDeserializing() override; 1942 1943 /// Function that will be invoked when we begin parsing a new 1944 /// translation unit involving this external AST source. 1945 /// 1946 /// This function will provide all of the external definitions to 1947 /// the ASTConsumer. 1948 void StartTranslationUnit(ASTConsumer *Consumer) override; 1949 1950 /// Print some statistics about AST usage. 1951 void PrintStats() override; 1952 1953 /// Dump information about the AST reader to standard error. 1954 void dump(); 1955 1956 /// Return the amount of memory used by memory buffers, breaking down 1957 /// by heap-backed versus mmap'ed memory. 1958 void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override; 1959 1960 /// Initialize the semantic source with the Sema instance 1961 /// being used to perform semantic analysis on the abstract syntax 1962 /// tree. 1963 void InitializeSema(Sema &S) override; 1964 1965 /// Inform the semantic consumer that Sema is no longer available. 1966 void ForgetSema() override { SemaObj = nullptr; } 1967 1968 /// Retrieve the IdentifierInfo for the named identifier. 1969 /// 1970 /// This routine builds a new IdentifierInfo for the given identifier. If any 1971 /// declarations with this name are visible from translation unit scope, their 1972 /// declarations will be deserialized and introduced into the declaration 1973 /// chain of the identifier. 1974 IdentifierInfo *get(StringRef Name) override; 1975 1976 /// Retrieve an iterator into the set of all identifiers 1977 /// in all loaded AST files. 1978 IdentifierIterator *getIdentifiers() override; 1979 1980 /// Load the contents of the global method pool for a given 1981 /// selector. 1982 void ReadMethodPool(Selector Sel) override; 1983 1984 /// Load the contents of the global method pool for a given 1985 /// selector if necessary. 1986 void updateOutOfDateSelector(Selector Sel) override; 1987 1988 /// Load the set of namespaces that are known to the external source, 1989 /// which will be used during typo correction. 1990 void ReadKnownNamespaces( 1991 SmallVectorImpl<NamespaceDecl *> &Namespaces) override; 1992 1993 void ReadUndefinedButUsed( 1994 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) override; 1995 1996 void ReadMismatchingDeleteExpressions(llvm::MapVector< 1997 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> & 1998 Exprs) override; 1999 2000 void ReadTentativeDefinitions( 2001 SmallVectorImpl<VarDecl *> &TentativeDefs) override; 2002 2003 void ReadUnusedFileScopedDecls( 2004 SmallVectorImpl<const DeclaratorDecl *> &Decls) override; 2005 2006 void ReadDelegatingConstructors( 2007 SmallVectorImpl<CXXConstructorDecl *> &Decls) override; 2008 2009 void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) override; 2010 2011 void ReadUnusedLocalTypedefNameCandidates( 2012 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override; 2013 2014 void ReadDeclsToCheckForDeferredDiags( 2015 llvm::SmallVector<Decl *, 4> &Decls) override; 2016 2017 void ReadReferencedSelectors( 2018 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) override; 2019 2020 void ReadWeakUndeclaredIdentifiers( 2021 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WI) override; 2022 2023 void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override; 2024 2025 void ReadPendingInstantiations( 2026 SmallVectorImpl<std::pair<ValueDecl *, 2027 SourceLocation>> &Pending) override; 2028 2029 void ReadLateParsedTemplates( 2030 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>> 2031 &LPTMap) override; 2032 2033 /// Load a selector from disk, registering its ID if it exists. 2034 void LoadSelector(Selector Sel); 2035 2036 void SetIdentifierInfo(unsigned ID, IdentifierInfo *II); 2037 void SetGloballyVisibleDecls(IdentifierInfo *II, 2038 const SmallVectorImpl<uint32_t> &DeclIDs, 2039 SmallVectorImpl<Decl *> *Decls = nullptr); 2040 2041 /// Report a diagnostic. 2042 DiagnosticBuilder Diag(unsigned DiagID) const; 2043 2044 /// Report a diagnostic. 2045 DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const; 2046 2047 IdentifierInfo *DecodeIdentifierInfo(serialization::IdentifierID ID); 2048 2049 IdentifierInfo *readIdentifier(ModuleFile &M, const RecordData &Record, 2050 unsigned &Idx) { 2051 return DecodeIdentifierInfo(getGlobalIdentifierID(M, Record[Idx++])); 2052 } 2053 2054 IdentifierInfo *GetIdentifier(serialization::IdentifierID ID) override { 2055 // Note that we are loading an identifier. 2056 Deserializing AnIdentifier(this); 2057 2058 return DecodeIdentifierInfo(ID); 2059 } 2060 2061 IdentifierInfo *getLocalIdentifier(ModuleFile &M, unsigned LocalID); 2062 2063 serialization::IdentifierID getGlobalIdentifierID(ModuleFile &M, 2064 unsigned LocalID); 2065 2066 void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo); 2067 2068 /// Retrieve the macro with the given ID. 2069 MacroInfo *getMacro(serialization::MacroID ID); 2070 2071 /// Retrieve the global macro ID corresponding to the given local 2072 /// ID within the given module file. 2073 serialization::MacroID getGlobalMacroID(ModuleFile &M, unsigned LocalID); 2074 2075 /// Read the source location entry with index ID. 2076 bool ReadSLocEntry(int ID) override; 2077 2078 /// Retrieve the module import location and module name for the 2079 /// given source manager entry ID. 2080 std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) override; 2081 2082 /// Retrieve the global submodule ID given a module and its local ID 2083 /// number. 2084 serialization::SubmoduleID 2085 getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID); 2086 2087 /// Retrieve the submodule that corresponds to a global submodule ID. 2088 /// 2089 Module *getSubmodule(serialization::SubmoduleID GlobalID); 2090 2091 /// Retrieve the module that corresponds to the given module ID. 2092 /// 2093 /// Note: overrides method in ExternalASTSource 2094 Module *getModule(unsigned ID) override; 2095 2096 /// Retrieve the module file with a given local ID within the specified 2097 /// ModuleFile. 2098 ModuleFile *getLocalModuleFile(ModuleFile &M, unsigned ID); 2099 2100 /// Get an ID for the given module file. 2101 unsigned getModuleFileID(ModuleFile *M); 2102 2103 /// Return a descriptor for the corresponding module. 2104 llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID) override; 2105 2106 ExtKind hasExternalDefinitions(const Decl *D) override; 2107 2108 /// Retrieve a selector from the given module with its local ID 2109 /// number. 2110 Selector getLocalSelector(ModuleFile &M, unsigned LocalID); 2111 2112 Selector DecodeSelector(serialization::SelectorID Idx); 2113 2114 Selector GetExternalSelector(serialization::SelectorID ID) override; 2115 uint32_t GetNumExternalSelectors() override; 2116 2117 Selector ReadSelector(ModuleFile &M, const RecordData &Record, unsigned &Idx) { 2118 return getLocalSelector(M, Record[Idx++]); 2119 } 2120 2121 /// Retrieve the global selector ID that corresponds to this 2122 /// the local selector ID in a given module. 2123 serialization::SelectorID getGlobalSelectorID(ModuleFile &F, 2124 unsigned LocalID) const; 2125 2126 /// Read the contents of a CXXCtorInitializer array. 2127 CXXCtorInitializer **GetExternalCXXCtorInitializers(uint64_t Offset) override; 2128 2129 /// Read a AlignPackInfo from raw form. 2130 Sema::AlignPackInfo ReadAlignPackInfo(uint32_t Raw) const { 2131 return Sema::AlignPackInfo::getFromRawEncoding(Raw); 2132 } 2133 2134 /// Read a source location from raw form and return it in its 2135 /// originating module file's source location space. 2136 SourceLocation ReadUntranslatedSourceLocation(uint32_t Raw) const { 2137 return SourceLocation::getFromRawEncoding((Raw >> 1) | (Raw << 31)); 2138 } 2139 2140 /// Read a source location from raw form. 2141 SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, uint32_t Raw) const { 2142 SourceLocation Loc = ReadUntranslatedSourceLocation(Raw); 2143 return TranslateSourceLocation(ModuleFile, Loc); 2144 } 2145 2146 /// Translate a source location from another module file's source 2147 /// location space into ours. 2148 SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile, 2149 SourceLocation Loc) const { 2150 if (!ModuleFile.ModuleOffsetMap.empty()) 2151 ReadModuleOffsetMap(ModuleFile); 2152 assert(ModuleFile.SLocRemap.find(Loc.getOffset()) != 2153 ModuleFile.SLocRemap.end() && 2154 "Cannot find offset to remap."); 2155 int Remap = ModuleFile.SLocRemap.find(Loc.getOffset())->second; 2156 return Loc.getLocWithOffset(Remap); 2157 } 2158 2159 /// Read a source location. 2160 SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, 2161 const RecordDataImpl &Record, 2162 unsigned &Idx) { 2163 return ReadSourceLocation(ModuleFile, Record[Idx++]); 2164 } 2165 2166 /// Read a source range. 2167 SourceRange ReadSourceRange(ModuleFile &F, 2168 const RecordData &Record, unsigned &Idx); 2169 2170 // Read a string 2171 static std::string ReadString(const RecordData &Record, unsigned &Idx); 2172 2173 // Skip a string 2174 static void SkipString(const RecordData &Record, unsigned &Idx) { 2175 Idx += Record[Idx] + 1; 2176 } 2177 2178 // Read a path 2179 std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx); 2180 2181 // Read a path 2182 std::string ReadPath(StringRef BaseDirectory, const RecordData &Record, 2183 unsigned &Idx); 2184 2185 // Skip a path 2186 static void SkipPath(const RecordData &Record, unsigned &Idx) { 2187 SkipString(Record, Idx); 2188 } 2189 2190 /// Read a version tuple. 2191 static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx); 2192 2193 CXXTemporary *ReadCXXTemporary(ModuleFile &F, const RecordData &Record, 2194 unsigned &Idx); 2195 2196 /// Reads a statement. 2197 Stmt *ReadStmt(ModuleFile &F); 2198 2199 /// Reads an expression. 2200 Expr *ReadExpr(ModuleFile &F); 2201 2202 /// Reads a sub-statement operand during statement reading. 2203 Stmt *ReadSubStmt() { 2204 assert(ReadingKind == Read_Stmt && 2205 "Should be called only during statement reading!"); 2206 // Subexpressions are stored from last to first, so the next Stmt we need 2207 // is at the back of the stack. 2208 assert(!StmtStack.empty() && "Read too many sub-statements!"); 2209 return StmtStack.pop_back_val(); 2210 } 2211 2212 /// Reads a sub-expression operand during statement reading. 2213 Expr *ReadSubExpr(); 2214 2215 /// Reads a token out of a record. 2216 Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx); 2217 2218 /// Reads the macro record located at the given offset. 2219 MacroInfo *ReadMacroRecord(ModuleFile &F, uint64_t Offset); 2220 2221 /// Determine the global preprocessed entity ID that corresponds to 2222 /// the given local ID within the given module. 2223 serialization::PreprocessedEntityID 2224 getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const; 2225 2226 /// Add a macro to deserialize its macro directive history. 2227 /// 2228 /// \param II The name of the macro. 2229 /// \param M The module file. 2230 /// \param MacroDirectivesOffset Offset of the serialized macro directive 2231 /// history. 2232 void addPendingMacro(IdentifierInfo *II, ModuleFile *M, 2233 uint32_t MacroDirectivesOffset); 2234 2235 /// Read the set of macros defined by this external macro source. 2236 void ReadDefinedMacros() override; 2237 2238 /// Update an out-of-date identifier. 2239 void updateOutOfDateIdentifier(IdentifierInfo &II) override; 2240 2241 /// Note that this identifier is up-to-date. 2242 void markIdentifierUpToDate(IdentifierInfo *II); 2243 2244 /// Load all external visible decls in the given DeclContext. 2245 void completeVisibleDeclsMap(const DeclContext *DC) override; 2246 2247 /// Retrieve the AST context that this AST reader supplements. 2248 ASTContext &getContext() { 2249 assert(ContextObj && "requested AST context when not loading AST"); 2250 return *ContextObj; 2251 } 2252 2253 // Contains the IDs for declarations that were requested before we have 2254 // access to a Sema object. 2255 SmallVector<uint64_t, 16> PreloadedDeclIDs; 2256 2257 /// Retrieve the semantic analysis object used to analyze the 2258 /// translation unit in which the precompiled header is being 2259 /// imported. 2260 Sema *getSema() { return SemaObj; } 2261 2262 /// Get the identifier resolver used for name lookup / updates 2263 /// in the translation unit scope. We have one of these even if we don't 2264 /// have a Sema object. 2265 IdentifierResolver &getIdResolver(); 2266 2267 /// Retrieve the identifier table associated with the 2268 /// preprocessor. 2269 IdentifierTable &getIdentifierTable(); 2270 2271 /// Record that the given ID maps to the given switch-case 2272 /// statement. 2273 void RecordSwitchCaseID(SwitchCase *SC, unsigned ID); 2274 2275 /// Retrieve the switch-case statement with the given ID. 2276 SwitchCase *getSwitchCaseWithID(unsigned ID); 2277 2278 void ClearSwitchCaseIDs(); 2279 2280 /// Cursors for comments blocks. 2281 SmallVector<std::pair<llvm::BitstreamCursor, 2282 serialization::ModuleFile *>, 8> CommentsCursors; 2283 2284 /// Loads comments ranges. 2285 void ReadComments() override; 2286 2287 /// Visit all the input files of the given module file. 2288 void visitInputFiles(serialization::ModuleFile &MF, 2289 bool IncludeSystem, bool Complain, 2290 llvm::function_ref<void(const serialization::InputFile &IF, 2291 bool isSystem)> Visitor); 2292 2293 /// Visit all the top-level module maps loaded when building the given module 2294 /// file. 2295 void visitTopLevelModuleMaps(serialization::ModuleFile &MF, 2296 llvm::function_ref< 2297 void(const FileEntry *)> Visitor); 2298 2299 bool isProcessingUpdateRecords() { return ProcessingUpdateRecords; } 2300 }; 2301 2302 } // namespace clang 2303 2304 #endif // LLVM_CLANG_SERIALIZATION_ASTREADER_H 2305