1 //===-- LanguageRuntime.cpp -------------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Target/LanguageRuntime.h"
11 #include "lldb/Target/Target.h"
12 #include "lldb/Core/PluginManager.h"
15 using namespace lldb_private;
18 class ExceptionSearchFilter : public SearchFilter
21 ExceptionSearchFilter (const lldb::TargetSP &target_sp,
22 lldb::LanguageType language) :
23 SearchFilter (target_sp),
24 m_language (language),
25 m_language_runtime (NULL),
28 UpdateModuleListIfNeeded ();
32 ModulePasses (const lldb::ModuleSP &module_sp)
34 UpdateModuleListIfNeeded ();
36 return m_filter_sp->ModulePasses (module_sp);
41 ModulePasses (const FileSpec &spec)
43 UpdateModuleListIfNeeded ();
45 return m_filter_sp->ModulePasses (spec);
51 Search (Searcher &searcher)
53 UpdateModuleListIfNeeded ();
55 m_filter_sp->Search (searcher);
59 GetDescription (Stream *s)
61 UpdateModuleListIfNeeded ();
63 m_filter_sp->GetDescription (s);
67 LanguageType m_language;
68 LanguageRuntime *m_language_runtime;
69 SearchFilterSP m_filter_sp;
72 UpdateModuleListIfNeeded ()
74 ProcessSP process_sp (m_target_sp->GetProcessSP());
77 bool refreash_filter = !m_filter_sp;
78 if (m_language_runtime == NULL)
80 m_language_runtime = process_sp->GetLanguageRuntime(m_language);
81 refreash_filter = true;
85 LanguageRuntime *language_runtime = process_sp->GetLanguageRuntime(m_language);
86 if (m_language_runtime != language_runtime)
88 m_language_runtime = language_runtime;
89 refreash_filter = true;
93 if (refreash_filter && m_language_runtime)
95 m_filter_sp = m_language_runtime->CreateExceptionSearchFilter ();
101 m_language_runtime = NULL;
106 // The Target is the one that knows how to create breakpoints, so this function
107 // is meant to be used either by the target or internally in Set/ClearExceptionBreakpoints.
108 class ExceptionBreakpointResolver : public BreakpointResolver
111 ExceptionBreakpointResolver (lldb::LanguageType language,
114 BreakpointResolver (NULL, BreakpointResolver::ExceptionResolver),
115 m_language (language),
116 m_language_runtime (NULL),
117 m_catch_bp (catch_bp),
118 m_throw_bp (throw_bp)
123 ~ExceptionBreakpointResolver()
127 virtual Searcher::CallbackReturn
128 SearchCallback (SearchFilter &filter,
129 SymbolContext &context,
134 if (SetActualResolver())
135 return m_actual_resolver_sp->SearchCallback (filter, context, addr, containing);
137 return eCallbackReturnStop;
140 virtual Searcher::Depth
143 if (SetActualResolver())
144 return m_actual_resolver_sp->GetDepth();
150 GetDescription (Stream *s)
152 s->Printf ("Exception breakpoint (catch: %s throw: %s)",
153 m_catch_bp ? "on" : "off",
154 m_throw_bp ? "on" : "off");
157 if (m_actual_resolver_sp)
159 s->Printf (" using: ");
160 m_actual_resolver_sp->GetDescription (s);
163 s->Printf (" the correct runtime exception handler will be determined when you run");
167 Dump (Stream *s) const
171 /// Methods for support type inquiry through isa, cast, and dyn_cast:
172 static inline bool classof(const BreakpointResolverName *) { return true; }
173 static inline bool classof(const BreakpointResolver *V) {
174 return V->getResolverID() == BreakpointResolver::ExceptionResolver;
180 ProcessSP process_sp;
183 process_sp = m_breakpoint->GetTarget().GetProcessSP();
186 bool refreash_resolver = !m_actual_resolver_sp;
187 if (m_language_runtime == NULL)
189 m_language_runtime = process_sp->GetLanguageRuntime(m_language);
190 refreash_resolver = true;
194 LanguageRuntime *language_runtime = process_sp->GetLanguageRuntime(m_language);
195 if (m_language_runtime != language_runtime)
197 m_language_runtime = language_runtime;
198 refreash_resolver = true;
202 if (refreash_resolver && m_language_runtime)
204 m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver (m_breakpoint, m_catch_bp, m_throw_bp);
209 m_actual_resolver_sp.reset();
210 m_language_runtime = NULL;
215 m_actual_resolver_sp.reset();
216 m_language_runtime = NULL;
218 return (bool)m_actual_resolver_sp;
220 lldb::BreakpointResolverSP m_actual_resolver_sp;
221 lldb::LanguageType m_language;
222 LanguageRuntime *m_language_runtime;
229 LanguageRuntime::FindPlugin (Process *process, lldb::LanguageType language)
231 std::unique_ptr<LanguageRuntime> language_runtime_ap;
232 LanguageRuntimeCreateInstance create_callback;
234 for (uint32_t idx = 0;
235 (create_callback = PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != NULL;
238 language_runtime_ap.reset (create_callback(process, language));
240 if (language_runtime_ap.get())
241 return language_runtime_ap.release();
247 //----------------------------------------------------------------------
249 //----------------------------------------------------------------------
250 LanguageRuntime::LanguageRuntime(Process *process) :
255 //----------------------------------------------------------------------
257 //----------------------------------------------------------------------
258 LanguageRuntime::~LanguageRuntime()
263 LanguageRuntime::CreateExceptionBreakpoint (Target &target,
264 lldb::LanguageType language,
269 BreakpointResolverSP resolver_sp(new ExceptionBreakpointResolver(language, catch_bp, throw_bp));
270 SearchFilterSP filter_sp(new ExceptionSearchFilter(target.shared_from_this(), language));
271 bool hardware = false;
272 bool resolve_indirect_functions = false;
273 BreakpointSP exc_breakpt_sp (target.CreateBreakpoint (filter_sp, resolver_sp, is_internal, hardware, resolve_indirect_functions));
275 exc_breakpt_sp->SetBreakpointKind("exception");
277 return exc_breakpt_sp;
280 struct language_name_pair {
285 struct language_name_pair language_names[] =
287 // To allow GetNameForLanguageType to be a simple array lookup, the first
288 // part of this array must follow enum LanguageType exactly.
289 { "unknown", eLanguageTypeUnknown },
290 { "c89", eLanguageTypeC89 },
291 { "c", eLanguageTypeC },
292 { "ada83", eLanguageTypeAda83 },
293 { "c++", eLanguageTypeC_plus_plus },
294 { "cobol74", eLanguageTypeCobol74 },
295 { "cobol85", eLanguageTypeCobol85 },
296 { "fortran77", eLanguageTypeFortran77 },
297 { "fortran90", eLanguageTypeFortran90 },
298 { "pascal83", eLanguageTypePascal83 },
299 { "modula2", eLanguageTypeModula2 },
300 { "java", eLanguageTypeJava },
301 { "c99", eLanguageTypeC99 },
302 { "ada95", eLanguageTypeAda95 },
303 { "fortran95", eLanguageTypeFortran95 },
304 { "pli", eLanguageTypePLI },
305 { "objective-c", eLanguageTypeObjC },
306 { "objective-c++", eLanguageTypeObjC_plus_plus },
307 { "upc", eLanguageTypeUPC },
308 { "d", eLanguageTypeD },
309 { "python", eLanguageTypePython },
310 // Now synonyms, in arbitrary order
311 { "objc", eLanguageTypeObjC },
312 { "objc++", eLanguageTypeObjC_plus_plus }
315 static uint32_t num_languages = sizeof(language_names) / sizeof (struct language_name_pair);
318 LanguageRuntime::GetLanguageTypeFromString (const char *string)
320 for (uint32_t i = 0; i < num_languages; i++)
322 if (strcasecmp (language_names[i].name, string) == 0)
323 return (LanguageType) language_names[i].type;
325 return eLanguageTypeUnknown;
329 LanguageRuntime::GetNameForLanguageType (LanguageType language)
331 if (language < num_languages)
332 return language_names[language].name;
334 return language_names[eLanguageTypeUnknown].name;
338 LanguageRuntime::CreateExceptionSearchFilter ()
340 return m_process->GetTarget().GetSearchFilterForModule(NULL);