clang  14.0.0git
ModuleDepCollector.cpp
Go to the documentation of this file.
1 //===- ModuleDepCollector.cpp - Callbacks to collect deps -------*- 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 
10 
12 #include "clang/Lex/Preprocessor.h"
14 #include "llvm/Support/StringSaver.h"
15 
16 using namespace clang;
17 using namespace tooling;
18 using namespace dependencies;
19 
21  ASTReader &Reader,
22  const serialization::ModuleFile &MF) {
23  // Only preserve search paths that were used during the dependency scan.
24  std::vector<HeaderSearchOptions::Entry> Entries = Opts.UserEntries;
25  Opts.UserEntries.clear();
26  for (unsigned I = 0; I < Entries.size(); ++I)
27  if (MF.SearchPathUsage[I])
28  Opts.UserEntries.push_back(Entries[I]);
29 }
30 
31 CompilerInvocation ModuleDepCollector::makeInvocationForModuleBuildWithoutPaths(
32  const ModuleDeps &Deps,
33  llvm::function_ref<void(CompilerInvocation &)> Optimize) const {
34  // Make a deep copy of the original Clang invocation.
35  CompilerInvocation CI(OriginalInvocation);
36 
37  CI.getLangOpts()->resetNonModularOptions();
38  CI.getPreprocessorOpts().resetNonModularOptions();
39 
40  // Remove options incompatible with explicit module build.
41  CI.getFrontendOpts().Inputs.clear();
42  CI.getFrontendOpts().OutputFile.clear();
43 
44  CI.getFrontendOpts().ProgramAction = frontend::GenerateModule;
45  CI.getLangOpts()->ModuleName = Deps.ID.ModuleName;
46  CI.getFrontendOpts().IsSystemModule = Deps.IsSystem;
47 
48  CI.getLangOpts()->ImplicitModules = false;
49 
50  // Report the prebuilt modules this module uses.
51  for (const auto &PrebuiltModule : Deps.PrebuiltModuleDeps) {
52  CI.getFrontendOpts().ModuleFiles.push_back(PrebuiltModule.PCMFile);
53  CI.getFrontendOpts().ModuleMapFiles.push_back(PrebuiltModule.ModuleMapFile);
54  }
55 
56  Optimize(CI);
57 
58  return CI;
59 }
60 
61 static std::vector<std::string>
63  // Set up string allocator.
64  llvm::BumpPtrAllocator Alloc;
65  llvm::StringSaver Strings(Alloc);
66  auto SA = [&Strings](const Twine &Arg) { return Strings.save(Arg).data(); };
67 
68  // Synthesize full command line from the CompilerInvocation, including "-cc1".
69  SmallVector<const char *, 32> Args{"-cc1"};
70  CI.generateCC1CommandLine(Args, SA);
71 
72  // Convert arguments to the return type.
73  return std::vector<std::string>{Args.begin(), Args.end()};
74 }
75 
76 std::vector<std::string> ModuleDeps::getCanonicalCommandLine(
77  std::function<StringRef(ModuleID)> LookupPCMPath,
78  std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps) const {
80  FrontendOptions &FrontendOpts = CI.getFrontendOpts();
81 
82  InputKind ModuleMapInputKind(FrontendOpts.DashX.getLanguage(),
83  InputKind::Format::ModuleMap);
84  FrontendOpts.Inputs.emplace_back(ClangModuleMapFile, ModuleMapInputKind);
85  FrontendOpts.OutputFile = std::string(LookupPCMPath(ID));
86 
88  ClangModuleDeps, LookupPCMPath, LookupModuleDeps,
89  FrontendOpts.ModuleFiles, FrontendOpts.ModuleMapFiles);
90 
91  return serializeCompilerInvocation(CI);
92 }
93 
94 std::vector<std::string>
97 }
98 
100  llvm::ArrayRef<ModuleID> Modules,
101  std::function<StringRef(ModuleID)> LookupPCMPath,
102  std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps,
103  std::vector<std::string> &PCMPaths, std::vector<std::string> &ModMapPaths) {
104  llvm::StringSet<> AlreadyAdded;
105 
106  std::function<void(llvm::ArrayRef<ModuleID>)> AddArgs =
107  [&](llvm::ArrayRef<ModuleID> Modules) {
108  for (const ModuleID &MID : Modules) {
109  if (!AlreadyAdded.insert(MID.ModuleName + MID.ContextHash).second)
110  continue;
111  const ModuleDeps &M = LookupModuleDeps(MID);
112  // Depth first traversal.
113  AddArgs(M.ClangModuleDeps);
114  PCMPaths.push_back(LookupPCMPath(MID).str());
115  if (!M.ClangModuleMapFile.empty())
116  ModMapPaths.push_back(M.ClangModuleMapFile);
117  }
118  };
119 
120  AddArgs(Modules);
121 }
122 
124  FileChangeReason Reason,
126  FileID PrevFID) {
127  if (Reason != PPCallbacks::EnterFile)
128  return;
129 
130  // This has to be delayed as the context hash can change at the start of
131  // `CompilerInstance::ExecuteAction`.
132  if (MDC.ContextHash.empty()) {
133  MDC.ContextHash = Instance.getInvocation().getModuleHash();
134  MDC.Consumer.handleContextHash(MDC.ContextHash);
135  }
136 
137  SourceManager &SM = Instance.getSourceManager();
138 
139  // Dependency generation really does want to go all the way to the
140  // file entry for a source location to find out what is depended on.
141  // We do not want #line markers to affect dependency generation!
143  SM.getNonBuiltinFilenameForID(SM.getFileID(SM.getExpansionLoc(Loc))))
144  MDC.FileDeps.push_back(
145  std::string(llvm::sys::path::remove_leading_dotslash(*Filename)));
146 }
147 
149  SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
150  bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
151  StringRef SearchPath, StringRef RelativePath, const Module *Imported,
152  SrcMgr::CharacteristicKind FileType) {
153  if (!File && !Imported) {
154  // This is a non-modular include that HeaderSearch failed to find. Add it
155  // here as `FileChanged` will never see it.
156  MDC.FileDeps.push_back(std::string(FileName));
157  }
158  handleImport(Imported);
159 }
160 
162  ModuleIdPath Path,
163  const Module *Imported) {
164  handleImport(Imported);
165 }
166 
167 void ModuleDepCollectorPP::handleImport(const Module *Imported) {
168  if (!Imported)
169  return;
170 
171  const Module *TopLevelModule = Imported->getTopLevelModule();
172 
173  if (MDC.isPrebuiltModule(TopLevelModule))
174  DirectPrebuiltModularDeps.insert(TopLevelModule);
175  else
176  DirectModularDeps.insert(TopLevelModule);
177 }
178 
180  FileID MainFileID = Instance.getSourceManager().getMainFileID();
181  MDC.MainFile = std::string(
182  Instance.getSourceManager().getFileEntryForID(MainFileID)->getName());
183 
184  if (!Instance.getPreprocessorOpts().ImplicitPCHInclude.empty())
185  MDC.FileDeps.push_back(Instance.getPreprocessorOpts().ImplicitPCHInclude);
186 
187  for (const Module *M : DirectModularDeps) {
188  // A top-level module might not be actually imported as a module when
189  // -fmodule-name is used to compile a translation unit that imports this
190  // module. In that case it can be skipped. The appropriate header
191  // dependencies will still be reported as expected.
192  if (!M->getASTFile())
193  continue;
194  handleTopLevelModule(M);
195  }
196 
197  MDC.Consumer.handleDependencyOutputOpts(*MDC.Opts);
198 
199  for (auto &&I : MDC.ModularDeps)
200  MDC.Consumer.handleModuleDependency(I.second);
201 
202  for (auto &&I : MDC.FileDeps)
203  MDC.Consumer.handleFileDependency(I);
204 
205  for (auto &&I : DirectPrebuiltModularDeps)
207 }
208 
209 ModuleID ModuleDepCollectorPP::handleTopLevelModule(const Module *M) {
210  assert(M == M->getTopLevelModule() && "Expected top level module!");
211 
212  // If this module has been handled already, just return its ID.
213  auto ModI = MDC.ModularDeps.insert({M, ModuleDeps{}});
214  if (!ModI.second)
215  return ModI.first->second.ID;
216 
217  ModuleDeps &MD = ModI.first->second;
218 
219  MD.ID.ModuleName = M->getFullModuleName();
220  MD.ImportedByMainFile = DirectModularDeps.contains(M);
221  MD.ImplicitModulePCMPath = std::string(M->getASTFile()->getName());
222  MD.IsSystem = M->IsSystem;
223 
224  const FileEntry *ModuleMap = Instance.getPreprocessor()
226  .getModuleMap()
228  MD.ClangModuleMapFile = std::string(ModuleMap ? ModuleMap->getName() : "");
229 
231  MDC.Instance.getASTReader()->getModuleManager().lookup(M->getASTFile());
232  MDC.Instance.getASTReader()->visitInputFiles(
233  *MF, true, true, [&](const serialization::InputFile &IF, bool isSystem) {
234  // __inferred_module.map is the result of the way in which an implicit
235  // module build handles inferred modules. It adds an overlay VFS with
236  // this file in the proper directory and relies on the rest of Clang to
237  // handle it like normal. With explicitly built modules we don't need
238  // to play VFS tricks, so replace it with the correct module map.
239  if (IF.getFile()->getName().endswith("__inferred_module.map")) {
240  MD.FileDeps.insert(ModuleMap->getName());
241  return;
242  }
243  MD.FileDeps.insert(IF.getFile()->getName());
244  });
245 
246  // Add direct prebuilt module dependencies now, so that we can use them when
247  // creating a CompilerInvocation and computing context hash for this
248  // ModuleDeps instance.
249  llvm::DenseSet<const Module *> SeenModules;
250  addAllSubmodulePrebuiltDeps(M, MD, SeenModules);
251 
252  MD.Invocation = MDC.makeInvocationForModuleBuildWithoutPaths(
253  MD, [&](CompilerInvocation &CI) {
254  if (MDC.OptimizeArgs)
256  *MDC.Instance.getASTReader(), *MF);
257  });
258  MD.ID.ContextHash = MD.Invocation.getModuleHash();
259 
260  llvm::DenseSet<const Module *> AddedModules;
261  addAllSubmoduleDeps(M, MD, AddedModules);
262 
263  return MD.ID;
264 }
265 
266 void ModuleDepCollectorPP::addAllSubmodulePrebuiltDeps(
267  const Module *M, ModuleDeps &MD,
268  llvm::DenseSet<const Module *> &SeenSubmodules) {
269  addModulePrebuiltDeps(M, MD, SeenSubmodules);
270 
271  for (const Module *SubM : M->submodules())
272  addAllSubmodulePrebuiltDeps(SubM, MD, SeenSubmodules);
273 }
274 
275 void ModuleDepCollectorPP::addModulePrebuiltDeps(
276  const Module *M, ModuleDeps &MD,
277  llvm::DenseSet<const Module *> &SeenSubmodules) {
278  for (const Module *Import : M->Imports)
279  if (Import->getTopLevelModule() != M->getTopLevelModule())
280  if (MDC.isPrebuiltModule(Import->getTopLevelModule()))
281  if (SeenSubmodules.insert(Import->getTopLevelModule()).second)
282  MD.PrebuiltModuleDeps.emplace_back(Import->getTopLevelModule());
283 }
284 
285 void ModuleDepCollectorPP::addAllSubmoduleDeps(
286  const Module *M, ModuleDeps &MD,
287  llvm::DenseSet<const Module *> &AddedModules) {
288  addModuleDep(M, MD, AddedModules);
289 
290  for (const Module *SubM : M->submodules())
291  addAllSubmoduleDeps(SubM, MD, AddedModules);
292 }
293 
294 void ModuleDepCollectorPP::addModuleDep(
295  const Module *M, ModuleDeps &MD,
296  llvm::DenseSet<const Module *> &AddedModules) {
297  for (const Module *Import : M->Imports) {
298  if (Import->getTopLevelModule() != M->getTopLevelModule() &&
299  !MDC.isPrebuiltModule(Import)) {
300  ModuleID ImportID = handleTopLevelModule(Import->getTopLevelModule());
301  if (AddedModules.insert(Import->getTopLevelModule()).second)
302  MD.ClangModuleDeps.push_back(ImportID);
303  }
304  }
305 }
306 
308  std::unique_ptr<DependencyOutputOptions> Opts, CompilerInstance &I,
309  DependencyConsumer &C, CompilerInvocation &&OriginalCI, bool OptimizeArgs)
310  : Instance(I), Consumer(C), Opts(std::move(Opts)),
311  OriginalInvocation(std::move(OriginalCI)), OptimizeArgs(OptimizeArgs) {}
312 
314  PP.addPPCallbacks(std::make_unique<ModuleDepCollectorPP>(Instance, *this));
315 }
316 
318 
319 bool ModuleDepCollector::isPrebuiltModule(const Module *M) {
321  const auto &PrebuiltModuleFiles =
323  auto PrebuiltModuleFileIt = PrebuiltModuleFiles.find(Name);
324  if (PrebuiltModuleFileIt == PrebuiltModuleFiles.end())
325  return false;
326  assert("Prebuilt module came from the expected AST file" &&
327  PrebuiltModuleFileIt->second == M->getASTFile()->getName());
328  return true;
329 }
clang::FrontendOptions::ModuleMapFiles
std::vector< std::string > ModuleMapFiles
The list of module map files to load before processing the input.
Definition: FrontendOptions.h:423
clang::tooling::dependencies::ModuleDeps::getCanonicalCommandLine
std::vector< std::string > getCanonicalCommandLine(std::function< StringRef(ModuleID)> LookupPCMPath, std::function< const ModuleDeps &(ModuleID)> LookupModuleDeps) const
Gets the canonical command line suitable for passing to clang.
Definition: ModuleDepCollector.cpp:76
clang::Module::getTopLevelModule
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:519
clang::tooling::dependencies::ModuleDeps::Invocation
CompilerInvocation Invocation
Compiler invocation that can be used to build this module (without paths).
Definition: ModuleDepCollector.h:104
clang::serialization::InputFile::getFile
OptionalFileEntryRefDegradesToFileEntryPtr getFile() const
Definition: ModuleFile.h:94
clang::tooling::dependencies::DependencyConsumer::handlePrebuiltModuleDependency
virtual void handlePrebuiltModuleDependency(PrebuiltModuleDep PMD)=0
clang::DeclaratorContext::File
@ File
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::tooling::dependencies::DependencyConsumer
Definition: DependencyScanningWorker.h:32
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::Module::getFullModuleName
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:219
Filename
StringRef Filename
Definition: Format.cpp:2333
clang::tooling::dependencies::DependencyConsumer::handleModuleDependency
virtual void handleModuleDependency(ModuleDeps MD)=0
clang::PPCallbacks::EnterFile
@ EnterFile
Definition: PPCallbacks.h:40
llvm::Optional
Definition: LLVM.h:40
clang::CompilerInvocationRefBase::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts()
Definition: CompilerInvocation.h:112
clang::SrcMgr::CharacteristicKind
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::InputKind
The kind of a file that we've been handed as an input.
Definition: FrontendOptions.h:145
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:626
clang::FrontendOptions::Inputs
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
Definition: FrontendOptions.h:386
Preprocessor.h
clang::tooling::dependencies::ModuleDepCollector::attachToPreprocessor
void attachToPreprocessor(Preprocessor &PP) override
Definition: ModuleDepCollector.cpp:313
clang::tooling::dependencies::ModuleDeps::ID
ModuleID ID
The identifier of the module.
Definition: ModuleDepCollector.h:70
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::CompilerInvocationValueBase::getFrontendOpts
FrontendOptions & getFrontendOpts()
Definition: CompilerInvocation.h:176
clang::FrontendOptions::OutputFile
std::string OutputFile
The output file, if any.
Definition: FrontendOptions.h:393
clang::tooling::dependencies::PrebuiltModuleDep
Modular dependency that has already been built prior to the dependency scan.
Definition: ModuleDepCollector.h:32
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::Module::getTopLevelModuleName
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:529
clang::SourceManager::getMainFileID
FileID getMainFileID() const
Returns the FileID of the main source file.
Definition: SourceManager.h:840
clang::FrontendOptions
FrontendOptions - Options for controlling the behavior of the frontend.
Definition: FrontendOptions.h:228
clang::tooling::dependencies::ModuleDeps::getCanonicalCommandLineWithoutModulePaths
std::vector< std::string > getCanonicalCommandLineWithoutModulePaths() const
Gets the canonical command line suitable for passing to clang, excluding arguments containing modules...
Definition: ModuleDepCollector.cpp:95
clang::InputKind::getLanguage
Language getLanguage() const
Definition: FrontendOptions.h:163
clang::ModuleMap::getModuleMapFileForUniquing
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module.
Definition: ModuleMap.cpp:1260
llvm::DenseSet
Definition: Sema.h:78
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:444
clang::FrontendOptions::DashX
InputKind DashX
The input kind, either specified via -x argument or deduced from the input file name.
Definition: FrontendOptions.h:383
DependencyScanningWorker.h
clang::Module::getASTFile
OptionalFileEntryRefDegradesToFileEntryPtr getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:534
clang::CompilerInvocation::generateCC1CommandLine
void generateCC1CommandLine(llvm::SmallVectorImpl< const char * > &Args, StringAllocator SA) const
Generate a cc1-compatible command line arguments from this instance.
Definition: CompilerInvocation.cpp:4635
clang::CompilerInstance
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Definition: CompilerInstance.h:74
clang::HeaderSearchOptions::PrebuiltModuleFiles
std::map< std::string, std::string, std::less<> > PrebuiltModuleFiles
The mapping of module names to prebuilt module files.
Definition: HeaderSearchOptions.h:119
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
clang::ModuleMap
Definition: ModuleMap.h:75
clang::CompilerInstance::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts()
Definition: CompilerInstance.h:308
clang::Module::submodules
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:628
ModuleDepCollector.h
clang::tooling::dependencies::ModuleDepCollectorPP::InclusionDirective
void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File, StringRef SearchPath, StringRef RelativePath, const Module *Imported, SrcMgr::CharacteristicKind FileType) override
Callback invoked whenever an inclusion directive of any kind (#include, #import, etc....
Definition: ModuleDepCollector.cpp:148
clang::tooling::dependencies::detail::collectPCMAndModuleMapPaths
void collectPCMAndModuleMapPaths(llvm::ArrayRef< ModuleID > Modules, std::function< StringRef(ModuleID)> LookupPCMPath, std::function< const ModuleDeps &(ModuleID)> LookupModuleDeps, std::vector< std::string > &PCMPaths, std::vector< std::string > &ModMapPaths)
Collect the paths of PCM and module map files for the modules in Modules transitively.
clang::PPCallbacks::FileChangeReason
FileChangeReason
Definition: PPCallbacks.h:39
clang::CompilerInvocation::getModuleHash
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
Definition: CompilerInvocation.cpp:4539
clang::frontend::GenerateModule
@ GenerateModule
Generate pre-compiled module from a module map.
Definition: FrontendOptions.h:82
clang::Module::IsSystem
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers).
Definition: Module.h:271
clang::serialization::ModuleFile::SearchPathUsage
llvm::BitVector SearchPathUsage
The bit vector denoting usage of each header search entry (true = used).
Definition: ModuleFile.h:178
llvm::ArrayRef
Definition: LLVM.h:34
clang::CompilerInstance::getInvocation
CompilerInvocation & getInvocation()
Definition: CompilerInstance.h:231
clang::tooling::dependencies::ModuleDepCollector::attachToASTReader
void attachToASTReader(ASTReader &R) override
Definition: ModuleDepCollector.cpp:317
clang::tooling::dependencies::ModuleDeps
Definition: ModuleDepCollector.h:68
clang::tooling::dependencies::ModuleDepCollectorPP::EndOfMainFile
void EndOfMainFile() override
Callback invoked when the end of the main file is reached.
Definition: ModuleDepCollector.cpp:179
clang::tooling::dependencies::ModuleDeps::ClangModuleMapFile
std::string ClangModuleMapFile
The path to the modulemap file which defines this module.
Definition: ModuleDepCollector.h:79
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:255
clang::tooling::dependencies::ModuleDepCollectorPP::moduleImport
void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported) override
Callback invoked whenever there was an explicit module-import syntax.
Definition: ModuleDepCollector.cpp:161
clang::Module::Imports
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:327
clang::HeaderSearchOptions::UserEntries
std::vector< Entry > UserEntries
User specified include entries.
Definition: HeaderSearchOptions.h:103
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:342
std
Definition: Format.h:4034
clang::FrontendOptions::ModuleFiles
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input.
Definition: FrontendOptions.h:427
clang
Definition: CalledOnceCheck.h:17
clang::Preprocessor::addPPCallbacks
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:1058
optimizeHeaderSearchOpts
static void optimizeHeaderSearchOpts(HeaderSearchOptions &Opts, ASTReader &Reader, const serialization::ModuleFile &MF)
Definition: ModuleDepCollector.cpp:20
clang::FileEntry::getName
StringRef getName() const
Definition: FileEntry.h:364
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:40
clang::CompilerInvocation
Helper class for holding the data necessary to invoke the compiler.
Definition: CompilerInvocation.h:193
clang::tooling::dependencies::DependencyConsumer::handleContextHash
virtual void handleContextHash(std::string Hash)=0
clang::SourceManager::getFileEntryForID
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
Definition: SourceManager.h:1030
clang::SrcMgr::isSystem
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
Definition: SourceManager.h:87
serializeCompilerInvocation
static std::vector< std::string > serializeCompilerInvocation(const CompilerInvocation &CI)
Definition: ModuleDepCollector.cpp:62
CompilerInstance.h
clang::tooling::dependencies::ModuleDepCollectorPP::FileChanged
void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override
Callback invoked whenever a source file is entered or exited.
Definition: ModuleDepCollector.cpp:123
clang::CompilerInstance::getASTReader
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: CompilerInstance.cpp:199
clang::CompilerInstance::getSourceManager
SourceManager & getSourceManager() const
Return the current source manager.
Definition: CompilerInstance.h:424
clang::tooling::dependencies::ModuleID
This is used to identify a specific module.
Definition: ModuleDepCollector.h:44
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:130
clang::tooling::dependencies::ModuleDeps::ClangModuleDeps
std::vector< ModuleID > ClangModuleDeps
A list of module identifiers this module directly depends on, not including transitive dependencies.
Definition: ModuleDepCollector.h:97
SM
#define SM(sm)
Definition: Cuda.cpp:78
clang::Preprocessor::getHeaderSearchInfo
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:965
clang::tooling::dependencies::DependencyConsumer::handleFileDependency
virtual void handleFileDependency(StringRef Filename)=0
clang::tooling::dependencies::DependencyConsumer::handleDependencyOutputOpts
virtual void handleDependencyOutputOpts(const DependencyOutputOptions &Opts)=0
clang::tooling::dependencies::ModuleDepCollector::ModuleDepCollector
ModuleDepCollector(std::unique_ptr< DependencyOutputOptions > Opts, CompilerInstance &I, DependencyConsumer &C, CompilerInvocation &&OriginalCI, bool OptimizeArgs)
Definition: ModuleDepCollector.cpp:307
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:740
clang::serialization::ModuleFile
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:111
clang::CompilerInstance::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts()
Definition: CompilerInstance.h:291
clang::PreprocessorOptions::ImplicitPCHInclude
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
Definition: PreprocessorOptions.h:96
clang::HeaderSearchOptions
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
Definition: HeaderSearchOptions.h:68