diff options
Diffstat (limited to 'source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h')
| -rw-r--r-- | source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h | 705 |
1 files changed, 434 insertions, 271 deletions
diff --git a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h index 2a0839a1a78b1..a1211a2814b78 100644 --- a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h +++ b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h @@ -19,397 +19,560 @@ #include <vector> // Other libraries and framework includes +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" // Project includes #include "lldb/Core/Module.h" +#include "lldb/Expression/LLVMUserExpression.h" #include "lldb/Target/CPPLanguageRuntime.h" #include "lldb/Target/LanguageRuntime.h" #include "lldb/lldb-private.h" -namespace lldb_private -{ -namespace lldb_renderscript -{ +namespace lldb_private { +namespace lldb_renderscript { typedef uint32_t RSSlot; class RSModuleDescriptor; struct RSGlobalDescriptor; struct RSKernelDescriptor; +struct RSReductionDescriptor; +struct RSScriptGroupDescriptor; typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP; typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP; typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP; -typedef std::array<uint32_t, 3> RSCoordinate; +typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP; -// 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 -{ +struct RSCoordinate { + uint32_t x, y, z; + + RSCoordinate() : x(), y(), z(){}; + + bool operator==(const lldb_renderscript::RSCoordinate &rhs) { + return x == rhs.x && y == rhs.y && z == rhs.z; + } +}; + +// 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) - { - } + RSBreakpointResolver(Breakpoint *bp, ConstString name) + : BreakpointResolver(bp, 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 GetDescription(Stream *strm) override { + if (strm) + strm->Printf("RenderScript kernel breakpoint for '%s'", + m_kernel_name.AsCString()); + } - void - Dump(Stream *s) const override - { - } + void Dump(Stream *s) const override {} - Searcher::CallbackReturn - SearchCallback(SearchFilter &filter, SymbolContext &context, Address *addr, bool containing) override; + Searcher::CallbackReturn SearchCallback(SearchFilter &filter, + SymbolContext &context, Address *addr, + bool containing) override; - Searcher::Depth - GetDepth() override - { - return Searcher::eDepthModule; - } + 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; - } + lldb::BreakpointResolverSP + CopyForBreakpoint(Breakpoint &breakpoint) override { + lldb::BreakpointResolverSP ret_sp( + new RSBreakpointResolver(&breakpoint, m_kernel_name)); + return ret_sp; + } protected: - ConstString m_kernel_name; + ConstString m_kernel_name; }; -struct RSKernelDescriptor -{ +class RSReduceBreakpointResolver : public BreakpointResolver { public: - RSKernelDescriptor(const RSModuleDescriptor *module, const char *name, uint32_t slot) - : m_module(module), m_name(name), m_slot(slot) - { - } + enum ReduceKernelTypeFlags { + eKernelTypeAll = ~(0), + eKernelTypeNone = 0, + eKernelTypeAccum = (1 << 0), + eKernelTypeInit = (1 << 1), + eKernelTypeComb = (1 << 2), + eKernelTypeOutC = (1 << 3), + eKernelTypeHalter = (1 << 4) + }; + + RSReduceBreakpointResolver( + Breakpoint *breakpoint, ConstString reduce_name, + std::vector<lldb_renderscript::RSModuleDescriptorSP> *rs_modules, + int kernel_types = eKernelTypeAll) + : BreakpointResolver(breakpoint, BreakpointResolver::NameResolver), + m_reduce_name(reduce_name), m_rsmodules(rs_modules), + m_kernel_types(kernel_types) { + // The reduce breakpoint resolver handles adding breakpoints for named + // reductions. + // Breakpoints will be resolved for all constituent kernels in the named + // reduction + } + + void GetDescription(Stream *strm) override { + if (strm) + strm->Printf("RenderScript reduce breakpoint for '%s'", + m_reduce_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 RSReduceBreakpointResolver( + &breakpoint, m_reduce_name, m_rsmodules, m_kernel_types)); + return ret_sp; + } - void - Dump(Stream &strm) const; +private: + ConstString m_reduce_name; // The name of the reduction + std::vector<lldb_renderscript::RSModuleDescriptorSP> *m_rsmodules; + int m_kernel_types; +}; - const RSModuleDescriptor *m_module; - ConstString m_name; - RSSlot m_slot; +struct RSKernelDescriptor { +public: + RSKernelDescriptor(const RSModuleDescriptor *module, llvm::StringRef 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 -{ +struct RSGlobalDescriptor { public: - RSGlobalDescriptor(const RSModuleDescriptor *module, const char *name) : m_module(module), m_name(name) {} + RSGlobalDescriptor(const RSModuleDescriptor *module, llvm::StringRef name) + : m_module(module), m_name(name) {} - void - Dump(Stream &strm) const; + void Dump(Stream &strm) const; - const RSModuleDescriptor *m_module; - ConstString m_name; + const RSModuleDescriptor *m_module; + ConstString m_name; +}; + +struct RSReductionDescriptor { + RSReductionDescriptor(const RSModuleDescriptor *module, uint32_t sig, + uint32_t accum_data_size, llvm::StringRef name, + llvm::StringRef init_name, llvm::StringRef accum_name, + llvm::StringRef comb_name, llvm::StringRef outc_name, + llvm::StringRef halter_name = ".") + : m_module(module), m_reduce_name(name), m_init_name(init_name), + m_accum_name(accum_name), m_comb_name(comb_name), + m_outc_name(outc_name), m_halter_name(halter_name) { + // TODO Check whether the combiner is an autogenerated name, and track + // this + } + + void Dump(Stream &strm) const; + + const RSModuleDescriptor *m_module; + ConstString m_reduce_name; // This is the name given to the general reduction + // as a group as passed to pragma + // reduce(m_reduce_name). There is no kernel function with this name + ConstString m_init_name; // The name of the initializer name. "." if no + // initializer given + ConstString m_accum_name; // The accumulator function name. "." if not given + ConstString m_comb_name; // The name of the combiner function. If this was not + // given, a name is generated by the + // compiler. TODO + ConstString m_outc_name; // The name of the outconverter + + ConstString m_halter_name; // The name of the halter function. XXX This is not + // yet specified by the RenderScript + // compiler or runtime, and its semantics and existence is still under + // discussion by the + // RenderScript Contributors + RSSlot m_accum_sig; // metatdata signature for this reduction (bitwise mask of + // type information (see + // libbcc/include/bcinfo/MetadataExtractor.h + uint32_t m_accum_data_size; // Data size of the accumulator function input + bool m_comb_name_generated; // Was the combiner name generated by the compiler }; -class RSModuleDescriptor -{ +class RSModuleDescriptor { + bool ParseExportForeachCount(llvm::StringRef *, size_t n_lines); + + bool ParseExportVarCount(llvm::StringRef *, size_t n_lines); + + bool ParseExportReduceCount(llvm::StringRef *, size_t n_lines); + + bool ParseBuildChecksum(llvm::StringRef *, size_t n_lines); + + bool ParsePragmaCount(llvm::StringRef *, size_t n_lines); + public: - RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) {} + RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) {} + + ~RSModuleDescriptor() = default; - ~RSModuleDescriptor() = default; + bool ParseRSInfo(); - bool - ParseRSInfo(); + void Dump(Stream &strm) const; - void - Dump(Stream &strm) const; + const lldb::ModuleSP m_module; + std::vector<RSKernelDescriptor> m_kernels; + std::vector<RSGlobalDescriptor> m_globals; + std::vector<RSReductionDescriptor> m_reductions; + std::map<std::string, std::string> m_pragmas; + std::string m_resname; +}; - 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; +struct RSScriptGroupDescriptor { + struct Kernel { + ConstString m_name; + lldb::addr_t m_addr; + }; + ConstString m_name; + std::vector<Kernel> m_kernels; }; +typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList; + +class RSScriptGroupBreakpointResolver : public BreakpointResolver { +public: + RSScriptGroupBreakpointResolver(Breakpoint *bp, const ConstString &name, + const RSScriptGroupList &groups, + bool stop_on_all) + : BreakpointResolver(bp, BreakpointResolver::NameResolver), + m_group_name(name), m_script_groups(groups), + m_stop_on_all(stop_on_all) {} + + void GetDescription(Stream *strm) override { + if (strm) + strm->Printf("RenderScript ScriptGroup breakpoint for '%s'", + m_group_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 RSScriptGroupBreakpointResolver( + &breakpoint, m_group_name, m_script_groups, m_stop_on_all)); + return ret_sp; + } + +protected: + const RSScriptGroupDescriptorSP + FindScriptGroup(const ConstString &name) const { + for (auto sg : m_script_groups) { + if (ConstString::Compare(sg->m_name, name) == 0) + return sg; + } + return RSScriptGroupDescriptorSP(); + } + + ConstString m_group_name; + const RSScriptGroupList &m_script_groups; + bool m_stop_on_all; +}; } // namespace lldb_renderscript -class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime -{ +class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime { public: - enum ModuleKind - { - eModuleKindIgnored, - eModuleKindLibRS, - eModuleKindDriver, - eModuleKindImpl, - eModuleKindKernelObj - }; + enum ModuleKind { + eModuleKindIgnored, + eModuleKindLibRS, + eModuleKindDriver, + eModuleKindImpl, + eModuleKindKernelObj + }; + + ~RenderScriptRuntime() override; + + //------------------------------------------------------------------ + // Static Functions + //------------------------------------------------------------------ + static void Initialize(); + + static void Terminate(); + + static lldb_private::LanguageRuntime * + CreateInstance(Process *process, lldb::LanguageType language); - ~RenderScriptRuntime() override; + static lldb::CommandObjectSP + GetCommandObject(CommandInterpreter &interpreter); - //------------------------------------------------------------------ - // Static Functions - //------------------------------------------------------------------ - static void - Initialize(); + static lldb_private::ConstString GetPluginNameStatic(); - static void - Terminate(); + static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp); - static lldb_private::LanguageRuntime * - CreateInstance(Process *process, lldb::LanguageType language); + static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp); - static lldb::CommandObjectSP - GetCommandObject(CommandInterpreter &interpreter); + static void ModulesDidLoad(const lldb::ProcessSP &process_sp, + const ModuleList &module_list); - static lldb_private::ConstString - GetPluginNameStatic(); + bool IsVTableName(const char *name) override; - static bool - IsRenderScriptModule(const lldb::ModuleSP &module_sp); + bool GetDynamicTypeAndAddress(ValueObject &in_value, + lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, + Address &address, + Value::ValueType &value_type) override; - static ModuleKind - GetModuleKind(const lldb::ModuleSP &module_sp); + TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) override; - static void - ModulesDidLoad(const lldb::ProcessSP &process_sp, const ModuleList &module_list); + bool CouldHaveDynamicValue(ValueObject &in_value) override; - bool - IsVTableName(const char *name) override; + lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bp, + bool catch_bp, + bool throw_bp) override; - bool - GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic, - TypeAndOrName &class_type_or_name, Address &address, - Value::ValueType &value_type) override; + bool LoadModule(const lldb::ModuleSP &module_sp); - TypeAndOrName - FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value) override; + void DumpModules(Stream &strm) const; - bool - CouldHaveDynamicValue(ValueObject &in_value) override; + void DumpContexts(Stream &strm) const; - lldb::BreakpointResolverSP - CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override; + void DumpKernels(Stream &strm) const; - bool - LoadModule(const lldb::ModuleSP &module_sp); + bool DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id); - void - DumpModules(Stream &strm) const; + void ListAllocations(Stream &strm, StackFrame *frame_ptr, + const uint32_t index); - void - DumpContexts(Stream &strm) const; + bool RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr); - void - DumpKernels(Stream &strm) const; + bool PlaceBreakpointOnKernel( + lldb::TargetSP target, Stream &messages, const char *name, + const lldb_renderscript::RSCoordinate *coords = nullptr); - bool - DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id); + bool PlaceBreakpointOnReduction( + lldb::TargetSP target, Stream &messages, const char *reduce_name, + const lldb_renderscript::RSCoordinate *coords = nullptr, + int kernel_types = ~(0)); - void - ListAllocations(Stream &strm, StackFrame *frame_ptr, const uint32_t index); + bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm, + const ConstString &name, bool stop_on_all); - bool - RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr); + void SetBreakAllKernels(bool do_break, lldb::TargetSP target); - void - PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array<int, 3> coords, Error &error, - lldb::TargetSP target); + void Status(Stream &strm) const; - void - SetBreakAllKernels(bool do_break, lldb::TargetSP target); + void ModulesDidLoad(const ModuleList &module_list) override; - void - Status(Stream &strm) const; + bool LoadAllocation(Stream &strm, const uint32_t alloc_id, + const char *filename, StackFrame *frame_ptr); - void - ModulesDidLoad(const ModuleList &module_list) override; + bool SaveAllocation(Stream &strm, const uint32_t alloc_id, + const char *filename, StackFrame *frame_ptr); - bool - LoadAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr); + void Update(); - bool - SaveAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr); + void Initiate(); - void - Update(); + const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const { + return m_scriptGroups; + }; - void - Initiate(); + bool IsKnownKernel(const ConstString &name) { + for (const auto &module : m_rsmodules) + for (const auto &kernel : module->m_kernels) + if (kernel.m_name == name) + return true; + return false; + } - //------------------------------------------------------------------ - // PluginInterface protocol - //------------------------------------------------------------------ - lldb_private::ConstString - GetPluginName() override; + //------------------------------------------------------------------ + // PluginInterface protocol + //------------------------------------------------------------------ + lldb_private::ConstString GetPluginName() override; - uint32_t - GetPluginVersion() override; + uint32_t GetPluginVersion() override; - static bool - GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord, Thread *thread_ptr); + static bool GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord, + Thread *thread_ptr); + + bool ResolveKernelName(lldb::addr_t kernel_address, ConstString &name); protected: - struct ScriptDetails; - struct AllocationDetails; - struct Element; - - void - InitSearchFilter(lldb::TargetSP target) - { - if (!m_filtersp) - m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target)); - } - - void - FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); + struct ScriptDetails; + struct AllocationDetails; + struct Element; + + lldb_renderscript::RSScriptGroupList m_scriptGroups; + + void InitSearchFilter(lldb::TargetSP target) { + if (!m_filtersp) + m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target)); + } + + void FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); + + void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind); - void - LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind); + bool RefreshAllocation(AllocationDetails *alloc, StackFrame *frame_ptr); - bool - RefreshAllocation(AllocationDetails *allocation, StackFrame *frame_ptr); + bool EvalRSExpression(const char *expression, StackFrame *frame_ptr, + uint64_t *result); - bool - EvalRSExpression(const char *expression, StackFrame *frame_ptr, uint64_t *result); + lldb::BreakpointSP CreateScriptGroupBreakpoint(const ConstString &name, + bool multi); - lldb::BreakpointSP - CreateKernelBreakpoint(const ConstString &name); + lldb::BreakpointSP CreateKernelBreakpoint(const ConstString &name); - void - BreakOnModuleKernels(const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); + lldb::BreakpointSP CreateReductionBreakpoint(const ConstString &name, + int kernel_types); - struct RuntimeHook; - typedef void (RenderScriptRuntime::*CaptureStateFn)(RuntimeHook *hook_info, - ExecutionContext &context); // Please do this! + void BreakOnModuleKernels( + const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); - struct HookDefn - { - const char *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; - }; + struct RuntimeHook; + typedef void (RenderScriptRuntime::*CaptureStateFn)( + RuntimeHook *hook_info, + ExecutionContext &context); // Please do this! - struct RuntimeHook - { - lldb::addr_t address; - const HookDefn *defn; - lldb::BreakpointSP bp_sp; - }; + struct HookDefn { + const char *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; + }; - typedef std::shared_ptr<RuntimeHook> RuntimeHookSP; + struct RuntimeHook { + lldb::addr_t address; + const HookDefn *defn; + lldb::BreakpointSP bp_sp; + }; - lldb::ModuleSP m_libRS; - lldb::ModuleSP m_libRSDriver; - lldb::ModuleSP m_libRSCpuRef; - std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules; + typedef std::shared_ptr<RuntimeHook> RuntimeHookSP; - std::vector<std::unique_ptr<ScriptDetails>> m_scripts; - std::vector<std::unique_ptr<AllocationDetails>> m_allocations; + lldb::ModuleSP m_libRS; + lldb::ModuleSP m_libRSDriver; + lldb::ModuleSP m_libRSCpuRef; + std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules; - std::map<lldb::addr_t, lldb_renderscript::RSModuleDescriptorSP> m_scriptMappings; - std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks; - std::map<lldb::user_id_t, std::shared_ptr<uint32_t>> m_conditional_breaks; + std::vector<std::unique_ptr<ScriptDetails>> m_scripts; + std::vector<std::unique_ptr<AllocationDetails>> m_allocations; - lldb::SearchFilterSP m_filtersp; // Needed to create breakpoints through Target API + std::map<lldb::addr_t, lldb_renderscript::RSModuleDescriptorSP> + m_scriptMappings; + std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks; + std::map<lldb::user_id_t, std::unique_ptr<lldb_renderscript::RSCoordinate>> + m_conditional_breaks; - bool m_initiated; - bool m_debuggerPresentFlagged; - bool m_breakAllKernels; - static const HookDefn s_runtimeHookDefns[]; - static const size_t s_runtimeHookCount; + 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; + LLVMUserExpression::IRPasses *m_ir_passes; 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); + 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); + + // Callback function when 'debugHintScriptGroup2' executes on the target. + void CaptureDebugHintScriptGroup2(RuntimeHook *hook_info, + ExecutionContext &context); + + void CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context); - static bool - KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id, - lldb::user_id_t break_loc_id); + void CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context); - void - HookCallback(RuntimeHook *hook_info, ExecutionContext &context); + void CaptureAllocationDestroy(RuntimeHook *hook_info, + ExecutionContext &context); - void - CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context); + void CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context); - void - CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context); + void CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info, + ExecutionContext &context); - void - CaptureAllocationDestroy(RuntimeHook *hook_info, ExecutionContext &context); + AllocationDetails *FindAllocByID(Stream &strm, const uint32_t alloc_id); - void - CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context); + std::shared_ptr<uint8_t> GetAllocationData(AllocationDetails *alloc, + StackFrame *frame_ptr); - void - CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info, ExecutionContext &context); + void SetElementSize(Element &elem); - AllocationDetails * - FindAllocByID(Stream &strm, const uint32_t alloc_id); + static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP, + const char *var_name, uint64_t &val); - std::shared_ptr<uint8_t> - GetAllocationData(AllocationDetails *allocation, StackFrame *frame_ptr); + void FindStructTypeName(Element &elem, StackFrame *frame_ptr); - void - SetElementSize(Element &elem); + size_t PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer, + size_t offset, const Element &elem); - static bool - GetFrameVarAsUnsigned(const lldb::StackFrameSP, const char *var_name, uint64_t &val); + size_t CalculateElementHeaderSize(const Element &elem); - void - FindStructTypeName(Element &elem, StackFrame *frame_ptr); + void SetConditional(lldb::BreakpointSP bp, lldb_private::Stream &messages, + const lldb_renderscript::RSCoordinate &coord); + // + // Helper functions for jitting the runtime + // - size_t - PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer, size_t offset, const Element &elem); + bool JITDataPointer(AllocationDetails *alloc, StackFrame *frame_ptr, + uint32_t x = 0, uint32_t y = 0, uint32_t z = 0); - size_t - CalculateElementHeaderSize(const Element &elem); + bool JITTypePointer(AllocationDetails *alloc, StackFrame *frame_ptr); - // - // Helper functions for jitting the runtime - // + bool JITTypePacked(AllocationDetails *alloc, StackFrame *frame_ptr); - bool - JITDataPointer(AllocationDetails *allocation, StackFrame *frame_ptr, - uint32_t x = 0, uint32_t y = 0, uint32_t z = 0); + bool JITElementPacked(Element &elem, const lldb::addr_t context, + StackFrame *frame_ptr); - bool - JITTypePointer(AllocationDetails *allocation, StackFrame *frame_ptr); + bool JITAllocationSize(AllocationDetails *alloc, StackFrame *frame_ptr); - bool - JITTypePacked(AllocationDetails *allocation, StackFrame *frame_ptr); + bool JITSubelements(Element &elem, const lldb::addr_t context, + StackFrame *frame_ptr); - bool - JITElementPacked(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr); + bool JITAllocationStride(AllocationDetails *alloc, StackFrame *frame_ptr); - bool - JITAllocationSize(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); - bool - JITSubelements(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr); + // 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. + AllocationDetails *LookUpAllocation(lldb::addr_t address); - bool - JITAllocationStride(AllocationDetails *allocation, StackFrame *frame_ptr); + // Creates a new allocation with the specified address assigning a new ID and + // removes + // any previous stored allocation which has the same address. + AllocationDetails *CreateAllocation(lldb::addr_t address); - // 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); + bool GetOverrideExprOptions(clang::TargetOptions &prototype) override; - // 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); + bool GetIRPasses(LLVMUserExpression::IRPasses &passes) override; }; } // namespace lldb_private |