diff options
Diffstat (limited to 'gnu/llvm/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp')
| -rw-r--r-- | gnu/llvm/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp | 4939 |
1 files changed, 4939 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp b/gnu/llvm/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp new file mode 100644 index 00000000000..4edb8dec608 --- /dev/null +++ b/gnu/llvm/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp @@ -0,0 +1,4939 @@ +//===-- RenderScriptRuntime.cpp ---------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "RenderScriptRuntime.h" +#include "RenderScriptScriptGroup.h" + +#include "lldb/Breakpoint/StoppointCallbackContext.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/DumpDataExtractor.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/ValueObjectVariable.h" +#include "lldb/DataFormatters/DumpValueObjectOptions.h" +#include "lldb/Expression/UserExpression.h" +#include "lldb/Host/OptionParser.h" +#include "lldb/Host/StringConvert.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Interpreter/CommandObjectMultiword.h" +#include "lldb/Interpreter/CommandReturnObject.h" +#include "lldb/Interpreter/Options.h" +#include "lldb/Symbol/Function.h" +#include "lldb/Symbol/Symbol.h" +#include "lldb/Symbol/Type.h" +#include "lldb/Symbol/VariableList.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/RegisterContext.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/Target.h" +#include "lldb/Target/Thread.h" +#include "lldb/Utility/Args.h" +#include "lldb/Utility/ConstString.h" +#include "lldb/Utility/Log.h" +#include "lldb/Utility/RegisterValue.h" +#include "lldb/Utility/RegularExpression.h" +#include "lldb/Utility/Status.h" + +#include "llvm/ADT/StringSwitch.h" + +#include <memory> + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_renderscript; + +#define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")" + +char RenderScriptRuntime::ID = 0; + +namespace { + +// The empirical_type adds a basic level of validation to arbitrary data +// allowing us to track if data has been discovered and stored or not. An +// empirical_type will be marked as valid only if it has been explicitly +// assigned to. +template <typename type_t> class empirical_type { +public: + // Ctor. Contents is invalid when constructed. + empirical_type() : valid(false) {} + + // Return true and copy contents to out if valid, else return false. + bool get(type_t &out) const { + if (valid) + out = data; + return valid; + } + + // Return a pointer to the contents or nullptr if it was not valid. + const type_t *get() const { return valid ? &data : nullptr; } + + // Assign data explicitly. + void set(const type_t in) { + data = in; + valid = true; + } + + // Mark contents as invalid. + void invalidate() { valid = false; } + + // Returns true if this type contains valid data. + bool isValid() const { return valid; } + + // Assignment operator. + empirical_type<type_t> &operator=(const type_t in) { + set(in); + return *this; + } + + // Dereference operator returns contents. + // Warning: Will assert if not valid so use only when you know data is valid. + const type_t &operator*() const { + assert(valid); + return data; + } + +protected: + bool valid; + type_t data; +}; + +// ArgItem is used by the GetArgs() function when reading function arguments +// from the target. +struct ArgItem { + enum { ePointer, eInt32, eInt64, eLong, eBool } type; + + uint64_t value; + + explicit operator uint64_t() const { return value; } +}; + +// Context structure to be passed into GetArgsXXX(), argument reading functions +// below. +struct GetArgsCtx { + RegisterContext *reg_ctx; + Process *process; +}; + +bool GetArgsX86(const GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + + for (size_t i = 0; i < num_args; ++i) { + ArgItem &arg = arg_list[i]; + // advance up the stack by one argument + sp += sizeof(uint32_t); + // get the argument type size + size_t arg_size = sizeof(uint32_t); + // read the argument from memory + arg.value = 0; + Status err; + size_t read = + ctx.process->ReadMemory(sp, &arg.value, sizeof(uint32_t), err); + if (read != arg_size || !err.Success()) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 " '%s'", + __FUNCTION__, uint64_t(i), err.AsCString()); + return false; + } + } + return true; +} + +bool GetArgsX86_64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + // number of arguments passed in registers + static const uint32_t args_in_reg = 6; + // register passing order + static const std::array<const char *, args_in_reg> reg_names{ + {"rdi", "rsi", "rdx", "rcx", "r8", "r9"}}; + // argument type to size mapping + static const std::array<size_t, 5> arg_size{{ + 8, // ePointer, + 4, // eInt32, + 8, // eInt64, + 8, // eLong, + 4, // eBool, + }}; + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + // step over the return address + sp += sizeof(uint64_t); + + // check the stack alignment was correct (16 byte aligned) + if ((sp & 0xf) != 0x0) { + LLDB_LOGF(log, "%s - stack misaligned", __FUNCTION__); + return false; + } + + // find the start of arguments on the stack + uint64_t sp_offset = 0; + for (uint32_t i = args_in_reg; i < num_args; ++i) { + sp_offset += arg_size[arg_list[i].type]; + } + // round up to multiple of 16 + sp_offset = (sp_offset + 0xf) & 0xf; + sp += sp_offset; + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = + ctx.reg_ctx->GetRegisterInfoByName(reg_names[i]); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + // get the argument type size + const size_t size = arg_size[arg_list[i].type]; + // read the argument from memory + arg.value = 0; + // note: due to little endian layout reading 4 or 8 bytes will give the + // correct value. + size_t read = ctx.process->ReadMemory(sp, &arg.value, size, err); + success = (err.Success() && read == size); + // advance past this argument + sp -= size; + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgsArm(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 4; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt32(0, &success); + } + // arguments passed on the stack + else { + // get the argument type size + const size_t arg_size = sizeof(uint32_t); + // clear all 64bits + arg.value = 0; + // read this argument from memory + size_t bytes_read = + ctx.process->ReadMemory(sp, &arg.value, arg_size, err); + success = (err.Success() && bytes_read == arg_size); + // advance the stack pointer + sp += sizeof(uint32_t); + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgsAarch64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 8; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + LLDB_LOGF(log, "%s - reading arguments spilled to stack not implemented", + __FUNCTION__); + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64, __FUNCTION__, + uint64_t(i)); + return false; + } + } + return true; +} + +bool GetArgsMipsel(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 4; + // register file offset to first argument + static const uint32_t reg_offset = 4; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // find offset to arguments on the stack (+16 to skip over a0-a3 shadow + // space) + uint64_t sp = ctx.reg_ctx->GetSP() + 16; + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = + ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + const size_t arg_size = sizeof(uint32_t); + arg.value = 0; + size_t bytes_read = + ctx.process->ReadMemory(sp, &arg.value, arg_size, err); + success = (err.Success() && bytes_read == arg_size); + // advance the stack pointer + sp += arg_size; + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgsMips64el(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) { + // number of arguments passed in registers + static const uint32_t args_in_reg = 8; + // register file offset to first argument + static const uint32_t reg_offset = 4; + + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + Status err; + + // get the current stack pointer + uint64_t sp = ctx.reg_ctx->GetSP(); + + for (size_t i = 0; i < num_args; ++i) { + bool success = false; + ArgItem &arg = arg_list[i]; + // arguments passed in registers + if (i < args_in_reg) { + const RegisterInfo *reg = + ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset); + RegisterValue reg_val; + if (ctx.reg_ctx->ReadRegister(reg, reg_val)) + arg.value = reg_val.GetAsUInt64(0, &success); + } + // arguments passed on the stack + else { + // get the argument type size + const size_t arg_size = sizeof(uint64_t); + // clear all 64bits + arg.value = 0; + // read this argument from memory + size_t bytes_read = + ctx.process->ReadMemory(sp, &arg.value, arg_size, err); + success = (err.Success() && bytes_read == arg_size); + // advance the stack pointer + sp += arg_size; + } + // fail if we couldn't read this argument + if (!success) { + LLDB_LOGF(log, "%s - error reading argument: %" PRIu64 ", reason: %s", + __FUNCTION__, uint64_t(i), err.AsCString("n/a")); + return false; + } + } + return true; +} + +bool GetArgs(ExecutionContext &exe_ctx, ArgItem *arg_list, size_t num_args) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + // verify that we have a target + if (!exe_ctx.GetTargetPtr()) { + LLDB_LOGF(log, "%s - invalid target", __FUNCTION__); + return false; + } + + GetArgsCtx ctx = {exe_ctx.GetRegisterContext(), exe_ctx.GetProcessPtr()}; + assert(ctx.reg_ctx && ctx.process); + + // dispatch based on architecture + switch (exe_ctx.GetTargetPtr()->GetArchitecture().GetMachine()) { + case llvm::Triple::ArchType::x86: + return GetArgsX86(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::x86_64: + return GetArgsX86_64(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::arm: + return GetArgsArm(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::aarch64: + return GetArgsAarch64(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::mipsel: + return GetArgsMipsel(ctx, arg_list, num_args); + + case llvm::Triple::ArchType::mips64el: + return GetArgsMips64el(ctx, arg_list, num_args); + + default: + // unsupported architecture + if (log) { + LLDB_LOGF(log, "%s - architecture not supported: '%s'", __FUNCTION__, + exe_ctx.GetTargetRef().GetArchitecture().GetArchitectureName()); + } + return false; + } +} + +bool IsRenderScriptScriptModule(ModuleSP module) { + if (!module) + return false; + return module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), + eSymbolTypeData) != nullptr; +} + +bool ParseCoordinate(llvm::StringRef coord_s, RSCoordinate &coord) { + // takes an argument of the form 'num[,num][,num]'. Where 'coord_s' is a + // comma separated 1,2 or 3-dimensional coordinate with the whitespace + // trimmed. Missing coordinates are defaulted to zero. If parsing of any + // elements fails the contents of &coord are undefined and `false` is + // returned, `true` otherwise + + llvm::SmallVector<llvm::StringRef, 4> matches; + + if (!RegularExpression("^([0-9]+),([0-9]+),([0-9]+)$") + .Execute(coord_s, &matches) && + !RegularExpression("^([0-9]+),([0-9]+)$").Execute(coord_s, &matches) && + !RegularExpression("^([0-9]+)$").Execute(coord_s, &matches)) + return false; + + auto get_index = [&](size_t idx, uint32_t &i) -> bool { + std::string group; + errno = 0; + if (idx + 1 < matches.size()) { + return !llvm::StringRef(matches[idx + 1]).getAsInteger<uint32_t>(10, i); + } + return true; + }; + + return get_index(0, coord.x) && get_index(1, coord.y) && + get_index(2, coord.z); +} + +bool SkipPrologue(lldb::ModuleSP &module, Address &addr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + SymbolContext sc; + uint32_t resolved_flags = + module->ResolveSymbolContextForAddress(addr, eSymbolContextFunction, sc); + if (resolved_flags & eSymbolContextFunction) { + if (sc.function) { + const uint32_t offset = sc.function->GetPrologueByteSize(); + ConstString name = sc.GetFunctionName(); + if (offset) + addr.Slide(offset); + LLDB_LOGF(log, "%s: Prologue offset for %s is %" PRIu32, __FUNCTION__, + name.AsCString(), offset); + } + return true; + } else + return false; +} +} // anonymous namespace + +// The ScriptDetails class collects data associated with a single script +// instance. +struct RenderScriptRuntime::ScriptDetails { + ~ScriptDetails() = default; + + enum ScriptType { eScript, eScriptC }; + + // The derived type of the script. + empirical_type<ScriptType> type; + // The name of the original source file. + empirical_type<std::string> res_name; + // Path to script .so file on the device. + empirical_type<std::string> shared_lib; + // Directory where kernel objects are cached on device. + empirical_type<std::string> cache_dir; + // Pointer to the context which owns this script. + empirical_type<lldb::addr_t> context; + // Pointer to the script object itself. + empirical_type<lldb::addr_t> script; +}; + +// This Element class represents the Element object in RS, defining the type +// associated with an Allocation. +struct RenderScriptRuntime::Element { + // 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 + }; + + // Taken from rsDefines.h + enum DataType { + 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, + + RS_TYPE_UNSIGNED_5_6_5, + RS_TYPE_UNSIGNED_5_5_5_1, + RS_TYPE_UNSIGNED_4_4_4_4, + + RS_TYPE_MATRIX_4X4, + RS_TYPE_MATRIX_3X3, + RS_TYPE_MATRIX_2X2, + + RS_TYPE_ELEMENT = 1000, + RS_TYPE_TYPE, + RS_TYPE_ALLOCATION, + RS_TYPE_SAMPLER, + RS_TYPE_SCRIPT, + RS_TYPE_MESH, + RS_TYPE_PROGRAM_FRAGMENT, + RS_TYPE_PROGRAM_VERTEX, + RS_TYPE_PROGRAM_RASTER, + RS_TYPE_PROGRAM_STORE, + RS_TYPE_FONT, + + RS_TYPE_INVALID = 10000 + }; + + std::vector<Element> children; // Child Element fields for structs + empirical_type<lldb::addr_t> + element_ptr; // Pointer to the RS Element of the Type + 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<uint32_t> field_count; // Number of Subelements + empirical_type<uint32_t> datum_size; // Size of a single Element with padding + empirical_type<uint32_t> padding; // Number of padding bytes + empirical_type<uint32_t> + array_size; // Number of items in array, only needed for structs + ConstString type_name; // Name of type, only needed for structs + + static ConstString + GetFallbackStructName(); // Print this as the type name of a struct Element + // If we can't resolve the actual struct name + + bool ShouldRefresh() const { + const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0; + const bool valid_type = + type.isValid() && type_vec_size.isValid() && type_kind.isValid(); + return !valid_ptr || !valid_type || !datum_size.isValid(); + } +}; + +// This AllocationDetails class collects data associated with a single +// allocation instance. +struct RenderScriptRuntime::AllocationDetails { + struct Dimension { + uint32_t dim_1; + uint32_t dim_2; + uint32_t dim_3; + uint32_t cube_map; + + Dimension() { + dim_1 = 0; + dim_2 = 0; + dim_3 = 0; + cube_map = 0; + } + }; + + // The FileHeader struct specifies the header we use for writing allocations + // to a binary file. Our format begins with the ASCII characters "RSAD", + // identifying the file as an allocation dump. Member variables dims and + // hdr_size are then written consecutively, immediately followed by an + // instance of the ElementHeader struct. Because Elements can contain + // subelements, there may be more than one instance of the ElementHeader + // struct. With this first instance being the root element, and the other + // instances being the root's descendants. To identify which instances are an + // ElementHeader's children, each struct is immediately followed by a + // sequence of consecutive offsets to the start of its child structs. These + // offsets are + // 4 bytes in size, and the 0 offset signifies no more children. + struct FileHeader { + uint8_t ident[4]; // ASCII 'RSAD' identifying the file + uint32_t dims[3]; // Dimensions + uint16_t hdr_size; // Header size in bytes, including all element headers + }; + + struct ElementHeader { + uint16_t type; // DataType enum + uint32_t kind; // DataKind enum + uint32_t element_size; // Size of a single element, including padding + uint16_t vector_size; // Vector width + uint32_t array_size; // Number of elements in array + }; + + // Monotonically increasing from 1 + static uint32_t 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[]; + + // Maps allocation types to format sizes for printing. + static const uint32_t RSTypeToFormat[][3]; + + // Give each allocation an ID as a way + // for commands to reference it. + const uint32_t id; + + // Allocation Element type + RenderScriptRuntime::Element element; + // Dimensions of the Allocation + empirical_type<Dimension> dimension; + // Pointer to address of the RS Allocation + empirical_type<lldb::addr_t> address; + // Pointer to the data held by the Allocation + empirical_type<lldb::addr_t> data_ptr; + // Pointer to the RS Type of the Allocation + empirical_type<lldb::addr_t> type_ptr; + // Pointer to the RS Context of the Allocation + empirical_type<lldb::addr_t> context; + // Size of the allocation + empirical_type<uint32_t> size; + // Stride between rows of the allocation + empirical_type<uint32_t> stride; + + // Give each allocation an id, so we can reference it in user commands. + AllocationDetails() : id(ID++) {} + + bool ShouldRefresh() const { + bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0; + valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0; + return !valid_ptrs || !dimension.isValid() || !size.isValid() || + element.ShouldRefresh(); + } +}; + +ConstString RenderScriptRuntime::Element::GetFallbackStructName() { + static const ConstString FallbackStructName("struct"); + return FallbackStructName; +} + +uint32_t RenderScriptRuntime::AllocationDetails::ID = 1; + +const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = { + "User", "Undefined", "Undefined", "Undefined", + "Undefined", "Undefined", "Undefined", // Enum jumps from 0 to 7 + "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"}, + {"packed_565", "packed_565", "packed_565", "packed_565"}, + {"packed_5551", "packed_5551", "packed_5551", "packed_5551"}, + {"packed_4444", "packed_4444", "packed_4444", "packed_4444"}, + {"rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4"}, + {"rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3"}, + {"rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2"}, + + // Handlers + {"RS Element", "RS Element", "RS Element", "RS Element"}, + {"RS Type", "RS Type", "RS Type", "RS Type"}, + {"RS Allocation", "RS Allocation", "RS Allocation", "RS Allocation"}, + {"RS Sampler", "RS Sampler", "RS Sampler", "RS Sampler"}, + {"RS Script", "RS Script", "RS Script", "RS Script"}, + + // Deprecated + {"RS Mesh", "RS Mesh", "RS Mesh", "RS Mesh"}, + {"RS Program Fragment", "RS Program Fragment", "RS Program Fragment", + "RS Program Fragment"}, + {"RS Program Vertex", "RS Program Vertex", "RS Program Vertex", + "RS Program Vertex"}, + {"RS Program Raster", "RS Program Raster", "RS Program Raster", + "RS Program Raster"}, + {"RS Program Store", "RS Program Store", "RS Program Store", + "RS Program Store"}, + {"RS Font", "RS Font", "RS Font", "RS Font"}}; + +// Used as an index into the RSTypeToFormat array elements +enum TypeToFormatIndex { eFormatSingle = 0, eFormatVector, eElementSize }; + +// { format enum of single element, format enum of element vector, size of +// element} +const uint32_t RenderScriptRuntime::AllocationDetails::RSTypeToFormat[][3] = { + // RS_TYPE_NONE + {eFormatHex, eFormatHex, 1}, + // RS_TYPE_FLOAT_16 + {eFormatFloat, eFormatVectorOfFloat16, 2}, + // RS_TYPE_FLOAT_32 + {eFormatFloat, eFormatVectorOfFloat32, sizeof(float)}, + // RS_TYPE_FLOAT_64 + {eFormatFloat, eFormatVectorOfFloat64, sizeof(double)}, + // RS_TYPE_SIGNED_8 + {eFormatDecimal, eFormatVectorOfSInt8, sizeof(int8_t)}, + // RS_TYPE_SIGNED_16 + {eFormatDecimal, eFormatVectorOfSInt16, sizeof(int16_t)}, + // RS_TYPE_SIGNED_32 + {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)}, + // RS_TYPE_SIGNED_64 + {eFormatDecimal, eFormatVectorOfSInt64, sizeof(int64_t)}, + // RS_TYPE_UNSIGNED_8 + {eFormatDecimal, eFormatVectorOfUInt8, sizeof(uint8_t)}, + // RS_TYPE_UNSIGNED_16 + {eFormatDecimal, eFormatVectorOfUInt16, sizeof(uint16_t)}, + // RS_TYPE_UNSIGNED_32 + {eFormatDecimal, eFormatVectorOfUInt32, sizeof(uint32_t)}, + // RS_TYPE_UNSIGNED_64 + {eFormatDecimal, eFormatVectorOfUInt64, sizeof(uint64_t)}, + // RS_TYPE_BOOL + {eFormatBoolean, eFormatBoolean, 1}, + // RS_TYPE_UNSIGNED_5_6_5 + {eFormatHex, eFormatHex, sizeof(uint16_t)}, + // RS_TYPE_UNSIGNED_5_5_5_1 + {eFormatHex, eFormatHex, sizeof(uint16_t)}, + // RS_TYPE_UNSIGNED_4_4_4_4 + {eFormatHex, eFormatHex, sizeof(uint16_t)}, + // RS_TYPE_MATRIX_4X4 + {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 16}, + // RS_TYPE_MATRIX_3X3 + {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 9}, + // RS_TYPE_MATRIX_2X2 + {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 4}}; + +// Static Functions +LanguageRuntime * +RenderScriptRuntime::CreateInstance(Process *process, + lldb::LanguageType language) { + + if (language == eLanguageTypeExtRenderScript) + return new RenderScriptRuntime(process); + else + return nullptr; +} + +// Callback with a module to search for matching symbols. We first check that +// the module contains RS kernels. Then look for a symbol which matches our +// kernel name. The breakpoint address is finally set using the address of this +// symbol. +Searcher::CallbackReturn +RSBreakpointResolver::SearchCallback(SearchFilter &filter, + SymbolContext &context, Address *) { + ModuleSP module = context.module_sp; + + if (!module || !IsRenderScriptScriptModule(module)) + return Searcher::eCallbackReturnContinue; + + // Attempt to set a breakpoint on the kernel name symbol within the module + // library. If it's not found, it's likely debug info is unavailable - try to + // set a breakpoint on <name>.expand. + const Symbol *kernel_sym = + module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode); + if (!kernel_sym) { + std::string kernel_name_expanded(m_kernel_name.AsCString()); + kernel_name_expanded.append(".expand"); + kernel_sym = module->FindFirstSymbolWithNameAndType( + ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode); + } + + if (kernel_sym) { + Address bp_addr = kernel_sym->GetAddress(); + if (filter.AddressPasses(bp_addr)) + m_breakpoint->AddLocation(bp_addr); + } + + return Searcher::eCallbackReturnContinue; +} + +Searcher::CallbackReturn +RSReduceBreakpointResolver::SearchCallback(lldb_private::SearchFilter &filter, + lldb_private::SymbolContext &context, + Address *) { + // We need to have access to the list of reductions currently parsed, as + // reduce names don't actually exist as symbols in a module. They are only + // identifiable by parsing the .rs.info packet, or finding the expand symbol. + // We therefore need access to the list of parsed rs modules to properly + // resolve reduction names. + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + ModuleSP module = context.module_sp; + + if (!module || !IsRenderScriptScriptModule(module)) + return Searcher::eCallbackReturnContinue; + + if (!m_rsmodules) + return Searcher::eCallbackReturnContinue; + + for (const auto &module_desc : *m_rsmodules) { + if (module_desc->m_module != module) + continue; + + for (const auto &reduction : module_desc->m_reductions) { + if (reduction.m_reduce_name != m_reduce_name) + continue; + + std::array<std::pair<ConstString, int>, 5> funcs{ + {{reduction.m_init_name, eKernelTypeInit}, + {reduction.m_accum_name, eKernelTypeAccum}, + {reduction.m_comb_name, eKernelTypeComb}, + {reduction.m_outc_name, eKernelTypeOutC}, + {reduction.m_halter_name, eKernelTypeHalter}}}; + + for (const auto &kernel : funcs) { + // Skip constituent functions that don't match our spec + if (!(m_kernel_types & kernel.second)) + continue; + + const auto kernel_name = kernel.first; + const auto symbol = module->FindFirstSymbolWithNameAndType( + kernel_name, eSymbolTypeCode); + if (!symbol) + continue; + + auto address = symbol->GetAddress(); + if (filter.AddressPasses(address)) { + bool new_bp; + if (!SkipPrologue(module, address)) { + LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__); + } + m_breakpoint->AddLocation(address, &new_bp); + LLDB_LOGF(log, "%s: %s reduction breakpoint on %s in %s", + __FUNCTION__, new_bp ? "new" : "existing", + kernel_name.GetCString(), + address.GetModule()->GetFileSpec().GetCString()); + } + } + } + } + return eCallbackReturnContinue; +} + +Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback( + SearchFilter &filter, SymbolContext &context, Address *addr) { + + if (!m_breakpoint) + return eCallbackReturnContinue; + + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); + ModuleSP &module = context.module_sp; + + if (!module || !IsRenderScriptScriptModule(module)) + return Searcher::eCallbackReturnContinue; + + std::vector<std::string> names; + m_breakpoint->GetNames(names); + if (names.empty()) + return eCallbackReturnContinue; + + for (auto &name : names) { + const RSScriptGroupDescriptorSP sg = FindScriptGroup(ConstString(name)); + if (!sg) { + LLDB_LOGF(log, "%s: could not find script group for %s", __FUNCTION__, + name.c_str()); + continue; + } + + LLDB_LOGF(log, "%s: Found ScriptGroup for %s", __FUNCTION__, name.c_str()); + + for (const RSScriptGroupDescriptor::Kernel &k : sg->m_kernels) { + if (log) { + LLDB_LOGF(log, "%s: Adding breakpoint for %s", __FUNCTION__, + k.m_name.AsCString()); + LLDB_LOGF(log, "%s: Kernel address 0x%" PRIx64, __FUNCTION__, k.m_addr); + } + + const lldb_private::Symbol *sym = + module->FindFirstSymbolWithNameAndType(k.m_name, eSymbolTypeCode); + if (!sym) { + LLDB_LOGF(log, "%s: Unable to find symbol for %s", __FUNCTION__, + k.m_name.AsCString()); + continue; + } + + if (log) { + LLDB_LOGF(log, "%s: Found symbol name is %s", __FUNCTION__, + sym->GetName().AsCString()); + } + + auto address = sym->GetAddress(); + if (!SkipPrologue(module, address)) { + LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__); + } + + bool new_bp; + m_breakpoint->AddLocation(address, &new_bp); + + LLDB_LOGF(log, "%s: Placed %sbreakpoint on %s", __FUNCTION__, + new_bp ? "new " : "", k.m_name.AsCString()); + + // exit after placing the first breakpoint if we do not intend to stop on + // all kernels making up this script group + if (!m_stop_on_all) + break; + } + } + + return eCallbackReturnContinue; +} + +void RenderScriptRuntime::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), + "RenderScript language support", CreateInstance, + GetCommandObject); +} + +void RenderScriptRuntime::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} + +lldb_private::ConstString RenderScriptRuntime::GetPluginNameStatic() { + static ConstString plugin_name("renderscript"); + return plugin_name; +} + +RenderScriptRuntime::ModuleKind +RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp) { + if (module_sp) { + if (IsRenderScriptScriptModule(module_sp)) + 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) { + std::lock_guard<std::recursive_mutex> guard(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::GetDynamicTypeAndAddress( + ValueObject &in_value, lldb::DynamicValueType use_dynamic, + TypeAndOrName &class_type_or_name, Address &address, + Value::ValueType &value_type) { + return false; +} + +TypeAndOrName +RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name, + ValueObject &static_value) { + return type_and_or_name; +} + +bool RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value) { + return false; +} + +lldb::BreakpointResolverSP +RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bp, bool catch_bp, + bool throw_bp) { + BreakpointResolverSP resolver_sp; + return resolver_sp; +} + +const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] = + { + // rsdScript + {"rsdScriptInit", "_Z13rsdScriptInitPKN7android12renderscript7ContextEP" + "NS0_7ScriptCEPKcS7_PKhjj", + "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_" + "7ScriptCEPKcS7_PKhmj", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureScriptInit}, + {"rsdScriptInvokeForEachMulti", + "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0" + "_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall", + "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0" + "_6ScriptEjPPKNS0_10AllocationEmPS6_PKvmPK12RsScriptCall", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureScriptInvokeForEachMulti}, + {"rsdScriptSetGlobalVar", "_Z21rsdScriptSetGlobalVarPKN7android12render" + "script7ContextEPKNS0_6ScriptEjPvj", + "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_" + "6ScriptEjPvm", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar}, + + // rsdAllocation + {"rsdAllocationInit", "_Z17rsdAllocationInitPKN7android12renderscript7C" + "ontextEPNS0_10AllocationEb", + "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_" + "10AllocationEb", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureAllocationInit}, + {"rsdAllocationRead2D", + "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_" + "10AllocationEjjj23RsAllocationCubemapFacejjPvjj", + "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_" + "10AllocationEjjj23RsAllocationCubemapFacejjPvmm", + 0, RenderScriptRuntime::eModuleKindDriver, nullptr}, + {"rsdAllocationDestroy", "_Z20rsdAllocationDestroyPKN7android12rendersc" + "ript7ContextEPNS0_10AllocationE", + "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_" + "10AllocationE", + 0, RenderScriptRuntime::eModuleKindDriver, + &lldb_private::RenderScriptRuntime::CaptureAllocationDestroy}, + + // renderscript script groups + {"rsdDebugHintScriptGroup2", "_ZN7android12renderscript21debugHintScrip" + "tGroup2EPKcjPKPFvPK24RsExpandKernelDriver" + "InfojjjEj", + "_ZN7android12renderscript21debugHintScriptGroup2EPKcjPKPFvPK24RsExpan" + "dKernelDriverInfojjjEj", + 0, RenderScriptRuntime::eModuleKindImpl, + &lldb_private::RenderScriptRuntime::CaptureDebugHintScriptGroup2}}; + +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 = (RuntimeHook *)baton; + ExecutionContext exe_ctx(ctx->exe_ctx_ref); + + RenderScriptRuntime *lang_rt = llvm::cast<RenderScriptRuntime>( + exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + lang_rt->HookCallback(hook, exe_ctx); + + return false; +} + +void RenderScriptRuntime::HookCallback(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + LLDB_LOGF(log, "%s - '%s'", __FUNCTION__, hook->defn->name); + + if (hook->defn->grabber) { + (this->*(hook->defn->grabber))(hook, exe_ctx); + } +} + +void RenderScriptRuntime::CaptureDebugHintScriptGroup2( + RuntimeHook *hook_info, ExecutionContext &context) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eGroupName = 0, + eGroupNameSize, + eKernel, + eKernelCount, + }; + + std::array<ArgItem, 4> args{{ + {ArgItem::ePointer, 0}, // const char *groupName + {ArgItem::eInt32, 0}, // const uint32_t groupNameSize + {ArgItem::ePointer, 0}, // const ExpandFuncTy *kernel + {ArgItem::eInt32, 0}, // const uint32_t kernelCount + }}; + + if (!GetArgs(context, args.data(), args.size())) { + LLDB_LOGF(log, "%s - Error while reading the function parameters", + __FUNCTION__); + return; + } else if (log) { + LLDB_LOGF(log, "%s - groupName : 0x%" PRIx64, __FUNCTION__, + addr_t(args[eGroupName])); + LLDB_LOGF(log, "%s - groupNameSize: %" PRIu64, __FUNCTION__, + uint64_t(args[eGroupNameSize])); + LLDB_LOGF(log, "%s - kernel : 0x%" PRIx64, __FUNCTION__, + addr_t(args[eKernel])); + LLDB_LOGF(log, "%s - kernelCount : %" PRIu64, __FUNCTION__, + uint64_t(args[eKernelCount])); + } + + // parse script group name + ConstString group_name; + { + Status err; + const uint64_t len = uint64_t(args[eGroupNameSize]); + std::unique_ptr<char[]> buffer(new char[uint32_t(len + 1)]); + m_process->ReadMemory(addr_t(args[eGroupName]), buffer.get(), len, err); + buffer.get()[len] = '\0'; + if (!err.Success()) { + LLDB_LOGF(log, "Error reading scriptgroup name from target"); + return; + } else { + LLDB_LOGF(log, "Extracted scriptgroup name %s", buffer.get()); + } + // write back the script group name + group_name.SetCString(buffer.get()); + } + + // create or access existing script group + RSScriptGroupDescriptorSP group; + { + // search for existing script group + for (auto sg : m_scriptGroups) { + if (sg->m_name == group_name) { + group = sg; + break; + } + } + if (!group) { + group = std::make_shared<RSScriptGroupDescriptor>(); + group->m_name = group_name; + m_scriptGroups.push_back(group); + } else { + // already have this script group + LLDB_LOGF(log, "Attempt to add duplicate script group %s", + group_name.AsCString()); + return; + } + } + assert(group); + + const uint32_t target_ptr_size = m_process->GetAddressByteSize(); + std::vector<addr_t> kernels; + // parse kernel addresses in script group + for (uint64_t i = 0; i < uint64_t(args[eKernelCount]); ++i) { + RSScriptGroupDescriptor::Kernel kernel; + // extract script group kernel addresses from the target + const addr_t ptr_addr = addr_t(args[eKernel]) + i * target_ptr_size; + uint64_t kernel_addr = 0; + Status err; + size_t read = + m_process->ReadMemory(ptr_addr, &kernel_addr, target_ptr_size, err); + if (!err.Success() || read != target_ptr_size) { + LLDB_LOGF(log, "Error parsing kernel address %" PRIu64 " in script group", + i); + return; + } + LLDB_LOGF(log, "Extracted scriptgroup kernel address - 0x%" PRIx64, + kernel_addr); + kernel.m_addr = kernel_addr; + + // try to resolve the associated kernel name + if (!ResolveKernelName(kernel.m_addr, kernel.m_name)) { + LLDB_LOGF(log, "Parsed scriptgroup kernel %" PRIu64 " - 0x%" PRIx64, i, + kernel_addr); + return; + } + + // try to find the non '.expand' function + { + const llvm::StringRef expand(".expand"); + const llvm::StringRef name_ref = kernel.m_name.GetStringRef(); + if (name_ref.endswith(expand)) { + const ConstString base_kernel(name_ref.drop_back(expand.size())); + // verify this function is a valid kernel + if (IsKnownKernel(base_kernel)) { + kernel.m_name = base_kernel; + LLDB_LOGF(log, "%s - found non expand version '%s'", __FUNCTION__, + base_kernel.GetCString()); + } + } + } + // add to a list of script group kernels we know about + group->m_kernels.push_back(kernel); + } + + // Resolve any pending scriptgroup breakpoints + { + Target &target = m_process->GetTarget(); + const BreakpointList &list = target.GetBreakpointList(); + const size_t num_breakpoints = list.GetSize(); + LLDB_LOGF(log, "Resolving %zu breakpoints", num_breakpoints); + for (size_t i = 0; i < num_breakpoints; ++i) { + const BreakpointSP bp = list.GetBreakpointAtIndex(i); + if (bp) { + if (bp->MatchesName(group_name.AsCString())) { + LLDB_LOGF(log, "Found breakpoint with name %s", + group_name.AsCString()); + bp->ResolveBreakpoint(); + } + } + } + } +} + +void RenderScriptRuntime::CaptureScriptInvokeForEachMulti( + RuntimeHook *hook, ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eRsContext = 0, + eRsScript, + eRsSlot, + eRsAIns, + eRsInLen, + eRsAOut, + eRsUsr, + eRsUsrLen, + eRsSc, + }; + + std::array<ArgItem, 9> args{{ + ArgItem{ArgItem::ePointer, 0}, // const Context *rsc + ArgItem{ArgItem::ePointer, 0}, // Script *s + ArgItem{ArgItem::eInt32, 0}, // uint32_t slot + ArgItem{ArgItem::ePointer, 0}, // const Allocation **aIns + ArgItem{ArgItem::eInt32, 0}, // size_t inLen + ArgItem{ArgItem::ePointer, 0}, // Allocation *aout + ArgItem{ArgItem::ePointer, 0}, // const void *usr + ArgItem{ArgItem::eInt32, 0}, // size_t usrLen + ArgItem{ArgItem::ePointer, 0}, // const RsScriptCall *sc + }}; + + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - Error while reading the function parameters", + __FUNCTION__); + return; + } + + const uint32_t target_ptr_size = m_process->GetAddressByteSize(); + Status err; + std::vector<uint64_t> allocs; + + // traverse allocation list + for (uint64_t i = 0; i < uint64_t(args[eRsInLen]); ++i) { + // calculate offest to allocation pointer + const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size; + + // Note: due to little endian layout, reading 32bits or 64bits into res + // will give the correct results. + uint64_t result = 0; + size_t read = m_process->ReadMemory(addr, &result, target_ptr_size, err); + if (read != target_ptr_size || !err.Success()) { + LLDB_LOGF(log, + "%s - Error while reading allocation list argument %" PRIu64, + __FUNCTION__, i); + } else { + allocs.push_back(result); + } + } + + // if there is an output allocation track it + if (uint64_t alloc_out = uint64_t(args[eRsAOut])) { + allocs.push_back(alloc_out); + } + + // for all allocations we have found + for (const uint64_t alloc_addr : allocs) { + AllocationDetails *alloc = LookUpAllocation(alloc_addr); + if (!alloc) + alloc = CreateAllocation(alloc_addr); + + if (alloc) { + // save the allocation address + if (alloc->address.isValid()) { + // check the allocation address we already have matches + assert(*alloc->address.get() == alloc_addr); + } else { + alloc->address = alloc_addr; + } + + // save the context + if (log) { + if (alloc->context.isValid() && + *alloc->context.get() != addr_t(args[eRsContext])) + LLDB_LOGF(log, "%s - Allocation used by multiple contexts", + __FUNCTION__); + } + alloc->context = addr_t(args[eRsContext]); + } + } + + // make sure we track this script object + if (lldb_private::RenderScriptRuntime::ScriptDetails *script = + LookUpScript(addr_t(args[eRsScript]), true)) { + if (log) { + if (script->context.isValid() && + *script->context.get() != addr_t(args[eRsContext])) + LLDB_LOGF(log, "%s - Script used by multiple contexts", __FUNCTION__); + } + script->context = addr_t(args[eRsContext]); + } +} + +void RenderScriptRuntime::CaptureSetGlobalVar(RuntimeHook *hook, + ExecutionContext &context) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eRsContext, + eRsScript, + eRsId, + eRsData, + eRsLength, + }; + + std::array<ArgItem, 5> args{{ + ArgItem{ArgItem::ePointer, 0}, // eRsContext + ArgItem{ArgItem::ePointer, 0}, // eRsScript + ArgItem{ArgItem::eInt32, 0}, // eRsId + ArgItem{ArgItem::ePointer, 0}, // eRsData + ArgItem{ArgItem::eInt32, 0}, // eRsLength + }}; + + bool success = GetArgs(context, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error reading the function parameters.", __FUNCTION__); + return; + } + + if (log) { + LLDB_LOGF(log, + "%s - 0x%" PRIx64 ",0x%" PRIx64 " slot %" PRIu64 " = 0x%" PRIx64 + ":%" PRIu64 "bytes.", + __FUNCTION__, uint64_t(args[eRsContext]), + uint64_t(args[eRsScript]), uint64_t(args[eRsId]), + uint64_t(args[eRsData]), uint64_t(args[eRsLength])); + + addr_t script_addr = addr_t(args[eRsScript]); + if (m_scriptMappings.find(script_addr) != m_scriptMappings.end()) { + auto rsm = m_scriptMappings[script_addr]; + if (uint64_t(args[eRsId]) < rsm->m_globals.size()) { + auto rsg = rsm->m_globals[uint64_t(args[eRsId])]; + LLDB_LOGF(log, "%s - Setting of '%s' within '%s' inferred", + __FUNCTION__, rsg.m_name.AsCString(), + rsm->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + } +} + +void RenderScriptRuntime::CaptureAllocationInit(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { eRsContext, eRsAlloc, eRsForceZero }; + + std::array<ArgItem, 3> args{{ + ArgItem{ArgItem::ePointer, 0}, // eRsContext + ArgItem{ArgItem::ePointer, 0}, // eRsAlloc + ArgItem{ArgItem::eBool, 0}, // eRsForceZero + }}; + + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error while reading the function parameters", + __FUNCTION__); + return; + } + + LLDB_LOGF(log, "%s - 0x%" PRIx64 ",0x%" PRIx64 ",0x%" PRIx64 " .", + __FUNCTION__, uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc]), + uint64_t(args[eRsForceZero])); + + AllocationDetails *alloc = CreateAllocation(uint64_t(args[eRsAlloc])); + if (alloc) + alloc->context = uint64_t(args[eRsContext]); +} + +void RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + enum { + eRsContext, + eRsAlloc, + }; + + std::array<ArgItem, 2> args{{ + ArgItem{ArgItem::ePointer, 0}, // eRsContext + ArgItem{ArgItem::ePointer, 0}, // eRsAlloc + }}; + + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error while reading the function parameters.", + __FUNCTION__); + return; + } + + LLDB_LOGF(log, "%s - 0x%" PRIx64 ", 0x%" PRIx64 ".", __FUNCTION__, + uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc])); + + for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter) { + auto &allocation_up = *iter; // get the unique pointer + if (allocation_up->address.isValid() && + *allocation_up->address.get() == addr_t(args[eRsAlloc])) { + m_allocations.erase(iter); + LLDB_LOGF(log, "%s - deleted allocation entry.", __FUNCTION__); + return; + } + } + + LLDB_LOGF(log, "%s - couldn't find destroyed allocation.", __FUNCTION__); +} + +void RenderScriptRuntime::CaptureScriptInit(RuntimeHook *hook, + ExecutionContext &exe_ctx) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + Status err; + Process *process = exe_ctx.GetProcessPtr(); + + enum { eRsContext, eRsScript, eRsResNamePtr, eRsCachedDirPtr }; + + std::array<ArgItem, 4> args{ + {ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}, + ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}}}; + bool success = GetArgs(exe_ctx, &args[0], args.size()); + if (!success) { + LLDB_LOGF(log, "%s - error while reading the function parameters.", + __FUNCTION__); + return; + } + + std::string res_name; + process->ReadCStringFromMemory(addr_t(args[eRsResNamePtr]), res_name, err); + if (err.Fail()) { + LLDB_LOGF(log, "%s - error reading res_name: %s.", __FUNCTION__, + err.AsCString()); + } + + std::string cache_dir; + process->ReadCStringFromMemory(addr_t(args[eRsCachedDirPtr]), cache_dir, err); + if (err.Fail()) { + LLDB_LOGF(log, "%s - error reading cache_dir: %s.", __FUNCTION__, + err.AsCString()); + } + + LLDB_LOGF(log, "%s - 0x%" PRIx64 ",0x%" PRIx64 " => '%s' at '%s' .", + __FUNCTION__, uint64_t(args[eRsContext]), uint64_t(args[eRsScript]), + res_name.c_str(), cache_dir.c_str()); + + if (res_name.size() > 0) { + StreamString strm; + strm.Printf("librs.%s.so", res_name.c_str()); + + ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true); + if (script) { + script->type = ScriptDetails::eScriptC; + script->cache_dir = cache_dir; + script->res_name = res_name; + script->shared_lib = strm.GetString(); + script->context = addr_t(args[eRsContext]); + } + + LLDB_LOGF(log, + "%s - '%s' tagged with context 0x%" PRIx64 + " and script 0x%" PRIx64 ".", + __FUNCTION__, strm.GetData(), uint64_t(args[eRsContext]), + uint64_t(args[eRsScript])); + } else if (log) { + LLDB_LOGF(log, "%s - resource name invalid, Script not tagged.", + __FUNCTION__); + } +} + +void RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module, + ModuleKind kind) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!module) { + return; + } + + Target &target = GetProcess()->GetTarget(); + const llvm::Triple::ArchType machine = target.GetArchitecture().GetMachine(); + + if (machine != llvm::Triple::ArchType::x86 && + machine != llvm::Triple::ArchType::arm && + machine != llvm::Triple::ArchType::aarch64 && + machine != llvm::Triple::ArchType::mipsel && + machine != llvm::Triple::ArchType::mips64el && + machine != llvm::Triple::ArchType::x86_64) { + LLDB_LOGF(log, "%s - unable to hook runtime functions.", __FUNCTION__); + return; + } + + const uint32_t target_ptr_size = + target.GetArchitecture().GetAddressByteSize(); + + std::array<bool, s_runtimeHookCount> hook_placed; + hook_placed.fill(false); + + for (size_t idx = 0; idx < s_runtimeHookCount; idx++) { + const HookDefn *hook_defn = &s_runtimeHookDefns[idx]; + if (hook_defn->kind != kind) { + continue; + } + + const char *symbol_name = (target_ptr_size == 4) + ? hook_defn->symbol_name_m32 + : hook_defn->symbol_name_m64; + + const Symbol *sym = module->FindFirstSymbolWithNameAndType( + ConstString(symbol_name), eSymbolTypeCode); + if (!sym) { + if (log) { + LLDB_LOGF(log, "%s - symbol '%s' related to the function %s not found", + __FUNCTION__, symbol_name, hook_defn->name); + } + continue; + } + + addr_t addr = sym->GetLoadAddress(&target); + if (addr == LLDB_INVALID_ADDRESS) { + LLDB_LOGF(log, + "%s - unable to resolve the address of hook function '%s' " + "with symbol '%s'.", + __FUNCTION__, hook_defn->name, symbol_name); + continue; + } else { + LLDB_LOGF(log, "%s - function %s, address resolved at 0x%" PRIx64, + __FUNCTION__, hook_defn->name, addr); + } + + 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) { + LLDB_LOGF(log, + "%s - successfully hooked '%s' in '%s' version %" PRIu64 + " at 0x%" PRIx64 ".", + __FUNCTION__, hook_defn->name, + module->GetFileSpec().GetFilename().AsCString(), + (uint64_t)hook_defn->version, (uint64_t)addr); + } + hook_placed[idx] = true; + } + + // log any unhooked function + if (log) { + for (size_t i = 0; i < hook_placed.size(); ++i) { + if (hook_placed[i]) + continue; + const HookDefn &hook_defn = s_runtimeHookDefns[i]; + if (hook_defn.kind != kind) + continue; + LLDB_LOGF(log, "%s - function %s was not hooked", __FUNCTION__, + hook_defn.name); + } + } +} + +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(); + + // Iterate over all of the scripts that we currently know of. Note: We cant + // push or pop to m_scripts here or it may invalidate rs_script. + for (const auto &rs_script : m_scripts) { + // Extract the expected .so file path for this script. + std::string shared_lib; + if (!rs_script->shared_lib.get(shared_lib)) + continue; + + // Only proceed if the module that has loaded corresponds to this script. + if (file.GetFilename() != ConstString(shared_lib.c_str())) + continue; + + // Obtain the script address which we use as a key. + lldb::addr_t script; + if (!rs_script->script.get(script)) + continue; + + // If we have a script mapping for the current script. + if (m_scriptMappings.find(script) != m_scriptMappings.end()) { + // if the module we have stored is different to the one we just received. + if (m_scriptMappings[script] != rsmodule_sp) { + LLDB_LOGF( + log, + "%s - script %" PRIx64 " wants reassigned to new rsmodule '%s'.", + __FUNCTION__, (uint64_t)script, + rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString()); + } + } + // We don't have a script mapping for the current script. + else { + // Obtain the script resource name. + std::string res_name; + if (rs_script->res_name.get(res_name)) + // Set the modules resource name. + rsmodule_sp->m_resname = res_name; + // Add Script/Module pair to map. + m_scriptMappings[script] = rsmodule_sp; + LLDB_LOGF(log, "%s - script %" PRIx64 " associated with rsmodule '%s'.", + __FUNCTION__, (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* parameter. Function returns true on success, and false on +// failure +bool RenderScriptRuntime::EvalRSExpression(const char *expr, + StackFrame *frame_ptr, + uint64_t *result) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + LLDB_LOGF(log, "%s(%s)", __FUNCTION__, expr); + + ValueObjectSP expr_result; + EvaluateExpressionOptions options; + options.SetLanguage(lldb::eLanguageTypeC_plus_plus); + // Perform the actual expression evaluation + auto &target = GetProcess()->GetTarget(); + target.EvaluateExpression(expr, frame_ptr, expr_result, options); + + if (!expr_result) { + LLDB_LOGF(log, "%s: couldn't evaluate expression.", __FUNCTION__); + return false; + } + + // The result of the expression is invalid + if (!expr_result->GetError().Success()) { + Status err = expr_result->GetError(); + // Expression returned is void, so this is actually a success + if (err.GetError() == UserExpression::kNoResult) { + LLDB_LOGF(log, "%s - expression returned void.", __FUNCTION__); + + result = nullptr; + return true; + } + + LLDB_LOGF(log, "%s - error evaluating expression result: %s", __FUNCTION__, + err.AsCString()); + return false; + } + + bool success = false; + // We only read the result as an uint32_t. + *result = expr_result->GetValueAsUnsigned(0, &success); + + if (!success) { + LLDB_LOGF(log, "%s - couldn't convert expression result to uint32_t", + __FUNCTION__); + return false; + } + + return true; +} + +namespace { +// Used to index expression format strings +enum ExpressionStrings { + eExprGetOffsetPtr = 0, + eExprAllocGetType, + eExprTypeDimX, + eExprTypeDimY, + eExprTypeDimZ, + eExprTypeElemPtr, + eExprElementType, + eExprElementKind, + eExprElementVec, + eExprElementFieldCount, + eExprSubelementsId, + eExprSubelementsName, + eExprSubelementsArrSize, + + _eExprLast // keep at the end, implicit size of the array runtime_expressions +}; + +// max length of an expanded expression +const int jit_max_expr_size = 512; + +// Retrieve the string to JIT for the given expression +#define JIT_TEMPLATE_CONTEXT "void* ctxt = (void*)rsDebugGetContextWrapper(0x%" PRIx64 "); " +const char *JITTemplate(ExpressionStrings e) { + // Format strings containing the expressions we may need to evaluate. + static std::array<const char *, _eExprLast> runtime_expressions = { + {// Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap) + "(int*)_" + "Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocation" + "CubemapFace" + "(0x%" PRIx64 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", 0, 0)", // eExprGetOffsetPtr + + // Type* rsaAllocationGetType(Context*, Allocation*) + JIT_TEMPLATE_CONTEXT "(void*)rsaAllocationGetType(ctxt, 0x%" PRIx64 ")", // eExprAllocGetType + + // 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 + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[0]", // eExprTypeDimX + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[1]", // eExprTypeDimY + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[2]", // eExprTypeDimZ + JIT_TEMPLATE_CONTEXT + "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 6); data[5]", // eExprTypeElemPtr + + // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size) + // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into + // elemData + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[0]", // eExprElementType + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[1]", // eExprElementKind + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[3]", // eExprElementVec + JIT_TEMPLATE_CONTEXT + "uint32_t data[5]; (void*)rsaElementGetNativeData(ctxt" + ", 0x%" PRIx64 ", data, 5); data[4]", // eExprElementFieldCount + + // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t + // *ids, const char **names, size_t *arraySizes, uint32_t dataSize) + // Needed for Allocations of structs to gather details about + // fields/Subelements Element* of field + JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 + "]; size_t arr_size[%" PRIu32 "];" + "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64 + ", ids, names, arr_size, %" PRIu32 "); ids[%" PRIu32 "]", // eExprSubelementsId + + // Name of field + JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 + "]; size_t arr_size[%" PRIu32 "];" + "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64 + ", ids, names, arr_size, %" PRIu32 "); names[%" PRIu32 "]", // eExprSubelementsName + + // Array size of field + JIT_TEMPLATE_CONTEXT "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 + "]; size_t arr_size[%" PRIu32 "];" + "(void*)rsaElementGetSubElements(ctxt, 0x%" PRIx64 + ", ids, names, arr_size, %" PRIu32 "); arr_size[%" PRIu32 "]"}}; // eExprSubelementsArrSize + + return runtime_expressions[e]; +} +} // end of the anonymous namespace + +// 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 *alloc, + StackFrame *frame_ptr, uint32_t x, + uint32_t y, uint32_t z) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const char *fmt_str = JITTemplate(eExprGetOffsetPtr); + char expr_buf[jit_max_expr_size]; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->address.get(), x, y, z); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t data_ptr = static_cast<lldb::addr_t>(result); + alloc->data_ptr = data_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 *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid() || !alloc->context.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const char *fmt_str = JITTemplate(eExprAllocGetType); + char expr_buf[jit_max_expr_size]; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->context.get(), *alloc->address.get()); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t type_ptr = static_cast<lldb::addr_t>(result); + alloc->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 *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->type_ptr.isValid() || !alloc->context.isValid()) { + LLDB_LOGF(log, "%s - Failed to find allocation details.", __FUNCTION__); + return false; + } + + // Expression is different depending on if device is 32 or 64 bit + uint32_t target_ptr_size = + GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize(); + const uint32_t bits = target_ptr_size == 4 ? 32 : 64; + + // We want 4 elements from packed data + const uint32_t num_exprs = 4; + static_assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1), + "Invalid number of expressions"); + + char expr_bufs[num_exprs][jit_max_expr_size]; + uint64_t results[num_exprs]; + + for (uint32_t i = 0; i < num_exprs; ++i) { + const char *fmt_str = JITTemplate(ExpressionStrings(eExprTypeDimX + i)); + int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, + *alloc->context.get(), bits, *alloc->type_ptr.get()); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + // Perform expression evaluation + if (!EvalRSExpression(expr_bufs[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]); + alloc->dimension = dims; + + addr_t element_ptr = static_cast<lldb::addr_t>(results[3]); + alloc->element.element_ptr = element_ptr; + + LLDB_LOGF(log, + "%s - dims (%" PRIu32 ", %" PRIu32 ", %" PRIu32 + ") Element*: 0x%" PRIx64 ".", + __FUNCTION__, dims.dim_1, dims.dim_2, dims.dim_3, element_ptr); + + return true; +} + +// JITs the RS runtime for information about the Element of an allocation Then +// sets type, type_vec_size, field_count and type_kind members in Element with +// the result. Returns true on success, false otherwise +bool RenderScriptRuntime::JITElementPacked(Element &elem, + const lldb::addr_t context, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!elem.element_ptr.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + // We want 4 elements from packed data + const uint32_t num_exprs = 4; + static_assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1), + "Invalid number of expressions"); + + char expr_bufs[num_exprs][jit_max_expr_size]; + uint64_t results[num_exprs]; + + for (uint32_t i = 0; i < num_exprs; i++) { + const char *fmt_str = JITTemplate(ExpressionStrings(eExprElementType + i)); + int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, context, + *elem.element_ptr.get()); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + // Perform expression evaluation + if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i])) + return false; + } + + // Assign results to allocation members + elem.type = static_cast<RenderScriptRuntime::Element::DataType>(results[0]); + elem.type_kind = + static_cast<RenderScriptRuntime::Element::DataKind>(results[1]); + elem.type_vec_size = static_cast<uint32_t>(results[2]); + elem.field_count = static_cast<uint32_t>(results[3]); + + LLDB_LOGF(log, + "%s - data type %" PRIu32 ", pixel type %" PRIu32 + ", vector size %" PRIu32 ", field count %" PRIu32, + __FUNCTION__, *elem.type.get(), *elem.type_kind.get(), + *elem.type_vec_size.get(), *elem.field_count.get()); + + // If this Element has subelements then JIT rsaElementGetSubElements() for + // details about its fields + return !(*elem.field_count.get() > 0 && + !JITSubelements(elem, context, frame_ptr)); +} + +// JITs the RS runtime for information about the subelements/fields of a struct +// allocation This is necessary for infering the struct type so we can pretty +// print the allocation's contents. Returns true on success, false otherwise +bool RenderScriptRuntime::JITSubelements(Element &elem, + const lldb::addr_t context, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!elem.element_ptr.isValid() || !elem.field_count.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const short num_exprs = 3; + static_assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1), + "Invalid number of expressions"); + + char expr_buffer[jit_max_expr_size]; + uint64_t results; + + // Iterate over struct fields. + const uint32_t field_count = *elem.field_count.get(); + for (uint32_t field_index = 0; field_index < field_count; ++field_index) { + Element child; + for (uint32_t expr_index = 0; expr_index < num_exprs; ++expr_index) { + const char *fmt_str = + JITTemplate(ExpressionStrings(eExprSubelementsId + expr_index)); + int written = snprintf(expr_buffer, jit_max_expr_size, fmt_str, + context, field_count, field_count, field_count, + *elem.element_ptr.get(), field_count, field_index); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + // Perform expression evaluation + if (!EvalRSExpression(expr_buffer, frame_ptr, &results)) + return false; + + LLDB_LOGF(log, "%s - expr result 0x%" PRIx64 ".", __FUNCTION__, results); + + switch (expr_index) { + case 0: // Element* of child + child.element_ptr = static_cast<addr_t>(results); + break; + case 1: // Name of child + { + lldb::addr_t address = static_cast<addr_t>(results); + Status err; + std::string name; + GetProcess()->ReadCStringFromMemory(address, name, err); + if (!err.Fail()) + child.type_name = ConstString(name); + else { + LLDB_LOGF(log, "%s - warning: Couldn't read field name.", + __FUNCTION__); + } + break; + } + case 2: // Array size of child + child.array_size = static_cast<uint32_t>(results); + break; + } + } + + // We need to recursively JIT each Element field of the struct since + // structs can be nested inside structs. + if (!JITElementPacked(child, context, frame_ptr)) + return false; + elem.children.push_back(child); + } + + // Try to infer the name of the struct type so we can pretty print the + // allocation contents. + FindStructTypeName(elem, frame_ptr); + + return true; +} + +// JITs the RS runtime for the address of the last element in the allocation. +// The `elem_size` parameter represents the size of a single element, including +// padding. Which is needed as an offset from the last element pointer. Using +// this offset minus the starting address we can calculate the size of the +// allocation. Returns true on success, false otherwise +bool RenderScriptRuntime::JITAllocationSize(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid() || !alloc->dimension.isValid() || + !alloc->data_ptr.isValid() || !alloc->element.datum_size.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + // Find dimensions + uint32_t dim_x = alloc->dimension.get()->dim_1; + uint32_t dim_y = alloc->dimension.get()->dim_2; + uint32_t dim_z = alloc->dimension.get()->dim_3; + + // Our plan of jitting the last element address doesn't seem to work for + // struct Allocations` Instead try to infer the size ourselves without any + // inter element padding. + if (alloc->element.children.size() > 0) { + if (dim_x == 0) + dim_x = 1; + if (dim_y == 0) + dim_y = 1; + if (dim_z == 0) + dim_z = 1; + + alloc->size = dim_x * dim_y * dim_z * *alloc->element.datum_size.get(); + + LLDB_LOGF(log, "%s - inferred size of struct allocation %" PRIu32 ".", + __FUNCTION__, *alloc->size.get()); + return true; + } + + const char *fmt_str = JITTemplate(eExprGetOffsetPtr); + char expr_buf[jit_max_expr_size]; + + // Calculate last element + dim_x = dim_x == 0 ? 0 : dim_x - 1; + dim_y = dim_y == 0 ? 0 : dim_y - 1; + dim_z = dim_z == 0 ? 0 : dim_z - 1; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->address.get(), dim_x, dim_y, dim_z); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t mem_ptr = static_cast<lldb::addr_t>(result); + // Find pointer to last element and add on size of an element + alloc->size = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get()) + + *alloc->element.datum_size.get(); + + return true; +} + +// JITs the RS runtime for information about the stride between rows in the +// allocation. This is done to detect padding, since allocated memory is +// 16-byte aligned. Returns true on success, false otherwise +bool RenderScriptRuntime::JITAllocationStride(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!alloc->address.isValid() || !alloc->data_ptr.isValid()) { + LLDB_LOGF(log, "%s - failed to find allocation details.", __FUNCTION__); + return false; + } + + const char *fmt_str = JITTemplate(eExprGetOffsetPtr); + char expr_buf[jit_max_expr_size]; + + int written = snprintf(expr_buf, jit_max_expr_size, fmt_str, + *alloc->address.get(), 0, 1, 0); + if (written < 0) { + LLDB_LOGF(log, "%s - encoding error in snprintf().", __FUNCTION__); + return false; + } else if (written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - expression too long.", __FUNCTION__); + return false; + } + + uint64_t result = 0; + if (!EvalRSExpression(expr_buf, frame_ptr, &result)) + return false; + + addr_t mem_ptr = static_cast<lldb::addr_t>(result); + alloc->stride = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get()); + + return true; +} + +// JIT all the current runtime info regarding an allocation +bool RenderScriptRuntime::RefreshAllocation(AllocationDetails *alloc, + StackFrame *frame_ptr) { + // GetOffsetPointer() + if (!JITDataPointer(alloc, frame_ptr)) + return false; + + // rsaAllocationGetType() + if (!JITTypePointer(alloc, frame_ptr)) + return false; + + // rsaTypeGetNativeData() + if (!JITTypePacked(alloc, frame_ptr)) + return false; + + // rsaElementGetNativeData() + if (!JITElementPacked(alloc->element, *alloc->context.get(), frame_ptr)) + return false; + + // Sets the datum_size member in Element + SetElementSize(alloc->element); + + // Use GetOffsetPointer() to infer size of the allocation + return JITAllocationSize(alloc, frame_ptr); +} + +// Function attempts to set the type_name member of the paramaterised Element +// object. This string should be the name of the struct type the Element +// represents. We need this string for pretty printing the Element to users. +void RenderScriptRuntime::FindStructTypeName(Element &elem, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!elem.type_name.IsEmpty()) // Name already set + return; + else + elem.type_name = Element::GetFallbackStructName(); // Default type name if + // we don't succeed + + // Find all the global variables from the script rs modules + VariableList var_list; + for (auto module_sp : m_rsmodules) + module_sp->m_module->FindGlobalVariables( + RegularExpression(llvm::StringRef(".")), UINT32_MAX, var_list); + + // Iterate over all the global variables looking for one with a matching type + // to the Element. We make the assumption a match exists since there needs to + // be a global variable to reflect the struct type back into java host code. + for (const VariableSP &var_sp : var_list) { + if (!var_sp) + continue; + + ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp); + if (!valobj_sp) + continue; + + // Find the number of variable fields. + // If it has no fields, or more fields than our Element, then it can't be + // the struct we're looking for. Don't check for equality since RS can add + // extra struct members for padding. + size_t num_children = valobj_sp->GetNumChildren(); + if (num_children > elem.children.size() || num_children == 0) + continue; + + // Iterate over children looking for members with matching field names. If + // all the field names match, this is likely the struct we want. + // TODO: This could be made more robust by also checking children data + // sizes, or array size + bool found = true; + for (size_t i = 0; i < num_children; ++i) { + ValueObjectSP child = valobj_sp->GetChildAtIndex(i, true); + if (!child || (child->GetName() != elem.children[i].type_name)) { + found = false; + break; + } + } + + // RS can add extra struct members for padding in the format + // '#rs_padding_[0-9]+' + if (found && num_children < elem.children.size()) { + const uint32_t size_diff = elem.children.size() - num_children; + LLDB_LOGF(log, "%s - %" PRIu32 " padding struct entries", __FUNCTION__, + size_diff); + + for (uint32_t i = 0; i < size_diff; ++i) { + ConstString name = elem.children[num_children + i].type_name; + if (strcmp(name.AsCString(), "#rs_padding") < 0) + found = false; + } + } + + // We've found a global variable with matching type + if (found) { + // Dereference since our Element type isn't a pointer. + if (valobj_sp->IsPointerType()) { + Status err; + ValueObjectSP deref_valobj = valobj_sp->Dereference(err); + if (!err.Fail()) + valobj_sp = deref_valobj; + } + + // Save name of variable in Element. + elem.type_name = valobj_sp->GetTypeName(); + LLDB_LOGF(log, "%s - element name set to %s", __FUNCTION__, + elem.type_name.AsCString()); + + return; + } + } +} + +// Function sets the datum_size member of Element. Representing the size of a +// single instance including padding. Assumes the relevant allocation +// information has already been jitted. +void RenderScriptRuntime::SetElementSize(Element &elem) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + const Element::DataType type = *elem.type.get(); + assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && + "Invalid allocation type"); + + const uint32_t vec_size = *elem.type_vec_size.get(); + uint32_t data_size = 0; + uint32_t padding = 0; + + // Element is of a struct type, calculate size recursively. + if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0)) { + for (Element &child : elem.children) { + SetElementSize(child); + const uint32_t array_size = + child.array_size.isValid() ? *child.array_size.get() : 1; + data_size += *child.datum_size.get() * array_size; + } + } + // These have been packed already + else if (type == Element::RS_TYPE_UNSIGNED_5_6_5 || + type == Element::RS_TYPE_UNSIGNED_5_5_5_1 || + type == Element::RS_TYPE_UNSIGNED_4_4_4_4) { + data_size = AllocationDetails::RSTypeToFormat[type][eElementSize]; + } else if (type < Element::RS_TYPE_ELEMENT) { + data_size = + vec_size * AllocationDetails::RSTypeToFormat[type][eElementSize]; + if (vec_size == 3) + padding = AllocationDetails::RSTypeToFormat[type][eElementSize]; + } else + data_size = + GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize(); + + elem.padding = padding; + elem.datum_size = data_size + padding; + LLDB_LOGF(log, "%s - element size set to %" PRIu32, __FUNCTION__, + data_size + padding); +} + +// Given an allocation, this function copies the allocation contents from +// device into a buffer on the heap. Returning a shared pointer to the buffer +// containing the data. +std::shared_ptr<uint8_t> +RenderScriptRuntime::GetAllocationData(AllocationDetails *alloc, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // JIT all the allocation details + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info", + __FUNCTION__); + + if (!RefreshAllocation(alloc, frame_ptr)) { + LLDB_LOGF(log, "%s - couldn't JIT allocation details", __FUNCTION__); + return nullptr; + } + } + + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && + alloc->element.type_vec_size.isValid() && alloc->size.isValid() && + "Allocation information not available"); + + // Allocate a buffer to copy data into + const uint32_t size = *alloc->size.get(); + std::shared_ptr<uint8_t> buffer(new uint8_t[size]); + if (!buffer) { + LLDB_LOGF(log, "%s - couldn't allocate a %" PRIu32 " byte buffer", + __FUNCTION__, size); + return nullptr; + } + + // Read the inferior memory + Status err; + lldb::addr_t data_ptr = *alloc->data_ptr.get(); + GetProcess()->ReadMemory(data_ptr, buffer.get(), size, err); + if (err.Fail()) { + LLDB_LOGF(log, + "%s - '%s' Couldn't read %" PRIu32 + " bytes of allocation data from 0x%" PRIx64, + __FUNCTION__, err.AsCString(), size, data_ptr); + return nullptr; + } + + return buffer; +} + +// Function copies data from a binary file into an allocation. There is a +// header at the start of the file, FileHeader, before the data content itself. +// Information from this header is used to display warnings to the user about +// incompatibilities +bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id, + const char *path, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // Find allocation with the given id + AllocationDetails *alloc = FindAllocByID(strm, alloc_id); + if (!alloc) + return false; + + LLDB_LOGF(log, "%s - found allocation 0x%" PRIx64, __FUNCTION__, + *alloc->address.get()); + + // JIT all the allocation details + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info.", + __FUNCTION__); + + if (!RefreshAllocation(alloc, frame_ptr)) { + LLDB_LOGF(log, "%s - couldn't JIT allocation details", __FUNCTION__); + return false; + } + } + + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && + alloc->element.type_vec_size.isValid() && alloc->size.isValid() && + alloc->element.datum_size.isValid() && + "Allocation information not available"); + + // Check we can read from file + FileSpec file(path); + FileSystem::Instance().Resolve(file); + if (!FileSystem::Instance().Exists(file)) { + strm.Printf("Error: File %s does not exist", path); + strm.EOL(); + return false; + } + + if (!FileSystem::Instance().Readable(file)) { + strm.Printf("Error: File %s does not have readable permissions", path); + strm.EOL(); + return false; + } + + // Read file into data buffer + auto data_sp = FileSystem::Instance().CreateDataBuffer(file.GetPath()); + + // Cast start of buffer to FileHeader and use pointer to read metadata + void *file_buf = data_sp->GetBytes(); + if (file_buf == nullptr || + data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) + + sizeof(AllocationDetails::ElementHeader))) { + strm.Printf("Error: File %s does not contain enough data for header", path); + strm.EOL(); + return false; + } + const AllocationDetails::FileHeader *file_header = + static_cast<AllocationDetails::FileHeader *>(file_buf); + + // Check file starts with ascii characters "RSAD" + if (memcmp(file_header->ident, "RSAD", 4)) { + strm.Printf("Error: File doesn't contain identifier for an RS allocation " + "dump. Are you sure this is the correct file?"); + strm.EOL(); + return false; + } + + // Look at the type of the root element in the header + AllocationDetails::ElementHeader root_el_hdr; + memcpy(&root_el_hdr, static_cast<uint8_t *>(file_buf) + + sizeof(AllocationDetails::FileHeader), + sizeof(AllocationDetails::ElementHeader)); + + LLDB_LOGF(log, "%s - header type %" PRIu32 ", element size %" PRIu32, + __FUNCTION__, root_el_hdr.type, root_el_hdr.element_size); + + // Check if the target allocation and file both have the same number of bytes + // for an Element + if (*alloc->element.datum_size.get() != root_el_hdr.element_size) { + strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32 + " bytes, allocation %" PRIu32 " bytes", + root_el_hdr.element_size, *alloc->element.datum_size.get()); + strm.EOL(); + } + + // Check if the target allocation and file both have the same type + const uint32_t alloc_type = static_cast<uint32_t>(*alloc->element.type.get()); + const uint32_t file_type = root_el_hdr.type; + + if (file_type > Element::RS_TYPE_FONT) { + strm.Printf("Warning: File has unknown allocation type"); + strm.EOL(); + } else if (alloc_type != file_type) { + // Enum value isn't monotonous, so doesn't always index RsDataTypeToString + // array + uint32_t target_type_name_idx = alloc_type; + uint32_t head_type_name_idx = file_type; + if (alloc_type >= Element::RS_TYPE_ELEMENT && + alloc_type <= Element::RS_TYPE_FONT) + target_type_name_idx = static_cast<Element::DataType>( + (alloc_type - Element::RS_TYPE_ELEMENT) + + Element::RS_TYPE_MATRIX_2X2 + 1); + + if (file_type >= Element::RS_TYPE_ELEMENT && + file_type <= Element::RS_TYPE_FONT) + head_type_name_idx = static_cast<Element::DataType>( + (file_type - Element::RS_TYPE_ELEMENT) + Element::RS_TYPE_MATRIX_2X2 + + 1); + + const char *head_type_name = + AllocationDetails::RsDataTypeToString[head_type_name_idx][0]; + const char *target_type_name = + AllocationDetails::RsDataTypeToString[target_type_name_idx][0]; + + strm.Printf( + "Warning: Mismatched Types - file '%s' type, allocation '%s' type", + head_type_name, target_type_name); + strm.EOL(); + } + + // Advance buffer past header + file_buf = static_cast<uint8_t *>(file_buf) + file_header->hdr_size; + + // Calculate size of allocation data in file + size_t size = data_sp->GetByteSize() - file_header->hdr_size; + + // Check if the target allocation and file both have the same total data + // size. + const uint32_t alloc_size = *alloc->size.get(); + if (alloc_size != size) { + strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64 + " bytes, allocation 0x%" PRIx32 " bytes", + (uint64_t)size, alloc_size); + strm.EOL(); + // Set length to copy to minimum + size = alloc_size < size ? alloc_size : size; + } + + // Copy file data from our buffer into the target allocation. + lldb::addr_t alloc_data = *alloc->data_ptr.get(); + Status err; + size_t written = GetProcess()->WriteMemory(alloc_data, file_buf, size, err); + if (!err.Success() || written != size) { + strm.Printf("Error: Couldn't write data to allocation %s", err.AsCString()); + strm.EOL(); + return false; + } + + strm.Printf("Contents of file '%s' read into allocation %" PRIu32, path, + alloc->id); + strm.EOL(); + + return true; +} + +// Function takes as parameters a byte buffer, which will eventually be written +// to file as the element header, an offset into that buffer, and an Element +// that will be saved into the buffer at the parametrised offset. Return value +// is the new offset after writing the element into the buffer. Elements are +// saved to the file as the ElementHeader struct followed by offsets to the +// structs of all the element's children. +size_t RenderScriptRuntime::PopulateElementHeaders( + const std::shared_ptr<uint8_t> header_buffer, size_t offset, + const Element &elem) { + // File struct for an element header with all the relevant details copied + // from elem. We assume members are valid already. + AllocationDetails::ElementHeader elem_header; + elem_header.type = *elem.type.get(); + elem_header.kind = *elem.type_kind.get(); + elem_header.element_size = *elem.datum_size.get(); + elem_header.vector_size = *elem.type_vec_size.get(); + elem_header.array_size = + elem.array_size.isValid() ? *elem.array_size.get() : 0; + const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader); + + // Copy struct into buffer and advance offset We assume that header_buffer + // has been checked for nullptr before this method is called + memcpy(header_buffer.get() + offset, &elem_header, elem_header_size); + offset += elem_header_size; + + // Starting offset of child ElementHeader struct + size_t child_offset = + offset + ((elem.children.size() + 1) * sizeof(uint32_t)); + for (const RenderScriptRuntime::Element &child : elem.children) { + // Recursively populate the buffer with the element header structs of + // children. Then save the offsets where they were set after the parent + // element header. + memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t)); + offset += sizeof(uint32_t); + + child_offset = PopulateElementHeaders(header_buffer, child_offset, child); + } + + // Zero indicates no more children + memset(header_buffer.get() + offset, 0, sizeof(uint32_t)); + + return child_offset; +} + +// Given an Element object this function returns the total size needed in the +// file header to store the element's details. Taking into account the size of +// the element header struct, plus the offsets to all the element's children. +// Function is recursive so that the size of all ancestors is taken into +// account. +size_t RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem) { + // Offsets to children plus zero terminator + size_t size = (elem.children.size() + 1) * sizeof(uint32_t); + // Size of header struct with type details + size += sizeof(AllocationDetails::ElementHeader); + + // Calculate recursively for all descendants + for (const Element &child : elem.children) + size += CalculateElementHeaderSize(child); + + return size; +} + +// Function copies allocation contents into a binary file. This file can then +// be loaded later into a different allocation. There is a header, FileHeader, +// before the allocation data containing meta-data. +bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id, + const char *path, + StackFrame *frame_ptr) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // Find allocation with the given id + AllocationDetails *alloc = FindAllocByID(strm, alloc_id); + if (!alloc) + return false; + + LLDB_LOGF(log, "%s - found allocation 0x%" PRIx64 ".", __FUNCTION__, + *alloc->address.get()); + + // JIT all the allocation details + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info.", + __FUNCTION__); + + if (!RefreshAllocation(alloc, frame_ptr)) { + LLDB_LOGF(log, "%s - couldn't JIT allocation details.", __FUNCTION__); + return false; + } + } + + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && + alloc->element.type_vec_size.isValid() && + alloc->element.datum_size.get() && + alloc->element.type_kind.isValid() && alloc->dimension.isValid() && + "Allocation information not available"); + + // Check we can create writable file + FileSpec file_spec(path); + FileSystem::Instance().Resolve(file_spec); + auto file = FileSystem::Instance().Open( + file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate | + File::eOpenOptionTruncate); + + if (!file) { + std::string error = llvm::toString(file.takeError()); + strm.Printf("Error: Failed to open '%s' for writing: %s", path, + error.c_str()); + strm.EOL(); + return false; + } + + // Read allocation into buffer of heap memory + const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr); + if (!buffer) { + strm.Printf("Error: Couldn't read allocation data into buffer"); + strm.EOL(); + return false; + } + + // Create the file header + AllocationDetails::FileHeader head; + memcpy(head.ident, "RSAD", 4); + head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1); + head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2); + head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3); + + const size_t element_header_size = CalculateElementHeaderSize(alloc->element); + assert((sizeof(AllocationDetails::FileHeader) + element_header_size) < + UINT16_MAX && + "Element header too large"); + head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) + + element_header_size); + + // Write the file header + size_t num_bytes = sizeof(AllocationDetails::FileHeader); + LLDB_LOGF(log, "%s - writing File Header, 0x%" PRIx64 " bytes", __FUNCTION__, + (uint64_t)num_bytes); + + Status err = file.get()->Write(&head, num_bytes); + if (!err.Success()) { + strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path); + strm.EOL(); + return false; + } + + // Create the headers describing the element type of the allocation. + std::shared_ptr<uint8_t> element_header_buffer( + new uint8_t[element_header_size]); + if (element_header_buffer == nullptr) { + strm.Printf("Internal Error: Couldn't allocate %" PRIu64 + " bytes on the heap", + (uint64_t)element_header_size); + strm.EOL(); + return false; + } + + PopulateElementHeaders(element_header_buffer, 0, alloc->element); + + // Write headers for allocation element type to file + num_bytes = element_header_size; + LLDB_LOGF(log, "%s - writing element headers, 0x%" PRIx64 " bytes.", + __FUNCTION__, (uint64_t)num_bytes); + + err = file.get()->Write(element_header_buffer.get(), num_bytes); + if (!err.Success()) { + strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path); + strm.EOL(); + return false; + } + + // Write allocation data to file + num_bytes = static_cast<size_t>(*alloc->size.get()); + LLDB_LOGF(log, "%s - writing 0x%" PRIx64 " bytes", __FUNCTION__, + (uint64_t)num_bytes); + + err = file.get()->Write(buffer.get(), num_bytes); + if (!err.Success()) { + strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path); + strm.EOL(); + return false; + } + + strm.Printf("Allocation written to file '%s'", path); + strm.EOL(); + 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) { + if (rs_module->m_module == module_sp) { + // Check if the user has enabled automatically breaking on all RS + // kernels. + if (m_breakAllKernels) + BreakOnModuleKernels(rs_module); + + return false; + } + } + bool module_loaded = false; + switch (GetModuleKind(module_sp)) { + case eModuleKindKernelObj: { + RSModuleDescriptorSP module_desc; + module_desc = std::make_shared<RSModuleDescriptor>(module_sp); + if (module_desc->ParseRSInfo()) { + m_rsmodules.push_back(module_desc); + module_desc->WarnIfVersionMismatch(GetProcess() + ->GetTarget() + .GetDebugger() + .GetAsyncOutputStream() + .get()); + 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: { + if (!m_libRSCpuRef) { + m_libRSCpuRef = module_sp; + LoadRuntimeHooks(m_libRSCpuRef, RenderScriptRuntime::eModuleKindImpl); + } + 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) { + Status err; + uint32_t flag = 0x00000001U; + Target &target = GetProcess()->GetTarget(); + addr_t addr = debug_present->GetLoadAddress(&target); + GetProcess()->WriteMemory(addr, &flag, sizeof(flag), err); + if (err.Success()) { + LLDB_LOGF(log, "%s - debugger present flag set on debugee.", + __FUNCTION__); + + m_debuggerPresentFlagged = true; + } else if (log) { + LLDB_LOGF(log, "%s - error writing debugger present flags '%s' ", + __FUNCTION__, err.AsCString()); + } + } else if (log) { + LLDB_LOGF( + log, + "%s - error writing debugger present flags - symbol not found", + __FUNCTION__); + } + } + break; + } + default: + break; + } + if (module_loaded) + Update(); + return module_loaded; + } + return false; +} + +void RenderScriptRuntime::Update() { + if (m_rsmodules.size() > 0) { + if (!m_initiated) { + Initiate(); + } + } +} + +void RSModuleDescriptor::WarnIfVersionMismatch(lldb_private::Stream *s) const { + if (!s) + return; + + if (m_slang_version.empty() || m_bcc_version.empty()) { + s->PutCString("WARNING: Unknown bcc or slang (llvm-rs-cc) version; debug " + "experience may be unreliable"); + s->EOL(); + } else if (m_slang_version != m_bcc_version) { + s->Printf("WARNING: The debug info emitted by the slang frontend " + "(llvm-rs-cc) used to build this module (%s) does not match the " + "version of bcc used to generate the debug information (%s). " + "This is an unsupported configuration and may result in a poor " + "debugging experience; proceed with caution", + m_slang_version.c_str(), m_bcc_version.c_str()); + s->EOL(); + } +} + +bool RSModuleDescriptor::ParsePragmaCount(llvm::StringRef *lines, + size_t n_lines) { + // Skip the pragma prototype line + ++lines; + for (; n_lines--; ++lines) { + const auto kv_pair = lines->split(" - "); + m_pragmas[kv_pair.first.trim().str()] = kv_pair.second.trim().str(); + } + return true; +} + +bool RSModuleDescriptor::ParseExportReduceCount(llvm::StringRef *lines, + size_t n_lines) { + // The list of reduction kernels in the `.rs.info` symbol is of the form + // "signature - accumulatordatasize - reduction_name - initializer_name - + // accumulator_name - combiner_name - outconverter_name - halter_name" Where + // a function is not explicitly named by the user, or is not generated by the + // compiler, it is named "." so the dash separated list should always be 8 + // items long + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + // Skip the exportReduceCount line + ++lines; + for (; n_lines--; ++lines) { + llvm::SmallVector<llvm::StringRef, 8> spec; + lines->split(spec, " - "); + if (spec.size() != 8) { + if (spec.size() < 8) { + if (log) + log->Error("Error parsing RenderScript reduction spec. wrong number " + "of fields"); + return false; + } else if (log) + log->Warning("Extraneous members in reduction spec: '%s'", + lines->str().c_str()); + } + + const auto sig_s = spec[0]; + uint32_t sig; + if (sig_s.getAsInteger(10, sig)) { + if (log) + log->Error("Error parsing Renderscript reduction spec: invalid kernel " + "signature: '%s'", + sig_s.str().c_str()); + return false; + } + + const auto accum_data_size_s = spec[1]; + uint32_t accum_data_size; + if (accum_data_size_s.getAsInteger(10, accum_data_size)) { + if (log) + log->Error("Error parsing Renderscript reduction spec: invalid " + "accumulator data size %s", + accum_data_size_s.str().c_str()); + return false; + } + + LLDB_LOGF(log, "Found RenderScript reduction '%s'", spec[2].str().c_str()); + + m_reductions.push_back(RSReductionDescriptor(this, sig, accum_data_size, + spec[2], spec[3], spec[4], + spec[5], spec[6], spec[7])); + } + return true; +} + +bool RSModuleDescriptor::ParseVersionInfo(llvm::StringRef *lines, + size_t n_lines) { + // Skip the versionInfo line + ++lines; + for (; n_lines--; ++lines) { + // We're only interested in bcc and slang versions, and ignore all other + // versionInfo lines + const auto kv_pair = lines->split(" - "); + if (kv_pair.first == "slang") + m_slang_version = kv_pair.second.str(); + else if (kv_pair.first == "bcc") + m_bcc_version = kv_pair.second.str(); + } + return true; +} + +bool RSModuleDescriptor::ParseExportForeachCount(llvm::StringRef *lines, + size_t n_lines) { + // Skip the exportForeachCount line + ++lines; + for (; n_lines--; ++lines) { + uint32_t slot; + // `forEach` kernels are listed in the `.rs.info` packet as a "slot - name" + // pair per line + const auto kv_pair = lines->split(" - "); + if (kv_pair.first.getAsInteger(10, slot)) + return false; + m_kernels.push_back(RSKernelDescriptor(this, kv_pair.second, slot)); + } + return true; +} + +bool RSModuleDescriptor::ParseExportVarCount(llvm::StringRef *lines, + size_t n_lines) { + // Skip the ExportVarCount line + ++lines; + for (; n_lines--; ++lines) + m_globals.push_back(RSGlobalDescriptor(this, *lines)); + return true; +} + +// 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() { + assert(m_module); + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType( + ConstString(".rs.info"), eSymbolTypeData); + if (!info_sym) + return false; + + const addr_t addr = info_sym->GetAddressRef().GetFileAddress(); + if (addr == LLDB_INVALID_ADDRESS) + return false; + + const addr_t size = info_sym->GetByteSize(); + const FileSpec fs = m_module->GetFileSpec(); + + auto buffer = + FileSystem::Instance().CreateDataBuffer(fs.GetPath(), size, addr); + if (!buffer) + return false; + + // split rs.info. contents into lines + llvm::SmallVector<llvm::StringRef, 128> info_lines; + { + const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes()); + raw_rs_info.split(info_lines, '\n'); + LLDB_LOGF(log, "'.rs.info symbol for '%s':\n%s", + m_module->GetFileSpec().GetCString(), raw_rs_info.str().c_str()); + } + + enum { + eExportVar, + eExportForEach, + eExportReduce, + ePragma, + eBuildChecksum, + eObjectSlot, + eVersionInfo, + }; + + const auto rs_info_handler = [](llvm::StringRef name) -> int { + return llvm::StringSwitch<int>(name) + // The number of visible global variables in the script + .Case("exportVarCount", eExportVar) + // The number of RenderScrip `forEach` kernels __attribute__((kernel)) + .Case("exportForEachCount", eExportForEach) + // The number of generalreductions: This marked in the script by + // `#pragma reduce()` + .Case("exportReduceCount", eExportReduce) + // Total count of all RenderScript specific `#pragmas` used in the + // script + .Case("pragmaCount", ePragma) + .Case("objectSlotCount", eObjectSlot) + .Case("versionInfo", eVersionInfo) + .Default(-1); + }; + + // parse all text lines of .rs.info + for (auto line = info_lines.begin(); line != info_lines.end(); ++line) { + const auto kv_pair = line->split(": "); + const auto key = kv_pair.first; + const auto val = kv_pair.second.trim(); + + const auto handler = rs_info_handler(key); + if (handler == -1) + continue; + // getAsInteger returns `true` on an error condition - we're only + // interested in numeric fields at the moment + uint64_t n_lines; + if (val.getAsInteger(10, n_lines)) { + LLDB_LOGV(log, "Failed to parse non-numeric '.rs.info' section {0}", + line->str()); + continue; + } + if (info_lines.end() - (line + 1) < (ptrdiff_t)n_lines) + return false; + + bool success = false; + switch (handler) { + case eExportVar: + success = ParseExportVarCount(line, n_lines); + break; + case eExportForEach: + success = ParseExportForeachCount(line, n_lines); + break; + case eExportReduce: + success = ParseExportReduceCount(line, n_lines); + break; + case ePragma: + success = ParsePragmaCount(line, n_lines); + break; + case eVersionInfo: + success = ParseVersionInfo(line, n_lines); + break; + default: { + LLDB_LOGF(log, "%s - skipping .rs.info field '%s'", __FUNCTION__, + line->str().c_str()); + continue; + } + } + if (!success) + return false; + line += n_lines; + } + return info_lines.size() > 0; +} + +void RenderScriptRuntime::DumpStatus(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(); + } + } 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; + + // Iterate over all of the currently discovered scripts. Note: We cant push + // or pop from m_scripts inside this loop or it may invalidate script. + for (const auto &script : m_scripts) { + if (!script->context.isValid()) + continue; + lldb::addr_t context = *script->context; + + if (contextReferences.find(context) != contextReferences.end()) { + contextReferences[context]++; + } else { + contextReferences[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(); +} + +RenderScriptRuntime::AllocationDetails * +RenderScriptRuntime::FindAllocByID(Stream &strm, const uint32_t alloc_id) { + AllocationDetails *alloc = nullptr; + + // See if we can find allocation using id as an index; + if (alloc_id <= m_allocations.size() && alloc_id != 0 && + m_allocations[alloc_id - 1]->id == alloc_id) { + alloc = m_allocations[alloc_id - 1].get(); + return alloc; + } + + // Fallback to searching + for (const auto &a : m_allocations) { + if (a->id == alloc_id) { + alloc = a.get(); + break; + } + } + + if (alloc == nullptr) { + strm.Printf("Error: Couldn't find allocation with id matching %" PRIu32, + alloc_id); + strm.EOL(); + } + + return alloc; +} + +// Prints the contents of an allocation to the output stream, which may be a +// file +bool RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr, + const uint32_t id) { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + // Check we can find the desired allocation + AllocationDetails *alloc = FindAllocByID(strm, id); + if (!alloc) + return false; // FindAllocByID() will print error message for us here + + LLDB_LOGF(log, "%s - found allocation 0x%" PRIx64, __FUNCTION__, + *alloc->address.get()); + + // Check we have information about the allocation, if not calculate it + if (alloc->ShouldRefresh()) { + LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info.", + __FUNCTION__); + + // JIT all the allocation information + if (!RefreshAllocation(alloc, frame_ptr)) { + strm.Printf("Error: Couldn't JIT allocation details"); + strm.EOL(); + return false; + } + } + + // Establish format and size of each data element + const uint32_t vec_size = *alloc->element.type_vec_size.get(); + const Element::DataType type = *alloc->element.type.get(); + + assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && + "Invalid allocation type"); + + lldb::Format format; + if (type >= Element::RS_TYPE_ELEMENT) + format = eFormatHex; + else + format = vec_size == 1 + ? static_cast<lldb::Format>( + AllocationDetails::RSTypeToFormat[type][eFormatSingle]) + : static_cast<lldb::Format>( + AllocationDetails::RSTypeToFormat[type][eFormatVector]); + + const uint32_t data_size = *alloc->element.datum_size.get(); + + LLDB_LOGF(log, "%s - element size %" PRIu32 " bytes, including padding", + __FUNCTION__, data_size); + + // Allocate a buffer to copy data into + std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr); + if (!buffer) { + strm.Printf("Error: Couldn't read allocation data"); + strm.EOL(); + return false; + } + + // Calculate stride between rows as there may be padding at end of rows since + // allocated memory is 16-byte aligned + if (!alloc->stride.isValid()) { + if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension + alloc->stride = 0; + else if (!JITAllocationStride(alloc, frame_ptr)) { + strm.Printf("Error: Couldn't calculate allocation row stride"); + strm.EOL(); + return false; + } + } + const uint32_t stride = *alloc->stride.get(); + const uint32_t size = *alloc->size.get(); // Size of whole allocation + const uint32_t padding = + alloc->element.padding.isValid() ? *alloc->element.padding.get() : 0; + LLDB_LOGF(log, + "%s - stride %" PRIu32 " bytes, size %" PRIu32 + " bytes, padding %" PRIu32, + __FUNCTION__, stride, size, padding); + + // Find dimensions used to index loops, so need to be non-zero + uint32_t dim_x = alloc->dimension.get()->dim_1; + dim_x = dim_x == 0 ? 1 : dim_x; + + uint32_t dim_y = alloc->dimension.get()->dim_2; + dim_y = dim_y == 0 ? 1 : dim_y; + + uint32_t dim_z = alloc->dimension.get()->dim_3; + dim_z = dim_z == 0 ? 1 : dim_z; + + // Use data extractor to format output + const uint32_t target_ptr_size = + GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize(); + DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(), + target_ptr_size); + + uint32_t offset = 0; // Offset in buffer to next element to be printed + uint32_t prev_row = 0; // Offset to the start of the previous row + + // Iterate over allocation dimensions, printing results to user + strm.Printf("Data (X, Y, Z):"); + for (uint32_t z = 0; z < dim_z; ++z) { + for (uint32_t y = 0; y < dim_y; ++y) { + // Use stride to index start of next row. + if (!(y == 0 && z == 0)) + offset = prev_row + stride; + prev_row = offset; + + // Print each element in the row individually + for (uint32_t x = 0; x < dim_x; ++x) { + strm.Printf("\n(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") = ", x, y, z); + if ((type == Element::RS_TYPE_NONE) && + (alloc->element.children.size() > 0) && + (alloc->element.type_name != Element::GetFallbackStructName())) { + // Here we are dumping an Element of struct type. This is done using + // expression evaluation with the name of the struct type and pointer + // to element. Don't print the name of the resulting expression, + // since this will be '$[0-9]+' + DumpValueObjectOptions expr_options; + expr_options.SetHideName(true); + + // Setup expression as dereferencing a pointer cast to element + // address. + char expr_char_buffer[jit_max_expr_size]; + int written = + snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64, + alloc->element.type_name.AsCString(), + *alloc->data_ptr.get() + offset); + + if (written < 0 || written >= jit_max_expr_size) { + LLDB_LOGF(log, "%s - error in snprintf().", __FUNCTION__); + continue; + } + + // Evaluate expression + ValueObjectSP expr_result; + GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer, + frame_ptr, expr_result); + + // Print the results to our stream. + expr_result->Dump(strm, expr_options); + } else { + DumpDataExtractor(alloc_data, &strm, offset, format, + data_size - padding, 1, 1, LLDB_INVALID_ADDRESS, 0, + 0); + } + offset += data_size; + } + } + } + strm.EOL(); + + return true; +} + +// Function recalculates all our cached information about allocations by +// jitting the RS runtime regarding each allocation we know about. Returns true +// if all allocations could be recomputed, false otherwise. +bool RenderScriptRuntime::RecomputeAllAllocations(Stream &strm, + StackFrame *frame_ptr) { + bool success = true; + for (auto &alloc : m_allocations) { + // JIT current allocation information + if (!RefreshAllocation(alloc.get(), frame_ptr)) { + strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32 + "\n", + alloc->id); + success = false; + } + } + + if (success) + strm.Printf("All allocations successfully recomputed"); + strm.EOL(); + + return success; +} + +// Prints information regarding currently loaded allocations. These details are +// gathered by jitting the runtime, which has as latency. Index parameter +// specifies a single allocation ID to print, or a zero value to print them all +void RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr, + const uint32_t index) { + strm.Printf("RenderScript Allocations:"); + strm.EOL(); + strm.IndentMore(); + + for (auto &alloc : m_allocations) { + // index will only be zero if we want to print all allocations + if (index != 0 && index != alloc->id) + continue; + + // JIT current allocation information + if (alloc->ShouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr)) { + strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32, + alloc->id); + strm.EOL(); + continue; + } + + strm.Printf("%" PRIu32 ":", alloc->id); + strm.EOL(); + 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("(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n", + alloc->dimension.get()->dim_1, alloc->dimension.get()->dim_2, + alloc->dimension.get()->dim_3); + + strm.Indent("Data Type: "); + if (!alloc->element.type.isValid() || + !alloc->element.type_vec_size.isValid()) + strm.Printf("unknown\n"); + else { + const int vector_size = *alloc->element.type_vec_size.get(); + Element::DataType type = *alloc->element.type.get(); + + if (!alloc->element.type_name.IsEmpty()) + strm.Printf("%s\n", alloc->element.type_name.AsCString()); + else { + // Enum value isn't monotonous, so doesn't always index + // RsDataTypeToString array + if (type >= Element::RS_TYPE_ELEMENT && type <= Element::RS_TYPE_FONT) + type = + static_cast<Element::DataType>((type - Element::RS_TYPE_ELEMENT) + + Element::RS_TYPE_MATRIX_2X2 + 1); + + if (type >= (sizeof(AllocationDetails::RsDataTypeToString) / + sizeof(AllocationDetails::RsDataTypeToString[0])) || + vector_size > 4 || vector_size < 1) + strm.Printf("invalid type\n"); + else + strm.Printf( + "%s\n", + AllocationDetails::RsDataTypeToString[static_cast<uint32_t>(type)] + [vector_size - 1]); + } + } + + strm.Indent("Data Kind: "); + if (!alloc->element.type_kind.isValid()) + strm.Printf("unknown\n"); + else { + const Element::DataKind kind = *alloc->element.type_kind.get(); + if (kind < Element::RS_KIND_USER || kind > Element::RS_KIND_PIXEL_YUV) + strm.Printf("invalid kind\n"); + else + strm.Printf( + "%s\n", + AllocationDetails::RsDataKindToString[static_cast<uint32_t>(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) + continue; + + CreateKernelBreakpoint(kernel.m_name); + } +} + +// Method is internally called by the 'kernel breakpoint all' command to enable +// or disable breaking on all kernels. When do_break is true we want to enable +// this functionality. When do_break is false we want to disable it. +void RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + InitSearchFilter(target); + + // Set breakpoints on all the kernels + if (do_break && !m_breakAllKernels) { + m_breakAllKernels = true; + + for (const auto &module : m_rsmodules) + BreakOnModuleKernels(module); + + LLDB_LOGF(log, + "%s(True) - breakpoints set on all currently loaded kernels.", + __FUNCTION__); + } else if (!do_break && + m_breakAllKernels) // Breakpoints won't be set on any new kernels. + { + m_breakAllKernels = false; + + LLDB_LOGF(log, "%s(False) - breakpoints no longer automatically set.", + __FUNCTION__); + } +} + +// Given the name of a kernel this function creates a breakpoint using our own +// breakpoint resolver, and returns the Breakpoint shared pointer. +BreakpointSP +RenderScriptRuntime::CreateKernelBreakpoint(ConstString name) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + if (!m_filtersp) { + LLDB_LOGF(log, "%s - error, no breakpoint search filter set.", + __FUNCTION__); + return nullptr; + } + + BreakpointResolverSP resolver_sp(new RSBreakpointResolver(nullptr, name)); + Target &target = GetProcess()->GetTarget(); + BreakpointSP bp = target.CreateBreakpoint( + m_filtersp, resolver_sp, false, false, false); + + // Give RS breakpoints a specific name, so the user can manipulate them as a + // group. + Status err; + target.AddNameToBreakpoint(bp, "RenderScriptKernel", err); + if (err.Fail() && log) + LLDB_LOGF(log, "%s - error setting break name, '%s'.", __FUNCTION__, + err.AsCString()); + + return bp; +} + +BreakpointSP +RenderScriptRuntime::CreateReductionBreakpoint(ConstString name, + int kernel_types) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + if (!m_filtersp) { + LLDB_LOGF(log, "%s - error, no breakpoint search filter set.", + __FUNCTION__); + return nullptr; + } + + BreakpointResolverSP resolver_sp(new RSReduceBreakpointResolver( + nullptr, name, &m_rsmodules, kernel_types)); + Target &target = GetProcess()->GetTarget(); + BreakpointSP bp = target.CreateBreakpoint( + m_filtersp, resolver_sp, false, false, false); + + // Give RS breakpoints a specific name, so the user can manipulate them as a + // group. + Status err; + target.AddNameToBreakpoint(bp, "RenderScriptReduction", err); + if (err.Fail() && log) + LLDB_LOGF(log, "%s - error setting break name, '%s'.", __FUNCTION__, + err.AsCString()); + + return bp; +} + +// Given an expression for a variable this function tries to calculate the +// variable's value. If this is possible it returns true and sets the uint64_t +// parameter to the variables unsigned value. Otherwise function returns false. +bool RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp, + const char *var_name, + uint64_t &val) { + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + Status err; + VariableSP var_sp; + + // Find variable in stack frame + ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath( + var_name, eNoDynamicValues, + StackFrame::eExpressionPathOptionCheckPtrVsMember | + StackFrame::eExpressionPathOptionsAllowDirectIVarAccess, + var_sp, err)); + if (!err.Success()) { + LLDB_LOGF(log, "%s - error, couldn't find '%s' in frame", __FUNCTION__, + var_name); + return false; + } + + // Find the uint32_t value for the variable + bool success = false; + val = value_sp->GetValueAsUnsigned(0, &success); + if (!success) { + LLDB_LOGF(log, "%s - error, couldn't parse '%s' as an uint32_t.", + __FUNCTION__, var_name); + return false; + } + + return true; +} + +// Function attempts to find the current coordinate of a kernel invocation by +// investigating the values of frame variables in the .expand function. These +// coordinates are returned via the coord array reference parameter. Returns +// true if the coordinates could be found, and false otherwise. +bool RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord, + Thread *thread_ptr) { + static const char *const x_expr = "rsIndex"; + static const char *const y_expr = "p->current.y"; + static const char *const z_expr = "p->current.z"; + + Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE)); + + if (!thread_ptr) { + LLDB_LOGF(log, "%s - Error, No thread pointer", __FUNCTION__); + + return false; + } + + // Walk the call stack looking for a function whose name has the suffix + // '.expand' and contains the variables we're looking for. + for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i) { + if (!thread_ptr->SetSelectedFrameByIndex(i)) + continue; + + StackFrameSP frame_sp = thread_ptr->GetSelectedFrame(); + if (!frame_sp) + continue; + + // Find the function name + const SymbolContext sym_ctx = + frame_sp->GetSymbolContext(eSymbolContextFunction); + const ConstString func_name = sym_ctx.GetFunctionName(); + if (!func_name) + continue; + + LLDB_LOGF(log, "%s - Inspecting function '%s'", __FUNCTION__, + func_name.GetCString()); + + // Check if function name has .expand suffix + if (!func_name.GetStringRef().endswith(".expand")) + continue; + + LLDB_LOGF(log, "%s - Found .expand function '%s'", __FUNCTION__, + func_name.GetCString()); + + // Get values for variables in .expand frame that tell us the current + // kernel invocation + uint64_t x, y, z; + bool found = GetFrameVarAsUnsigned(frame_sp, x_expr, x) && + GetFrameVarAsUnsigned(frame_sp, y_expr, y) && + GetFrameVarAsUnsigned(frame_sp, z_expr, z); + + if (found) { + // The RenderScript runtime uses uint32_t for these vars. If they're not + // within bounds, our frame parsing is garbage + assert(x <= UINT32_MAX && y <= UINT32_MAX && z <= UINT32_MAX); + coord.x = (uint32_t)x; + coord.y = (uint32_t)y; + coord.z = (uint32_t)z; + return true; + } + } + return false; +} + +// Callback when a kernel breakpoint hits and we're looking for a specific +// coordinate. Baton parameter contains a pointer to the target coordinate we +// want to break on. Function then checks the .expand frame for the current +// coordinate and breaks to user if it matches. Parameter 'break_id' is the id +// of the Breakpoint which made the callback. Parameter 'break_loc_id' is the +// id for the BreakpointLocation which was hit, a single logical breakpoint can +// have multiple addresses. +bool RenderScriptRuntime::KernelBreakpointHit(void *baton, + StoppointCallbackContext *ctx, + user_id_t break_id, + user_id_t break_loc_id) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + assert(baton && + "Error: null baton in conditional kernel breakpoint callback"); + + // Coordinate we want to stop on + RSCoordinate target_coord = *static_cast<RSCoordinate *>(baton); + + LLDB_LOGF(log, "%s - Break ID %" PRIu64 ", " FMT_COORD, __FUNCTION__, + break_id, target_coord.x, target_coord.y, target_coord.z); + + // Select current thread + ExecutionContext context(ctx->exe_ctx_ref); + Thread *thread_ptr = context.GetThreadPtr(); + assert(thread_ptr && "Null thread pointer"); + + // Find current kernel invocation from .expand frame variables + RSCoordinate current_coord{}; + if (!GetKernelCoordinate(current_coord, thread_ptr)) { + LLDB_LOGF(log, "%s - Error, couldn't select .expand stack frame", + __FUNCTION__); + return false; + } + + LLDB_LOGF(log, "%s - " FMT_COORD, __FUNCTION__, current_coord.x, + current_coord.y, current_coord.z); + + // Check if the current kernel invocation coordinate matches our target + // coordinate + if (target_coord == current_coord) { + LLDB_LOGF(log, "%s, BREAKING " FMT_COORD, __FUNCTION__, current_coord.x, + current_coord.y, current_coord.z); + + BreakpointSP breakpoint_sp = + context.GetTargetPtr()->GetBreakpointByID(break_id); + assert(breakpoint_sp != nullptr && + "Error: Couldn't find breakpoint matching break id for callback"); + breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint + // should only be hit once. + return true; + } + + // No match on coordinate + return false; +} + +void RenderScriptRuntime::SetConditional(BreakpointSP bp, Stream &messages, + const RSCoordinate &coord) { + messages.Printf("Conditional kernel breakpoint on coordinate " FMT_COORD, + coord.x, coord.y, coord.z); + messages.EOL(); + + // Allocate memory for the baton, and copy over coordinate + RSCoordinate *baton = new RSCoordinate(coord); + + // Create a callback that will be invoked every time the breakpoint is hit. + // The baton object passed to the handler is the target coordinate we want to + // break on. + bp->SetCallback(KernelBreakpointHit, baton, true); + + // Store a shared pointer to the baton, so the memory will eventually be + // cleaned up after destruction + m_conditional_breaks[bp->GetID()] = std::unique_ptr<RSCoordinate>(baton); +} + +// Tries to set a breakpoint on the start of a kernel, resolved using the +// kernel name. Argument 'coords', represents a three dimensional coordinate +// which can be used to specify a single kernel instance to break on. If this +// is set then we add a callback to the breakpoint. +bool RenderScriptRuntime::PlaceBreakpointOnKernel(TargetSP target, + Stream &messages, + const char *name, + const RSCoordinate *coord) { + if (!name) + return false; + + InitSearchFilter(target); + + ConstString kernel_name(name); + BreakpointSP bp = CreateKernelBreakpoint(kernel_name); + if (!bp) + return false; + + // We have a conditional breakpoint on a specific coordinate + if (coord) + SetConditional(bp, messages, *coord); + + bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false); + + return true; +} + +BreakpointSP +RenderScriptRuntime::CreateScriptGroupBreakpoint(ConstString name, + bool stop_on_all) { + Log *log( + GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); + + if (!m_filtersp) { + LLDB_LOGF(log, "%s - error, no breakpoint search filter set.", + __FUNCTION__); + return nullptr; + } + + BreakpointResolverSP resolver_sp(new RSScriptGroupBreakpointResolver( + nullptr, name, m_scriptGroups, stop_on_all)); + Target &target = GetProcess()->GetTarget(); + BreakpointSP bp = target.CreateBreakpoint( + m_filtersp, resolver_sp, false, false, false); + // Give RS breakpoints a specific name, so the user can manipulate them as a + // group. + Status err; + target.AddNameToBreakpoint(bp, name.GetCString(), err); + if (err.Fail() && log) + LLDB_LOGF(log, "%s - error setting break name, '%s'.", __FUNCTION__, + err.AsCString()); + // ask the breakpoint to resolve itself + bp->ResolveBreakpoint(); + return bp; +} + +bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target, + Stream &strm, + ConstString name, + bool multi) { + InitSearchFilter(target); + BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi); + if (bp) + bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false); + return bool(bp); +} + +bool RenderScriptRuntime::PlaceBreakpointOnReduction(TargetSP target, + Stream &messages, + const char *reduce_name, + const RSCoordinate *coord, + int kernel_types) { + if (!reduce_name) + return false; + + InitSearchFilter(target); + BreakpointSP bp = + CreateReductionBreakpoint(ConstString(reduce_name), kernel_types); + if (!bp) + return false; + + if (coord) + SetConditional(bp, messages, *coord); + + bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false); + + return true; +} + +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(); +} + +RenderScriptRuntime::ScriptDetails * +RenderScriptRuntime::LookUpScript(addr_t address, bool create) { + for (const auto &s : m_scripts) { + if (s->script.isValid()) + if (*s->script == address) + return s.get(); + } + if (create) { + std::unique_ptr<ScriptDetails> s(new ScriptDetails); + s->script = address; + m_scripts.push_back(std::move(s)); + return m_scripts.back().get(); + } + return nullptr; +} + +RenderScriptRuntime::AllocationDetails * +RenderScriptRuntime::LookUpAllocation(addr_t address) { + for (const auto &a : m_allocations) { + if (a->address.isValid()) + if (*a->address == address) + return a.get(); + } + return nullptr; +} + +RenderScriptRuntime::AllocationDetails * +RenderScriptRuntime::CreateAllocation(addr_t address) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE); + + // Remove any previous allocation which contains the same address + auto it = m_allocations.begin(); + while (it != m_allocations.end()) { + if (*((*it)->address) == address) { + LLDB_LOGF(log, "%s - Removing allocation id: %d, address: 0x%" PRIx64, + __FUNCTION__, (*it)->id, address); + + it = m_allocations.erase(it); + } else { + it++; + } + } + + std::unique_ptr<AllocationDetails> a(new AllocationDetails); + a->address = address; + m_allocations.push_back(std::move(a)); + return m_allocations.back().get(); +} + +bool RenderScriptRuntime::ResolveKernelName(lldb::addr_t kernel_addr, + ConstString &name) { + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS); + + Target &target = GetProcess()->GetTarget(); + Address resolved; + // RenderScript module + if (!target.GetSectionLoadList().ResolveLoadAddress(kernel_addr, resolved)) { + LLDB_LOGF(log, "%s: unable to resolve 0x%" PRIx64 " to a loaded symbol", + __FUNCTION__, kernel_addr); + return false; + } + + Symbol *sym = resolved.CalculateSymbolContextSymbol(); + if (!sym) + return false; + + name = sym->GetName(); + assert(IsRenderScriptModule(resolved.CalculateSymbolContextModule())); + LLDB_LOGF(log, "%s: 0x%" PRIx64 " resolved to the symbol '%s'", __FUNCTION__, + kernel_addr, name.GetCString()); + return true; +} + +void RSModuleDescriptor::Dump(Stream &strm) const { + int indent = strm.GetIndentLevel(); + + strm.Indent(); + m_module->GetFileSpec().Dump(strm.AsRawOstream()); + strm.Indent(m_module->GetNumCompileUnits() ? "Debug info loaded." + : "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.IndentLess(); + + strm.Indent(); + strm.Printf("Pragmas: %" PRIu64, static_cast<uint64_t>(m_pragmas.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &key_val : m_pragmas) { + strm.Indent(); + strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str()); + strm.EOL(); + } + strm.IndentLess(); + + strm.Indent(); + strm.Printf("Reductions: %" PRIu64, + static_cast<uint64_t>(m_reductions.size())); + strm.EOL(); + strm.IndentMore(); + for (const auto &reduction : m_reductions) { + reduction.Dump(strm); + } + + strm.SetIndentLevel(indent); +} + +void RSGlobalDescriptor::Dump(Stream &strm) const { + strm.Indent(m_name.AsCString()); + VariableList var_list; + m_module->m_module->FindGlobalVariables(m_name, nullptr, 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(); +} + +void RSReductionDescriptor::Dump(lldb_private::Stream &stream) const { + stream.Indent(m_reduce_name.AsCString()); + stream.IndentMore(); + stream.EOL(); + stream.Indent(); + stream.Printf("accumulator: %s", m_accum_name.AsCString()); + stream.EOL(); + stream.Indent(); + stream.Printf("initializer: %s", m_init_name.AsCString()); + stream.EOL(); + stream.Indent(); + stream.Printf("combiner: %s", m_comb_name.AsCString()); + stream.EOL(); + stream.Indent(); + stream.Printf("outconverter: %s", m_outc_name.AsCString()); + stream.EOL(); + // XXX This is currently unspecified by RenderScript, and unused + // stream.Indent(); + // stream.Printf("halter: '%s'", m_init_name.AsCString()); + // stream.EOL(); + stream.IndentLess(); +} + +class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript module dump", + "Dumps renderscript specific information for all modules.", + "renderscript module dump", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeModuleDump() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpModules(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript module", + "Commands that deal with RenderScript modules.", + nullptr) { + LoadSubCommand( + "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeModule() override = default; +}; + +class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel list", + "Lists renderscript kernel names and associated script resources.", + "renderscript kernel list", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeKernelList() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpKernels(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +static constexpr OptionDefinition g_renderscript_reduction_bp_set_options[] = { + {LLDB_OPT_SET_1, false, "function-role", 't', + OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeOneLiner, + "Break on a comma separated set of reduction kernel types " + "(accumulator,outcoverter,combiner,initializer"}, + {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument, + nullptr, {}, 0, eArgTypeValue, + "Set a breakpoint on a single invocation of the kernel with specified " + "coordinate.\n" + "Coordinate takes the form 'x[,y][,z] where x,y,z are positive " + "integers representing kernel dimensions. " + "Any unset dimensions will be defaulted to zero."}}; + +class CommandObjectRenderScriptRuntimeReductionBreakpointSet + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeReductionBreakpointSet( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript reduction breakpoint set", + "Set a breakpoint on named RenderScript general reductions", + "renderscript reduction breakpoint set <kernel_name> [-t " + "<reduction_kernel_type,...>]", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused), + m_options(){}; + + class CommandOptions : public Options { + public: + CommandOptions() + : Options(), + m_kernel_types(RSReduceBreakpointResolver::eKernelTypeAll) {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + StreamString err_str; + const int short_option = m_getopt_table[option_idx].val; + switch (short_option) { + case 't': + if (!ParseReductionTypes(option_arg, err_str)) + err.SetErrorStringWithFormat( + "Unable to deduce reduction types for %s: %s", + option_arg.str().c_str(), err_str.GetData()); + break; + case 'c': { + auto coord = RSCoordinate{}; + if (!ParseCoordinate(option_arg, coord)) + err.SetErrorStringWithFormat("unable to parse coordinate for %s", + option_arg.str().c_str()); + else { + m_have_coord = true; + m_coord = coord; + } + break; + } + default: + err.SetErrorStringWithFormat("Invalid option '-%c'", short_option); + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { + m_have_coord = false; + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_reduction_bp_set_options); + } + + bool ParseReductionTypes(llvm::StringRef option_val, + StreamString &err_str) { + m_kernel_types = RSReduceBreakpointResolver::eKernelTypeNone; + const auto reduce_name_to_type = [](llvm::StringRef name) -> int { + return llvm::StringSwitch<int>(name) + .Case("accumulator", RSReduceBreakpointResolver::eKernelTypeAccum) + .Case("initializer", RSReduceBreakpointResolver::eKernelTypeInit) + .Case("outconverter", RSReduceBreakpointResolver::eKernelTypeOutC) + .Case("combiner", RSReduceBreakpointResolver::eKernelTypeComb) + .Case("all", RSReduceBreakpointResolver::eKernelTypeAll) + // Currently not exposed by the runtime + // .Case("halter", RSReduceBreakpointResolver::eKernelTypeHalter) + .Default(0); + }; + + // Matching a comma separated list of known words is fairly + // straightforward with PCRE, but we're using ERE, so we end up with a + // little ugliness... + RegularExpression match_type_list( + llvm::StringRef("^([[:alpha:]]+)(,[[:alpha:]]+){0,4}$")); + + assert(match_type_list.IsValid()); + + if (!match_type_list.Execute(option_val)) { + err_str.PutCString( + "a comma-separated list of kernel types is required"); + return false; + } + + // splitting on commas is much easier with llvm::StringRef than regex + llvm::SmallVector<llvm::StringRef, 5> type_names; + llvm::StringRef(option_val).split(type_names, ','); + + for (const auto &name : type_names) { + const int type = reduce_name_to_type(name); + if (!type) { + err_str.Printf("unknown kernel type name %s", name.str().c_str()); + return false; + } + m_kernel_types |= type; + } + + return true; + } + + int m_kernel_types; + llvm::StringRef m_reduce_name; + RSCoordinate m_coord; + bool m_have_coord; + }; + + Options *GetOptions() override { return &m_options; } + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc < 1) { + result.AppendErrorWithFormat("'%s' takes 1 argument of reduction name, " + "and an optional kernel type list", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + auto &outstream = result.GetOutputStream(); + auto name = command.GetArgumentAtIndex(0); + auto &target = m_exe_ctx.GetTargetSP(); + auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr; + if (!runtime->PlaceBreakpointOnReduction(target, outstream, name, coord, + m_options.m_kernel_types)) { + result.SetStatus(eReturnStatusFailed); + result.AppendError("Error: unable to place breakpoint on reduction"); + return false; + } + result.AppendMessage("Breakpoint(s) created"); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + +private: + CommandOptions m_options; +}; + +static constexpr OptionDefinition g_renderscript_kernel_bp_set_options[] = { + {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument, + nullptr, {}, 0, eArgTypeValue, + "Set a breakpoint on a single invocation of the kernel with specified " + "coordinate.\n" + "Coordinate takes the form 'x[,y][,z] where x,y,z are positive " + "integers representing kernel dimensions. " + "Any unset dimensions will be defaulted to zero."}}; + +class CommandObjectRenderScriptRuntimeKernelBreakpointSet + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelBreakpointSet( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel breakpoint set", + "Sets a breakpoint on a renderscript kernel.", + "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused), + m_options() {} + + ~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default; + + Options *GetOptions() override { return &m_options; } + + class CommandOptions : public Options { + public: + CommandOptions() : Options() {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + const int short_option = m_getopt_table[option_idx].val; + + switch (short_option) { + case 'c': { + auto coord = RSCoordinate{}; + if (!ParseCoordinate(option_arg, coord)) + err.SetErrorStringWithFormat( + "Couldn't parse coordinate '%s', should be in format 'x,y,z'.", + option_arg.str().c_str()); + else { + m_have_coord = true; + m_coord = coord; + } + break; + } + default: + err.SetErrorStringWithFormat("unrecognized option '%c'", short_option); + break; + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { + m_have_coord = false; + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_kernel_bp_set_options); + } + + RSCoordinate m_coord; + bool m_have_coord; + }; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc < 1) { + result.AppendErrorWithFormat( + "'%s' takes 1 argument of kernel name, and an optional coordinate.", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + auto &outstream = result.GetOutputStream(); + auto &target = m_exe_ctx.GetTargetSP(); + auto name = command.GetArgumentAtIndex(0); + auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr; + if (!runtime->PlaceBreakpointOnKernel(target, outstream, name, coord)) { + result.SetStatus(eReturnStatusFailed); + result.AppendErrorWithFormat( + "Error: unable to set breakpoint on kernel '%s'", name); + return false; + } + + result.AppendMessage("Breakpoint(s) created"); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + +private: + CommandOptions m_options; +}; + +class CommandObjectRenderScriptRuntimeKernelBreakpointAll + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelBreakpointAll( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel breakpoint all", + "Automatically sets a breakpoint on all renderscript kernels that " + "are or will be loaded.\n" + "Disabling option means breakpoints will no longer be set on any " + "kernels loaded in the future, " + "but does not remove currently set breakpoints.", + "renderscript kernel breakpoint all <enable/disable>", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused) {} + + ~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc != 1) { + result.AppendErrorWithFormat( + "'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + bool do_break = false; + const char *argument = command.GetArgumentAtIndex(0); + if (strcmp(argument, "enable") == 0) { + do_break = true; + result.AppendMessage("Breakpoints will be set on all kernels."); + } else if (strcmp(argument, "disable") == 0) { + do_break = false; + result.AppendMessage("Breakpoints will not be set on any new kernels."); + } else { + result.AppendErrorWithFormat( + "Argument must be either 'enable' or 'disable'"); + result.SetStatus(eReturnStatusFailed); + return false; + } + + runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP()); + + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeReductionBreakpoint + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeReductionBreakpoint( + CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript reduction breakpoint", + "Commands that manipulate breakpoints on " + "renderscript general reductions.", + nullptr) { + LoadSubCommand( + "set", CommandObjectSP( + new CommandObjectRenderScriptRuntimeReductionBreakpointSet( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeReductionBreakpoint() override = default; +}; + +class CommandObjectRenderScriptRuntimeKernelCoordinate + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeKernelCoordinate( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript kernel coordinate", + "Shows the (x,y,z) coordinate of the current kernel invocation.", + "renderscript kernel coordinate", + eCommandRequiresProcess | eCommandProcessMustBeLaunched | + eCommandProcessMustBePaused) {} + + ~CommandObjectRenderScriptRuntimeKernelCoordinate() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RSCoordinate coord{}; + bool success = RenderScriptRuntime::GetKernelCoordinate( + coord, m_exe_ctx.GetThreadPtr()); + Stream &stream = result.GetOutputStream(); + + if (success) { + stream.Printf("Coordinate: " FMT_COORD, coord.x, coord.y, coord.z); + stream.EOL(); + result.SetStatus(eReturnStatusSuccessFinishResult); + } else { + stream.Printf("Error: Coordinate could not be found."); + stream.EOL(); + result.SetStatus(eReturnStatusFailed); + } + return true; + } +}; + +class CommandObjectRenderScriptRuntimeKernelBreakpoint + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeKernelBreakpoint( + CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript kernel", + "Commands that generate breakpoints on renderscript kernels.", + nullptr) { + LoadSubCommand( + "set", + CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointSet( + interpreter))); + LoadSubCommand( + "all", + CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointAll( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeKernelBreakpoint() override = default; +}; + +class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript kernel", + "Commands that deal with RenderScript kernels.", + nullptr) { + LoadSubCommand( + "list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList( + interpreter))); + LoadSubCommand( + "coordinate", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeKernelCoordinate(interpreter))); + LoadSubCommand( + "breakpoint", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter))); + } + + ~CommandObjectRenderScriptRuntimeKernel() override = default; +}; + +class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript context dump", + "Dumps renderscript context information.", + "renderscript context dump", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeContextDump() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpContexts(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +static constexpr OptionDefinition g_renderscript_runtime_alloc_dump_options[] = { + {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, + nullptr, {}, 0, eArgTypeFilename, + "Print results to specified file instead of command line."}}; + +class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript context", + "Commands that deal with RenderScript contexts.", + nullptr) { + LoadSubCommand( + "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeContext() override = default; +}; + +class CommandObjectRenderScriptRuntimeAllocationDump + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationDump( + CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript allocation dump", + "Displays the contents of a particular allocation", + "renderscript allocation dump <ID>", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched), + m_options() {} + + ~CommandObjectRenderScriptRuntimeAllocationDump() override = default; + + Options *GetOptions() override { return &m_options; } + + class CommandOptions : public Options { + public: + CommandOptions() : Options() {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + const int short_option = m_getopt_table[option_idx].val; + + switch (short_option) { + case 'f': + m_outfile.SetFile(option_arg, FileSpec::Style::native); + FileSystem::Instance().Resolve(m_outfile); + if (FileSystem::Instance().Exists(m_outfile)) { + m_outfile.Clear(); + err.SetErrorStringWithFormat("file already exists: '%s'", + option_arg.str().c_str()); + } + break; + default: + err.SetErrorStringWithFormat("unrecognized option '%c'", short_option); + break; + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { + m_outfile.Clear(); + } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_runtime_alloc_dump_options); + } + + FileSpec m_outfile; + }; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc < 1) { + result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. " + "As well as an optional -f argument", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + const char *id_cstr = command.GetArgumentAtIndex(0); + bool success = false; + const uint32_t id = + StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success); + if (!success) { + result.AppendErrorWithFormat("invalid allocation id argument '%s'", + id_cstr); + result.SetStatus(eReturnStatusFailed); + return false; + } + + Stream *output_stream_p = nullptr; + std::unique_ptr<Stream> output_stream_storage; + + const FileSpec &outfile_spec = + m_options.m_outfile; // Dump allocation to file instead + if (outfile_spec) { + // Open output file + std::string path = outfile_spec.GetPath(); + auto file = FileSystem::Instance().Open( + outfile_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate); + if (file) { + output_stream_storage = + std::make_unique<StreamFile>(std::move(file.get())); + output_stream_p = output_stream_storage.get(); + result.GetOutputStream().Printf("Results written to '%s'", + path.c_str()); + result.GetOutputStream().EOL(); + } else { + std::string error = llvm::toString(file.takeError()); + result.AppendErrorWithFormat("Couldn't open file '%s': %s", + path.c_str(), error.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + } else + output_stream_p = &result.GetOutputStream(); + + assert(output_stream_p != nullptr); + bool dumped = + runtime->DumpAllocation(*output_stream_p, m_exe_ctx.GetFramePtr(), id); + + if (dumped) + result.SetStatus(eReturnStatusSuccessFinishResult); + else + result.SetStatus(eReturnStatusFailed); + + return true; + } + +private: + CommandOptions m_options; +}; + +static constexpr OptionDefinition g_renderscript_runtime_alloc_list_options[] = { + {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument, nullptr, + {}, 0, eArgTypeIndex, + "Only show details of a single allocation with specified id."}}; + +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() {} + + ~CommandObjectRenderScriptRuntimeAllocationList() override = default; + + Options *GetOptions() override { return &m_options; } + + class CommandOptions : public Options { + public: + CommandOptions() : Options(), m_id(0) {} + + ~CommandOptions() override = default; + + Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *exe_ctx) override { + Status err; + const int short_option = m_getopt_table[option_idx].val; + + switch (short_option) { + case 'i': + if (option_arg.getAsInteger(0, m_id)) + err.SetErrorStringWithFormat("invalid integer value for option '%c'", + short_option); + break; + default: + err.SetErrorStringWithFormat("unrecognized option '%c'", short_option); + break; + } + return err; + } + + void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; } + + llvm::ArrayRef<OptionDefinition> GetDefinitions() override { + return llvm::makeArrayRef(g_renderscript_runtime_alloc_list_options); + } + + uint32_t m_id; + }; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(), + m_options.m_id); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } + +private: + CommandOptions m_options; +}; + +class CommandObjectRenderScriptRuntimeAllocationLoad + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationLoad( + CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "renderscript allocation load", + "Loads renderscript allocation contents from a file.", + "renderscript allocation load <ID> <filename>", + eCommandRequiresProcess | eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeAllocationLoad() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc != 2) { + result.AppendErrorWithFormat( + "'%s' takes 2 arguments, an allocation ID and filename to read from.", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + const char *id_cstr = command.GetArgumentAtIndex(0); + bool success = false; + const uint32_t id = + StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success); + if (!success) { + result.AppendErrorWithFormat("invalid allocation id argument '%s'", + id_cstr); + result.SetStatus(eReturnStatusFailed); + return false; + } + + const char *path = command.GetArgumentAtIndex(1); + bool loaded = runtime->LoadAllocation(result.GetOutputStream(), id, path, + m_exe_ctx.GetFramePtr()); + + if (loaded) + result.SetStatus(eReturnStatusSuccessFinishResult); + else + result.SetStatus(eReturnStatusFailed); + + return true; + } +}; + +class CommandObjectRenderScriptRuntimeAllocationSave + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationSave( + CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript allocation save", + "Write renderscript allocation contents to a file.", + "renderscript allocation save <ID> <filename>", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeAllocationSave() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); + if (argc != 2) { + result.AppendErrorWithFormat( + "'%s' takes 2 arguments, an allocation ID and filename to read from.", + m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } + + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + const char *id_cstr = command.GetArgumentAtIndex(0); + bool success = false; + const uint32_t id = + StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success); + if (!success) { + result.AppendErrorWithFormat("invalid allocation id argument '%s'", + id_cstr); + result.SetStatus(eReturnStatusFailed); + return false; + } + + const char *path = command.GetArgumentAtIndex(1); + bool saved = runtime->SaveAllocation(result.GetOutputStream(), id, path, + m_exe_ctx.GetFramePtr()); + + if (saved) + result.SetStatus(eReturnStatusSuccessFinishResult); + else + result.SetStatus(eReturnStatusFailed); + + return true; + } +}; + +class CommandObjectRenderScriptRuntimeAllocationRefresh + : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeAllocationRefresh( + CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript allocation refresh", + "Recomputes the details of all allocations.", + "renderscript allocation refresh", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeAllocationRefresh() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + + bool success = runtime->RecomputeAllAllocations(result.GetOutputStream(), + m_exe_ctx.GetFramePtr()); + + if (success) { + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } else { + result.SetStatus(eReturnStatusFailed); + return false; + } + } +}; + +class CommandObjectRenderScriptRuntimeAllocation + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript allocation", + "Commands that deal with RenderScript allocations.", nullptr) { + LoadSubCommand( + "list", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationList(interpreter))); + LoadSubCommand( + "dump", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationDump(interpreter))); + LoadSubCommand( + "save", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationSave(interpreter))); + LoadSubCommand( + "load", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeAllocationLoad(interpreter))); + LoadSubCommand( + "refresh", + CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationRefresh( + interpreter))); + } + + ~CommandObjectRenderScriptRuntimeAllocation() override = default; +}; + +class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed { +public: + CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "renderscript status", + "Displays current RenderScript runtime status.", + "renderscript status", + eCommandRequiresProcess | + eCommandProcessMustBeLaunched) {} + + ~CommandObjectRenderScriptRuntimeStatus() override = default; + + bool DoExecute(Args &command, CommandReturnObject &result) override { + RenderScriptRuntime *runtime = llvm::cast<RenderScriptRuntime>( + m_exe_ctx.GetProcessPtr()->GetLanguageRuntime( + eLanguageTypeExtRenderScript)); + runtime->DumpStatus(result.GetOutputStream()); + result.SetStatus(eReturnStatusSuccessFinishResult); + return true; + } +}; + +class CommandObjectRenderScriptRuntimeReduction + : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntimeReduction(CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "renderscript reduction", + "Commands that handle general reduction kernels", + nullptr) { + LoadSubCommand( + "breakpoint", + CommandObjectSP(new CommandObjectRenderScriptRuntimeReductionBreakpoint( + interpreter))); + } + ~CommandObjectRenderScriptRuntimeReduction() override = default; +}; + +class CommandObjectRenderScriptRuntime : public CommandObjectMultiword { +public: + CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "renderscript", + "Commands for operating on the RenderScript runtime.", + "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))); + LoadSubCommand("scriptgroup", + NewCommandObjectRenderScriptScriptGroup(interpreter)); + LoadSubCommand( + "reduction", + CommandObjectSP( + new CommandObjectRenderScriptRuntimeReduction(interpreter))); + } + + ~CommandObjectRenderScriptRuntime() override = default; +}; + +void RenderScriptRuntime::Initiate() { assert(!m_initiated); } + +RenderScriptRuntime::RenderScriptRuntime(Process *process) + : lldb_private::CPPLanguageRuntime(process), m_initiated(false), + m_debuggerPresentFlagged(false), m_breakAllKernels(false), + m_ir_passes(nullptr) { + ModulesDidLoad(process->GetTarget().GetImages()); +} + +lldb::CommandObjectSP RenderScriptRuntime::GetCommandObject( + lldb_private::CommandInterpreter &interpreter) { + return CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter)); +} + +RenderScriptRuntime::~RenderScriptRuntime() = default; |