| //===-- ClangModulesDeclVendor.h --------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGMODULESDECLVENDOR_H |
| #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGMODULESDECLVENDOR_H |
| |
| #include "lldb/Symbol/SourceModule.h" |
| #include "lldb/Target/Platform.h" |
| |
| #include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h" |
| |
| #include <set> |
| #include <vector> |
| |
| namespace lldb_private { |
| |
| class ClangModulesDeclVendor : public ClangDeclVendor { |
| public: |
| // Constructors and Destructors |
| ClangModulesDeclVendor(); |
| |
| ~ClangModulesDeclVendor() override; |
| |
| static bool classof(const DeclVendor *vendor) { |
| return vendor->GetKind() == eClangModuleDeclVendor; |
| } |
| |
| static ClangModulesDeclVendor *Create(Target &target); |
| |
| typedef std::vector<ConstString> ModulePath; |
| typedef uintptr_t ModuleID; |
| typedef std::vector<ModuleID> ModuleVector; |
| |
| /// Add a module to the list of modules to search. |
| /// |
| /// \param[in] module |
| /// The path to the exact module to be loaded. E.g., if the desired |
| /// module is std.io, then this should be { "std", "io" }. |
| /// |
| /// \param[in] exported_modules |
| /// If non-NULL, a pointer to a vector to populate with the ID of every |
| /// module that is re-exported by the specified module. |
| /// |
| /// \param[in] error_stream |
| /// A stream to populate with the output of the Clang parser when |
| /// it tries to load the module. |
| /// |
| /// \return |
| /// True if the module could be loaded; false if not. If the |
| /// compiler encountered a fatal error during a previous module |
| /// load, then this will always return false for this ModuleImporter. |
| virtual bool AddModule(const SourceModule &module, |
| ModuleVector *exported_modules, |
| Stream &error_stream) = 0; |
| |
| /// Add all modules referred to in a given compilation unit to the list |
| /// of modules to search. |
| /// |
| /// \param[in] cu |
| /// The compilation unit to scan for imported modules. |
| /// |
| /// \param[in] exported_modules |
| /// A vector to populate with the ID of each module loaded (directly |
| /// and via re-exports) in this way. |
| /// |
| /// \param[in] error_stream |
| /// A stream to populate with the output of the Clang parser when |
| /// it tries to load the modules. |
| /// |
| /// \return |
| /// True if all modules referred to by the compilation unit could be |
| /// loaded; false if one could not be loaded. If the compiler |
| /// encountered a fatal error during a previous module |
| /// load, then this will always return false for this ModuleImporter. |
| virtual bool AddModulesForCompileUnit(CompileUnit &cu, |
| ModuleVector &exported_modules, |
| Stream &error_stream) = 0; |
| |
| /// Enumerate all the macros that are defined by a given set of modules |
| /// that are already imported. |
| /// |
| /// \param[in] modules |
| /// The unique IDs for all modules to query. Later modules have higher |
| /// priority, just as if you @imported them in that order. This matters |
| /// if module A #defines a macro and module B #undefs it. |
| /// |
| /// \param[in] handler |
| /// A function to call with the identifier of this macro and the text of |
| /// each #define (including the #define directive). #undef directives are |
| /// not included; we simply elide any corresponding #define. If this |
| /// function returns true, we stop the iteration immediately. |
| virtual void ForEachMacro( |
| const ModuleVector &modules, |
| std::function<bool(llvm::StringRef, llvm::StringRef)> handler) = 0; |
| |
| /// Query whether Clang supports modules for a particular language. |
| /// LLDB uses this to decide whether to try to find the modules loaded |
| /// by a given compile unit. |
| /// |
| /// \param[in] language |
| /// The language to query for. |
| /// |
| /// \return |
| /// True if Clang has modules for the given language. |
| static bool LanguageSupportsClangModules(lldb::LanguageType language); |
| }; |
| |
| } // namespace lldb_private |
| |
| #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGMODULESDECLVENDOR_H |