diff options
Diffstat (limited to 'source/Plugins/LanguageRuntime')
4 files changed, 1480 insertions, 0 deletions
diff --git a/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp b/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp index 50537eb119f29..7d21b779ebd2c 100644 --- a/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp +++ b/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp @@ -281,6 +281,46 @@ ItaniumABILanguageRuntime::IsVTableName (const char *name) return false; } +static std::map<ConstString, std::vector<ConstString> >& +GetAlternateManglingPrefixes() +{ + static std::map<ConstString, std::vector<ConstString> > g_alternate_mangling_prefixes; + return g_alternate_mangling_prefixes; +} + + +size_t +ItaniumABILanguageRuntime::GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) +{ + if (!mangled) + return static_cast<size_t>(0); + + alternates.clear(); + const char *mangled_cstr = mangled.AsCString(); + std::map<ConstString, std::vector<ConstString> >& alternate_mangling_prefixes = GetAlternateManglingPrefixes(); + for (std::map<ConstString, std::vector<ConstString> >::iterator it = alternate_mangling_prefixes.begin(); + it != alternate_mangling_prefixes.end(); + ++it) + { + const char *prefix_cstr = it->first.AsCString(); + if (strncmp(mangled_cstr, prefix_cstr, strlen(prefix_cstr)) == 0) + { + const std::vector<ConstString> &alternate_prefixes = it->second; + for (size_t i = 0; i < alternate_prefixes.size(); ++i) + { + std::string alternate_mangling(alternate_prefixes[i].AsCString()); + alternate_mangling.append(mangled_cstr + strlen(prefix_cstr)); + + alternates.push_back(ConstString(alternate_mangling.c_str())); + } + + return alternates.size(); + } + } + + return static_cast<size_t>(0); +} + //------------------------------------------------------------------ // Static Functions //------------------------------------------------------------------ @@ -304,6 +344,17 @@ ItaniumABILanguageRuntime::Initialize() PluginManager::RegisterPlugin (GetPluginNameStatic(), "Itanium ABI for the C++ language", CreateInstance); + + // Alternate manglings for std::basic_string<...> + std::vector<ConstString> basic_string_alternates; + basic_string_alternates.push_back(ConstString("_ZNSs")); + basic_string_alternates.push_back(ConstString("_ZNKSs")); + std::map<ConstString, std::vector<ConstString> >& alternate_mangling_prefixes = GetAlternateManglingPrefixes(); + + alternate_mangling_prefixes[ConstString("_ZNSbIcSt17char_traits<char>St15allocator<char>E")] = + basic_string_alternates; + alternate_mangling_prefixes[ConstString("_ZNKSbIcSt17char_traits<char>St15allocator<char>E")] = + basic_string_alternates; } void diff --git a/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h b/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h index cd0a4b2c15eb8..bc5d83be4bf57 100644 --- a/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h +++ b/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h @@ -20,6 +20,9 @@ #include "lldb/Target/CPPLanguageRuntime.h" #include "lldb/Core/Value.h" +#include <map> +#include <vector> + namespace lldb_private { class ItaniumABILanguageRuntime : @@ -82,6 +85,9 @@ namespace lldb_private { virtual lldb::SearchFilterSP CreateExceptionSearchFilter (); + virtual size_t + GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates); + protected: lldb::BreakpointResolverSP diff --git a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp new file mode 100644 index 0000000000000..2490cf31409b6 --- /dev/null +++ b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp @@ -0,0 +1,1191 @@ +//===-- RenderScriptRuntime.cpp ---------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "RenderScriptRuntime.h" + +#include "lldb/Core/ConstString.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/Error.h" +#include "lldb/Core/Log.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/Target.h" +#include "lldb/Interpreter/Args.h" +#include "lldb/Interpreter/Options.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Target/RegisterContext.h" + +#include "lldb/Symbol/VariableList.h" + +using namespace lldb; +using namespace lldb_private; + +//------------------------------------------------------------------ +// Static Functions +//------------------------------------------------------------------ +LanguageRuntime * +RenderScriptRuntime::CreateInstance(Process *process, lldb::LanguageType language) +{ + + if (language == eLanguageTypeExtRenderScript) + return new RenderScriptRuntime(process); + else + return NULL; +} + +void +RenderScriptRuntime::Initialize() +{ + PluginManager::RegisterPlugin(GetPluginNameStatic(), "RenderScript language support", CreateInstance, GetCommandObject); +} + +void +RenderScriptRuntime::Terminate() +{ + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString +RenderScriptRuntime::GetPluginNameStatic() +{ + static ConstString g_name("renderscript"); + return g_name; +} + +RenderScriptRuntime::ModuleKind +RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp) +{ + if (module_sp) + { + // Is this a module containing renderscript kernels? + const Symbol *info_sym = module_sp->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData); + if (info_sym) + { + return eModuleKindKernelObj; + } + + // Is this the main RS runtime library + const ConstString rs_lib("libRS.so"); + if (module_sp->GetFileSpec().GetFilename() == rs_lib) + { + return eModuleKindLibRS; + } + + const ConstString rs_driverlib("libRSDriver.so"); + if (module_sp->GetFileSpec().GetFilename() == rs_driverlib) + { + return eModuleKindDriver; + } + + const ConstString rs_cpureflib("libRSCPURef.so"); + if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib) + { + return eModuleKindImpl; + } + + } + return eModuleKindIgnored; +} + +bool +RenderScriptRuntime::IsRenderScriptModule(const lldb::ModuleSP &module_sp) +{ + return GetModuleKind(module_sp) != eModuleKindIgnored; +} + + +void +RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list ) +{ + Mutex::Locker locker (module_list.GetMutex ()); + + size_t num_modules = module_list.GetSize(); + for (size_t i = 0; i < num_modules; i++) + { + auto mod = module_list.GetModuleAtIndex (i); + if (IsRenderScriptModule (mod)) + { + LoadModule(mod); + } + } +} + + +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +lldb_private::ConstString +RenderScriptRuntime::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +RenderScriptRuntime::GetPluginVersion() +{ + return 1; +} + +bool +RenderScriptRuntime::IsVTableName(const char *name) +{ + return false; +} + +bool +RenderScriptRuntime::GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address) +{ + return false; +} + +bool +RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value) +{ + return false; +} + +lldb::BreakpointResolverSP +RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) +{ + BreakpointResolverSP resolver_sp; + return resolver_sp; +} + + +const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] = +{ + //rsdScript + {"rsdScriptInit", "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_7ScriptCEPKcS7_PKhjj", 0, RenderScriptRuntime::eModuleKindDriver, &lldb_private::RenderScriptRuntime::CaptureScriptInit1}, + {"rsdScriptInvokeForEach", "_Z22rsdScriptInvokeForEachPKN7android12renderscript7ContextEPNS0_6ScriptEjPKNS0_10AllocationEPS6_PKvjPK12RsScriptCall", 0, RenderScriptRuntime::eModuleKindDriver, nullptr}, + {"rsdScriptInvokeForEachMulti", "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall", 0, RenderScriptRuntime::eModuleKindDriver, nullptr}, + {"rsdScriptInvokeFunction", "_Z23rsdScriptInvokeFunctionPKN7android12renderscript7ContextEPNS0_6ScriptEjPKvj", 0, RenderScriptRuntime::eModuleKindDriver, nullptr}, + {"rsdScriptSetGlobalVar", "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_6ScriptEjPvj", 0, RenderScriptRuntime::eModuleKindDriver, &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar1}, + + //rsdAllocation + {"rsdAllocationInit", "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_10AllocationEb", 0, RenderScriptRuntime::eModuleKindDriver, &lldb_private::RenderScriptRuntime::CaptureAllocationInit1}, + {"rsdAllocationRead2D", "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_10AllocationEjjj23RsAllocationCubemapFacejjPvjj", 0, RenderScriptRuntime::eModuleKindDriver, nullptr}, +}; +const size_t RenderScriptRuntime::s_runtimeHookCount = sizeof(s_runtimeHookDefns)/sizeof(s_runtimeHookDefns[0]); + + +bool +RenderScriptRuntime::HookCallback(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id, lldb::user_id_t break_loc_id) +{ + RuntimeHook* hook_info = (RuntimeHook*)baton; + ExecutionContext context(ctx->exe_ctx_ref); + + RenderScriptRuntime *lang_rt = (RenderScriptRuntime *)context.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + + lang_rt->HookCallback(hook_info, context); + + return false; +} + + +void +RenderScriptRuntime::HookCallback(RuntimeHook* hook_info, ExecutionContext& context) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if(log) + log->Printf ("RenderScriptRuntime::HookCallback - '%s' .", hook_info->defn->name); + + if (hook_info->defn->grabber) + { + (this->*(hook_info->defn->grabber))(hook_info, context); + } +} + + +bool +RenderScriptRuntime::GetArg32Simple(ExecutionContext& context, uint32_t arg, uint32_t *data) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!data) + return false; + + Error error; + RegisterContext* reg_ctx = context.GetRegisterContext(); + Process* process = context.GetProcessPtr(); + + if (context.GetTargetPtr()->GetArchitecture().GetMachine() == llvm::Triple::ArchType::x86) + { + uint64_t sp = reg_ctx->GetSP(); + { + uint32_t offset = (1 + arg) * sizeof(uint32_t); + process->ReadMemory(sp + offset, data, sizeof(uint32_t), error); + if(error.Fail()) + { + if(log) + log->Printf ("RenderScriptRuntime:: GetArg32Simple - error reading X86 stack: %s.", error.AsCString()); + } + } + } + else if (context.GetTargetPtr()->GetArchitecture().GetMachine() == llvm::Triple::ArchType::arm) + { + if (arg < 4) + { + const RegisterInfo* rArg = reg_ctx->GetRegisterInfoAtIndex(arg); + RegisterValue rVal; + reg_ctx->ReadRegister(rArg, rVal); + (*data) = rVal.GetAsUInt32(); + } + else + { + uint64_t sp = reg_ctx->GetSP(); + { + uint32_t offset = (arg-4) * sizeof(uint32_t); + process->ReadMemory(sp + offset, &data, sizeof(uint32_t), error); + if(error.Fail()) + { + if(log) + log->Printf ("RenderScriptRuntime:: GetArg32Simple - error reading ARM stack: %s.", error.AsCString()); + } + } + } + } + return true; +} + +void +RenderScriptRuntime::CaptureSetGlobalVar1(RuntimeHook* hook_info, ExecutionContext& context) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + //Context, Script, int, data, length + + Error error; + + uint32_t rs_context_u32 = 0U; + uint32_t rs_script_u32 = 0U; + uint32_t rs_id_u32 = 0U; + uint32_t rs_data_u32 = 0U; + uint32_t rs_length_u32 = 0U; + + std::string resname; + std::string cachedir; + + GetArg32Simple(context, 0, &rs_context_u32); + GetArg32Simple(context, 1, &rs_script_u32); + GetArg32Simple(context, 2, &rs_id_u32); + GetArg32Simple(context, 3, &rs_data_u32); + GetArg32Simple(context, 4, &rs_length_u32); + + if(log) + { + log->Printf ("RenderScriptRuntime::CaptureSetGlobalVar1 - 0x%" PRIx64 ",0x%" PRIx64 " slot %" PRIu64 " = 0x%" PRIx64 ":%" PRIu64 "bytes.", + (uint64_t)rs_context_u32, (uint64_t)rs_script_u32, (uint64_t)rs_id_u32, (uint64_t)rs_data_u32, (uint64_t)rs_length_u32); + + addr_t script_addr = (addr_t)rs_script_u32; + if (m_scriptMappings.find( script_addr ) != m_scriptMappings.end()) + { + auto rsm = m_scriptMappings[script_addr]; + if (rs_id_u32 < rsm->m_globals.size()) + { + auto rsg = rsm->m_globals[rs_id_u32]; + log->Printf ("RenderScriptRuntime::CaptureSetGlobalVar1 - Setting of '%s' within '%s' inferred", rsg.m_name.AsCString(), + rsm->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + } +} + +void +RenderScriptRuntime::CaptureAllocationInit1(RuntimeHook* hook_info, ExecutionContext& context) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + //Context, Alloc, bool + + Error error; + + uint32_t rs_context_u32 = 0U; + uint32_t rs_alloc_u32 = 0U; + uint32_t rs_forceZero_u32 = 0U; + + GetArg32Simple(context, 0, &rs_context_u32); + GetArg32Simple(context, 1, &rs_alloc_u32); + GetArg32Simple(context, 2, &rs_forceZero_u32); + + if(log) + log->Printf ("RenderScriptRuntime::CaptureAllocationInit1 - 0x%" PRIx64 ",0x%" PRIx64 ",0x%" PRIx64 " .", + (uint64_t)rs_context_u32, (uint64_t)rs_alloc_u32, (uint64_t)rs_forceZero_u32); +} + +void +RenderScriptRuntime::CaptureScriptInit1(RuntimeHook* hook_info, ExecutionContext& context) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + //Context, Script, resname Str, cachedir Str + Error error; + Process* process = context.GetProcessPtr(); + + uint32_t rs_context_u32 = 0U; + uint32_t rs_script_u32 = 0U; + uint32_t rs_resnameptr_u32 = 0U; + uint32_t rs_cachedirptr_u32 = 0U; + + std::string resname; + std::string cachedir; + + GetArg32Simple(context, 0, &rs_context_u32); + GetArg32Simple(context, 1, &rs_script_u32); + GetArg32Simple(context, 2, &rs_resnameptr_u32); + GetArg32Simple(context, 3, &rs_cachedirptr_u32); + + process->ReadCStringFromMemory((lldb::addr_t)rs_resnameptr_u32, resname, error); + if (error.Fail()) + { + if(log) + log->Printf ("RenderScriptRuntime::CaptureScriptInit1 - error reading resname: %s.", error.AsCString()); + + } + + process->ReadCStringFromMemory((lldb::addr_t)rs_cachedirptr_u32, cachedir, error); + if (error.Fail()) + { + if(log) + log->Printf ("RenderScriptRuntime::CaptureScriptInit1 - error reading cachedir: %s.", error.AsCString()); + } + + if (log) + log->Printf ("RenderScriptRuntime::CaptureScriptInit1 - 0x%" PRIx64 ",0x%" PRIx64 " => '%s' at '%s' .", + (uint64_t)rs_context_u32, (uint64_t)rs_script_u32, resname.c_str(), cachedir.c_str()); + + if (resname.size() > 0) + { + StreamString strm; + strm.Printf("librs.%s.so", resname.c_str()); + + ScriptDetails script; + script.cachedir = cachedir; + script.resname = resname; + script.scriptDyLib.assign(strm.GetData()); + script.script = rs_script_u32; + script.context = rs_context_u32; + + m_scripts.push_back(script); + + if (log) + log->Printf ("RenderScriptRuntime::CaptureScriptInit1 - '%s' tagged with context 0x%" PRIx64 " and script 0x%" PRIx64 ".", + strm.GetData(), (uint64_t)rs_context_u32, (uint64_t)rs_script_u32); + } + else if (log) + { + log->Printf ("RenderScriptRuntime::CaptureScriptInit1 - resource name invalid, Script not tagged"); + } + +} + + +void +RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!module) + { + return; + } + + if ((GetProcess()->GetTarget().GetArchitecture().GetMachine() != llvm::Triple::ArchType::x86) + && (GetProcess()->GetTarget().GetArchitecture().GetMachine() != llvm::Triple::ArchType::arm)) + { + if (log) + log->Printf ("RenderScriptRuntime::LoadRuntimeHooks - Unable to hook runtime. Only X86, ARM supported currently."); + + return; + } + + Target &target = GetProcess()->GetTarget(); + + for (size_t idx = 0; idx < s_runtimeHookCount; idx++) + { + const HookDefn* hook_defn = &s_runtimeHookDefns[idx]; + if (hook_defn->kind != kind) { + continue; + } + + const Symbol *sym = module->FindFirstSymbolWithNameAndType(ConstString(hook_defn->symbol_name), eSymbolTypeCode); + + addr_t addr = sym->GetLoadAddress(&target); + if (addr == LLDB_INVALID_ADDRESS) + { + if(log) + log->Printf ("RenderScriptRuntime::LoadRuntimeHooks - Unable to resolve the address of hook function '%s' with symbol '%s'.", + hook_defn->name, hook_defn->symbol_name); + continue; + } + + RuntimeHookSP hook(new RuntimeHook()); + hook->address = addr; + hook->defn = hook_defn; + hook->bp_sp = target.CreateBreakpoint(addr, true, false); + hook->bp_sp->SetCallback(HookCallback, hook.get(), true); + m_runtimeHooks[addr] = hook; + if (log) + { + log->Printf ("RenderScriptRuntime::LoadRuntimeHooks - Successfully hooked '%s' in '%s' version %" PRIu64 " at 0x%" PRIx64 ".", + hook_defn->name, module->GetFileSpec().GetFilename().AsCString(), (uint64_t)hook_defn->version, (uint64_t)addr); + } + } +} + +void +RenderScriptRuntime::FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp) +{ + if (!rsmodule_sp) + return; + + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + const ModuleSP module = rsmodule_sp->m_module; + const FileSpec& file = module->GetPlatformFileSpec(); + + for (const auto &rs_script : m_scripts) + { + if (file.GetFilename() == ConstString(rs_script.scriptDyLib.c_str())) + { + if (m_scriptMappings.find( rs_script.script ) != m_scriptMappings.end()) + { + if (m_scriptMappings[rs_script.script] != rsmodule_sp) + { + if (log) + { + log->Printf ("RenderScriptRuntime::FixupScriptDetails - Error: script %" PRIx64 " wants reassigned to new rsmodule '%s'.", + (uint64_t)rs_script.script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + } + else + { + m_scriptMappings[rs_script.script] = rsmodule_sp; + rsmodule_sp->m_resname = rs_script.resname; + if (log) + { + log->Printf ("RenderScriptRuntime::FixupScriptDetails - script %" PRIx64 " associated with rsmodule '%s'.", + (uint64_t)rs_script.script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + } + } + +} + +bool +RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp) +{ + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (module_sp) + { + for (const auto &rs_module : m_rsmodules) + { + if (rs_module->m_module == module_sp) + return false; + } + bool module_loaded = false; + switch (GetModuleKind(module_sp)) + { + case eModuleKindKernelObj: + { + RSModuleDescriptorSP module_desc; + module_desc.reset(new RSModuleDescriptor(module_sp)); + if (module_desc->ParseRSInfo()) + { + m_rsmodules.push_back(module_desc); + module_loaded = true; + } + if (module_loaded) + { + FixupScriptDetails(module_desc); + } + break; + } + case eModuleKindDriver: + { + if (!m_libRSDriver) + { + m_libRSDriver = module_sp; + LoadRuntimeHooks(m_libRSDriver, RenderScriptRuntime::eModuleKindDriver); + } + break; + } + case eModuleKindImpl: + { + m_libRSCpuRef = module_sp; + break; + } + case eModuleKindLibRS: + { + if (!m_libRS) + { + m_libRS = module_sp; + static ConstString gDbgPresentStr("gDebuggerPresent"); + const Symbol* debug_present = m_libRS->FindFirstSymbolWithNameAndType(gDbgPresentStr, eSymbolTypeData); + if (debug_present) + { + Error error; + uint32_t flag = 0x00000001U; + Target &target = GetProcess()->GetTarget(); + addr_t addr = debug_present->GetLoadAddress(&target); + GetProcess()->WriteMemory(addr, &flag, sizeof(flag), error); + if(error.Success()) + { + if (log) + log->Printf ("RenderScriptRuntime::LoadModule - Debugger present flag set on debugee"); + + m_debuggerPresentFlagged = true; + } + else if (log) + { + log->Printf ("RenderScriptRuntime::LoadModule - Error writing debugger present flags '%s' ", error.AsCString()); + } + } + else if (log) + { + log->Printf ("RenderScriptRuntime::LoadModule - Error writing debugger present flags - symbol not found"); + } + } + break; + } + default: + break; + } + if (module_loaded) + Update(); + return module_loaded; + } + return false; +} + +void +RenderScriptRuntime::Update() +{ + if (m_rsmodules.size() > 0) + { + if (!m_initiated) + { + Initiate(); + } + } +} + + +// The maximum line length of an .rs.info packet +#define MAXLINE 500 + +// The .rs.info symbol in renderscript modules contains a string which needs to be parsed. +// The string is basic and is parsed on a line by line basis. +bool +RSModuleDescriptor::ParseRSInfo() +{ + const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData); + if (info_sym) + { + const addr_t addr = info_sym->GetAddressRef().GetFileAddress(); + const addr_t size = info_sym->GetByteSize(); + const FileSpec fs = m_module->GetFileSpec(); + + DataBufferSP buffer = fs.ReadFileContents(addr, size); + + if (!buffer) + return false; + + std::string info((const char *)buffer->GetBytes()); + + std::vector<std::string> info_lines; + size_t lpos = info.find_first_of("\n"); + while (lpos != std::string::npos) + { + info_lines.push_back(info.substr(0, lpos)); + info = info.substr(lpos + 1); + lpos = info.find_first_of("\n"); + } + size_t offset = 0; + while (offset < info_lines.size()) + { + std::string line = info_lines[offset]; + // Parse directives + uint32_t numDefns = 0; + if (sscanf(line.c_str(), "exportVarCount: %u", &numDefns) == 1) + { + while (numDefns--) + m_globals.push_back(RSGlobalDescriptor(this, info_lines[++offset].c_str())); + } + else if (sscanf(line.c_str(), "exportFuncCount: %u", &numDefns) == 1) + { + } + else if (sscanf(line.c_str(), "exportForEachCount: %u", &numDefns) == 1) + { + char name[MAXLINE]; + while (numDefns--) + { + uint32_t slot = 0; + name[0] = '\0'; + if (sscanf(info_lines[++offset].c_str(), "%u - %s", &slot, &name[0]) == 2) + { + m_kernels.push_back(RSKernelDescriptor(this, name, slot)); + } + } + } + else if (sscanf(line.c_str(), "pragmaCount: %u", &numDefns) == 1) + { + char name[MAXLINE]; + char value[MAXLINE]; + while (numDefns--) + { + name[0] = '\0'; + value[0] = '\0'; + if (sscanf(info_lines[++offset].c_str(), "%s - %s", &name[0], &value[0]) != 0 + && (name[0] != '\0')) + { + m_pragmas[std::string(name)] = value; + } + } + } + else if (sscanf(line.c_str(), "objectSlotCount: %u", &numDefns) == 1) + { + } + + offset++; + } + return m_kernels.size() > 0; + } + return false; +} + +bool +RenderScriptRuntime::ProbeModules(const ModuleList module_list) +{ + bool rs_found = false; + size_t num_modules = module_list.GetSize(); + for (size_t i = 0; i < num_modules; i++) + { + auto module = module_list.GetModuleAtIndex(i); + rs_found |= LoadModule(module); + } + return rs_found; +} + +void +RenderScriptRuntime::Status(Stream &strm) const +{ + if (m_libRS) + { + strm.Printf("Runtime Library discovered."); + strm.EOL(); + } + if (m_libRSDriver) + { + strm.Printf("Runtime Driver discovered."); + strm.EOL(); + } + if (m_libRSCpuRef) + { + strm.Printf("CPU Reference Implementation discovered."); + strm.EOL(); + } + + if (m_runtimeHooks.size()) + { + strm.Printf("Runtime functions hooked:"); + strm.EOL(); + for (auto b : m_runtimeHooks) + { + strm.Indent(b.second->defn->name); + strm.EOL(); + } + strm.EOL(); + } + else + { + strm.Printf("Runtime is not hooked."); + strm.EOL(); + } +} + +void +RenderScriptRuntime::DumpContexts(Stream &strm) const +{ + strm.Printf("Inferred RenderScript Contexts:"); + strm.EOL(); + strm.IndentMore(); + + std::map<addr_t, uint64_t> contextReferences; + + for (const auto &script : m_scripts) + { + if (contextReferences.find(script.context) != contextReferences.end()) + { + contextReferences[script.context]++; + } + else + { + contextReferences[script.context] = 1; + } + } + + for (const auto& cRef : contextReferences) + { + strm.Printf("Context 0x%" PRIx64 ": %" PRIu64 " script instances", cRef.first, cRef.second); + strm.EOL(); + } + strm.IndentLess(); +} + +void +RenderScriptRuntime::DumpKernels(Stream &strm) const +{ + strm.Printf("RenderScript Kernels:"); + strm.EOL(); + strm.IndentMore(); + for (const auto &module : m_rsmodules) + { + strm.Printf("Resource '%s':",module->m_resname.c_str()); + strm.EOL(); + for (const auto &kernel : module->m_kernels) + { + strm.Indent(kernel.m_name.AsCString()); + strm.EOL(); + } + } + strm.IndentLess(); +} + +void +RenderScriptRuntime::AttemptBreakpointAtKernelName(Stream &strm, const char* name, Error& error) +{ + if (!name) + { + error.SetErrorString("invalid kernel name"); + return; + } + + bool kernels_found; + ConstString kernel_name(name); + for (const auto &module : m_rsmodules) + { + for (const auto &kernel : module->m_kernels) + { + if (kernel.m_name == kernel_name) + { + //Attempt to set a breakpoint on this symbol, within the module library + //If it's not found, it's likely debug info is unavailable - set a + //breakpoint on <name>.expand and emit a warning. + + const Symbol* kernel_sym = module->m_module->FindFirstSymbolWithNameAndType(kernel_name, eSymbolTypeCode); + + if (!kernel_sym) + { + std::string kernel_name_expanded(name); + kernel_name_expanded.append(".expand"); + kernel_sym = module->m_module->FindFirstSymbolWithNameAndType(ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode); + + if (kernel_sym) + { + strm.Printf("Kernel '%s' could not be found, but expansion exists. ", name); + strm.Printf("Breakpoint placed on expanded kernel. Have you compiled in debug mode?"); + strm.EOL(); + } + else + { + error.SetErrorStringWithFormat("Could not locate symbols for loaded kernel '%s'.", name); + return; + } + } + + addr_t bp_addr = kernel_sym->GetLoadAddress(&GetProcess()->GetTarget()); + if (bp_addr == LLDB_INVALID_ADDRESS) + { + error.SetErrorStringWithFormat("Could not locate load address for symbols of kernel '%s'.", name); + return; + } + + BreakpointSP bp = GetProcess()->GetTarget().CreateBreakpoint(bp_addr, false, false); + strm.Printf("Breakpoint %" PRIu64 ": kernel '%s' within script '%s'", (uint64_t)bp->GetID(), name, module->m_resname.c_str()); + strm.EOL(); + + kernels_found = true; + } + } + } + + if (!kernels_found) + { + error.SetErrorString("kernel name not found"); + } + return; +} + +void +RenderScriptRuntime::DumpModules(Stream &strm) const +{ + strm.Printf("RenderScript Modules:"); + strm.EOL(); + strm.IndentMore(); + for (const auto &module : m_rsmodules) + { + module->Dump(strm); + } + strm.IndentLess(); +} + +void +RSModuleDescriptor::Dump(Stream &strm) const +{ + strm.Indent(); + m_module->GetFileSpec().Dump(&strm); + m_module->ParseAllDebugSymbols(); + if(m_module->GetNumCompileUnits()) + { + strm.Indent("Debug info loaded."); + } + else + { + strm.Indent("Debug info does not exist."); + } + strm.EOL(); + strm.IndentMore(); + strm.Indent(); + strm.Printf("Globals: %" PRIu64, static_cast<uint64_t>(m_globals.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &global : m_globals) + { + global.Dump(strm); + } + strm.IndentLess(); + strm.Indent(); + strm.Printf("Kernels: %" PRIu64, static_cast<uint64_t>(m_kernels.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &kernel : m_kernels) + { + kernel.Dump(strm); + } + strm.Printf("Pragmas: %" PRIu64 , static_cast<uint64_t>(m_pragmas.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &key_val : m_pragmas) + { + strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str()); + strm.EOL(); + } + strm.IndentLess(4); +} + +void +RSGlobalDescriptor::Dump(Stream &strm) const +{ + strm.Indent(m_name.AsCString()); + VariableList var_list; + m_module->m_module->FindGlobalVariables(m_name, nullptr, true, 1U, var_list); + if (var_list.GetSize() == 1) + { + auto var = var_list.GetVariableAtIndex(0); + auto type = var->GetType(); + if(type) + { + strm.Printf(" - "); + type->DumpTypeName(&strm); + } + else + { + strm.Printf(" - Unknown Type"); + } + } + else + { + strm.Printf(" - variable identified, but not found in binary"); + const Symbol* s = m_module->m_module->FindFirstSymbolWithNameAndType(m_name, eSymbolTypeData); + if (s) + { + strm.Printf(" (symbol exists) "); + } + } + + strm.EOL(); +} + +void +RSKernelDescriptor::Dump(Stream &strm) const +{ + strm.Indent(m_name.AsCString()); + strm.EOL(); +} + +class CommandObjectRenderScriptRuntimeModuleProbe : public CommandObjectParsed +{ + private: + public: + CommandObjectRenderScriptRuntimeModuleProbe(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript module probe", + "Initiates a Probe of all loaded modules for kernels and other renderscript objects.", + "renderscript module probe", + eCommandRequiresTarget | eCommandRequiresProcess | eCommandProcessMustBeLaunched) + { + } + + ~CommandObjectRenderScriptRuntimeModuleProbe() {} + + bool + DoExecute(Args &command, CommandReturnObject &result) + { + const size_t argc = command.GetArgumentCount(); + if (argc == 0) + { + Target *target = m_exe_ctx.GetTargetPtr(); + RenderScriptRuntime *runtime = + (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + auto module_list = target->GetImages(); + bool new_rs_details = runtime->ProbeModules(module_list); + if (new_rs_details) + { + result.AppendMessage("New renderscript modules added to runtime model."); + } + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + + result.AppendErrorWithFormat("'%s' takes no arguments", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } +}; + +class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed +{ + private: + public: + CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript module dump", + "Dumps renderscript specific information for all modules.", "renderscript module dump", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) + { + } + + ~CommandObjectRenderScriptRuntimeModuleDump() {} + + bool + DoExecute(Args &command, CommandReturnObject &result) + { + RenderScriptRuntime *runtime = + (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + runtime->DumpModules(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword +{ + private: + public: + CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript module", "Commands that deal with renderscript modules.", + NULL) + { + LoadSubCommand("probe", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleProbe(interpreter))); + LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump(interpreter))); + } + + ~CommandObjectRenderScriptRuntimeModule() {} +}; + +class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed +{ + private: + public: + CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript kernel list", + "Lists renderscript kernel names and associated script resources.", "renderscript kernel list", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) + { + } + + ~CommandObjectRenderScriptRuntimeKernelList() {} + + bool + DoExecute(Args &command, CommandReturnObject &result) + { + RenderScriptRuntime *runtime = + (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + runtime->DumpKernels(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeKernelBreakpoint : public CommandObjectParsed +{ + private: + public: + CommandObjectRenderScriptRuntimeKernelBreakpoint(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript kernel breakpoint", + "Sets a breakpoint on a renderscript kernel.", "renderscript kernel breakpoint", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) + { + } + + ~CommandObjectRenderScriptRuntimeKernelBreakpoint() {} + + bool + DoExecute(Args &command, CommandReturnObject &result) + { + const size_t argc = command.GetArgumentCount(); + if (argc == 1) + { + RenderScriptRuntime *runtime = + (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + + Error error; + runtime->AttemptBreakpointAtKernelName(result.GetOutputStream(), command.GetArgumentAtIndex(0), error); + + if (error.Success()) + { + result.AppendMessage("Breakpoint(s) created"); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + result.SetStatus(eReturnStatusFailed); + result.AppendErrorWithFormat("Error: %s", error.AsCString()); + return false; + } + + result.AppendErrorWithFormat("'%s' takes 1 argument of kernel name", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } +}; + +class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword +{ + private: + public: + CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript kernel", "Commands that deal with renderscript kernels.", + NULL) + { + LoadSubCommand("list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList(interpreter))); + LoadSubCommand("breakpoint", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter))); + } + + ~CommandObjectRenderScriptRuntimeKernel() {} +}; + +class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed +{ + private: + public: + CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript context dump", + "Dumps renderscript context information.", "renderscript context dump", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) + { + } + + ~CommandObjectRenderScriptRuntimeContextDump() {} + + bool + DoExecute(Args &command, CommandReturnObject &result) + { + RenderScriptRuntime *runtime = + (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + runtime->DumpContexts(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword +{ + private: + public: + CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript context", "Commands that deal with renderscript contexts.", + NULL) + { + LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(interpreter))); + } + + ~CommandObjectRenderScriptRuntimeContext() {} +}; + +class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed +{ + private: + public: + CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript status", + "Displays current renderscript runtime status.", "renderscript status", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) + { + } + + ~CommandObjectRenderScriptRuntimeStatus() {} + + bool + DoExecute(Args &command, CommandReturnObject &result) + { + RenderScriptRuntime *runtime = + (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript); + runtime->Status(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntime : public CommandObjectMultiword +{ + public: + CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript", "A set of commands for operating on renderscript.", + "renderscript <subcommand> [<subcommand-options>]") + { + LoadSubCommand("module", CommandObjectSP(new CommandObjectRenderScriptRuntimeModule(interpreter))); + LoadSubCommand("status", CommandObjectSP(new CommandObjectRenderScriptRuntimeStatus(interpreter))); + LoadSubCommand("kernel", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernel(interpreter))); + LoadSubCommand("context", CommandObjectSP(new CommandObjectRenderScriptRuntimeContext(interpreter))); + } + + ~CommandObjectRenderScriptRuntime() {} +}; + +void +RenderScriptRuntime::Initiate() +{ + assert(!m_initiated); +} + +RenderScriptRuntime::RenderScriptRuntime(Process *process) + : lldb_private::CPPLanguageRuntime(process), m_initiated(false), m_debuggerPresentFlagged(false) +{ + ModulesDidLoad(process->GetTarget().GetImages()); +} + +lldb::CommandObjectSP +RenderScriptRuntime::GetCommandObject(lldb_private::CommandInterpreter& interpreter) +{ + static CommandObjectSP command_object; + if(!command_object) + { + command_object.reset(new CommandObjectRenderScriptRuntime(interpreter)); + } + return command_object; +} + diff --git a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h new file mode 100644 index 0000000000000..2a01e744e9768 --- /dev/null +++ b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h @@ -0,0 +1,232 @@ +//===-- RenderScriptRuntime.h -----------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_RenderScriptRuntime_h_ +#define liblldb_RenderScriptRuntime_h_ + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "lldb/lldb-private.h" +#include "lldb/Target/LanguageRuntime.h" +#include "lldb/Target/CPPLanguageRuntime.h" +#include "lldb/Core/Module.h" + +namespace lldb_private +{ + +typedef uint32_t RSSlot; +class RSModuleDescriptor; +struct RSGlobalDescriptor; +struct RSKernelDescriptor; + +typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP; +typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP; +typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP; + + + +struct RSKernelDescriptor +{ + public: + RSKernelDescriptor(const RSModuleDescriptor *module, const char *name, uint32_t slot) + : m_module(module) + , m_name(name) + , m_slot(slot) + { + } + + void Dump(Stream &strm) const; + + const RSModuleDescriptor *m_module; + ConstString m_name; + RSSlot m_slot; +}; + +struct RSGlobalDescriptor +{ + public: + RSGlobalDescriptor(const RSModuleDescriptor *module, const char *name ) + : m_module(module) + , m_name(name) + { + } + + void Dump(Stream &strm) const; + + const RSModuleDescriptor *m_module; + ConstString m_name; +}; + +class RSModuleDescriptor +{ + public: + RSModuleDescriptor(const lldb::ModuleSP &module) + : m_module(module) + { + } + + ~RSModuleDescriptor() {} + + bool ParseRSInfo(); + + void Dump(Stream &strm) const; + + const lldb::ModuleSP m_module; + std::vector<RSKernelDescriptor> m_kernels; + std::vector<RSGlobalDescriptor> m_globals; + std::map<std::string, std::string> m_pragmas; + std::string m_resname; +}; + +class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime +{ + public: + + enum ModuleKind + { + eModuleKindIgnored, + eModuleKindLibRS, + eModuleKindDriver, + eModuleKindImpl, + eModuleKindKernelObj + }; + + + ~RenderScriptRuntime() {} + + //------------------------------------------------------------------ + // Static Functions + //------------------------------------------------------------------ + static void Initialize(); + + static void Terminate(); + + static lldb_private::LanguageRuntime *CreateInstance(Process *process, lldb::LanguageType language); + + static lldb::CommandObjectSP GetCommandObject(CommandInterpreter& interpreter); + + static lldb_private::ConstString GetPluginNameStatic(); + + static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp); + + static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp); + + static void ModulesDidLoad(const lldb::ProcessSP& process_sp, const ModuleList &module_list ); + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + virtual lldb_private::ConstString GetPluginName(); + + virtual uint32_t GetPluginVersion(); + + virtual bool IsVTableName(const char *name); + + virtual bool GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address); + + virtual bool CouldHaveDynamicValue(ValueObject &in_value); + + virtual lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp); + + bool LoadModule(const lldb::ModuleSP &module_sp); + + bool ProbeModules(const ModuleList module_list); + + void DumpModules(Stream &strm) const; + + void DumpContexts(Stream &strm) const; + + void DumpKernels(Stream &strm) const; + + void AttemptBreakpointAtKernelName(Stream &strm, const char *name, Error &error); + + void Status(Stream &strm) const; + + virtual size_t GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) { + return static_cast<size_t>(0); + } + + virtual void ModulesDidLoad(const ModuleList &module_list ); + + void Update(); + + void Initiate(); + + protected: + + void FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp); + + void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind); + + struct RuntimeHook; + typedef void (RenderScriptRuntime::*CaptureStateFn)(RuntimeHook* hook_info, ExecutionContext &context); // Please do this! + + struct HookDefn + { + const char * name; + const char * symbol_name; + uint32_t version; + ModuleKind kind; + CaptureStateFn grabber; + }; + + struct RuntimeHook + { + lldb::addr_t address; + const HookDefn *defn; + lldb::BreakpointSP bp_sp; + }; + + typedef std::shared_ptr<RuntimeHook> RuntimeHookSP; + + struct ScriptDetails + { + std::string resname; + std::string scriptDyLib; + std::string cachedir; + lldb::addr_t context; + lldb::addr_t script; + }; + + lldb::ModuleSP m_libRS; + lldb::ModuleSP m_libRSDriver; + lldb::ModuleSP m_libRSCpuRef; + std::vector<RSModuleDescriptorSP> m_rsmodules; + std::vector<ScriptDetails> m_scripts; + + std::map<lldb::addr_t, RSModuleDescriptorSP> m_scriptMappings; + std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks; + + bool m_initiated; + bool m_debuggerPresentFlagged; + static const HookDefn s_runtimeHookDefns[]; + static const size_t s_runtimeHookCount; + + private: + RenderScriptRuntime(Process *process); // Call CreateInstance instead. + + static bool HookCallback(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id, + lldb::user_id_t break_loc_id); + + void HookCallback(RuntimeHook* hook_info, ExecutionContext& context); + + bool GetArg32Simple(ExecutionContext& context, uint32_t arg, uint32_t *data); + + void CaptureScriptInit1(RuntimeHook* hook_info, ExecutionContext& context); + void CaptureAllocationInit1(RuntimeHook* hook_info, ExecutionContext& context); + void CaptureSetGlobalVar1(RuntimeHook* hook_info, ExecutionContext& context); + +}; + +} // namespace lldb_private + +#endif // liblldb_RenderScriptRuntime_h_ |