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

   1 //===-- ClangModulesDeclVendor.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_CLANGMODULESDECLVENDOR_H
  10 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGMODULESDECLVENDOR_H
  11
  12 #include "lldb/Symbol/SourceModule.h"
  13 #include "lldb/Target/Platform.h"
  14
  15 #include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
  16
  17 #include <set>
  18 #include <vector>
  19
  20 namespace lldb_private {
  21
  22 class ClangModulesDeclVendor : public ClangDeclVendor {
  23 public:
  24   // Constructors and Destructors
  25   ClangModulesDeclVendor();
  26
  27   ~ClangModulesDeclVendor() override;
  28
  29   static bool classof(const DeclVendor *vendor) {
  30     return vendor->GetKind() == eClangModuleDeclVendor;
  31   }
  32
  33   static ClangModulesDeclVendor *Create(Target &target);
  34
  35   typedef std::vector<ConstString> ModulePath;
  36   typedef uintptr_t ModuleID;
  37   typedef std::vector<ModuleID> ModuleVector;
  38
  39   /// Add a module to the list of modules to search.
  40   ///
  41   /// \param[in] module
  42   ///     The path to the exact module to be loaded.  E.g., if the desired
  43   ///     module is std.io, then this should be { "std", "io" }.
  44   ///
  45   /// \param[in] exported_modules
  46   ///     If non-NULL, a pointer to a vector to populate with the ID of every
  47   ///     module that is re-exported by the specified module.
  48   ///
  49   /// \param[in] error_stream
  50   ///     A stream to populate with the output of the Clang parser when
  51   ///     it tries to load the module.
  52   ///
  53   /// \return
  54   ///     True if the module could be loaded; false if not.  If the
  55   ///     compiler encountered a fatal error during a previous module
  56   ///     load, then this will always return false for this ModuleImporter.
  57   virtual bool AddModule(const SourceModule &module,
  58                          ModuleVector *exported_modules,
  59                          Stream &error_stream) = 0;
  60
  61   /// Add all modules referred to in a given compilation unit to the list
  62   /// of modules to search.
  63   ///
  64   /// \param[in] cu
  65   ///     The compilation unit to scan for imported modules.
  66   ///
  67   /// \param[in] exported_modules
  68   ///     A vector to populate with the ID of each module loaded (directly
  69   ///     and via re-exports) in this way.
  70   ///
  71   /// \param[in] error_stream
  72   ///     A stream to populate with the output of the Clang parser when
  73   ///     it tries to load the modules.
  74   ///
  75   /// \return
  76   ///     True if all modules referred to by the compilation unit could be
  77   ///     loaded; false if one could not be loaded.  If the compiler
  78   ///     encountered a fatal error during a previous module
  79   ///     load, then this will always return false for this ModuleImporter.
  80   virtual bool AddModulesForCompileUnit(CompileUnit &cu,
  81                                         ModuleVector &exported_modules,
  82                                         Stream &error_stream) = 0;
  83
  84   /// Enumerate all the macros that are defined by a given set of modules
  85   /// that are already imported.
  86   ///
  87   /// \param[in] modules
  88   ///     The unique IDs for all modules to query.  Later modules have higher
  89   ///     priority, just as if you @imported them in that order.  This matters
  90   ///     if module A #defines a macro and module B #undefs it.
  91   ///
  92   /// \param[in] handler
  93   ///     A function to call with the identifier of this macro and the text of
  94   ///     each #define (including the #define directive). #undef directives are
  95   ///     not included; we simply elide any corresponding #define. If this
  96   ///     function returns true, we stop the iteration immediately.
  97   virtual void ForEachMacro(
  98       const ModuleVector &modules,
  99       std::function<bool(llvm::StringRef, llvm::StringRef)> handler) = 0;
 100
 101   /// Query whether Clang supports modules for a particular language.
 102   /// LLDB uses this to decide whether to try to find the modules loaded
 103   /// by a given compile unit.
 104   ///
 105   /// \param[in] language
 106   ///     The language to query for.
 107   ///
 108   /// \return
 109   ///     True if Clang has modules for the given language.
 110   static bool LanguageSupportsClangModules(lldb::LanguageType language);
 111 };
 112
 113 } // namespace lldb_private
 114
 115 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGMODULESDECLVENDOR_H