clang  8.0.0svn
GlobalModuleIndex.h
Go to the documentation of this file.
1 //===--- GlobalModuleIndex.h - Global Module Index --------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the GlobalModuleIndex class, which manages a global index
11 // containing all of the identifiers known to the various modules within a given
12 // subdirectory of the module cache. It is used to improve the performance of
13 // queries such as "do any modules know about this identifier?"
14 //
15 //===----------------------------------------------------------------------===//
16 #ifndef LLVM_CLANG_SERIALIZATION_GLOBALMODULEINDEX_H
17 #define LLVM_CLANG_SERIALIZATION_GLOBALMODULEINDEX_H
18 
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/ADT/StringRef.h"
24 #include <memory>
25 #include <utility>
26 
27 namespace llvm {
28 class BitstreamCursor;
29 class MemoryBuffer;
30 }
31 
32 namespace clang {
33 
34 class DirectoryEntry;
35 class FileEntry;
36 class FileManager;
37 class IdentifierIterator;
38 class PCHContainerOperations;
39 class PCHContainerReader;
40 
41 namespace serialization {
42  class ModuleFile;
43 }
44 
45 /// A global index for a set of module files, providing information about
46 /// the identifiers within those module files.
47 ///
48 /// The global index is an aid for name lookup into modules, offering a central
49 /// place where one can look for identifiers determine which
50 /// module files contain any information about that identifier. This
51 /// allows the client to restrict the search to only those module files known
52 /// to have a information about that identifier, improving performance. Moreover,
53 /// the global module index may know about module files that have not been
54 /// imported, and can be queried to determine which modules the current
55 /// translation could or should load to fix a problem.
58 
59  /// Buffer containing the index file, which is lazily accessed so long
60  /// as the global module index is live.
61  std::unique_ptr<llvm::MemoryBuffer> Buffer;
62 
63  /// The hash table.
64  ///
65  /// This pointer actually points to a IdentifierIndexTable object,
66  /// but that type is only accessible within the implementation of
67  /// GlobalModuleIndex.
68  void *IdentifierIndex;
69 
70  /// Information about a given module file.
71  struct ModuleInfo {
72  ModuleInfo() : File(), Size(), ModTime() { }
73 
74  /// The module file, once it has been resolved.
75  ModuleFile *File;
76 
77  /// The module file name.
78  std::string FileName;
79 
80  /// Size of the module file at the time the global index was built.
81  off_t Size;
82 
83  /// Modification time of the module file at the time the global
84  /// index was built.
85  time_t ModTime;
86 
87  /// The module IDs on which this module directly depends.
88  /// FIXME: We don't really need a vector here.
89  llvm::SmallVector<unsigned, 4> Dependencies;
90  };
91 
92  /// A mapping from module IDs to information about each module.
93  ///
94  /// This vector may have gaps, if module files have been removed or have
95  /// been updated since the index was built. A gap is indicated by an empty
96  /// file name.
98 
99  /// Lazily-populated mapping from module files to their
100  /// corresponding index into the \c Modules vector.
101  llvm::DenseMap<ModuleFile *, unsigned> ModulesByFile;
102 
103  /// The set of modules that have not yet been resolved.
104  ///
105  /// The string is just the name of the module itself, which maps to the
106  /// module ID.
107  llvm::StringMap<unsigned> UnresolvedModules;
108 
109  /// The number of identifier lookups we performed.
110  unsigned NumIdentifierLookups;
111 
112  /// The number of identifier lookup hits, where we recognize the
113  /// identifier.
114  unsigned NumIdentifierLookupHits;
115 
116  /// Internal constructor. Use \c readIndex() to read an index.
117  explicit GlobalModuleIndex(std::unique_ptr<llvm::MemoryBuffer> Buffer,
118  llvm::BitstreamCursor Cursor);
119 
120  GlobalModuleIndex(const GlobalModuleIndex &) = delete;
121  GlobalModuleIndex &operator=(const GlobalModuleIndex &) = delete;
122 
123 public:
125 
126  /// An error code returned when trying to read an index.
127  enum ErrorCode {
128  /// No error occurred.
130  /// No index was found.
132  /// Some other process is currently building the index; it is not
133  /// available yet.
135  /// There was an unspecified I/O error reading or writing the index.
136  EC_IOError
137  };
138 
139  /// Read a global index file for the given directory.
140  ///
141  /// \param Path The path to the specific module cache where the module files
142  /// for the intended configuration reside.
143  ///
144  /// \returns A pair containing the global module index (if it exists) and
145  /// the error code.
146  static std::pair<GlobalModuleIndex *, ErrorCode>
147  readIndex(llvm::StringRef Path);
148 
149  /// Returns an iterator for identifiers stored in the index table.
150  ///
151  /// The caller accepts ownership of the returned object.
152  IdentifierIterator *createIdentifierIterator() const;
153 
154  /// Retrieve the set of modules that have up-to-date indexes.
155  ///
156  /// \param ModuleFiles Will be populated with the set of module files that
157  /// have been indexed.
158  void getKnownModules(llvm::SmallVectorImpl<ModuleFile *> &ModuleFiles);
159 
160  /// Retrieve the set of module files on which the given module file
161  /// directly depends.
162  void getModuleDependencies(ModuleFile *File,
164 
165  /// A set of module files in which we found a result.
166  typedef llvm::SmallPtrSet<ModuleFile *, 4> HitSet;
167 
168  /// Look for all of the module files with information about the given
169  /// identifier, e.g., a global function, variable, or type with that name.
170  ///
171  /// \param Name The identifier to look for.
172  ///
173  /// \param Hits Will be populated with the set of module files that have
174  /// information about this name.
175  ///
176  /// \returns true if the identifier is known to the index, false otherwise.
177  bool lookupIdentifier(llvm::StringRef Name, HitSet &Hits);
178 
179  /// Note that the given module file has been loaded.
180  ///
181  /// \returns false if the global module index has information about this
182  /// module file, and true otherwise.
183  bool loadedModuleFile(ModuleFile *File);
184 
185  /// Print statistics to standard error.
186  void printStats();
187 
188  /// Print debugging view to standard error.
189  void dump();
190 
191  /// Write a global index into the given
192  ///
193  /// \param FileMgr The file manager to use to load module files.
194  /// \param PCHContainerRdr - The PCHContainerOperations to use for loading and
195  /// creating modules.
196  /// \param Path The path to the directory containing module files, into
197  /// which the global index will be written.
198  static ErrorCode writeIndex(FileManager &FileMgr,
199  const PCHContainerReader &PCHContainerRdr,
200  llvm::StringRef Path);
201 };
202 }
203 
204 #endif
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:122
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
ErrorCode
An error code returned when trying to read an index.
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:108
An iterator that walks over all of the known identifiers in the lookup table.
A global index for a set of module files, providing information about the identifiers within those mo...
Dataflow Directional Tag Classes.
Some other process is currently building the index; it is not available yet.