From 66b75430a93929d6fc6ed63db14ca28e3ad5b1f6 Mon Sep 17 00:00:00 2001 From: dim Date: Wed, 30 Dec 2015 11:55:28 +0000 Subject: Vendor import of stripped lldb trunk r256633: https://llvm.org/svn/llvm-project/lldb/trunk@256633 --- .../RenderScriptRuntime/RenderScriptRuntime.h | 229 +++++++++++++++++---- 1 file changed, 185 insertions(+), 44 deletions(-) (limited to 'source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h') diff --git a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h index 2a01e74..0ca268c 100644 --- a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h +++ b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h @@ -12,6 +12,12 @@ // C Includes // C++ Includes +#include +#include +#include +#include +#include + // Other libraries and framework includes // Project includes #include "lldb/lldb-private.h" @@ -19,8 +25,8 @@ #include "lldb/Target/CPPLanguageRuntime.h" #include "lldb/Core/Module.h" -namespace lldb_private -{ +namespace lldb_private { +namespace lldb_renderscript { typedef uint32_t RSSlot; class RSModuleDescriptor; @@ -31,11 +37,56 @@ typedef std::shared_ptr RSModuleDescriptorSP; typedef std::shared_ptr RSGlobalDescriptorSP; typedef std::shared_ptr RSKernelDescriptorSP; +// Breakpoint Resolvers decide where a breakpoint is placed, +// so having our own allows us to limit the search scope to RS kernel modules. +// As well as check for .expand kernels as a fallback. +class RSBreakpointResolver : public BreakpointResolver +{ +public: + RSBreakpointResolver(Breakpoint *bkpt, ConstString name): + BreakpointResolver (bkpt, BreakpointResolver::NameResolver), + m_kernel_name(name) + { + } + + void + GetDescription(Stream *strm) override + { + if (strm) + strm->Printf("RenderScript kernel breakpoint for '%s'", m_kernel_name.AsCString()); + } + + void + Dump(Stream *s) const override + { + } + + Searcher::CallbackReturn + SearchCallback(SearchFilter &filter, + SymbolContext &context, + Address *addr, + bool containing) override; + + Searcher::Depth + GetDepth() override + { + return Searcher::eDepthModule; + } + + lldb::BreakpointResolverSP + CopyForBreakpoint(Breakpoint &breakpoint) override + { + lldb::BreakpointResolverSP ret_sp(new RSBreakpointResolver(&breakpoint, m_kernel_name)); + return ret_sp; + } +protected: + ConstString m_kernel_name; +}; struct RSKernelDescriptor { - public: +public: RSKernelDescriptor(const RSModuleDescriptor *module, const char *name, uint32_t slot) : m_module(module) , m_name(name) @@ -52,7 +103,7 @@ struct RSKernelDescriptor struct RSGlobalDescriptor { - public: +public: RSGlobalDescriptor(const RSModuleDescriptor *module, const char *name ) : m_module(module) , m_name(name) @@ -67,13 +118,13 @@ struct RSGlobalDescriptor class RSModuleDescriptor { - public: +public: RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) { } - ~RSModuleDescriptor() {} + ~RSModuleDescriptor() = default; bool ParseRSInfo(); @@ -86,10 +137,11 @@ class RSModuleDescriptor std::string m_resname; }; +} // namespace lldb_renderscript + class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime { - public: - +public: enum ModuleKind { eModuleKindIgnored, @@ -99,8 +151,7 @@ class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime eModuleKindKernelObj }; - - ~RenderScriptRuntime() {} + ~RenderScriptRuntime() override; //------------------------------------------------------------------ // Static Functions @@ -121,21 +172,19 @@ class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime static void ModulesDidLoad(const lldb::ProcessSP& process_sp, const ModuleList &module_list ); - //------------------------------------------------------------------ - // PluginInterface protocol - //------------------------------------------------------------------ - virtual lldb_private::ConstString GetPluginName(); - - virtual uint32_t GetPluginVersion(); + bool IsVTableName(const char *name) override; - virtual bool IsVTableName(const char *name); - - virtual bool GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, - TypeAndOrName &class_type_or_name, Address &address); + bool GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address, + Value::ValueType &value_type) override; + + TypeAndOrName + FixUpDynamicType(const TypeAndOrName& type_and_or_name, + ValueObject& static_value) override; - virtual bool CouldHaveDynamicValue(ValueObject &in_value); + bool CouldHaveDynamicValue(ValueObject &in_value) override; - virtual lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp); + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override; bool LoadModule(const lldb::ModuleSP &module_sp); @@ -147,25 +196,60 @@ class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime void DumpKernels(Stream &strm) const; - void AttemptBreakpointAtKernelName(Stream &strm, const char *name, Error &error); + bool DumpAllocation(Stream &strm, StackFrame* frame_ptr, const uint32_t id); + + void ListAllocations(Stream &strm, StackFrame* frame_ptr, bool recompute); + + void PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array coords, + Error &error, lldb::TargetSP target); + + void SetBreakAllKernels(bool do_break, lldb::TargetSP target); void Status(Stream &strm) const; - virtual size_t GetAlternateManglings(const ConstString &mangled, std::vector &alternates) { + size_t GetAlternateManglings(const ConstString &mangled, std::vector &alternates) override { return static_cast(0); } - virtual void ModulesDidLoad(const ModuleList &module_list ); + void ModulesDidLoad(const ModuleList &module_list) override; + + bool LoadAllocation(Stream &strm, const uint32_t alloc_id, const char* filename, StackFrame* frame_ptr); + + bool SaveAllocation(Stream &strm, const uint32_t alloc_id, const char* filename, StackFrame* frame_ptr); void Update(); void Initiate(); + + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + lldb_private::ConstString GetPluginName() override; + + uint32_t GetPluginVersion() override; + +protected: + struct ScriptDetails; + struct AllocationDetails; + struct Element; + + void InitSearchFilter(lldb::TargetSP target) + { + if (!m_filtersp) + m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target)); + } - protected: - - void FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp); + void FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind); + + bool RefreshAllocation(AllocationDetails* allocation, StackFrame* frame_ptr); + + bool EvalRSExpression(const char* expression, StackFrame* frame_ptr, uint64_t* result); + + lldb::BreakpointSP CreateKernelBreakpoint(const ConstString& name); + + void BreakOnModuleKernels(const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); struct RuntimeHook; typedef void (RenderScriptRuntime::*CaptureStateFn)(RuntimeHook* hook_info, ExecutionContext &context); // Please do this! @@ -173,7 +257,8 @@ class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime struct HookDefn { const char * name; - const char * symbol_name; + const char * symbol_name_m32; // mangled name for the 32 bit architectures + const char * symbol_name_m64; // mangled name for the 64 bit archs uint32_t version; ModuleKind kind; CaptureStateFn grabber; @@ -185,46 +270,102 @@ class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime const HookDefn *defn; lldb::BreakpointSP bp_sp; }; - - typedef std::shared_ptr RuntimeHookSP; - struct ScriptDetails - { - std::string resname; - std::string scriptDyLib; - std::string cachedir; - lldb::addr_t context; - lldb::addr_t script; - }; + typedef std::shared_ptr RuntimeHookSP; lldb::ModuleSP m_libRS; lldb::ModuleSP m_libRSDriver; lldb::ModuleSP m_libRSCpuRef; - std::vector m_rsmodules; - std::vector m_scripts; + std::vector m_rsmodules; + + std::vector> m_scripts; + std::vector> m_allocations; - std::map m_scriptMappings; + std::map m_scriptMappings; std::map m_runtimeHooks; + std::map> m_conditional_breaks; + + lldb::SearchFilterSP m_filtersp; // Needed to create breakpoints through Target API bool m_initiated; bool m_debuggerPresentFlagged; + bool m_breakAllKernels; static const HookDefn s_runtimeHookDefns[]; static const size_t s_runtimeHookCount; - private: +private: + // Used to index expression format strings + enum ExpressionStrings + { + eExprGetOffsetPtr = 0, + eExprAllocGetType, + eExprTypeDimX, + eExprTypeDimY, + eExprTypeDimZ, + eExprTypeElemPtr, + eExprElementType, + eExprElementKind, + eExprElementVec, + eExprElementFieldCount, + eExprSubelementsId, + eExprSubelementsName, + eExprSubelementsArrSize + }; + 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); + static bool KernelBreakpointHit(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); + bool GetArgSimple(ExecutionContext& context, uint32_t arg, uint64_t* data); void CaptureScriptInit1(RuntimeHook* hook_info, ExecutionContext& context); void CaptureAllocationInit1(RuntimeHook* hook_info, ExecutionContext& context); + void CaptureAllocationDestroy(RuntimeHook* hook_info, ExecutionContext& context); void CaptureSetGlobalVar1(RuntimeHook* hook_info, ExecutionContext& context); + AllocationDetails* FindAllocByID(Stream &strm, const uint32_t alloc_id); + std::shared_ptr GetAllocationData(AllocationDetails* allocation, StackFrame* frame_ptr); + void SetElementSize(Element& elem); + static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP, const char* var_name, uint64_t& val); + void FindStructTypeName(Element& elem, StackFrame* frame_ptr); + + // + // Helper functions for jitting the runtime + // + const char* JITTemplate(ExpressionStrings e); + + bool JITDataPointer(AllocationDetails* allocation, StackFrame* frame_ptr, + unsigned int x = 0, unsigned int y = 0, unsigned int z = 0); + + bool JITTypePointer(AllocationDetails* allocation, StackFrame* frame_ptr); + + bool JITTypePacked(AllocationDetails* allocation, StackFrame* frame_ptr); + + bool JITElementPacked(Element& elem, const lldb::addr_t context, StackFrame* frame_ptr); + + bool JITAllocationSize(AllocationDetails* allocation, StackFrame* frame_ptr); + + bool JITSubelements(Element& elem, const lldb::addr_t context, StackFrame* frame_ptr); + + bool JITAllocationStride(AllocationDetails* allocation, StackFrame* frame_ptr); + + // Search for a script detail object using a target address. + // If a script does not currently exist this function will return nullptr. + // If 'create' is true and there is no previous script with this address, + // then a new Script detail object will be created for this address and returned. + ScriptDetails* LookUpScript(lldb::addr_t address, bool create); + + // Search for a previously saved allocation detail object using a target address. + // If an allocation does not exist for this address then nullptr will be returned. + // If 'create' is true and there is no previous allocation then a new allocation + // detail object will be created for this address and returned. + AllocationDetails* LookUpAllocation(lldb::addr_t address, bool create); }; } // namespace lldb_private -- cgit v1.1