RenderScript command for printing allocation information

[EwanCrawford]

Summary

This patch adds a new command 'language renderscript allocation list' for printing the details of all loaded RS allocations.

In order to work out this information lldb JITs the runtime for the data it wants.
This has a penalty of a couple seconds latency, so is only done once for each allocation and the results cached.

If the user later wants to recalculate this information however, they can force lldb to do so with the --refresh flag.

[clayborg]

Back from vacation, sorry for the delay. Looks good.

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

public:
     bool ProbeModules(const ModuleList module_list);
 
     void DumpModules(Stream &strm) const;
 
     void DumpContexts(Stream &strm) const;
 
     void DumpKernels(Stream &strm) const;
 
+    void ListAllocations(Stream &strm, StackFrame* frame_ptr, bool recompute);
+
     void AttemptBreakpointAtKernelName(Stream &strm, const char *name, 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) {
         return static_cast<size_t>(0);
     }
 
     virtual void ModulesDidLoad(const ModuleList &module_list );
 
     void Update();
 
     void Initiate();
     
   protected:
 
+    struct ScriptDetails;
+    struct AllocationDetails;
+
     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);
 
+    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!
 
     struct HookDefn
protected:
     {
         lldb::addr_t address;
         const HookDefn  *defn;
         lldb::BreakpointSP bp_sp;
     };
     
     typedef std::shared_ptr<RuntimeHook> RuntimeHookSP;
 
-    struct ScriptDetails;
-    struct AllocationDetails;
-
     lldb::ModuleSP m_libRS;
     lldb::ModuleSP m_libRSDriver;
     lldb::ModuleSP m_libRSCpuRef;
     std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules;
 
     std::vector<std::unique_ptr<ScriptDetails>> m_scripts;
     std::vector<std::unique_ptr<AllocationDetails>> m_allocations;
 
private:
     void HookCallback(RuntimeHook* hook_info, ExecutionContext& context);
 
     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 CaptureSetGlobalVar1(RuntimeHook* hook_info, ExecutionContext& context);
 
+    //
+    // Helper functions for jitting the runtime
+    //
+    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(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
 
 #endif // liblldb_RenderScriptRuntime_h_

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 #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/Expression/UserExpression.h"
 #include "lldb/Symbol/VariableList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_renderscript;
 
 namespace {
 
struct RenderScriptRuntime::ScriptDetails
     // Pointer to the script object itself.
     empirical_type<lldb::addr_t> script;
 };
 
 // This AllocationDetails class collects data associated with a single
 // allocation instance.
 struct RenderScriptRuntime::AllocationDetails
 {
-    ~AllocationDetails () {};
+   // Taken from rsDefines.h
+   enum DataKind
+   {
+       RS_KIND_USER,
+       RS_KIND_PIXEL_L = 7,
+       RS_KIND_PIXEL_A,
+       RS_KIND_PIXEL_LA,
+       RS_KIND_PIXEL_RGB,
+       RS_KIND_PIXEL_RGBA,
+       RS_KIND_PIXEL_DEPTH,
+       RS_KIND_PIXEL_YUV,
+       RS_KIND_INVALID = 100
+   };
 
-    enum DataType
-    {
-        eInt,
+   // Taken from rsDefines.h
+       RS_TYPE_NONE = 0,
+       RS_TYPE_FLOAT_16,
+       RS_TYPE_FLOAT_32,
+       RS_TYPE_FLOAT_64,
+       RS_TYPE_SIGNED_8,
+       RS_TYPE_SIGNED_16,
+       RS_TYPE_SIGNED_32,
+       RS_TYPE_SIGNED_64,
+       RS_TYPE_UNSIGNED_8,
+       RS_TYPE_UNSIGNED_16,
+       RS_TYPE_UNSIGNED_32,
+       RS_TYPE_UNSIGNED_64,
+       RS_TYPE_BOOLEAN
     };
 
-    enum Dimension
+    struct Dimension
     {
-        e1d,
-        e2d,
-        e3d,
-        eCubeMap,
+        uint32_t dim_1;
+        uint32_t dim_2;
+        uint32_t dim_3;
+        uint32_t cubeMap;
+
+        Dimension()
+        {
+             dim_1 = 0;
+             dim_2 = 0;
+             dim_3 = 0;
+             cubeMap = 0;
+        }
     };
 
-    empirical_type<DataType> type;
-    empirical_type<Dimension> dimension;
-    empirical_type<lldb::addr_t> address;
-    empirical_type<lldb::addr_t> dataPtr;
-    empirical_type<lldb::addr_t> context;
+    // Monotonically increasing from 1
+    static unsigned int ID;
+
+    // Maps Allocation DataType enum and vector size to printable strings
+    // using mapping from RenderScript numerical types summary documentation
+    static const char* RsDataTypeToString[][4];
+
+    // Maps Allocation DataKind enum to printable strings
+    static const char* RsDataKindToString[];
+
+    // Give each allocation an ID as a way
+    // for commands to reference it.
+    const unsigned int id;
+
+    empirical_type<DataType> type;            // Type of each data pointer stored by the allocation
+    empirical_type<DataKind> type_kind;       // Defines pixel type if Allocation is created from an image
+    empirical_type<uint32_t> type_vec_size;   // Vector size of each data point, e.g '4' for uchar4
+    empirical_type<Dimension> dimension;      // Dimensions of the Allocation
+    empirical_type<lldb::addr_t> address;     // Pointer to address of the RS Allocation
+    empirical_type<lldb::addr_t> data_ptr;    // Pointer to the data held by the Allocation
+    empirical_type<lldb::addr_t> type_ptr;    // Pointer to the RS Type of the Allocation
+    empirical_type<lldb::addr_t> element_ptr; // Pointer to the RS Element of the Type
+    empirical_type<lldb::addr_t> context;     // Pointer to the RS Context of the Allocation
+
+    // Give each allocation an id, so we can reference it in user commands.
+    AllocationDetails(): id(ID++)
+    {
+    }
+
+};
+
+unsigned int RenderScriptRuntime::AllocationDetails::ID = 1;
+
+const char* RenderScriptRuntime::AllocationDetails::RsDataKindToString[] =
+{
+   "User",
+   "Undefined", "Undefined", "Undefined", // Enum jumps from 0 to 7
+   "Undefined", "Undefined", "Undefined",
+   "L Pixel",
+   "A Pixel",
+   "LA Pixel",
+   "RGB Pixel",
+   "RGBA Pixel",
+   "Pixel Depth",
+   "YUV Pixel"
+};
+
+const char* RenderScriptRuntime::AllocationDetails::RsDataTypeToString[][4] =
+{
+    {"None", "None", "None", "None"},
+    {"half", "half2", "half3", "half4"},
+    {"float", "float2", "float3", "float4"},
+    {"double", "double2", "double3", "double4"},
+    {"char", "char2", "char3", "char4"},
+    {"short", "short2", "short3", "short4"},
+    {"int", "int2", "int3", "int4"},
+    {"long", "long2", "long3", "long4"},
+    {"uchar", "uchar2", "uchar3", "uchar4"},
+    {"ushort", "ushort2", "ushort3", "ushort4"},
+    {"uint", "uint2", "uint3", "uint4"},
+    {"ulong", "ulong2", "ulong3", "ulong4"},
+    {"bool", "bool2", "bool3", "bool4"}
 };
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 LanguageRuntime *
 RenderScriptRuntime::CreateInstance(Process *process, lldb::LanguageType language)
 {
if (module_sp)
         }
 
         const ConstString rs_driverlib("libRSDriver.so");
         if (module_sp->GetFileSpec().GetFilename() == rs_driverlib)
         {
             return eModuleKindDriver;
         }
 
-        const ConstString rs_cpureflib("libRSCPURef.so");
+        const ConstString rs_cpureflib("libRSCpuRef.so");
         if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib)
         {
             return eModuleKindImpl;
         }
 
     }
     return eModuleKindIgnored;
 }
for (const auto & rs_script : m_scripts)
             m_scriptMappings[script] = rsmodule_sp;
             if (log)
                 log->Printf ("RenderScriptRuntime::FixupScriptDetails - script %" PRIx64 " associated with rsmodule '%s'.",
                                 (uint64_t)script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
         }
     }
 }
 
+// Uses the Target API to evaluate the expression passed as a parameter to the function
+// The result of that expression is returned an unsigned 64 bit int, via the result* paramter.
+// Function returns true on success, and false on failure
+bool
+RenderScriptRuntime::EvalRSExpression(const char* expression, StackFrame* frame_ptr, uint64_t* result)
+{
+    Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+    if (log)
+        log->Printf("RenderScriptRuntime::EvalRSExpression(%s)", expression);
+
+    ValueObjectSP expr_result;
+    // Perform the actual expression evaluation
+    GetProcess()->GetTarget().EvaluateExpression(expression, frame_ptr, expr_result);
+
+    if (!expr_result)
+    {
+       if (log)
+           log->Printf("RenderScriptRuntime::EvalRSExpression -  Error: Couldn't evaluate expression");
+       return false;
+    }
+
+    // The result of the expression is invalid
+    if (!expr_result->GetError().Success())
+    {
+        Error err = expr_result->GetError();
+        if (err.GetError() == UserExpression::kNoResult) // Expression returned void, so this is actually a success
+        {
+            if (log)
+                log->Printf("RenderScriptRuntime::EvalRSExpression - Expression returned void");
+
+            result = nullptr;
+            return true;
+        }
+
+        if (log)
+            log->Printf("RenderScriptRuntime::EvalRSExpression - Error evaluating expression result: %s", err.AsCString());
+        return false;
+    }
+
+    bool success = false;
+    *result = expr_result->GetValueAsUnsigned(0, &success); // We only read the result as an unsigned int.
+
+    if (!success)
+    {
+       if (log)
+           log->Printf("RenderScriptRuntime::EvalRSExpression -  Error: Couldn't convert expression result to unsigned int");
+       return false;
+    }
+
+    return true;
+}
+
+// Used to index expression format strings
+enum ExpressionStrings
+{
+   eExprGetOffsetPtr = 0,
+   eExprAllocGetType,
+   eExprTypeDimX,
+   eExprTypeDimY,
+   eExprTypeDimZ,
+   eExprTypeElemPtr,
+   eExprElementType,
+   eExprElementKind,
+   eExprElementVec
+};
+
+// Format strings containing the expressions we may need to evaluate.
+const char runtimeExpressions[][256] =
+{
+ // Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap)
+ "(int*)_Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocationCubemapFace(0x%lx, %u, %u, %u, 0, 0)",
+
+ // Type* rsaAllocationGetType(Context*, Allocation*)
+ "(void*)rsaAllocationGetType(0x%lx, 0x%lx)",
+
+ // rsaTypeGetNativeData(Context*, Type*, void* typeData, size)
+ // Pack the data in the following way mHal.state.dimX; mHal.state.dimY; mHal.state.dimZ;
+ // mHal.state.lodCount; mHal.state.faces; mElement; into typeData
+ // Need to specify 32 or 64 bit for uint_t since this differs between devices
+ "uint%u_t data[6]; (void*)rsaTypeGetNativeData(0x%lx, 0x%lx, data, 6); data[0]", // X dim
+ "uint%u_t data[6]; (void*)rsaTypeGetNativeData(0x%lx, 0x%lx, data, 6); data[1]", // Y dim
+ "uint%u_t data[6]; (void*)rsaTypeGetNativeData(0x%lx, 0x%lx, data, 6); data[2]", // Z dim
+ "uint%u_t data[6]; (void*)rsaTypeGetNativeData(0x%lx, 0x%lx, data, 6); data[5]", // Element ptr
+
+ // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
+ // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into elemData
+ "uint32_t data[6]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data, 5); data[0]", // Type
+ "uint32_t data[6]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data, 5); data[1]", // Kind
+ "uint32_t data[6]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data, 5); data[3]"  // Vector Size
+};
+
+// JITs the RS runtime for the internal data pointer of an allocation.
+// Is passed x,y,z coordinates for the pointer to a specific element.
+// Then sets the data_ptr member in Allocation with the result.
+// Returns true on success, false otherwise
+bool
+RenderScriptRuntime::JITDataPointer(AllocationDetails* allocation, StackFrame* frame_ptr,
+                                    unsigned int x, unsigned int y, unsigned int z)
+{
+    Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+    if (!allocation->address.isValid())
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITDataPointer - Failed to find allocation details");
+        return false;
+    }
+
+    const char* expr_cstr = runtimeExpressions[eExprGetOffsetPtr];
+    const int max_expr_size = 512; // Max expression size
+    char buffer[max_expr_size];
+
+    int chars_written = snprintf(buffer, max_expr_size, expr_cstr, *allocation->address.get(), x, y, z);
+    if (chars_written < 0)
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITDataPointer - Encoding error in snprintf()");
+        return false;
+    }
+    else if (chars_written >= max_expr_size)
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITDataPointer - Expression too long");
+        return false;
+    }
+
+    uint64_t result = 0;
+    if (!EvalRSExpression(buffer, frame_ptr, &result))
+        return false;
+
+    addr_t mem_ptr = static_cast<lldb::addr_t>(result);
+    allocation->data_ptr = mem_ptr;
+
+    return true;
+}
+
+// JITs the RS runtime for the internal pointer to the RS Type of an allocation
+// Then sets the type_ptr member in Allocation with the result.
+// Returns true on success, false otherwise
+bool
+RenderScriptRuntime::JITTypePointer(AllocationDetails* allocation, StackFrame* frame_ptr)
+{
+    Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+    if (!allocation->address.isValid() || !allocation->context.isValid())
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITTypePointer - Failed to find allocation details");
+        return false;
+    }
+
+    const char* expr_cstr = runtimeExpressions[eExprAllocGetType];
+    const int max_expr_size = 512; // Max expression size
+    char buffer[max_expr_size];
+
+    int chars_written = snprintf(buffer, max_expr_size, expr_cstr, *allocation->context.get(), *allocation->address.get());
+    if (chars_written < 0)
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITDataPointer - Encoding error in snprintf()");
+        return false;
+    }
+    else if (chars_written >= max_expr_size)
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITTypePointer - Expression too long");
+        return false;
+    }
+
+    uint64_t result = 0;
+    if (!EvalRSExpression(buffer, frame_ptr, &result))
+        return false;
+
+    addr_t type_ptr = static_cast<lldb::addr_t>(result);
+    allocation->type_ptr = type_ptr;
+
+    return true;
+}
+
+// JITs the RS runtime for information about the dimensions and type of an allocation
+// Then sets dimension and element_ptr members in Allocation with the result.
+// Returns true on success, false otherwise
+bool
+RenderScriptRuntime::JITTypePacked(AllocationDetails* allocation, StackFrame* frame_ptr)
+{
+    Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+    if (!allocation->type_ptr.isValid() || !allocation->context.isValid())
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITTypePacked - Failed to find allocation details");
+        return false;
+    }
+
+    // Expression is different depending on if device is 32 or 64 bit
+    uint32_t archByteSize = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
+    const unsigned int bits = archByteSize == 4 ? 32 : 64;
+
+    // We want 4 elements from packed data
+    const unsigned int num_exprs = 4;
+    assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) && "Invalid number of expressions");
+
+    const int max_expr_size = 512; // Max expression size
+    char buffer[num_exprs][max_expr_size];
+    uint64_t results[num_exprs];
+
+    for (unsigned int i = 0; i < num_exprs; ++i)
+    {
+        int chars_written = snprintf(buffer[i], max_expr_size, runtimeExpressions[eExprTypeDimX + i], bits,
+                                     *allocation->context.get(), *allocation->type_ptr.get());
+        if (chars_written < 0)
+        {
+            if (log)
+                log->Printf("RenderScriptRuntime::JITDataPointer - Encoding error in snprintf()");
+            return false;
+        }
+        else if (chars_written >= max_expr_size)
+        {
+            if (log)
+                log->Printf("RenderScriptRuntime::JITTypePacked - Expression too long");
+            return false;
+        }
+
+        // Perform expression evaluation
+        if (!EvalRSExpression(buffer[i], frame_ptr, &results[i]))
+            return false;
+    }
+
+    // Assign results to allocation members
+    AllocationDetails::Dimension dims;
+    dims.dim_1 = static_cast<uint32_t>(results[0]);
+    dims.dim_2 = static_cast<uint32_t>(results[1]);
+    dims.dim_3 = static_cast<uint32_t>(results[2]);
+    allocation->dimension = dims;
+
+    addr_t elem_ptr = static_cast<lldb::addr_t>(results[3]);
+    allocation->element_ptr = elem_ptr;
+
+    if (log)
+        log->Printf("RenderScriptRuntime::JITTypePacked - dims (%u, %u, %u) Element*: 0x%" PRIx64,
+                    dims.dim_1, dims.dim_2, dims.dim_3, elem_ptr);
+
+    return true;
+}
+
+// JITs the RS runtime for information about the Element of an allocation
+// Then sets type, type_vec_size, and type_kind members in Allocation with the result.
+// Returns true on success, false otherwise
+bool
+RenderScriptRuntime::JITElementPacked(AllocationDetails* allocation, StackFrame* frame_ptr)
+{
+    Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+    if (!allocation->element_ptr.isValid() || !allocation->context.isValid())
+    {
+        if (log)
+            log->Printf("RenderScriptRuntime::JITElementPacked - Failed to find allocation details");
+        return false;
+    }
+
+    // We want 3 elements from packed data
+    const unsigned int num_exprs = 3;
+    assert(num_exprs == (eExprElementVec - eExprElementType + 1) && "Invalid number of expressions");
+
+    const int max_expr_size = 512; // Max expression size
+    char buffer[num_exprs][max_expr_size];
+    uint64_t results[num_exprs];
+
+    for (unsigned int i = 0; i < num_exprs; i++)
+    {
+        int chars_written = snprintf(buffer[i], max_expr_size, runtimeExpressions[eExprElementType + i], *allocation->context.get(), *allocation->element_ptr.get());
+        if (chars_written < 0)
+        {
+            if (log)
+                log->Printf("RenderScriptRuntime::JITDataPointer - Encoding error in snprintf()");
+            return false;
+        }
+        else if (chars_written >= max_expr_size)
+        {
+            if (log)
+                log->Printf("RenderScriptRuntime::JITElementPacked - Expression too long");
+            return false;
+        }
+
+        // Perform expression evaluation
+        if (!EvalRSExpression(buffer[i], frame_ptr, &results[i]))
+            return false;
+    }
+
+    // Assign results to allocation members
+    allocation->type = static_cast<RenderScriptRuntime::AllocationDetails::DataType>(results[0]);
+    allocation->type_kind = static_cast<RenderScriptRuntime::AllocationDetails::DataKind>(results[1]);
+    allocation->type_vec_size = static_cast<uint32_t>(results[2]);
+
+    if (log)
+        log->Printf("RenderScriptRuntime::JITElementPacked - data type %u, pixel type %u, vector size %u",
+                    *allocation->type.get(), *allocation->type_kind.get(), *allocation->type_vec_size.get());
+
+    return true;
+}
+
+// JIT all the current runtime info regarding an allocation
+bool
+RenderScriptRuntime::RefreshAllocation(AllocationDetails* allocation, StackFrame* frame_ptr)
+{
+    // GetOffsetPointer()
+    if (!JITDataPointer(allocation, frame_ptr))
+        return false;
+
+    // rsaAllocationGetType()
+    if (!JITTypePointer(allocation, frame_ptr))
+        return false;
+
+    // rsaTypeGetNativeData()
+    if (!JITTypePacked(allocation, frame_ptr))
+        return false;
+
+    // rsaElementGetNativeData()
+    if (!JITElementPacked(allocation, frame_ptr))
+        return false;
+
+    return true;
+}
+
 bool
 RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp)
 {
     Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
     if (module_sp)
     {
         for (const auto &rs_module : m_rsmodules)
for (const auto &module : m_rsmodules)
         {
             strm.Indent(kernel.m_name.AsCString());
             strm.EOL();
         }
     }
     strm.IndentLess();
 }
 
+// Prints infomation regarding all the currently loaded allocations.
+// These details are gathered by jitting the runtime, which has as latency.
+void
+RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame* frame_ptr, bool recompute)
+{
+    strm.Printf("RenderScript Allocations:");
+    strm.EOL();
+    strm.IndentMore();
+
+    for (auto &alloc : m_allocations)
+    {
+        // JIT the allocation info if we haven't done it, or the user forces us to.
+        bool do_refresh = !alloc->data_ptr.isValid() || recompute;
+
+        // JIT current allocation information
+        if (do_refresh && !RefreshAllocation(alloc.get(), frame_ptr))
+        {
+            strm.Printf("Error: Couldn't evaluate details for allocation %u\n", alloc->id);
+            continue;
+        }
+
+        strm.Printf("%u:\n",alloc->id);
+        strm.IndentMore();
+
+        strm.Indent("Context: ");
+        if (!alloc->context.isValid())
+            strm.Printf("unknown\n");
+        else
+            strm.Printf("0x%" PRIx64 "\n", *alloc->context.get());
+
+        strm.Indent("Address: ");
+        if (!alloc->address.isValid())
+            strm.Printf("unknown\n");
+        else
+            strm.Printf("0x%" PRIx64 "\n", *alloc->address.get());
+
+        strm.Indent("Data pointer: ");
+        if (!alloc->data_ptr.isValid())
+            strm.Printf("unknown\n");
+        else
+            strm.Printf("0x%" PRIx64 "\n", *alloc->data_ptr.get());
+
+        strm.Indent("Dimensions: ");
+        if (!alloc->dimension.isValid())
+            strm.Printf("unknown\n");
+        else
+            strm.Printf("(%d, %d, %d)\n", alloc->dimension.get()->dim_1,
+                                          alloc->dimension.get()->dim_2,
+                                          alloc->dimension.get()->dim_3);
+
+        strm.Indent("Data Type: ");
+        if (!alloc->type.isValid() || !alloc->type_vec_size.isValid())
+            strm.Printf("unknown\n");
+        else
+        {
+            const int vector_size = *alloc->type_vec_size.get();
+            const AllocationDetails::DataType type = *alloc->type.get();
+
+            if (vector_size > 4 || vector_size < 1 ||
+                type < AllocationDetails::RS_TYPE_NONE || type > AllocationDetails::RS_TYPE_BOOLEAN)
+                strm.Printf("invalid type\n");
+            else
+                strm.Printf("%s\n", AllocationDetails::RsDataTypeToString[static_cast<unsigned int>(type)][vector_size-1]);
+        }
+
+        strm.Indent("Data Kind: ");
+        if (!alloc->type_kind.isValid())
+            strm.Printf("unknown\n");
+        else
+        {
+            const AllocationDetails::DataKind kind = *alloc->type_kind.get();
+            if (kind < AllocationDetails::RS_KIND_USER || kind > AllocationDetails::RS_KIND_PIXEL_YUV)
+                strm.Printf("invalid kind\n");
+            else
+                strm.Printf("%s\n", AllocationDetails::RsDataKindToString[static_cast<unsigned int>(kind)]);
+        }
+
+        strm.EOL();
+        strm.IndentLess();
+    }
+    strm.IndentLess();
+}
+
 // Set breakpoints on every kernel found in RS module
 void
 RenderScriptRuntime::BreakOnModuleKernels(const RSModuleDescriptorSP rsmodule_sp)
 {
     for (const auto &kernel : rsmodule_sp->m_kernels)
     {
         // Don't set breakpoint on 'root' kernel
         if (strcmp(kernel.m_name.AsCString(), "root") == 0)
CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter)
                                  NULL)
     {
         LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(interpreter)));
     }
 
     ~CommandObjectRenderScriptRuntimeContext() {}
 };
 
+class CommandObjectRenderScriptRuntimeAllocationList : public CommandObjectParsed
+{
+  public:
+    CommandObjectRenderScriptRuntimeAllocationList(CommandInterpreter &interpreter)
+        : CommandObjectParsed(interpreter, "renderscript allocation list",
+                              "List renderscript allocations and their information.", "renderscript allocation list",
+                              eCommandRequiresProcess | eCommandProcessMustBeLaunched), m_options(interpreter)
+    {
+    }
+
+    virtual Options*
+    GetOptions()
+    {
+        return &m_options;
+    }
+
+    class CommandOptions : public Options
+    {
+      public:
+        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter), m_refresh(false)
+        {
+        }
+
+        virtual
+        ~CommandOptions()
+        {
+        }
+
+        virtual Error
+        SetOptionValue(uint32_t option_idx, const char *option_arg)
+        {
+            Error error;
+            const int short_option = m_getopt_table[option_idx].val;
+
+            switch (short_option)
+            {
+                case 'r':
+                    m_refresh = true;
+                    break;
+                default:
+                    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
+                    break;
+            }
+            return error;
+        }
+
+        void
+        OptionParsingStarting()
+        {
+            m_refresh = false;
+        }
+
+        const OptionDefinition*
+        GetDefinitions()
+        {
+            return g_option_table;
+        }
+
+        static OptionDefinition g_option_table[];
+        bool m_refresh;
+    };
+
+    ~CommandObjectRenderScriptRuntimeAllocationList() {}
+
+    bool
+    DoExecute(Args &command, CommandReturnObject &result)
+    {
+        RenderScriptRuntime *runtime =
+          static_cast<RenderScriptRuntime *>(m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
+        runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(), m_options.m_refresh);
+        result.SetStatus(eReturnStatusSuccessFinishResult);
+        return true;
+    }
+
+  private:
+    CommandOptions m_options;
+};
+
+OptionDefinition
+CommandObjectRenderScriptRuntimeAllocationList::CommandOptions::g_option_table[] =
+{
+    { LLDB_OPT_SET_1, false, "refresh", 'r', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,
+      "Recompute allocation details."},
+    { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
+};
+
+
+class CommandObjectRenderScriptRuntimeAllocation : public CommandObjectMultiword
+{
+  private:
+  public:
+    CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter)
+        : CommandObjectMultiword(interpreter, "renderscript allocation", "Commands that deal with renderscript allocations.",
+                                 NULL)
+    {
+        LoadSubCommand("list", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationList(interpreter)));
+    }
+
+    ~CommandObjectRenderScriptRuntimeAllocation() {}
+};
+
+
 class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed
 {
   private:
   public:
     CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "renderscript status",
                               "Displays current renderscript runtime status.", "renderscript status",
                               eCommandRequiresProcess | eCommandProcessMustBeLaunched)
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)));
+        LoadSubCommand("allocation", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocation(interpreter)));
     }
 
     ~CommandObjectRenderScriptRuntime() {}
 };
 
 void
 RenderScriptRuntime::Initiate()
 {