1 //===-- LanguageRuntime.cpp -------------------------------------*- 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 #include "lldb/Target/LanguageRuntime.h"
10 #include "lldb/Core/PluginManager.h"
11 #include "lldb/Core/SearchFilter.h"
12 #include "lldb/Interpreter/CommandInterpreter.h"
13 #include "lldb/Target/Language.h"
14 #include "lldb/Target/Target.h"
15
16 using namespace lldb;
17 using namespace lldb_private;
18
19 char LanguageRuntime::ID = 0;
20
ExceptionSearchFilter(const lldb::TargetSP & target_sp,lldb::LanguageType language,bool update_module_list)21 ExceptionSearchFilter::ExceptionSearchFilter(const lldb::TargetSP &target_sp,
22 lldb::LanguageType language,
23 bool update_module_list)
24 : SearchFilter(target_sp, FilterTy::Exception), m_language(language),
25 m_language_runtime(nullptr), m_filter_sp() {
26 if (update_module_list)
27 UpdateModuleListIfNeeded();
28 }
29
ModulePasses(const lldb::ModuleSP & module_sp)30 bool ExceptionSearchFilter::ModulePasses(const lldb::ModuleSP &module_sp) {
31 UpdateModuleListIfNeeded();
32 if (m_filter_sp)
33 return m_filter_sp->ModulePasses(module_sp);
34 return false;
35 }
36
ModulePasses(const FileSpec & spec)37 bool ExceptionSearchFilter::ModulePasses(const FileSpec &spec) {
38 UpdateModuleListIfNeeded();
39 if (m_filter_sp)
40 return m_filter_sp->ModulePasses(spec);
41 return false;
42 }
43
Search(Searcher & searcher)44 void ExceptionSearchFilter::Search(Searcher &searcher) {
45 UpdateModuleListIfNeeded();
46 if (m_filter_sp)
47 m_filter_sp->Search(searcher);
48 }
49
GetDescription(Stream * s)50 void ExceptionSearchFilter::GetDescription(Stream *s) {
51 UpdateModuleListIfNeeded();
52 if (m_filter_sp)
53 m_filter_sp->GetDescription(s);
54 }
55
UpdateModuleListIfNeeded()56 void ExceptionSearchFilter::UpdateModuleListIfNeeded() {
57 ProcessSP process_sp(m_target_sp->GetProcessSP());
58 if (process_sp) {
59 bool refreash_filter = !m_filter_sp;
60 if (m_language_runtime == nullptr) {
61 m_language_runtime = process_sp->GetLanguageRuntime(m_language);
62 refreash_filter = true;
63 } else {
64 LanguageRuntime *language_runtime =
65 process_sp->GetLanguageRuntime(m_language);
66 if (m_language_runtime != language_runtime) {
67 m_language_runtime = language_runtime;
68 refreash_filter = true;
69 }
70 }
71
72 if (refreash_filter && m_language_runtime) {
73 m_filter_sp = m_language_runtime->CreateExceptionSearchFilter();
74 }
75 } else {
76 m_filter_sp.reset();
77 m_language_runtime = nullptr;
78 }
79 }
80
81 SearchFilterSP
DoCopyForBreakpoint(Breakpoint & breakpoint)82 ExceptionSearchFilter::DoCopyForBreakpoint(Breakpoint &breakpoint) {
83 return SearchFilterSP(
84 new ExceptionSearchFilter(TargetSP(), m_language, false));
85 }
86
CreateFromStructuredData(Target & target,const StructuredData::Dictionary & data_dict,Status & error)87 SearchFilter *ExceptionSearchFilter::CreateFromStructuredData(
88 Target &target, const StructuredData::Dictionary &data_dict,
89 Status &error) {
90 SearchFilter *result = nullptr;
91 return result;
92 }
93
SerializeToStructuredData()94 StructuredData::ObjectSP ExceptionSearchFilter::SerializeToStructuredData() {
95 StructuredData::ObjectSP result_sp;
96
97 return result_sp;
98 }
99
100 // The Target is the one that knows how to create breakpoints, so this function
101 // is meant to be used either by the target or internally in
102 // Set/ClearExceptionBreakpoints.
103 class ExceptionBreakpointResolver : public BreakpointResolver {
104 public:
ExceptionBreakpointResolver(lldb::LanguageType language,bool catch_bp,bool throw_bp)105 ExceptionBreakpointResolver(lldb::LanguageType language, bool catch_bp,
106 bool throw_bp)
107 : BreakpointResolver(nullptr, BreakpointResolver::ExceptionResolver),
108 m_language(language), m_language_runtime(nullptr), m_catch_bp(catch_bp),
109 m_throw_bp(throw_bp) {}
110
111 ~ExceptionBreakpointResolver() override = default;
112
SearchCallback(SearchFilter & filter,SymbolContext & context,Address * addr)113 Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
114 SymbolContext &context,
115 Address *addr) override {
116
117 if (SetActualResolver())
118 return m_actual_resolver_sp->SearchCallback(filter, context, addr);
119 else
120 return eCallbackReturnStop;
121 }
122
GetDepth()123 lldb::SearchDepth GetDepth() override {
124 if (SetActualResolver())
125 return m_actual_resolver_sp->GetDepth();
126 else
127 return lldb::eSearchDepthTarget;
128 }
129
GetDescription(Stream * s)130 void GetDescription(Stream *s) override {
131 Language *language_plugin = Language::FindPlugin(m_language);
132 if (language_plugin)
133 language_plugin->GetExceptionResolverDescription(m_catch_bp, m_throw_bp,
134 *s);
135 else
136 Language::GetDefaultExceptionResolverDescription(m_catch_bp, m_throw_bp,
137 *s);
138
139 SetActualResolver();
140 if (m_actual_resolver_sp) {
141 s->Printf(" using: ");
142 m_actual_resolver_sp->GetDescription(s);
143 } else
144 s->Printf(" the correct runtime exception handler will be determined "
145 "when you run");
146 }
147
Dump(Stream * s) const148 void Dump(Stream *s) const override {}
149
150 /// Methods for support type inquiry through isa, cast, and dyn_cast:
classof(const BreakpointResolverName *)151 static inline bool classof(const BreakpointResolverName *) { return true; }
classof(const BreakpointResolver * V)152 static inline bool classof(const BreakpointResolver *V) {
153 return V->getResolverID() == BreakpointResolver::ExceptionResolver;
154 }
155
156 protected:
CopyForBreakpoint(Breakpoint & breakpoint)157 BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override {
158 BreakpointResolverSP ret_sp(
159 new ExceptionBreakpointResolver(m_language, m_catch_bp, m_throw_bp));
160 ret_sp->SetBreakpoint(&breakpoint);
161 return ret_sp;
162 }
163
SetActualResolver()164 bool SetActualResolver() {
165 ProcessSP process_sp;
166 if (m_breakpoint) {
167 process_sp = m_breakpoint->GetTarget().GetProcessSP();
168 if (process_sp) {
169 bool refreash_resolver = !m_actual_resolver_sp;
170 if (m_language_runtime == nullptr) {
171 m_language_runtime = process_sp->GetLanguageRuntime(m_language);
172 refreash_resolver = true;
173 } else {
174 LanguageRuntime *language_runtime =
175 process_sp->GetLanguageRuntime(m_language);
176 if (m_language_runtime != language_runtime) {
177 m_language_runtime = language_runtime;
178 refreash_resolver = true;
179 }
180 }
181
182 if (refreash_resolver && m_language_runtime) {
183 m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver(
184 m_breakpoint, m_catch_bp, m_throw_bp);
185 }
186 } else {
187 m_actual_resolver_sp.reset();
188 m_language_runtime = nullptr;
189 }
190 } else {
191 m_actual_resolver_sp.reset();
192 m_language_runtime = nullptr;
193 }
194 return (bool)m_actual_resolver_sp;
195 }
196
197 lldb::BreakpointResolverSP m_actual_resolver_sp;
198 lldb::LanguageType m_language;
199 LanguageRuntime *m_language_runtime;
200 bool m_catch_bp;
201 bool m_throw_bp;
202 };
203
FindPlugin(Process * process,lldb::LanguageType language)204 LanguageRuntime *LanguageRuntime::FindPlugin(Process *process,
205 lldb::LanguageType language) {
206 std::unique_ptr<LanguageRuntime> language_runtime_up;
207 LanguageRuntimeCreateInstance create_callback;
208
209 for (uint32_t idx = 0;
210 (create_callback =
211 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) !=
212 nullptr;
213 ++idx) {
214 language_runtime_up.reset(create_callback(process, language));
215
216 if (language_runtime_up)
217 return language_runtime_up.release();
218 }
219
220 return nullptr;
221 }
222
LanguageRuntime(Process * process)223 LanguageRuntime::LanguageRuntime(Process *process) : m_process(process) {}
224
225 LanguageRuntime::~LanguageRuntime() = default;
226
227 BreakpointPreconditionSP
GetExceptionPrecondition(LanguageType language,bool throw_bp)228 LanguageRuntime::GetExceptionPrecondition(LanguageType language,
229 bool throw_bp) {
230 LanguageRuntimeCreateInstance create_callback;
231 for (uint32_t idx = 0;
232 (create_callback =
233 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) !=
234 nullptr;
235 idx++) {
236 if (auto precondition_callback =
237 PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(
238 idx)) {
239 if (BreakpointPreconditionSP precond =
240 precondition_callback(language, throw_bp))
241 return precond;
242 }
243 }
244 return BreakpointPreconditionSP();
245 }
246
CreateExceptionBreakpoint(Target & target,lldb::LanguageType language,bool catch_bp,bool throw_bp,bool is_internal)247 BreakpointSP LanguageRuntime::CreateExceptionBreakpoint(
248 Target &target, lldb::LanguageType language, bool catch_bp, bool throw_bp,
249 bool is_internal) {
250 BreakpointResolverSP resolver_sp(
251 new ExceptionBreakpointResolver(language, catch_bp, throw_bp));
252 SearchFilterSP filter_sp(
253 new ExceptionSearchFilter(target.shared_from_this(), language));
254 bool hardware = false;
255 bool resolve_indirect_functions = false;
256 BreakpointSP exc_breakpt_sp(
257 target.CreateBreakpoint(filter_sp, resolver_sp, is_internal, hardware,
258 resolve_indirect_functions));
259 if (exc_breakpt_sp) {
260 if (auto precond = GetExceptionPrecondition(language, throw_bp))
261 exc_breakpt_sp->SetPrecondition(precond);
262
263 if (is_internal)
264 exc_breakpt_sp->SetBreakpointKind("exception");
265 }
266
267 return exc_breakpt_sp;
268 }
269
InitializeCommands(CommandObject * parent)270 void LanguageRuntime::InitializeCommands(CommandObject *parent) {
271 if (!parent)
272 return;
273
274 if (!parent->IsMultiwordObject())
275 return;
276
277 LanguageRuntimeCreateInstance create_callback;
278
279 for (uint32_t idx = 0;
280 (create_callback =
281 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) !=
282 nullptr;
283 ++idx) {
284 if (LanguageRuntimeGetCommandObject command_callback =
285 PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(idx)) {
286 CommandObjectSP command =
287 command_callback(parent->GetCommandInterpreter());
288 if (command) {
289 // the CommandObject vended by a Language plugin cannot be created once
290 // and cached because we may create multiple debuggers and need one
291 // instance of the command each - the implementing function is meant to
292 // create a new instance of the command each time it is invoked.
293 parent->LoadSubCommand(command->GetCommandName().str().c_str(), command);
294 }
295 }
296 }
297 }
298