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