| //===-- LanguageRuntime.cpp -------------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Target/LanguageRuntime.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Core/PluginManager.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| LanguageRuntime* |
| LanguageRuntime::FindPlugin (Process *process, lldb::LanguageType language) |
| { |
| std::auto_ptr<LanguageRuntime> language_runtime_ap; |
| LanguageRuntimeCreateInstance create_callback; |
| |
| for (uint32_t idx = 0; |
| (create_callback = PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != NULL; |
| ++idx) |
| { |
| language_runtime_ap.reset (create_callback(process, language)); |
| |
| if (language_runtime_ap.get()) |
| return language_runtime_ap.release(); |
| } |
| |
| return NULL; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Constructor |
| //---------------------------------------------------------------------- |
| LanguageRuntime::LanguageRuntime(Process *process) : |
| m_process (process) |
| { |
| } |
| |
| //---------------------------------------------------------------------- |
| // Destructor |
| //---------------------------------------------------------------------- |
| LanguageRuntime::~LanguageRuntime() |
| { |
| } |
| |
| BreakpointSP |
| LanguageRuntime::CreateExceptionBreakpoint( |
| Target &target, |
| lldb::LanguageType language, |
| bool catch_bp, |
| bool throw_bp, |
| bool is_internal) |
| { |
| BreakpointSP exc_breakpt_sp; |
| BreakpointResolverSP resolver_sp(new ExceptionBreakpointResolver(NULL, language, catch_bp, throw_bp)); |
| SearchFilterSP filter_sp(target.GetSearchFilterForModule(NULL)); |
| |
| exc_breakpt_sp = target.CreateBreakpoint (filter_sp, resolver_sp, is_internal); |
| |
| return exc_breakpt_sp; |
| } |
| |
| LanguageRuntime::ExceptionBreakpointResolver::ExceptionBreakpointResolver (Breakpoint *bkpt, |
| LanguageType language, |
| bool catch_bp, |
| bool throw_bp) : |
| BreakpointResolver (bkpt, BreakpointResolver::ExceptionResolver), |
| m_language (language), |
| m_catch_bp (catch_bp), |
| m_throw_bp (throw_bp) |
| |
| { |
| } |
| |
| void |
| LanguageRuntime::ExceptionBreakpointResolver::GetDescription (Stream *s) |
| { |
| s->Printf ("Exception breakpoint (catch: %s throw: %s)", |
| m_catch_bp ? "on" : "off", |
| m_throw_bp ? "on" : "off"); |
| |
| SetActualResolver(); |
| if (m_actual_resolver_sp) |
| { |
| s->Printf (" using: "); |
| m_actual_resolver_sp->GetDescription (s); |
| } |
| else |
| s->Printf (" the correct runtime exception handler will be determined when you run"); |
| } |
| |
| bool |
| LanguageRuntime::ExceptionBreakpointResolver::SetActualResolver() |
| { |
| ProcessSP process_sp = m_process_wp.lock(); |
| |
| // See if our process weak pointer is still good: |
| if (!process_sp) |
| { |
| // If not, our resolver is no good, so chuck that. Then see if we can get the |
| // target's new process. |
| m_actual_resolver_sp.reset(); |
| if (m_breakpoint) |
| { |
| Target &target = m_breakpoint->GetTarget(); |
| process_sp = target.GetProcessSP(); |
| if (process_sp) |
| { |
| m_process_wp = process_sp; |
| process_sp = m_process_wp.lock(); |
| } |
| } |
| } |
| |
| if (process_sp) |
| { |
| if (m_actual_resolver_sp) |
| return true; |
| else |
| { |
| // If we have a process but not a resolver, set one now. |
| LanguageRuntime *runtime = process_sp->GetLanguageRuntime(m_language); |
| if (runtime) |
| { |
| m_actual_resolver_sp = runtime->CreateExceptionResolver (m_breakpoint, m_catch_bp, m_throw_bp); |
| return (bool) m_actual_resolver_sp; |
| } |
| else |
| return false; |
| } |
| } |
| else |
| return false; |
| } |
| |
| Searcher::CallbackReturn |
| LanguageRuntime::ExceptionBreakpointResolver::SearchCallback (SearchFilter &filter, |
| SymbolContext &context, |
| Address *addr, |
| bool containing) |
| { |
| |
| if (!SetActualResolver()) |
| { |
| return eCallbackReturnStop; |
| } |
| else |
| return m_actual_resolver_sp->SearchCallback (filter, context, addr, containing); |
| } |
| |
| Searcher::Depth |
| LanguageRuntime::ExceptionBreakpointResolver::GetDepth () |
| { |
| if (!SetActualResolver()) |
| return eDepthTarget; |
| else |
| return m_actual_resolver_sp->GetDepth(); |
| } |
| |
| /* |
| typedef enum LanguageType |
| { |
| eLanguageTypeUnknown = 0x0000, ///< Unknown or invalid language value. |
| eLanguageTypeC89 = 0x0001, ///< ISO C:1989. |
| eLanguageTypeC = 0x0002, ///< Non-standardized C, such as K&R. |
| eLanguageTypeAda83 = 0x0003, ///< ISO Ada:1983. |
| eLanguageTypeC_plus_plus = 0x0004, ///< ISO C++:1998. |
| eLanguageTypeCobol74 = 0x0005, ///< ISO Cobol:1974. |
| eLanguageTypeCobol85 = 0x0006, ///< ISO Cobol:1985. |
| eLanguageTypeFortran77 = 0x0007, ///< ISO Fortran 77. |
| eLanguageTypeFortran90 = 0x0008, ///< ISO Fortran 90. |
| eLanguageTypePascal83 = 0x0009, ///< ISO Pascal:1983. |
| eLanguageTypeModula2 = 0x000a, ///< ISO Modula-2:1996. |
| eLanguageTypeJava = 0x000b, ///< Java. |
| eLanguageTypeC99 = 0x000c, ///< ISO C:1999. |
| eLanguageTypeAda95 = 0x000d, ///< ISO Ada:1995. |
| eLanguageTypeFortran95 = 0x000e, ///< ISO Fortran 95. |
| eLanguageTypePLI = 0x000f, ///< ANSI PL/I:1976. |
| eLanguageTypeObjC = 0x0010, ///< Objective-C. |
| eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++. |
| eLanguageTypeUPC = 0x0012, ///< Unified Parallel C. |
| eLanguageTypeD = 0x0013, ///< D. |
| eLanguageTypePython = 0x0014 ///< Python. |
| } LanguageType; |
| */ |
| |
| struct language_name_pair { |
| const char *name; |
| LanguageType type; |
| }; |
| |
| struct language_name_pair language_names[] = |
| { |
| // To allow GetNameForLanguageType to be a simple array lookup, the first |
| // part of this array must follow enum LanguageType exactly. |
| { "unknown", eLanguageTypeUnknown }, |
| { "c89", eLanguageTypeC89 }, |
| { "c", eLanguageTypeC }, |
| { "ada83", eLanguageTypeAda83 }, |
| { "c++", eLanguageTypeC_plus_plus }, |
| { "cobol74", eLanguageTypeCobol74 }, |
| { "cobol85", eLanguageTypeCobol85 }, |
| { "fortran77", eLanguageTypeFortran77 }, |
| { "fortran90", eLanguageTypeFortran90 }, |
| { "pascal83", eLanguageTypePascal83 }, |
| { "modula2", eLanguageTypeModula2 }, |
| { "java", eLanguageTypeJava }, |
| { "c99", eLanguageTypeC99 }, |
| { "ada95", eLanguageTypeAda95 }, |
| { "fortran95", eLanguageTypeFortran95 }, |
| { "pli", eLanguageTypePLI }, |
| { "objective-c", eLanguageTypeObjC }, |
| { "objective-c++", eLanguageTypeObjC_plus_plus }, |
| { "upc", eLanguageTypeUPC }, |
| { "d", eLanguageTypeD }, |
| { "python", eLanguageTypePython }, |
| // Now synonyms, in arbitrary order |
| { "objc", eLanguageTypeObjC }, |
| { "objc++", eLanguageTypeObjC_plus_plus } |
| }; |
| |
| static uint32_t num_languages = sizeof(language_names) / sizeof (struct language_name_pair); |
| |
| LanguageType |
| LanguageRuntime::GetLanguageTypeFromString (const char *string) |
| { |
| for (uint32_t i = 0; i < num_languages; i++) |
| { |
| if (strcasecmp (language_names[i].name, string) == 0) |
| return (LanguageType) language_names[i].type; |
| } |
| return eLanguageTypeUnknown; |
| } |
| |
| const char * |
| LanguageRuntime::GetNameForLanguageType (LanguageType language) |
| { |
| if (language < num_languages) |
| return language_names[language].name; |
| else |
| return language_names[eLanguageTypeUnknown].name; |
| } |
| |