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