Vendor import of stripped lldb trunk r256633:

https://llvm.org/svn/llvm-project/lldb/trunk@256633

1 files changed, 185 insertions, 44 deletions

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 <array>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
 // 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<RSModuleDescriptor> RSModuleDescriptorSP;
 typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP;
 typedef std::shared_ptr<RSKernelDescriptor> 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<int,3> 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<ConstString> &alternates) {
+    size_t GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) override {
         return static_cast<size_t>(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<RuntimeHook> RuntimeHookSP;
 
-    struct ScriptDetails
-    {
-        std::string resname;
-        std::string scriptDyLib;
-        std::string cachedir;
-        lldb::addr_t context;
-        lldb::addr_t script;
-    };
+    typedef std::shared_ptr<RuntimeHook> RuntimeHookSP;
 
     lldb::ModuleSP m_libRS;
     lldb::ModuleSP m_libRSDriver;
     lldb::ModuleSP m_libRSCpuRef;
-    std::vector<RSModuleDescriptorSP> m_rsmodules;
-    std::vector<ScriptDetails> m_scripts;
+    std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules;
+
+    std::vector<std::unique_ptr<ScriptDetails>> m_scripts;
+    std::vector<std::unique_ptr<AllocationDetails>> m_allocations;
 
-    std::map<lldb::addr_t, RSModuleDescriptorSP> m_scriptMappings;
+    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<int>> 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<uint8_t> 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