LLDB mainline
ClangModulesDeclVendor.h
Go to the documentation of this file.
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
14
16
17#include <set>
18#include <vector>
19
20namespace lldb_private {
21
23public:
24 // Constructors and Destructors
26
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.
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.
111};
112
113} // namespace lldb_private
114
115#endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGMODULESDECLVENDOR_H
static ClangModulesDeclVendor * Create(Target &target)
virtual bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules, Stream &error_stream)=0
Add all modules referred to in a given compilation unit to the list of modules to search.
virtual void ForEachMacro(const ModuleVector &modules, std::function< bool(llvm::StringRef, llvm::StringRef)> handler)=0
Enumerate all the macros that are defined by a given set of modules that are already imported.
static bool LanguageSupportsClangModules(lldb::LanguageType language)
Query whether Clang supports modules for a particular language.
virtual bool AddModule(const SourceModule &module, ModuleVector *exported_modules, Stream &error_stream)=0
Add a module to the list of modules to search.
static bool classof(const DeclVendor *vendor)
A class that describes a compilation unit.
Definition: CompileUnit.h:41
DeclVendorKind GetKind() const
Definition: DeclVendor.h:33
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
LanguageType
Programming language type.
Information needed to import a source-language module.
Definition: SourceModule.h:18