lldb/source/Plugins/ExpressionParser/Clang/CppModuleConfiguration.h

   1 //===-- CppModuleConfiguration.h --------------------------------*- 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 LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CPPMODULECONFIGURATION_H
  10 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CPPMODULECONFIGURATION_H
  11
  12 #include <lldb/Utility/FileSpecList.h>
  13 #include <llvm/Support/Regex.h>
  14
  15 namespace lldb_private {
  16
  17 /// A Clang configuration when importing C++ modules.
  18 ///
  19 /// This class computes a list of include paths and module names that can be
  20 /// imported given a list of source files. Currently only used when importing
  21 /// the 'std' module and its dependencies.
  22 class CppModuleConfiguration {
  23   /// Utility class for a path that can only be set once.
  24   class SetOncePath {
  25     std::string m_path;
  26     bool m_valid = false;
  27     /// True iff this path hasn't been set yet.
  28     bool m_first = true;
  29
  30   public:
  31     /// Try setting the path. Returns true if the path was set and false if
  32     /// the path was already set.
  33     [[nodiscard]] bool TrySet(llvm::StringRef path);
  34     /// Return the path if there is one.
  35     llvm::StringRef Get() const {
  36       assert(m_valid && "Called Get() on an invalid SetOncePath?");
  37       return m_path;
  38     }
  39     /// Returns true iff this path was set exactly once so far.
  40     bool Valid() const { return m_valid; }
  41   };
  42
  43   /// If valid, the include path used for the std module.
  44   SetOncePath m_std_inc;
  45   /// If valid, the per-target include path used for the std module.
  46   /// This is an optional path only required on some systems.
  47   SetOncePath m_std_target_inc;
  48   /// If valid, the include path to the C library (e.g. /usr/include).
  49   SetOncePath m_c_inc;
  50   /// If valid, the include path to target-specific C library files
  51   /// (e.g. /usr/include/x86_64-linux-gnu).
  52   /// This is an optional path only required on some systems.
  53   SetOncePath m_c_target_inc;
  54   /// The Clang resource include path for this configuration.
  55   std::string m_resource_inc;
  56
  57   std::vector<std::string> m_include_dirs;
  58   std::vector<std::string> m_imported_modules;
  59
  60   /// Analyze a given source file to build the current configuration.
  61   /// Returns false iff there was a fatal error that makes analyzing any
  62   /// further files pointless as the configuration is now invalid.
  63   bool analyzeFile(const FileSpec &f, const llvm::Triple &triple);
  64
  65 public:
  66   /// Creates a configuration by analyzing the given list of used source files.
  67   /// The triple (if valid) is used to search for target-specific include paths.
  68   explicit CppModuleConfiguration(const FileSpecList &support_files,
  69                                   const llvm::Triple &triple);
  70   /// Creates an empty and invalid configuration.
  71   CppModuleConfiguration() = default;
  72
  73   /// Returns true iff this is a valid configuration that can be used to
  74   /// load and compile modules.
  75   bool hasValidConfig();
  76
  77   /// Returns a list of include directories that should be used when using this
  78   /// configuration (e.g. {"/usr/include", "/usr/include/c++/v1"}).
  79   llvm::ArrayRef<std::string> GetIncludeDirs() const { return m_include_dirs; }
  80
  81   /// Returns a list of (top level) modules that should be imported when using
  82   /// this configuration (e.g. {"std"}).
  83   llvm::ArrayRef<std::string> GetImportedModules() const {
  84     return m_imported_modules;
  85   }
  86 };
  87
  88 } // namespace lldb_private
  89
  90 #endif