forked from OSchip/llvm-project
496 lines
15 KiB
C++
496 lines
15 KiB
C++
//===-- 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/ObjCLanguageRuntime.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/SearchFilter.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
|
|
class ExceptionSearchFilter : public SearchFilter
|
|
{
|
|
public:
|
|
ExceptionSearchFilter (const lldb::TargetSP &target_sp,
|
|
lldb::LanguageType language,
|
|
bool update_module_list = true) :
|
|
SearchFilter (target_sp),
|
|
m_language (language),
|
|
m_language_runtime (NULL),
|
|
m_filter_sp ()
|
|
{
|
|
if (update_module_list)
|
|
UpdateModuleListIfNeeded ();
|
|
}
|
|
|
|
virtual
|
|
~ExceptionSearchFilter() {}
|
|
|
|
bool
|
|
ModulePasses (const lldb::ModuleSP &module_sp) override
|
|
{
|
|
UpdateModuleListIfNeeded ();
|
|
if (m_filter_sp)
|
|
return m_filter_sp->ModulePasses (module_sp);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ModulePasses (const FileSpec &spec) override
|
|
{
|
|
UpdateModuleListIfNeeded ();
|
|
if (m_filter_sp)
|
|
return m_filter_sp->ModulePasses (spec);
|
|
return false;
|
|
|
|
}
|
|
|
|
void
|
|
Search (Searcher &searcher) override
|
|
{
|
|
UpdateModuleListIfNeeded ();
|
|
if (m_filter_sp)
|
|
m_filter_sp->Search (searcher);
|
|
}
|
|
|
|
void
|
|
GetDescription (Stream *s) override
|
|
{
|
|
UpdateModuleListIfNeeded ();
|
|
if (m_filter_sp)
|
|
m_filter_sp->GetDescription (s);
|
|
}
|
|
|
|
protected:
|
|
LanguageType m_language;
|
|
LanguageRuntime *m_language_runtime;
|
|
SearchFilterSP m_filter_sp;
|
|
|
|
SearchFilterSP
|
|
DoCopyForBreakpoint(Breakpoint &breakpoint) override
|
|
{
|
|
return SearchFilterSP(new ExceptionSearchFilter(TargetSP(), m_language, false));
|
|
}
|
|
|
|
void
|
|
UpdateModuleListIfNeeded ()
|
|
{
|
|
ProcessSP process_sp (m_target_sp->GetProcessSP());
|
|
if (process_sp)
|
|
{
|
|
bool refreash_filter = !m_filter_sp;
|
|
if (m_language_runtime == NULL)
|
|
{
|
|
m_language_runtime = process_sp->GetLanguageRuntime(m_language);
|
|
refreash_filter = true;
|
|
}
|
|
else
|
|
{
|
|
LanguageRuntime *language_runtime = process_sp->GetLanguageRuntime(m_language);
|
|
if (m_language_runtime != language_runtime)
|
|
{
|
|
m_language_runtime = language_runtime;
|
|
refreash_filter = true;
|
|
}
|
|
}
|
|
|
|
if (refreash_filter && m_language_runtime)
|
|
{
|
|
m_filter_sp = m_language_runtime->CreateExceptionSearchFilter ();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_filter_sp.reset();
|
|
m_language_runtime = NULL;
|
|
}
|
|
}
|
|
};
|
|
|
|
// The Target is the one that knows how to create breakpoints, so this function
|
|
// is meant to be used either by the target or internally in Set/ClearExceptionBreakpoints.
|
|
class ExceptionBreakpointResolver : public BreakpointResolver
|
|
{
|
|
public:
|
|
ExceptionBreakpointResolver (lldb::LanguageType language,
|
|
bool catch_bp,
|
|
bool throw_bp) :
|
|
BreakpointResolver (NULL, BreakpointResolver::ExceptionResolver),
|
|
m_language (language),
|
|
m_language_runtime (NULL),
|
|
m_catch_bp (catch_bp),
|
|
m_throw_bp (throw_bp)
|
|
{
|
|
}
|
|
|
|
virtual
|
|
~ExceptionBreakpointResolver()
|
|
{
|
|
}
|
|
|
|
Searcher::CallbackReturn
|
|
SearchCallback (SearchFilter &filter,
|
|
SymbolContext &context,
|
|
Address *addr,
|
|
bool containing) override
|
|
{
|
|
|
|
if (SetActualResolver())
|
|
return m_actual_resolver_sp->SearchCallback (filter, context, addr, containing);
|
|
else
|
|
return eCallbackReturnStop;
|
|
}
|
|
|
|
Searcher::Depth
|
|
GetDepth () override
|
|
{
|
|
if (SetActualResolver())
|
|
return m_actual_resolver_sp->GetDepth();
|
|
else
|
|
return eDepthTarget;
|
|
}
|
|
|
|
void
|
|
GetDescription (Stream *s) override
|
|
{
|
|
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");
|
|
}
|
|
|
|
void
|
|
Dump (Stream *s) const override
|
|
{
|
|
}
|
|
|
|
/// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const BreakpointResolverName *) { return true; }
|
|
static inline bool classof(const BreakpointResolver *V) {
|
|
return V->getResolverID() == BreakpointResolver::ExceptionResolver;
|
|
}
|
|
protected:
|
|
BreakpointResolverSP
|
|
CopyForBreakpoint (Breakpoint &breakpoint) override
|
|
{
|
|
return BreakpointResolverSP(new ExceptionBreakpointResolver(m_language, m_catch_bp, m_throw_bp));
|
|
}
|
|
|
|
bool
|
|
SetActualResolver()
|
|
{
|
|
ProcessSP process_sp;
|
|
if (m_breakpoint)
|
|
{
|
|
process_sp = m_breakpoint->GetTarget().GetProcessSP();
|
|
if (process_sp)
|
|
{
|
|
bool refreash_resolver = !m_actual_resolver_sp;
|
|
if (m_language_runtime == NULL)
|
|
{
|
|
m_language_runtime = process_sp->GetLanguageRuntime(m_language);
|
|
refreash_resolver = true;
|
|
}
|
|
else
|
|
{
|
|
LanguageRuntime *language_runtime = process_sp->GetLanguageRuntime(m_language);
|
|
if (m_language_runtime != language_runtime)
|
|
{
|
|
m_language_runtime = language_runtime;
|
|
refreash_resolver = true;
|
|
}
|
|
}
|
|
|
|
if (refreash_resolver && m_language_runtime)
|
|
{
|
|
m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver (m_breakpoint, m_catch_bp, m_throw_bp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_actual_resolver_sp.reset();
|
|
m_language_runtime = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_actual_resolver_sp.reset();
|
|
m_language_runtime = NULL;
|
|
}
|
|
return (bool)m_actual_resolver_sp;
|
|
}
|
|
lldb::BreakpointResolverSP m_actual_resolver_sp;
|
|
lldb::LanguageType m_language;
|
|
LanguageRuntime *m_language_runtime;
|
|
bool m_catch_bp;
|
|
bool m_throw_bp;
|
|
};
|
|
|
|
|
|
LanguageRuntime*
|
|
LanguageRuntime::FindPlugin (Process *process, lldb::LanguageType language)
|
|
{
|
|
std::unique_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()
|
|
{
|
|
}
|
|
|
|
Breakpoint::BreakpointPreconditionSP
|
|
LanguageRuntime::CreateExceptionPrecondition (lldb::LanguageType language,
|
|
bool catch_bp,
|
|
bool throw_bp)
|
|
{
|
|
switch (language)
|
|
{
|
|
case eLanguageTypeObjC:
|
|
if (throw_bp)
|
|
return Breakpoint::BreakpointPreconditionSP(new ObjCLanguageRuntime::ObjCExceptionPrecondition ());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Breakpoint::BreakpointPreconditionSP();
|
|
}
|
|
|
|
BreakpointSP
|
|
LanguageRuntime::CreateExceptionBreakpoint (Target &target,
|
|
lldb::LanguageType language,
|
|
bool catch_bp,
|
|
bool throw_bp,
|
|
bool is_internal)
|
|
{
|
|
BreakpointResolverSP resolver_sp(new ExceptionBreakpointResolver(language, catch_bp, throw_bp));
|
|
SearchFilterSP filter_sp(new ExceptionSearchFilter(target.shared_from_this(), language));
|
|
bool hardware = false;
|
|
bool resolve_indirect_functions = false;
|
|
BreakpointSP exc_breakpt_sp (target.CreateBreakpoint (filter_sp, resolver_sp, is_internal, hardware, resolve_indirect_functions));
|
|
if (exc_breakpt_sp)
|
|
{
|
|
Breakpoint::BreakpointPreconditionSP precondition_sp = CreateExceptionPrecondition(language, catch_bp, throw_bp);
|
|
if (precondition_sp)
|
|
exc_breakpt_sp->SetPrecondition(precondition_sp);
|
|
|
|
if (is_internal)
|
|
exc_breakpt_sp->SetBreakpointKind("exception");
|
|
}
|
|
|
|
return exc_breakpt_sp;
|
|
}
|
|
|
|
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 },
|
|
{ "opencl", eLanguageTypeOpenCL },
|
|
{ "go", eLanguageTypeGo },
|
|
{ "modula3", eLanguageTypeModula3 },
|
|
{ "haskell", eLanguageTypeHaskell },
|
|
{ "c++03", eLanguageTypeC_plus_plus_03 },
|
|
{ "c++11", eLanguageTypeC_plus_plus_11 },
|
|
{ "ocaml", eLanguageTypeOCaml },
|
|
{ "rust", eLanguageTypeRust },
|
|
{ "c11", eLanguageTypeC11 },
|
|
{ "swift", eLanguageTypeSwift },
|
|
{ "julia", eLanguageTypeJulia },
|
|
{ "dylan", eLanguageTypeDylan },
|
|
{ "c++14", eLanguageTypeC_plus_plus_14 },
|
|
{ "fortran03", eLanguageTypeFortran03 },
|
|
{ "fortran08", eLanguageTypeFortran08 },
|
|
// Vendor Extensions
|
|
{ "mipsassem", eLanguageTypeMipsAssembler },
|
|
{ "renderscript", eLanguageTypeExtRenderScript},
|
|
// Now synonyms, in arbitrary order
|
|
{ "objc", eLanguageTypeObjC },
|
|
{ "objc++", eLanguageTypeObjC_plus_plus },
|
|
{ "pascal", eLanguageTypePascal83 }
|
|
};
|
|
|
|
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;
|
|
}
|
|
|
|
void
|
|
LanguageRuntime::PrintAllLanguages (Stream &s, const char *prefix, const char *suffix)
|
|
{
|
|
for (uint32_t i = 1; i < num_languages; i++)
|
|
{
|
|
s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
|
|
}
|
|
}
|
|
|
|
bool
|
|
LanguageRuntime::LanguageIsCPlusPlus (LanguageType language)
|
|
{
|
|
switch (language)
|
|
{
|
|
case eLanguageTypeC_plus_plus:
|
|
case eLanguageTypeC_plus_plus_03:
|
|
case eLanguageTypeC_plus_plus_11:
|
|
case eLanguageTypeC_plus_plus_14:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
LanguageRuntime::LanguageIsObjC (LanguageType language)
|
|
{
|
|
switch (language)
|
|
{
|
|
case eLanguageTypeObjC:
|
|
case eLanguageTypeObjC_plus_plus:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
LanguageRuntime::LanguageIsC (LanguageType language)
|
|
{
|
|
switch (language)
|
|
{
|
|
case eLanguageTypeC:
|
|
case eLanguageTypeC89:
|
|
case eLanguageTypeC99:
|
|
case eLanguageTypeC11:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
LanguageRuntime::LanguageIsPascal (LanguageType language)
|
|
{
|
|
switch (language)
|
|
{
|
|
case eLanguageTypePascal83:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void
|
|
LanguageRuntime::InitializeCommands (CommandObject* parent)
|
|
{
|
|
if (!parent)
|
|
return;
|
|
|
|
if (!parent->IsMultiwordObject())
|
|
return;
|
|
|
|
LanguageRuntimeCreateInstance create_callback;
|
|
|
|
for (uint32_t idx = 0;
|
|
(create_callback = PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != nullptr;
|
|
++idx)
|
|
{
|
|
if (LanguageRuntimeGetCommandObject command_callback =
|
|
PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(idx))
|
|
{
|
|
CommandObjectSP command = command_callback(parent->GetCommandInterpreter());
|
|
if (command)
|
|
{
|
|
parent->LoadSubCommand(command->GetCommandName(), command);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
lldb::SearchFilterSP
|
|
LanguageRuntime::CreateExceptionSearchFilter ()
|
|
{
|
|
return m_process->GetTarget().GetSearchFilterForModule(NULL);
|
|
}
|