Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- DependencyScanningWorker.h - clang-scan-deps worker ===---*- 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. #ifndef LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_DEPENDENCYSCANNINGWORKER_H
  10. #define LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_DEPENDENCYSCANNINGWORKER_H
  11.  
  12. #include "clang/Basic/DiagnosticOptions.h"
  13. #include "clang/Basic/FileManager.h"
  14. #include "clang/Basic/LLVM.h"
  15. #include "clang/Frontend/PCHContainerOperations.h"
  16. #include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
  17. #include "clang/Tooling/DependencyScanning/ModuleDepCollector.h"
  18. #include "llvm/Support/Error.h"
  19. #include "llvm/Support/FileSystem.h"
  20. #include <optional>
  21. #include <string>
  22.  
  23. namespace clang {
  24.  
  25. class DependencyOutputOptions;
  26.  
  27. namespace tooling {
  28. namespace dependencies {
  29.  
  30. class DependencyScanningWorkerFilesystem;
  31.  
  32. /// A command-line tool invocation that is part of building a TU.
  33. ///
  34. /// \see FullDependencies::Commands.
  35. struct Command {
  36.   std::string Executable;
  37.   std::vector<std::string> Arguments;
  38. };
  39.  
  40. class DependencyConsumer {
  41. public:
  42.   virtual ~DependencyConsumer() {}
  43.  
  44.   virtual void handleProvidedAndRequiredStdCXXModules(
  45.       std::optional<P1689ModuleInfo> Provided,
  46.       std::vector<P1689ModuleInfo> Requires) {}
  47.  
  48.   virtual void handleBuildCommand(Command Cmd) {}
  49.  
  50.   virtual void
  51.   handleDependencyOutputOpts(const DependencyOutputOptions &Opts) = 0;
  52.  
  53.   virtual void handleFileDependency(StringRef Filename) = 0;
  54.  
  55.   virtual void handlePrebuiltModuleDependency(PrebuiltModuleDep PMD) = 0;
  56.  
  57.   virtual void handleModuleDependency(ModuleDeps MD) = 0;
  58.  
  59.   virtual void handleContextHash(std::string Hash) = 0;
  60.  
  61.   virtual std::string lookupModuleOutput(const ModuleID &ID,
  62.                                          ModuleOutputKind Kind) = 0;
  63. };
  64.  
  65. /// An individual dependency scanning worker that is able to run on its own
  66. /// thread.
  67. ///
  68. /// The worker computes the dependencies for the input files by preprocessing
  69. /// sources either using a fast mode where the source files are minimized, or
  70. /// using the regular processing run.
  71. class DependencyScanningWorker {
  72. public:
  73.   DependencyScanningWorker(DependencyScanningService &Service,
  74.                            llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS);
  75.  
  76.   /// Run the dependency scanning tool for a given clang driver command-line,
  77.   /// and report the discovered dependencies to the provided consumer. If \p
  78.   /// ModuleName isn't empty, this function reports the dependencies of module
  79.   /// \p ModuleName.
  80.   ///
  81.   /// \returns false if clang errors occurred (with diagnostics reported to
  82.   /// \c DiagConsumer), true otherwise.
  83.   bool computeDependencies(StringRef WorkingDirectory,
  84.                            const std::vector<std::string> &CommandLine,
  85.                            DependencyConsumer &DepConsumer,
  86.                            DiagnosticConsumer &DiagConsumer,
  87.                            std::optional<StringRef> ModuleName = std::nullopt);
  88.   /// \returns A \c StringError with the diagnostic output if clang errors
  89.   /// occurred, success otherwise.
  90.   llvm::Error
  91.   computeDependencies(StringRef WorkingDirectory,
  92.                       const std::vector<std::string> &CommandLine,
  93.                       DependencyConsumer &Consumer,
  94.                       std::optional<StringRef> ModuleName = std::nullopt);
  95.  
  96.   bool shouldEagerLoadModules() const { return EagerLoadModules; }
  97.  
  98. private:
  99.   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
  100.   /// The file system to be used during the scan.
  101.   /// This is either \c FS passed in the constructor (when performing canonical
  102.   /// preprocessing), or \c DepFS (when performing dependency directives scan).
  103.   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS;
  104.   /// When performing dependency directives scan, this is the caching (and
  105.   /// dependency-directives-extracting) filesystem overlaid on top of \c FS
  106.   /// (passed in the constructor).
  107.   llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS;
  108.   ScanningOutputFormat Format;
  109.   /// Whether to optimize the modules' command-line arguments.
  110.   bool OptimizeArgs;
  111.   /// Whether to set up command-lines to load PCM files eagerly.
  112.   bool EagerLoadModules;
  113. };
  114.  
  115. } // end namespace dependencies
  116. } // end namespace tooling
  117. } // end namespace clang
  118.  
  119. #endif // LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_DEPENDENCYSCANNINGWORKER_H
  120.