contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

   1 //===-- RenderScriptRuntime.cpp ---------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C Includes
  11 // C++ Includes
  12 // Other libraries and framework includes
  13 // Project includes
  14 #include "RenderScriptRuntime.h"
  15
  16 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  17 #include "lldb/Core/ConstString.h"
  18 #include "lldb/Core/Debugger.h"
  19 #include "lldb/Core/Error.h"
  20 #include "lldb/Core/Log.h"
  21 #include "lldb/Core/PluginManager.h"
  22 #include "lldb/Core/RegularExpression.h"
  23 #include "lldb/Core/ValueObjectVariable.h"
  24 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
  25 #include "lldb/Expression/UserExpression.h"
  26 #include "lldb/Host/StringConvert.h"
  27 #include "lldb/Interpreter/Args.h"
  28 #include "lldb/Interpreter/CommandInterpreter.h"
  29 #include "lldb/Interpreter/CommandObjectMultiword.h"
  30 #include "lldb/Interpreter/CommandReturnObject.h"
  31 #include "lldb/Interpreter/Options.h"
  32 #include "lldb/Symbol/Symbol.h"
  33 #include "lldb/Symbol/Type.h"
  34 #include "lldb/Symbol/VariableList.h"
  35 #include "lldb/Target/Process.h"
  36 #include "lldb/Target/RegisterContext.h"
  37 #include "lldb/Target/Target.h"
  38 #include "lldb/Target/Thread.h"
  39
  40 using namespace lldb;
  41 using namespace lldb_private;
  42 using namespace lldb_renderscript;
  43
  44 namespace
  45 {
  46
  47 // The empirical_type adds a basic level of validation to arbitrary data
  48 // allowing us to track if data has been discovered and stored or not.
  49 // An empirical_type will be marked as valid only if it has been explicitly assigned to.
  50 template <typename type_t> class empirical_type
  51 {
  52 public:
  53     // Ctor. Contents is invalid when constructed.
  54     empirical_type() : valid(false) {}
  55
  56     // Return true and copy contents to out if valid, else return false.
  57     bool
  58     get(type_t &out) const
  59     {
  60         if (valid)
  61             out = data;
  62         return valid;
  63     }
  64
  65     // Return a pointer to the contents or nullptr if it was not valid.
  66     const type_t *
  67     get() const
  68     {
  69         return valid ? &data : nullptr;
  70     }
  71
  72     // Assign data explicitly.
  73     void
  74     set(const type_t in)
  75     {
  76         data = in;
  77         valid = true;
  78     }
  79
  80     // Mark contents as invalid.
  81     void
  82     invalidate()
  83     {
  84         valid = false;
  85     }
  86
  87     // Returns true if this type contains valid data.
  88     bool
  89     isValid() const
  90     {
  91         return valid;
  92     }
  93
  94     // Assignment operator.
  95     empirical_type<type_t> &
  96     operator=(const type_t in)
  97     {
  98         set(in);
  99         return *this;
 100     }
 101
 102     // Dereference operator returns contents.
 103     // Warning: Will assert if not valid so use only when you know data is valid.
 104     const type_t &operator*() const
 105     {
 106         assert(valid);
 107         return data;
 108     }
 109
 110 protected:
 111     bool valid;
 112     type_t data;
 113 };
 114
 115 // ArgItem is used by the GetArgs() function when reading function arguments from the target.
 116 struct ArgItem
 117 {
 118     enum
 119     {
 120         ePointer,
 121         eInt32,
 122         eInt64,
 123         eLong,
 124         eBool
 125     } type;
 126
 127     uint64_t value;
 128
 129     explicit operator uint64_t() const { return value; }
 130 };
 131
 132 // Context structure to be passed into GetArgsXXX(), argument reading functions below.
 133 struct GetArgsCtx
 134 {
 135     RegisterContext *reg_ctx;
 136     Process *process;
 137 };
 138
 139 bool
 140 GetArgsX86(const GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
 141 {
 142     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 143
 144     Error error;
 145
 146     // get the current stack pointer
 147     uint64_t sp = ctx.reg_ctx->GetSP();
 148
 149     for (size_t i = 0; i < num_args; ++i)
 150     {
 151         ArgItem &arg = arg_list[i];
 152         // advance up the stack by one argument
 153         sp += sizeof(uint32_t);
 154         // get the argument type size
 155         size_t arg_size = sizeof(uint32_t);
 156         // read the argument from memory
 157         arg.value = 0;
 158         Error error;
 159         size_t read = ctx.process->ReadMemory(sp, &arg.value, sizeof(uint32_t), error);
 160         if (read != arg_size || !error.Success())
 161         {
 162             if (log)
 163                 log->Printf("%s - error reading argument: %" PRIu64 " '%s'", __FUNCTION__, uint64_t(i),
 164                             error.AsCString());
 165             return false;
 166         }
 167     }
 168     return true;
 169 }
 170
 171 bool
 172 GetArgsX86_64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
 173 {
 174     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 175
 176     // number of arguments passed in registers
 177     static const uint32_t c_args_in_reg = 6;
 178     // register passing order
 179     static const std::array<const char *, c_args_in_reg> c_reg_names{{"rdi", "rsi", "rdx", "rcx", "r8", "r9"}};
 180     // argument type to size mapping
 181     static const std::array<size_t, 5> arg_size{{
 182         8, // ePointer,
 183         4, // eInt32,
 184         8, // eInt64,
 185         8, // eLong,
 186         4, // eBool,
 187     }};
 188
 189     Error error;
 190
 191     // get the current stack pointer
 192     uint64_t sp = ctx.reg_ctx->GetSP();
 193     // step over the return address
 194     sp += sizeof(uint64_t);
 195
 196     // check the stack alignment was correct (16 byte aligned)
 197     if ((sp & 0xf) != 0x0)
 198     {
 199         if (log)
 200             log->Printf("%s - stack misaligned", __FUNCTION__);
 201         return false;
 202     }
 203
 204     // find the start of arguments on the stack
 205     uint64_t sp_offset = 0;
 206     for (uint32_t i = c_args_in_reg; i < num_args; ++i)
 207     {
 208         sp_offset += arg_size[arg_list[i].type];
 209     }
 210     // round up to multiple of 16
 211     sp_offset = (sp_offset + 0xf) & 0xf;
 212     sp += sp_offset;
 213
 214     for (size_t i = 0; i < num_args; ++i)
 215     {
 216         bool success = false;
 217         ArgItem &arg = arg_list[i];
 218         // arguments passed in registers
 219         if (i < c_args_in_reg)
 220         {
 221             const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoByName(c_reg_names[i]);
 222             RegisterValue rVal;
 223             if (ctx.reg_ctx->ReadRegister(rArg, rVal))
 224                 arg.value = rVal.GetAsUInt64(0, &success);
 225         }
 226         // arguments passed on the stack
 227         else
 228         {
 229             // get the argument type size
 230             const size_t size = arg_size[arg_list[i].type];
 231             // read the argument from memory
 232             arg.value = 0;
 233             // note: due to little endian layout reading 4 or 8 bytes will give the correct value.
 234             size_t read = ctx.process->ReadMemory(sp, &arg.value, size, error);
 235             success = (error.Success() && read==size);
 236             // advance past this argument
 237             sp -= size;
 238         }
 239         // fail if we couldn't read this argument
 240         if (!success)
 241         {
 242             if (log)
 243                 log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
 244                             __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
 245             return false;
 246         }
 247     }
 248     return true;
 249 }
 250
 251 bool
 252 GetArgsArm(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
 253 {
 254     // number of arguments passed in registers
 255     static const uint32_t c_args_in_reg = 4;
 256
 257     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 258
 259     Error error;
 260
 261     // get the current stack pointer
 262     uint64_t sp = ctx.reg_ctx->GetSP();
 263
 264     for (size_t i = 0; i < num_args; ++i)
 265     {
 266         bool success = false;
 267         ArgItem &arg = arg_list[i];
 268         // arguments passed in registers
 269         if (i < c_args_in_reg)
 270         {
 271             const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
 272             RegisterValue rVal;
 273             if (ctx.reg_ctx->ReadRegister(rArg, rVal))
 274                 arg.value = rVal.GetAsUInt32(0, &success);
 275         }
 276         // arguments passed on the stack
 277         else
 278         {
 279             // get the argument type size
 280             const size_t arg_size = sizeof(uint32_t);
 281             // clear all 64bits
 282             arg.value = 0;
 283             // read this argument from memory
 284             size_t bytes_read = ctx.process->ReadMemory(sp, &arg.value, arg_size, error);
 285             success = (error.Success() && bytes_read == arg_size);
 286             // advance the stack pointer
 287             sp += sizeof(uint32_t);
 288         }
 289         // fail if we couldn't read this argument
 290         if (!success)
 291         {
 292             if (log)
 293                 log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
 294                             __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
 295             return false;
 296         }
 297     }
 298     return true;
 299 }
 300
 301 bool
 302 GetArgsAarch64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
 303 {
 304     // number of arguments passed in registers
 305     static const uint32_t c_args_in_reg = 8;
 306
 307     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 308
 309     for (size_t i = 0; i < num_args; ++i)
 310     {
 311         bool success = false;
 312         ArgItem &arg = arg_list[i];
 313         // arguments passed in registers
 314         if (i < c_args_in_reg)
 315         {
 316             const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
 317             RegisterValue rVal;
 318             if (ctx.reg_ctx->ReadRegister(rArg, rVal))
 319                 arg.value = rVal.GetAsUInt64(0, &success);
 320         }
 321         // arguments passed on the stack
 322         else
 323         {
 324             if (log)
 325                 log->Printf("%s - reading arguments spilled to stack not implemented", __FUNCTION__);
 326         }
 327         // fail if we couldn't read this argument
 328         if (!success)
 329         {
 330             if (log)
 331                 log->Printf("%s - error reading argument: %" PRIu64, __FUNCTION__,
 332                             uint64_t(i));
 333             return false;
 334         }
 335     }
 336     return true;
 337 }
 338
 339 bool
 340 GetArgsMipsel(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
 341 {
 342     // number of arguments passed in registers
 343     static const uint32_t c_args_in_reg = 4;
 344     // register file offset to first argument
 345     static const uint32_t c_reg_offset = 4;
 346
 347     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 348
 349     Error error;
 350
 351     // find offset to arguments on the stack (+16 to skip over a0-a3 shadow space)
 352     uint64_t sp = ctx.reg_ctx->GetSP() + 16;
 353
 354     for (size_t i = 0; i < num_args; ++i)
 355     {
 356         bool success = false;
 357         ArgItem &arg = arg_list[i];
 358         // arguments passed in registers
 359         if (i < c_args_in_reg)
 360         {
 361             const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i + c_reg_offset);
 362             RegisterValue rVal;
 363             if (ctx.reg_ctx->ReadRegister(rArg, rVal))
 364                 arg.value = rVal.GetAsUInt64(0, &success);
 365         }
 366         // arguments passed on the stack
 367         else
 368         {
 369             const size_t arg_size = sizeof(uint32_t);
 370             arg.value = 0;
 371             size_t bytes_read = ctx.process->ReadMemory(sp, &arg.value, arg_size, error);
 372             success = (error.Success() && bytes_read == arg_size);
 373             // advance the stack pointer
 374             sp += arg_size;
 375         }
 376         // fail if we couldn't read this argument
 377         if (!success)
 378         {
 379             if (log)
 380                 log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
 381                             __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
 382             return false;
 383         }
 384     }
 385     return true;
 386 }
 387
 388 bool
 389 GetArgsMips64el(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
 390 {
 391     // number of arguments passed in registers
 392     static const uint32_t c_args_in_reg = 8;
 393     // register file offset to first argument
 394     static const uint32_t c_reg_offset = 4;
 395
 396     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 397
 398     Error error;
 399
 400     // get the current stack pointer
 401     uint64_t sp = ctx.reg_ctx->GetSP();
 402
 403     for (size_t i = 0; i < num_args; ++i)
 404     {
 405         bool success = false;
 406         ArgItem &arg = arg_list[i];
 407         // arguments passed in registers
 408         if (i < c_args_in_reg)
 409         {
 410             const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i + c_reg_offset);
 411             RegisterValue rVal;
 412             if (ctx.reg_ctx->ReadRegister(rArg, rVal))
 413                 arg.value = rVal.GetAsUInt64(0, &success);
 414         }
 415         // arguments passed on the stack
 416         else
 417         {
 418             // get the argument type size
 419             const size_t arg_size = sizeof(uint64_t);
 420             // clear all 64bits
 421             arg.value = 0;
 422             // read this argument from memory
 423             size_t bytes_read = ctx.process->ReadMemory(sp, &arg.value, arg_size, error);
 424             success = (error.Success() && bytes_read == arg_size);
 425             // advance the stack pointer
 426             sp += arg_size;
 427         }
 428         // fail if we couldn't read this argument
 429         if (!success)
 430         {
 431             if (log)
 432                 log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
 433                             __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
 434             return false;
 435         }
 436     }
 437     return true;
 438 }
 439
 440 bool
 441 GetArgs(ExecutionContext &context, ArgItem *arg_list, size_t num_args)
 442 {
 443     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 444
 445     // verify that we have a target
 446     if (!context.GetTargetPtr())
 447     {
 448         if (log)
 449             log->Printf("%s - invalid target", __FUNCTION__);
 450         return false;
 451     }
 452
 453     GetArgsCtx ctx = {context.GetRegisterContext(), context.GetProcessPtr()};
 454     assert(ctx.reg_ctx && ctx.process);
 455
 456     // dispatch based on architecture
 457     switch (context.GetTargetPtr()->GetArchitecture().GetMachine())
 458     {
 459         case llvm::Triple::ArchType::x86:
 460             return GetArgsX86(ctx, arg_list, num_args);
 461
 462         case llvm::Triple::ArchType::x86_64:
 463             return GetArgsX86_64(ctx, arg_list, num_args);
 464
 465         case llvm::Triple::ArchType::arm:
 466             return GetArgsArm(ctx, arg_list, num_args);
 467
 468         case llvm::Triple::ArchType::aarch64:
 469             return GetArgsAarch64(ctx, arg_list, num_args);
 470
 471         case llvm::Triple::ArchType::mipsel:
 472             return GetArgsMipsel(ctx, arg_list, num_args);
 473
 474         case llvm::Triple::ArchType::mips64el:
 475             return GetArgsMips64el(ctx, arg_list, num_args);
 476
 477         default:
 478             // unsupported architecture
 479             if (log)
 480             {
 481                 log->Printf("%s - architecture not supported: '%s'", __FUNCTION__,
 482                             context.GetTargetRef().GetArchitecture().GetArchitectureName());
 483             }
 484             return false;
 485     }
 486 }
 487 } // anonymous namespace
 488
 489 // The ScriptDetails class collects data associated with a single script instance.
 490 struct RenderScriptRuntime::ScriptDetails
 491 {
 492     ~ScriptDetails() = default;
 493
 494     enum ScriptType
 495     {
 496         eScript,
 497         eScriptC
 498     };
 499
 500     // The derived type of the script.
 501     empirical_type<ScriptType> type;
 502     // The name of the original source file.
 503     empirical_type<std::string> resName;
 504     // Path to script .so file on the device.
 505     empirical_type<std::string> scriptDyLib;
 506     // Directory where kernel objects are cached on device.
 507     empirical_type<std::string> cacheDir;
 508     // Pointer to the context which owns this script.
 509     empirical_type<lldb::addr_t> context;
 510     // Pointer to the script object itself.
 511     empirical_type<lldb::addr_t> script;
 512 };
 513
 514 // This Element class represents the Element object in RS,
 515 // defining the type associated with an Allocation.
 516 struct RenderScriptRuntime::Element
 517 {
 518     // Taken from rsDefines.h
 519     enum DataKind
 520     {
 521         RS_KIND_USER,
 522         RS_KIND_PIXEL_L = 7,
 523         RS_KIND_PIXEL_A,
 524         RS_KIND_PIXEL_LA,
 525         RS_KIND_PIXEL_RGB,
 526         RS_KIND_PIXEL_RGBA,
 527         RS_KIND_PIXEL_DEPTH,
 528         RS_KIND_PIXEL_YUV,
 529         RS_KIND_INVALID = 100
 530     };
 531
 532     // Taken from rsDefines.h
 533     enum DataType
 534     {
 535         RS_TYPE_NONE = 0,
 536         RS_TYPE_FLOAT_16,
 537         RS_TYPE_FLOAT_32,
 538         RS_TYPE_FLOAT_64,
 539         RS_TYPE_SIGNED_8,
 540         RS_TYPE_SIGNED_16,
 541         RS_TYPE_SIGNED_32,
 542         RS_TYPE_SIGNED_64,
 543         RS_TYPE_UNSIGNED_8,
 544         RS_TYPE_UNSIGNED_16,
 545         RS_TYPE_UNSIGNED_32,
 546         RS_TYPE_UNSIGNED_64,
 547         RS_TYPE_BOOLEAN,
 548
 549         RS_TYPE_UNSIGNED_5_6_5,
 550         RS_TYPE_UNSIGNED_5_5_5_1,
 551         RS_TYPE_UNSIGNED_4_4_4_4,
 552
 553         RS_TYPE_MATRIX_4X4,
 554         RS_TYPE_MATRIX_3X3,
 555         RS_TYPE_MATRIX_2X2,
 556
 557         RS_TYPE_ELEMENT = 1000,
 558         RS_TYPE_TYPE,
 559         RS_TYPE_ALLOCATION,
 560         RS_TYPE_SAMPLER,
 561         RS_TYPE_SCRIPT,
 562         RS_TYPE_MESH,
 563         RS_TYPE_PROGRAM_FRAGMENT,
 564         RS_TYPE_PROGRAM_VERTEX,
 565         RS_TYPE_PROGRAM_RASTER,
 566         RS_TYPE_PROGRAM_STORE,
 567         RS_TYPE_FONT,
 568
 569         RS_TYPE_INVALID = 10000
 570     };
 571
 572     std::vector<Element> children;            // Child Element fields for structs
 573     empirical_type<lldb::addr_t> element_ptr; // Pointer to the RS Element of the Type
 574     empirical_type<DataType> type;            // Type of each data pointer stored by the allocation
 575     empirical_type<DataKind> type_kind;       // Defines pixel type if Allocation is created from an image
 576     empirical_type<uint32_t> type_vec_size;   // Vector size of each data point, e.g '4' for uchar4
 577     empirical_type<uint32_t> field_count;     // Number of Subelements
 578     empirical_type<uint32_t> datum_size;      // Size of a single Element with padding
 579     empirical_type<uint32_t> padding;         // Number of padding bytes
 580     empirical_type<uint32_t> array_size;      // Number of items in array, only needed for strucrs
 581     ConstString type_name;                    // Name of type, only needed for structs
 582
 583     static const ConstString &
 584     GetFallbackStructName(); // Print this as the type name of a struct Element
 585                              // If we can't resolve the actual struct name
 586
 587     bool
 588     shouldRefresh() const
 589     {
 590         const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
 591         const bool valid_type = type.isValid() && type_vec_size.isValid() && type_kind.isValid();
 592         return !valid_ptr || !valid_type || !datum_size.isValid();
 593     }
 594 };
 595
 596 // This AllocationDetails class collects data associated with a single
 597 // allocation instance.
 598 struct RenderScriptRuntime::AllocationDetails
 599 {
 600     struct Dimension
 601     {
 602         uint32_t dim_1;
 603         uint32_t dim_2;
 604         uint32_t dim_3;
 605         uint32_t cubeMap;
 606
 607         Dimension()
 608         {
 609             dim_1 = 0;
 610             dim_2 = 0;
 611             dim_3 = 0;
 612             cubeMap = 0;
 613         }
 614     };
 615
 616     // The FileHeader struct specifies the header we use for writing allocations to a binary file.
 617     // Our format begins with the ASCII characters "RSAD", identifying the file as an allocation dump.
 618     // Member variables dims and hdr_size are then written consecutively, immediately followed by an instance of
 619     // the ElementHeader struct. Because Elements can contain subelements, there may be more than one instance
 620     // of the ElementHeader struct. With this first instance being the root element, and the other instances being
 621     // the root's descendants. To identify which instances are an ElementHeader's children, each struct
 622     // is immediately followed by a sequence of consecutive offsets to the start of its child structs.
 623     // These offsets are 4 bytes in size, and the 0 offset signifies no more children.
 624     struct FileHeader
 625     {
 626         uint8_t ident[4];  // ASCII 'RSAD' identifying the file
 627         uint32_t dims[3];  // Dimensions
 628         uint16_t hdr_size; // Header size in bytes, including all element headers
 629     };
 630
 631     struct ElementHeader
 632     {
 633         uint16_t type;         // DataType enum
 634         uint32_t kind;         // DataKind enum
 635         uint32_t element_size; // Size of a single element, including padding
 636         uint16_t vector_size;  // Vector width
 637         uint32_t array_size;   // Number of elements in array
 638     };
 639
 640     // Monotonically increasing from 1
 641     static uint32_t ID;
 642
 643     // Maps Allocation DataType enum and vector size to printable strings
 644     // using mapping from RenderScript numerical types summary documentation
 645     static const char *RsDataTypeToString[][4];
 646
 647     // Maps Allocation DataKind enum to printable strings
 648     static const char *RsDataKindToString[];
 649
 650     // Maps allocation types to format sizes for printing.
 651     static const uint32_t RSTypeToFormat[][3];
 652
 653     // Give each allocation an ID as a way
 654     // for commands to reference it.
 655     const uint32_t id;
 656
 657     RenderScriptRuntime::Element element;  // Allocation Element type
 658     empirical_type<Dimension> dimension;   // Dimensions of the Allocation
 659     empirical_type<lldb::addr_t> address;  // Pointer to address of the RS Allocation
 660     empirical_type<lldb::addr_t> data_ptr; // Pointer to the data held by the Allocation
 661     empirical_type<lldb::addr_t> type_ptr; // Pointer to the RS Type of the Allocation
 662     empirical_type<lldb::addr_t> context;  // Pointer to the RS Context of the Allocation
 663     empirical_type<uint32_t> size;         // Size of the allocation
 664     empirical_type<uint32_t> stride;       // Stride between rows of the allocation
 665
 666     // Give each allocation an id, so we can reference it in user commands.
 667     AllocationDetails() : id(ID++) {}
 668
 669     bool
 670     shouldRefresh() const
 671     {
 672         bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0;
 673         valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0;
 674         return !valid_ptrs || !dimension.isValid() || !size.isValid() || element.shouldRefresh();
 675     }
 676 };
 677
 678 const ConstString &
 679 RenderScriptRuntime::Element::GetFallbackStructName()
 680 {
 681     static const ConstString FallbackStructName("struct");
 682     return FallbackStructName;
 683 }
 684
 685 uint32_t RenderScriptRuntime::AllocationDetails::ID = 1;
 686
 687 const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = {
 688     "User",
 689     "Undefined",  "Undefined",   "Undefined", "Undefined", "Undefined",  "Undefined", // Enum jumps from 0 to 7
 690     "L Pixel",    "A Pixel",     "LA Pixel",  "RGB Pixel",
 691     "RGBA Pixel", "Pixel Depth", "YUV Pixel"};
 692
 693 const char *RenderScriptRuntime::AllocationDetails::RsDataTypeToString[][4] = {
 694     {"None", "None", "None", "None"},
 695     {"half", "half2", "half3", "half4"},
 696     {"float", "float2", "float3", "float4"},
 697     {"double", "double2", "double3", "double4"},
 698     {"char", "char2", "char3", "char4"},
 699     {"short", "short2", "short3", "short4"},
 700     {"int", "int2", "int3", "int4"},
 701     {"long", "long2", "long3", "long4"},
 702     {"uchar", "uchar2", "uchar3", "uchar4"},
 703     {"ushort", "ushort2", "ushort3", "ushort4"},
 704     {"uint", "uint2", "uint3", "uint4"},
 705     {"ulong", "ulong2", "ulong3", "ulong4"},
 706     {"bool", "bool2", "bool3", "bool4"},
 707     {"packed_565", "packed_565", "packed_565", "packed_565"},
 708     {"packed_5551", "packed_5551", "packed_5551", "packed_5551"},
 709     {"packed_4444", "packed_4444", "packed_4444", "packed_4444"},
 710     {"rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4", "rs_matrix4x4"},
 711     {"rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3", "rs_matrix3x3"},
 712     {"rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2", "rs_matrix2x2"},
 713
 714     // Handlers
 715     {"RS Element", "RS Element", "RS Element", "RS Element"},
 716     {"RS Type", "RS Type", "RS Type", "RS Type"},
 717     {"RS Allocation", "RS Allocation", "RS Allocation", "RS Allocation"},
 718     {"RS Sampler", "RS Sampler", "RS Sampler", "RS Sampler"},
 719     {"RS Script", "RS Script", "RS Script", "RS Script"},
 720
 721     // Deprecated
 722     {"RS Mesh", "RS Mesh", "RS Mesh", "RS Mesh"},
 723     {"RS Program Fragment", "RS Program Fragment", "RS Program Fragment", "RS Program Fragment"},
 724     {"RS Program Vertex", "RS Program Vertex", "RS Program Vertex", "RS Program Vertex"},
 725     {"RS Program Raster", "RS Program Raster", "RS Program Raster", "RS Program Raster"},
 726     {"RS Program Store", "RS Program Store", "RS Program Store", "RS Program Store"},
 727     {"RS Font", "RS Font", "RS Font", "RS Font"}};
 728
 729 // Used as an index into the RSTypeToFormat array elements
 730 enum TypeToFormatIndex
 731 {
 732     eFormatSingle = 0,
 733     eFormatVector,
 734     eElementSize
 735 };
 736
 737 // { format enum of single element, format enum of element vector, size of element}
 738 const uint32_t RenderScriptRuntime::AllocationDetails::RSTypeToFormat[][3] = {
 739     {eFormatHex, eFormatHex, 1},                                          // RS_TYPE_NONE
 740     {eFormatFloat, eFormatVectorOfFloat16, 2},                            // RS_TYPE_FLOAT_16
 741     {eFormatFloat, eFormatVectorOfFloat32, sizeof(float)},                // RS_TYPE_FLOAT_32
 742     {eFormatFloat, eFormatVectorOfFloat64, sizeof(double)},               // RS_TYPE_FLOAT_64
 743     {eFormatDecimal, eFormatVectorOfSInt8, sizeof(int8_t)},               // RS_TYPE_SIGNED_8
 744     {eFormatDecimal, eFormatVectorOfSInt16, sizeof(int16_t)},             // RS_TYPE_SIGNED_16
 745     {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)},             // RS_TYPE_SIGNED_32
 746     {eFormatDecimal, eFormatVectorOfSInt64, sizeof(int64_t)},             // RS_TYPE_SIGNED_64
 747     {eFormatDecimal, eFormatVectorOfUInt8, sizeof(uint8_t)},              // RS_TYPE_UNSIGNED_8
 748     {eFormatDecimal, eFormatVectorOfUInt16, sizeof(uint16_t)},            // RS_TYPE_UNSIGNED_16
 749     {eFormatDecimal, eFormatVectorOfUInt32, sizeof(uint32_t)},            // RS_TYPE_UNSIGNED_32
 750     {eFormatDecimal, eFormatVectorOfUInt64, sizeof(uint64_t)},            // RS_TYPE_UNSIGNED_64
 751     {eFormatBoolean, eFormatBoolean, 1},                                  // RS_TYPE_BOOL
 752     {eFormatHex, eFormatHex, sizeof(uint16_t)},                           // RS_TYPE_UNSIGNED_5_6_5
 753     {eFormatHex, eFormatHex, sizeof(uint16_t)},                           // RS_TYPE_UNSIGNED_5_5_5_1
 754     {eFormatHex, eFormatHex, sizeof(uint16_t)},                           // RS_TYPE_UNSIGNED_4_4_4_4
 755     {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 16}, // RS_TYPE_MATRIX_4X4
 756     {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 9},  // RS_TYPE_MATRIX_3X3
 757     {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 4}   // RS_TYPE_MATRIX_2X2
 758 };
 759
 760 //------------------------------------------------------------------
 761 // Static Functions
 762 //------------------------------------------------------------------
 763 LanguageRuntime *
 764 RenderScriptRuntime::CreateInstance(Process *process, lldb::LanguageType language)
 765 {
 766
 767     if (language == eLanguageTypeExtRenderScript)
 768         return new RenderScriptRuntime(process);
 769     else
 770         return nullptr;
 771 }
 772
 773 // Callback with a module to search for matching symbols.
 774 // We first check that the module contains RS kernels.
 775 // Then look for a symbol which matches our kernel name.
 776 // The breakpoint address is finally set using the address of this symbol.
 777 Searcher::CallbackReturn
 778 RSBreakpointResolver::SearchCallback(SearchFilter &filter, SymbolContext &context, Address *, bool)
 779 {
 780     ModuleSP module = context.module_sp;
 781
 782     if (!module)
 783         return Searcher::eCallbackReturnContinue;
 784
 785     // Is this a module containing renderscript kernels?
 786     if (nullptr == module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData))
 787         return Searcher::eCallbackReturnContinue;
 788
 789     // Attempt to set a breakpoint on the kernel name symbol within the module library.
 790     // If it's not found, it's likely debug info is unavailable - try to set a
 791     // breakpoint on <name>.expand.
 792
 793     const Symbol *kernel_sym = module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
 794     if (!kernel_sym)
 795     {
 796         std::string kernel_name_expanded(m_kernel_name.AsCString());
 797         kernel_name_expanded.append(".expand");
 798         kernel_sym = module->FindFirstSymbolWithNameAndType(ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode);
 799     }
 800
 801     if (kernel_sym)
 802     {
 803         Address bp_addr = kernel_sym->GetAddress();
 804         if (filter.AddressPasses(bp_addr))
 805             m_breakpoint->AddLocation(bp_addr);
 806     }
 807
 808     return Searcher::eCallbackReturnContinue;
 809 }
 810
 811 void
 812 RenderScriptRuntime::Initialize()
 813 {
 814     PluginManager::RegisterPlugin(GetPluginNameStatic(), "RenderScript language support", CreateInstance,
 815                                   GetCommandObject);
 816 }
 817
 818 void
 819 RenderScriptRuntime::Terminate()
 820 {
 821     PluginManager::UnregisterPlugin(CreateInstance);
 822 }
 823
 824 lldb_private::ConstString
 825 RenderScriptRuntime::GetPluginNameStatic()
 826 {
 827     static ConstString g_name("renderscript");
 828     return g_name;
 829 }
 830
 831 RenderScriptRuntime::ModuleKind
 832 RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp)
 833 {
 834     if (module_sp)
 835     {
 836         // Is this a module containing renderscript kernels?
 837         const Symbol *info_sym = module_sp->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData);
 838         if (info_sym)
 839         {
 840             return eModuleKindKernelObj;
 841         }
 842
 843         // Is this the main RS runtime library
 844         const ConstString rs_lib("libRS.so");
 845         if (module_sp->GetFileSpec().GetFilename() == rs_lib)
 846         {
 847             return eModuleKindLibRS;
 848         }
 849
 850         const ConstString rs_driverlib("libRSDriver.so");
 851         if (module_sp->GetFileSpec().GetFilename() == rs_driverlib)
 852         {
 853             return eModuleKindDriver;
 854         }
 855
 856         const ConstString rs_cpureflib("libRSCpuRef.so");
 857         if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib)
 858         {
 859             return eModuleKindImpl;
 860         }
 861     }
 862     return eModuleKindIgnored;
 863 }
 864
 865 bool
 866 RenderScriptRuntime::IsRenderScriptModule(const lldb::ModuleSP &module_sp)
 867 {
 868     return GetModuleKind(module_sp) != eModuleKindIgnored;
 869 }
 870
 871 void
 872 RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list)
 873 {
 874     std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
 875
 876     size_t num_modules = module_list.GetSize();
 877     for (size_t i = 0; i < num_modules; i++)
 878     {
 879         auto mod = module_list.GetModuleAtIndex(i);
 880         if (IsRenderScriptModule(mod))
 881         {
 882             LoadModule(mod);
 883         }
 884     }
 885 }
 886
 887 //------------------------------------------------------------------
 888 // PluginInterface protocol
 889 //------------------------------------------------------------------
 890 lldb_private::ConstString
 891 RenderScriptRuntime::GetPluginName()
 892 {
 893     return GetPluginNameStatic();
 894 }
 895
 896 uint32_t
 897 RenderScriptRuntime::GetPluginVersion()
 898 {
 899     return 1;
 900 }
 901
 902 bool
 903 RenderScriptRuntime::IsVTableName(const char *name)
 904 {
 905     return false;
 906 }
 907
 908 bool
 909 RenderScriptRuntime::GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic,
 910                                               TypeAndOrName &class_type_or_name, Address &address,
 911                                               Value::ValueType &value_type)
 912 {
 913     return false;
 914 }
 915
 916 TypeAndOrName
 917 RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value)
 918 {
 919     return type_and_or_name;
 920 }
 921
 922 bool
 923 RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value)
 924 {
 925     return false;
 926 }
 927
 928 lldb::BreakpointResolverSP
 929 RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp)
 930 {
 931     BreakpointResolverSP resolver_sp;
 932     return resolver_sp;
 933 }
 934
 935 const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] = {
 936     // rsdScript
 937     {
 938         "rsdScriptInit",
 939         "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_7ScriptCEPKcS7_PKhjj",
 940         "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_7ScriptCEPKcS7_PKhmj",
 941         0,
 942         RenderScriptRuntime::eModuleKindDriver,
 943         &lldb_private::RenderScriptRuntime::CaptureScriptInit
 944     },
 945     {
 946         "rsdScriptInvokeForEachMulti",
 947         "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall",
 948         "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0_6ScriptEjPPKNS0_10AllocationEmPS6_PKvmPK12RsScriptCall",
 949         0,
 950         RenderScriptRuntime::eModuleKindDriver,
 951         &lldb_private::RenderScriptRuntime::CaptureScriptInvokeForEachMulti
 952     },
 953     {
 954         "rsdScriptSetGlobalVar",
 955         "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_6ScriptEjPvj",
 956         "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_6ScriptEjPvm",
 957         0,
 958         RenderScriptRuntime::eModuleKindDriver,
 959         &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar
 960     },
 961
 962     // rsdAllocation
 963     {
 964         "rsdAllocationInit",
 965         "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_10AllocationEb",
 966         "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_10AllocationEb",
 967         0,
 968         RenderScriptRuntime::eModuleKindDriver,
 969         &lldb_private::RenderScriptRuntime::CaptureAllocationInit
 970     },
 971     {
 972         "rsdAllocationRead2D",
 973         "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_10AllocationEjjj23RsAllocationCubemapFacejjPvjj",
 974         "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_10AllocationEjjj23RsAllocationCubemapFacejjPvmm",
 975         0,
 976         RenderScriptRuntime::eModuleKindDriver,
 977         nullptr
 978     },
 979     {
 980         "rsdAllocationDestroy",
 981         "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_10AllocationE",
 982         "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_10AllocationE",
 983         0,
 984         RenderScriptRuntime::eModuleKindDriver,
 985         &lldb_private::RenderScriptRuntime::CaptureAllocationDestroy
 986     },
 987 };
 988
 989 const size_t RenderScriptRuntime::s_runtimeHookCount = sizeof(s_runtimeHookDefns) / sizeof(s_runtimeHookDefns[0]);
 990
 991 bool
 992 RenderScriptRuntime::HookCallback(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id,
 993                                   lldb::user_id_t break_loc_id)
 994 {
 995     RuntimeHook *hook_info = (RuntimeHook *)baton;
 996     ExecutionContext context(ctx->exe_ctx_ref);
 997
 998     RenderScriptRuntime *lang_rt =
 999         (RenderScriptRuntime *)context.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
1000
1001     lang_rt->HookCallback(hook_info, context);
1002
1003     return false;
1004 }
1005
1006 void
1007 RenderScriptRuntime::HookCallback(RuntimeHook *hook_info, ExecutionContext &context)
1008 {
1009     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1010
1011     if (log)
1012         log->Printf("%s - '%s'", __FUNCTION__, hook_info->defn->name);
1013
1014     if (hook_info->defn->grabber)
1015     {
1016         (this->*(hook_info->defn->grabber))(hook_info, context);
1017     }
1018 }
1019
1020 void
1021 RenderScriptRuntime::CaptureScriptInvokeForEachMulti(RuntimeHook* hook_info,
1022                                                      ExecutionContext& context)
1023 {
1024     Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1025
1026     enum
1027     {
1028         eRsContext = 0,
1029         eRsScript,
1030         eRsSlot,
1031         eRsAIns,
1032         eRsInLen,
1033         eRsAOut,
1034         eRsUsr,
1035         eRsUsrLen,
1036         eRsSc,
1037     };
1038
1039     std::array<ArgItem, 9> args{{
1040         ArgItem{ArgItem::ePointer, 0}, // const Context       *rsc
1041         ArgItem{ArgItem::ePointer, 0}, // Script              *s
1042         ArgItem{ArgItem::eInt32, 0},   // uint32_t             slot
1043         ArgItem{ArgItem::ePointer, 0}, // const Allocation   **aIns
1044         ArgItem{ArgItem::eInt32, 0},   // size_t               inLen
1045         ArgItem{ArgItem::ePointer, 0}, // Allocation          *aout
1046         ArgItem{ArgItem::ePointer, 0}, // const void          *usr
1047         ArgItem{ArgItem::eInt32, 0},   // size_t               usrLen
1048         ArgItem{ArgItem::ePointer, 0}, // const RsScriptCall  *sc
1049     }};
1050
1051     bool success = GetArgs(context, &args[0], args.size());
1052     if (!success)
1053     {
1054         if (log)
1055             log->Printf("%s - Error while reading the function parameters", __FUNCTION__);
1056         return;
1057     }
1058
1059     const uint32_t target_ptr_size = m_process->GetAddressByteSize();
1060     Error error;
1061     std::vector<uint64_t> allocs;
1062
1063     // traverse allocation list
1064     for (uint64_t i = 0; i < uint64_t(args[eRsInLen]); ++i)
1065     {
1066         // calculate offest to allocation pointer
1067         const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size;
1068
1069         // Note: due to little endian layout, reading 32bits or 64bits into res64 will
1070         //       give the correct results.
1071
1072         uint64_t res64 = 0;
1073         size_t read = m_process->ReadMemory(addr, &res64, target_ptr_size, error);
1074         if (read != target_ptr_size || !error.Success())
1075         {
1076             if (log)
1077                 log->Printf("%s - Error while reading allocation list argument %" PRIu64, __FUNCTION__, i);
1078         }
1079         else
1080         {
1081             allocs.push_back(res64);
1082         }
1083     }
1084
1085     // if there is an output allocation track it
1086     if (uint64_t aOut = uint64_t(args[eRsAOut]))
1087     {
1088         allocs.push_back(aOut);
1089     }
1090
1091     // for all allocations we have found
1092     for (const uint64_t alloc_addr : allocs)
1093     {
1094         AllocationDetails* alloc = LookUpAllocation(alloc_addr, true);
1095         if (alloc)
1096         {
1097             // save the allocation address
1098             if (alloc->address.isValid())
1099             {
1100                 // check the allocation address we already have matches
1101                 assert(*alloc->address.get() == alloc_addr);
1102             }
1103             else
1104             {
1105                 alloc->address = alloc_addr;
1106             }
1107
1108             // save the context
1109             if (log)
1110             {
1111                 if (alloc->context.isValid() && *alloc->context.get() != addr_t(args[eRsContext]))
1112                     log->Printf("%s - Allocation used by multiple contexts", __FUNCTION__);
1113             }
1114             alloc->context = addr_t(args[eRsContext]);
1115         }
1116     }
1117
1118     // make sure we track this script object
1119     if (lldb_private::RenderScriptRuntime::ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true))
1120     {
1121         if (log)
1122         {
1123             if (script->context.isValid() && *script->context.get() != addr_t(args[eRsContext]))
1124                 log->Printf("%s - Script used by multiple contexts", __FUNCTION__);
1125         }
1126         script->context = addr_t(args[eRsContext]);
1127     }
1128 }
1129
1130 void
1131 RenderScriptRuntime::CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context)
1132 {
1133     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1134
1135     enum
1136     {
1137         eRsContext,
1138         eRsScript,
1139         eRsId,
1140         eRsData,
1141         eRsLength,
1142     };
1143
1144     std::array<ArgItem, 5> args{{
1145         ArgItem{ArgItem::ePointer, 0}, // eRsContext
1146         ArgItem{ArgItem::ePointer, 0}, // eRsScript
1147         ArgItem{ArgItem::eInt32, 0},   // eRsId
1148         ArgItem{ArgItem::ePointer, 0}, // eRsData
1149         ArgItem{ArgItem::eInt32, 0},   // eRsLength
1150     }};
1151
1152     bool success = GetArgs(context, &args[0], args.size());
1153     if (!success)
1154     {
1155         if (log)
1156             log->Printf("%s - error reading the function parameters.", __FUNCTION__);
1157         return;
1158     }
1159
1160     if (log)
1161     {
1162         log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 " slot %" PRIu64 " = 0x%" PRIx64 ":%" PRIu64 "bytes.", __FUNCTION__,
1163                     uint64_t(args[eRsContext]), uint64_t(args[eRsScript]), uint64_t(args[eRsId]),
1164                     uint64_t(args[eRsData]), uint64_t(args[eRsLength]));
1165
1166         addr_t script_addr = addr_t(args[eRsScript]);
1167         if (m_scriptMappings.find(script_addr) != m_scriptMappings.end())
1168         {
1169             auto rsm = m_scriptMappings[script_addr];
1170             if (uint64_t(args[eRsId]) < rsm->m_globals.size())
1171             {
1172                 auto rsg = rsm->m_globals[uint64_t(args[eRsId])];
1173                 log->Printf("%s - Setting of '%s' within '%s' inferred", __FUNCTION__, rsg.m_name.AsCString(),
1174                             rsm->m_module->GetFileSpec().GetFilename().AsCString());
1175             }
1176         }
1177     }
1178 }
1179
1180 void
1181 RenderScriptRuntime::CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context)
1182 {
1183     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1184
1185     enum
1186     {
1187         eRsContext,
1188         eRsAlloc,
1189         eRsForceZero
1190     };
1191
1192     std::array<ArgItem, 3> args{{
1193         ArgItem{ArgItem::ePointer, 0}, // eRsContext
1194         ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
1195         ArgItem{ArgItem::eBool, 0},    // eRsForceZero
1196     }};
1197
1198     bool success = GetArgs(context, &args[0], args.size());
1199     if (!success) // error case
1200     {
1201         if (log)
1202             log->Printf("%s - error while reading the function parameters", __FUNCTION__);
1203         return; // abort
1204     }
1205
1206     if (log)
1207         log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 ",0x%" PRIx64 " .", __FUNCTION__, uint64_t(args[eRsContext]),
1208                     uint64_t(args[eRsAlloc]), uint64_t(args[eRsForceZero]));
1209
1210     AllocationDetails *alloc = LookUpAllocation(uint64_t(args[eRsAlloc]), true);
1211     if (alloc)
1212         alloc->context = uint64_t(args[eRsContext]);
1213 }
1214
1215 void
1216 RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook_info, ExecutionContext &context)
1217 {
1218     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1219
1220     enum
1221     {
1222         eRsContext,
1223         eRsAlloc,
1224     };
1225
1226     std::array<ArgItem, 2> args{{
1227         ArgItem{ArgItem::ePointer, 0}, // eRsContext
1228         ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
1229     }};
1230
1231     bool success = GetArgs(context, &args[0], args.size());
1232     if (!success)
1233     {
1234         if (log)
1235             log->Printf("%s - error while reading the function parameters.", __FUNCTION__);
1236         return;
1237     }
1238
1239     if (log)
1240         log->Printf("%s - 0x%" PRIx64 ", 0x%" PRIx64 ".", __FUNCTION__, uint64_t(args[eRsContext]),
1241                     uint64_t(args[eRsAlloc]));
1242
1243     for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter)
1244     {
1245         auto &allocation_ap = *iter; // get the unique pointer
1246         if (allocation_ap->address.isValid() && *allocation_ap->address.get() == addr_t(args[eRsAlloc]))
1247         {
1248             m_allocations.erase(iter);
1249             if (log)
1250                 log->Printf("%s - deleted allocation entry.", __FUNCTION__);
1251             return;
1252         }
1253     }
1254
1255     if (log)
1256         log->Printf("%s - couldn't find destroyed allocation.", __FUNCTION__);
1257 }
1258
1259 void
1260 RenderScriptRuntime::CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context)
1261 {
1262     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1263
1264     Error error;
1265     Process *process = context.GetProcessPtr();
1266
1267     enum
1268     {
1269         eRsContext,
1270         eRsScript,
1271         eRsResNamePtr,
1272         eRsCachedDirPtr
1273     };
1274
1275     std::array<ArgItem, 4> args{{ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0},
1276                                  ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}}};
1277     bool success = GetArgs(context, &args[0], args.size());
1278     if (!success)
1279     {
1280         if (log)
1281             log->Printf("%s - error while reading the function parameters.", __FUNCTION__);
1282         return;
1283     }
1284
1285     std::string resname;
1286     process->ReadCStringFromMemory(addr_t(args[eRsResNamePtr]), resname, error);
1287     if (error.Fail())
1288     {
1289         if (log)
1290             log->Printf("%s - error reading resname: %s.", __FUNCTION__, error.AsCString());
1291     }
1292
1293     std::string cachedir;
1294     process->ReadCStringFromMemory(addr_t(args[eRsCachedDirPtr]), cachedir, error);
1295     if (error.Fail())
1296     {
1297         if (log)
1298             log->Printf("%s - error reading cachedir: %s.", __FUNCTION__, error.AsCString());
1299     }
1300
1301     if (log)
1302         log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 " => '%s' at '%s' .", __FUNCTION__, uint64_t(args[eRsContext]),
1303                     uint64_t(args[eRsScript]), resname.c_str(), cachedir.c_str());
1304
1305     if (resname.size() > 0)
1306     {
1307         StreamString strm;
1308         strm.Printf("librs.%s.so", resname.c_str());
1309
1310         ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true);
1311         if (script)
1312         {
1313             script->type = ScriptDetails::eScriptC;
1314             script->cacheDir = cachedir;
1315             script->resName = resname;
1316             script->scriptDyLib = strm.GetData();
1317             script->context = addr_t(args[eRsContext]);
1318         }
1319
1320         if (log)
1321             log->Printf("%s - '%s' tagged with context 0x%" PRIx64 " and script 0x%" PRIx64 ".", __FUNCTION__,
1322                         strm.GetData(), uint64_t(args[eRsContext]), uint64_t(args[eRsScript]));
1323     }
1324     else if (log)
1325     {
1326         log->Printf("%s - resource name invalid, Script not tagged.", __FUNCTION__);
1327     }
1328 }
1329
1330 void
1331 RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind)
1332 {
1333     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1334
1335     if (!module)
1336     {
1337         return;
1338     }
1339
1340     Target &target = GetProcess()->GetTarget();
1341     llvm::Triple::ArchType targetArchType = target.GetArchitecture().GetMachine();
1342
1343     if (targetArchType != llvm::Triple::ArchType::x86 &&
1344         targetArchType != llvm::Triple::ArchType::arm &&
1345         targetArchType != llvm::Triple::ArchType::aarch64 &&
1346         targetArchType != llvm::Triple::ArchType::mipsel &&
1347         targetArchType != llvm::Triple::ArchType::mips64el &&
1348         targetArchType != llvm::Triple::ArchType::x86_64)
1349     {
1350         if (log)
1351             log->Printf("%s - unable to hook runtime functions.", __FUNCTION__);
1352         return;
1353     }
1354
1355     uint32_t archByteSize = target.GetArchitecture().GetAddressByteSize();
1356
1357     for (size_t idx = 0; idx < s_runtimeHookCount; idx++)
1358     {
1359         const HookDefn *hook_defn = &s_runtimeHookDefns[idx];
1360         if (hook_defn->kind != kind)
1361         {
1362             continue;
1363         }
1364
1365         const char *symbol_name = (archByteSize == 4) ? hook_defn->symbol_name_m32 : hook_defn->symbol_name_m64;
1366
1367         const Symbol *sym = module->FindFirstSymbolWithNameAndType(ConstString(symbol_name), eSymbolTypeCode);
1368         if (!sym)
1369         {
1370             if (log)
1371             {
1372                 log->Printf("%s - symbol '%s' related to the function %s not found",
1373                             __FUNCTION__, symbol_name, hook_defn->name);
1374             }
1375             continue;
1376         }
1377
1378         addr_t addr = sym->GetLoadAddress(&target);
1379         if (addr == LLDB_INVALID_ADDRESS)
1380         {
1381             if (log)
1382                 log->Printf("%s - unable to resolve the address of hook function '%s' with symbol '%s'.",
1383                             __FUNCTION__, hook_defn->name, symbol_name);
1384             continue;
1385         }
1386         else
1387         {
1388             if (log)
1389                 log->Printf("%s - function %s, address resolved at 0x%" PRIx64,
1390                             __FUNCTION__, hook_defn->name, addr);
1391         }
1392
1393         RuntimeHookSP hook(new RuntimeHook());
1394         hook->address = addr;
1395         hook->defn = hook_defn;
1396         hook->bp_sp = target.CreateBreakpoint(addr, true, false);
1397         hook->bp_sp->SetCallback(HookCallback, hook.get(), true);
1398         m_runtimeHooks[addr] = hook;
1399         if (log)
1400         {
1401             log->Printf("%s - successfully hooked '%s' in '%s' version %" PRIu64 " at 0x%" PRIx64 ".",
1402                         __FUNCTION__, hook_defn->name, module->GetFileSpec().GetFilename().AsCString(),
1403                         (uint64_t)hook_defn->version, (uint64_t)addr);
1404         }
1405     }
1406 }
1407
1408 void
1409 RenderScriptRuntime::FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp)
1410 {
1411     if (!rsmodule_sp)
1412         return;
1413
1414     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1415
1416     const ModuleSP module = rsmodule_sp->m_module;
1417     const FileSpec &file = module->GetPlatformFileSpec();
1418
1419     // Iterate over all of the scripts that we currently know of.
1420     // Note: We cant push or pop to m_scripts here or it may invalidate rs_script.
1421     for (const auto &rs_script : m_scripts)
1422     {
1423         // Extract the expected .so file path for this script.
1424         std::string dylib;
1425         if (!rs_script->scriptDyLib.get(dylib))
1426             continue;
1427
1428         // Only proceed if the module that has loaded corresponds to this script.
1429         if (file.GetFilename() != ConstString(dylib.c_str()))
1430             continue;
1431
1432         // Obtain the script address which we use as a key.
1433         lldb::addr_t script;
1434         if (!rs_script->script.get(script))
1435             continue;
1436
1437         // If we have a script mapping for the current script.
1438         if (m_scriptMappings.find(script) != m_scriptMappings.end())
1439         {
1440             // if the module we have stored is different to the one we just received.
1441             if (m_scriptMappings[script] != rsmodule_sp)
1442             {
1443                 if (log)
1444                     log->Printf("%s - script %" PRIx64 " wants reassigned to new rsmodule '%s'.", __FUNCTION__,
1445                                 (uint64_t)script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
1446             }
1447         }
1448         // We don't have a script mapping for the current script.
1449         else
1450         {
1451             // Obtain the script resource name.
1452             std::string resName;
1453             if (rs_script->resName.get(resName))
1454                 // Set the modules resource name.
1455                 rsmodule_sp->m_resname = resName;
1456             // Add Script/Module pair to map.
1457             m_scriptMappings[script] = rsmodule_sp;
1458             if (log)
1459                 log->Printf("%s - script %" PRIx64 " associated with rsmodule '%s'.", __FUNCTION__,
1460                             (uint64_t)script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
1461         }
1462     }
1463 }
1464
1465 // Uses the Target API to evaluate the expression passed as a parameter to the function
1466 // The result of that expression is returned an unsigned 64 bit int, via the result* paramter.
1467 // Function returns true on success, and false on failure
1468 bool
1469 RenderScriptRuntime::EvalRSExpression(const char *expression, StackFrame *frame_ptr, uint64_t *result)
1470 {
1471     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1472     if (log)
1473         log->Printf("%s(%s)", __FUNCTION__, expression);
1474
1475     ValueObjectSP expr_result;
1476     EvaluateExpressionOptions options;
1477     options.SetLanguage(lldb::eLanguageTypeC_plus_plus);
1478     // Perform the actual expression evaluation
1479     GetProcess()->GetTarget().EvaluateExpression(expression, frame_ptr, expr_result, options);
1480
1481     if (!expr_result)
1482     {
1483         if (log)
1484             log->Printf("%s: couldn't evaluate expression.", __FUNCTION__);
1485         return false;
1486     }
1487
1488     // The result of the expression is invalid
1489     if (!expr_result->GetError().Success())
1490     {
1491         Error err = expr_result->GetError();
1492         if (err.GetError() == UserExpression::kNoResult) // Expression returned void, so this is actually a success
1493         {
1494             if (log)
1495                 log->Printf("%s - expression returned void.", __FUNCTION__);
1496
1497             result = nullptr;
1498             return true;
1499         }
1500
1501         if (log)
1502             log->Printf("%s - error evaluating expression result: %s", __FUNCTION__,
1503                         err.AsCString());
1504         return false;
1505     }
1506
1507     bool success = false;
1508     *result = expr_result->GetValueAsUnsigned(0, &success); // We only read the result as an uint32_t.
1509
1510     if (!success)
1511     {
1512         if (log)
1513             log->Printf("%s - couldn't convert expression result to uint32_t", __FUNCTION__);
1514         return false;
1515     }
1516
1517     return true;
1518 }
1519
1520 namespace
1521 {
1522 // Used to index expression format strings
1523 enum ExpressionStrings
1524 {
1525    eExprGetOffsetPtr = 0,
1526    eExprAllocGetType,
1527    eExprTypeDimX,
1528    eExprTypeDimY,
1529    eExprTypeDimZ,
1530    eExprTypeElemPtr,
1531    eExprElementType,
1532    eExprElementKind,
1533    eExprElementVec,
1534    eExprElementFieldCount,
1535    eExprSubelementsId,
1536    eExprSubelementsName,
1537    eExprSubelementsArrSize,
1538
1539    _eExprLast // keep at the end, implicit size of the array runtimeExpressions
1540 };
1541
1542 // max length of an expanded expression
1543 const int jit_max_expr_size = 512;
1544
1545 // Retrieve the string to JIT for the given expression
1546 const char*
1547 JITTemplate(ExpressionStrings e)
1548 {
1549     // Format strings containing the expressions we may need to evaluate.
1550     static std::array<const char*, _eExprLast> runtimeExpressions = {{
1551      // Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap)
1552      "(int*)_Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocationCubemapFace"
1553      "(0x%" PRIx64 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", 0, 0)",
1554
1555      // Type* rsaAllocationGetType(Context*, Allocation*)
1556      "(void*)rsaAllocationGetType(0x%" PRIx64 ", 0x%" PRIx64 ")",
1557
1558      // rsaTypeGetNativeData(Context*, Type*, void* typeData, size)
1559      // Pack the data in the following way mHal.state.dimX; mHal.state.dimY; mHal.state.dimZ;
1560      // mHal.state.lodCount; mHal.state.faces; mElement; into typeData
1561      // Need to specify 32 or 64 bit for uint_t since this differs between devices
1562      "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[0]", // X dim
1563      "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[1]", // Y dim
1564      "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[2]", // Z dim
1565      "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[5]", // Element ptr
1566
1567      // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
1568      // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into elemData
1569      "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[0]", // Type
1570      "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[1]", // Kind
1571      "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[3]", // Vector Size
1572      "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[4]", // Field Count
1573
1574      // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t *ids, const char **names,
1575      // size_t *arraySizes, uint32_t dataSize)
1576      // Needed for Allocations of structs to gather details about fields/Subelements
1577      // Element* of field
1578      "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 "]; size_t arr_size[%" PRIu32 "];"
1579      "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64 ", ids, names, arr_size, %" PRIu32 "); ids[%" PRIu32 "]",
1580
1581      // Name of field
1582      "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 "]; size_t arr_size[%" PRIu32 "];"
1583      "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64 ", ids, names, arr_size, %" PRIu32 "); names[%" PRIu32 "]",
1584
1585      // Array size of field
1586      "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 "]; size_t arr_size[%" PRIu32 "];"
1587      "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64 ", ids, names, arr_size, %" PRIu32 "); arr_size[%" PRIu32 "]"
1588     }};
1589
1590     return runtimeExpressions[e];
1591 }
1592 } // end of the anonymous namespace
1593
1594
1595 // JITs the RS runtime for the internal data pointer of an allocation.
1596 // Is passed x,y,z coordinates for the pointer to a specific element.
1597 // Then sets the data_ptr member in Allocation with the result.
1598 // Returns true on success, false otherwise
1599 bool
1600 RenderScriptRuntime::JITDataPointer(AllocationDetails *allocation, StackFrame *frame_ptr, uint32_t x,
1601                                     uint32_t y, uint32_t z)
1602 {
1603     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1604
1605     if (!allocation->address.isValid())
1606     {
1607         if (log)
1608             log->Printf("%s - failed to find allocation details.", __FUNCTION__);
1609         return false;
1610     }
1611
1612     const char *expr_cstr = JITTemplate(eExprGetOffsetPtr);
1613     char buffer[jit_max_expr_size];
1614
1615     int chars_written = snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->address.get(), x, y, z);
1616     if (chars_written < 0)
1617     {
1618         if (log)
1619             log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1620         return false;
1621     }
1622     else if (chars_written >= jit_max_expr_size)
1623     {
1624         if (log)
1625             log->Printf("%s - expression too long.", __FUNCTION__);
1626         return false;
1627     }
1628
1629     uint64_t result = 0;
1630     if (!EvalRSExpression(buffer, frame_ptr, &result))
1631         return false;
1632
1633     addr_t mem_ptr = static_cast<lldb::addr_t>(result);
1634     allocation->data_ptr = mem_ptr;
1635
1636     return true;
1637 }
1638
1639 // JITs the RS runtime for the internal pointer to the RS Type of an allocation
1640 // Then sets the type_ptr member in Allocation with the result.
1641 // Returns true on success, false otherwise
1642 bool
1643 RenderScriptRuntime::JITTypePointer(AllocationDetails *allocation, StackFrame *frame_ptr)
1644 {
1645     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1646
1647     if (!allocation->address.isValid() || !allocation->context.isValid())
1648     {
1649         if (log)
1650             log->Printf("%s - failed to find allocation details.", __FUNCTION__);
1651         return false;
1652     }
1653
1654     const char *expr_cstr = JITTemplate(eExprAllocGetType);
1655     char buffer[jit_max_expr_size];
1656
1657     int chars_written =
1658         snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->context.get(), *allocation->address.get());
1659     if (chars_written < 0)
1660     {
1661         if (log)
1662             log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1663         return false;
1664     }
1665     else if (chars_written >= jit_max_expr_size)
1666     {
1667         if (log)
1668             log->Printf("%s - expression too long.", __FUNCTION__);
1669         return false;
1670     }
1671
1672     uint64_t result = 0;
1673     if (!EvalRSExpression(buffer, frame_ptr, &result))
1674         return false;
1675
1676     addr_t type_ptr = static_cast<lldb::addr_t>(result);
1677     allocation->type_ptr = type_ptr;
1678
1679     return true;
1680 }
1681
1682 // JITs the RS runtime for information about the dimensions and type of an allocation
1683 // Then sets dimension and element_ptr members in Allocation with the result.
1684 // Returns true on success, false otherwise
1685 bool
1686 RenderScriptRuntime::JITTypePacked(AllocationDetails *allocation, StackFrame *frame_ptr)
1687 {
1688     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1689
1690     if (!allocation->type_ptr.isValid() || !allocation->context.isValid())
1691     {
1692         if (log)
1693             log->Printf("%s - Failed to find allocation details.", __FUNCTION__);
1694         return false;
1695     }
1696
1697     // Expression is different depending on if device is 32 or 64 bit
1698     uint32_t archByteSize = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
1699     const uint32_t bits = archByteSize == 4 ? 32 : 64;
1700
1701     // We want 4 elements from packed data
1702     const uint32_t num_exprs = 4;
1703     assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) && "Invalid number of expressions");
1704
1705     char buffer[num_exprs][jit_max_expr_size];
1706     uint64_t results[num_exprs];
1707
1708     for (uint32_t i = 0; i < num_exprs; ++i)
1709     {
1710         const char *expr_cstr = JITTemplate(ExpressionStrings(eExprTypeDimX + i));
1711         int chars_written = snprintf(buffer[i], jit_max_expr_size, expr_cstr, bits, *allocation->context.get(),
1712                                      *allocation->type_ptr.get());
1713         if (chars_written < 0)
1714         {
1715             if (log)
1716                 log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1717             return false;
1718         }
1719         else if (chars_written >= jit_max_expr_size)
1720         {
1721             if (log)
1722                 log->Printf("%s - expression too long.", __FUNCTION__);
1723             return false;
1724         }
1725
1726         // Perform expression evaluation
1727         if (!EvalRSExpression(buffer[i], frame_ptr, &results[i]))
1728             return false;
1729     }
1730
1731     // Assign results to allocation members
1732     AllocationDetails::Dimension dims;
1733     dims.dim_1 = static_cast<uint32_t>(results[0]);
1734     dims.dim_2 = static_cast<uint32_t>(results[1]);
1735     dims.dim_3 = static_cast<uint32_t>(results[2]);
1736     allocation->dimension = dims;
1737
1738     addr_t elem_ptr = static_cast<lldb::addr_t>(results[3]);
1739     allocation->element.element_ptr = elem_ptr;
1740
1741     if (log)
1742         log->Printf("%s - dims (%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") Element*: 0x%" PRIx64 ".", __FUNCTION__,
1743                     dims.dim_1, dims.dim_2, dims.dim_3, elem_ptr);
1744
1745     return true;
1746 }
1747
1748 // JITs the RS runtime for information about the Element of an allocation
1749 // Then sets type, type_vec_size, field_count and type_kind members in Element with the result.
1750 // Returns true on success, false otherwise
1751 bool
1752 RenderScriptRuntime::JITElementPacked(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr)
1753 {
1754     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1755
1756     if (!elem.element_ptr.isValid())
1757     {
1758         if (log)
1759             log->Printf("%s - failed to find allocation details.", __FUNCTION__);
1760         return false;
1761     }
1762
1763     // We want 4 elements from packed data
1764     const uint32_t num_exprs = 4;
1765     assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1) && "Invalid number of expressions");
1766
1767     char buffer[num_exprs][jit_max_expr_size];
1768     uint64_t results[num_exprs];
1769
1770     for (uint32_t i = 0; i < num_exprs; i++)
1771     {
1772         const char *expr_cstr = JITTemplate(ExpressionStrings(eExprElementType + i));
1773         int chars_written = snprintf(buffer[i], jit_max_expr_size, expr_cstr, context, *elem.element_ptr.get());
1774         if (chars_written < 0)
1775         {
1776             if (log)
1777                 log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1778             return false;
1779         }
1780         else if (chars_written >= jit_max_expr_size)
1781         {
1782             if (log)
1783                 log->Printf("%s - expression too long.", __FUNCTION__);
1784             return false;
1785         }
1786
1787         // Perform expression evaluation
1788         if (!EvalRSExpression(buffer[i], frame_ptr, &results[i]))
1789             return false;
1790     }
1791
1792     // Assign results to allocation members
1793     elem.type = static_cast<RenderScriptRuntime::Element::DataType>(results[0]);
1794     elem.type_kind = static_cast<RenderScriptRuntime::Element::DataKind>(results[1]);
1795     elem.type_vec_size = static_cast<uint32_t>(results[2]);
1796     elem.field_count = static_cast<uint32_t>(results[3]);
1797
1798     if (log)
1799         log->Printf("%s - data type %" PRIu32 ", pixel type %" PRIu32 ", vector size %" PRIu32 ", field count %" PRIu32,
1800                     __FUNCTION__, *elem.type.get(), *elem.type_kind.get(), *elem.type_vec_size.get(), *elem.field_count.get());
1801
1802     // If this Element has subelements then JIT rsaElementGetSubElements() for details about its fields
1803     if (*elem.field_count.get() > 0 && !JITSubelements(elem, context, frame_ptr))
1804         return false;
1805
1806     return true;
1807 }
1808
1809 // JITs the RS runtime for information about the subelements/fields of a struct allocation
1810 // This is necessary for infering the struct type so we can pretty print the allocation's contents.
1811 // Returns true on success, false otherwise
1812 bool
1813 RenderScriptRuntime::JITSubelements(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr)
1814 {
1815     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1816
1817     if (!elem.element_ptr.isValid() || !elem.field_count.isValid())
1818     {
1819         if (log)
1820             log->Printf("%s - failed to find allocation details.", __FUNCTION__);
1821         return false;
1822     }
1823
1824     const short num_exprs = 3;
1825     assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1) && "Invalid number of expressions");
1826
1827     char expr_buffer[jit_max_expr_size];
1828     uint64_t results;
1829
1830     // Iterate over struct fields.
1831     const uint32_t field_count = *elem.field_count.get();
1832     for (uint32_t field_index = 0; field_index < field_count; ++field_index)
1833     {
1834         Element child;
1835         for (uint32_t expr_index = 0; expr_index < num_exprs; ++expr_index)
1836         {
1837             const char *expr_cstr = JITTemplate(ExpressionStrings(eExprSubelementsId + expr_index));
1838             int chars_written = snprintf(expr_buffer, jit_max_expr_size, expr_cstr,
1839                                          field_count, field_count, field_count,
1840                                          context, *elem.element_ptr.get(), field_count, field_index);
1841             if (chars_written < 0)
1842             {
1843                 if (log)
1844                     log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1845                 return false;
1846             }
1847             else if (chars_written >= jit_max_expr_size)
1848             {
1849                 if (log)
1850                     log->Printf("%s - expression too long.", __FUNCTION__);
1851                 return false;
1852             }
1853
1854             // Perform expression evaluation
1855             if (!EvalRSExpression(expr_buffer, frame_ptr, &results))
1856                 return false;
1857
1858             if (log)
1859                 log->Printf("%s - expr result 0x%" PRIx64 ".", __FUNCTION__, results);
1860
1861             switch (expr_index)
1862             {
1863                 case 0: // Element* of child
1864                     child.element_ptr = static_cast<addr_t>(results);
1865                     break;
1866                 case 1: // Name of child
1867                 {
1868                     lldb::addr_t address = static_cast<addr_t>(results);
1869                     Error err;
1870                     std::string name;
1871                     GetProcess()->ReadCStringFromMemory(address, name, err);
1872                     if (!err.Fail())
1873                         child.type_name = ConstString(name);
1874                     else
1875                     {
1876                         if (log)
1877                             log->Printf("%s - warning: Couldn't read field name.", __FUNCTION__);
1878                     }
1879                     break;
1880                 }
1881                 case 2: // Array size of child
1882                     child.array_size = static_cast<uint32_t>(results);
1883                     break;
1884             }
1885         }
1886
1887         // We need to recursively JIT each Element field of the struct since
1888         // structs can be nested inside structs.
1889         if (!JITElementPacked(child, context, frame_ptr))
1890             return false;
1891         elem.children.push_back(child);
1892     }
1893
1894     // Try to infer the name of the struct type so we can pretty print the allocation contents.
1895     FindStructTypeName(elem, frame_ptr);
1896
1897     return true;
1898 }
1899
1900 // JITs the RS runtime for the address of the last element in the allocation.
1901 // The `elem_size` paramter represents the size of a single element, including padding.
1902 // Which is needed as an offset from the last element pointer.
1903 // Using this offset minus the starting address we can calculate the size of the allocation.
1904 // Returns true on success, false otherwise
1905 bool
1906 RenderScriptRuntime::JITAllocationSize(AllocationDetails *allocation, StackFrame *frame_ptr)
1907 {
1908     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1909
1910     if (!allocation->address.isValid() || !allocation->dimension.isValid() || !allocation->data_ptr.isValid() ||
1911         !allocation->element.datum_size.isValid())
1912     {
1913         if (log)
1914             log->Printf("%s - failed to find allocation details.", __FUNCTION__);
1915         return false;
1916     }
1917
1918     // Find dimensions
1919     uint32_t dim_x = allocation->dimension.get()->dim_1;
1920     uint32_t dim_y = allocation->dimension.get()->dim_2;
1921     uint32_t dim_z = allocation->dimension.get()->dim_3;
1922
1923     // Our plan of jitting the last element address doesn't seem to work for struct Allocations
1924     // Instead try to infer the size ourselves without any inter element padding.
1925     if (allocation->element.children.size() > 0)
1926     {
1927         if (dim_x == 0) dim_x = 1;
1928         if (dim_y == 0) dim_y = 1;
1929         if (dim_z == 0) dim_z = 1;
1930
1931         allocation->size = dim_x * dim_y * dim_z * *allocation->element.datum_size.get();
1932
1933         if (log)
1934             log->Printf("%s - infered size of struct allocation %" PRIu32 ".", __FUNCTION__,
1935                         *allocation->size.get());
1936         return true;
1937     }
1938
1939     const char *expr_cstr = JITTemplate(eExprGetOffsetPtr);
1940     char buffer[jit_max_expr_size];
1941
1942     // Calculate last element
1943     dim_x = dim_x == 0 ? 0 : dim_x - 1;
1944     dim_y = dim_y == 0 ? 0 : dim_y - 1;
1945     dim_z = dim_z == 0 ? 0 : dim_z - 1;
1946
1947     int chars_written = snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->address.get(), dim_x, dim_y, dim_z);
1948     if (chars_written < 0)
1949     {
1950         if (log)
1951             log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1952         return false;
1953     }
1954     else if (chars_written >= jit_max_expr_size)
1955     {
1956         if (log)
1957             log->Printf("%s - expression too long.", __FUNCTION__);
1958         return false;
1959     }
1960
1961     uint64_t result = 0;
1962     if (!EvalRSExpression(buffer, frame_ptr, &result))
1963         return false;
1964
1965     addr_t mem_ptr = static_cast<lldb::addr_t>(result);
1966     // Find pointer to last element and add on size of an element
1967     allocation->size =
1968         static_cast<uint32_t>(mem_ptr - *allocation->data_ptr.get()) + *allocation->element.datum_size.get();
1969
1970     return true;
1971 }
1972
1973 // JITs the RS runtime for information about the stride between rows in the allocation.
1974 // This is done to detect padding, since allocated memory is 16-byte aligned.
1975 // Returns true on success, false otherwise
1976 bool
1977 RenderScriptRuntime::JITAllocationStride(AllocationDetails *allocation, StackFrame *frame_ptr)
1978 {
1979     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
1980
1981     if (!allocation->address.isValid() || !allocation->data_ptr.isValid())
1982     {
1983         if (log)
1984             log->Printf("%s - failed to find allocation details.", __FUNCTION__);
1985         return false;
1986     }
1987
1988     const char *expr_cstr = JITTemplate(eExprGetOffsetPtr);
1989     char buffer[jit_max_expr_size];
1990
1991     int chars_written = snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->address.get(), 0, 1, 0);
1992     if (chars_written < 0)
1993     {
1994         if (log)
1995             log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
1996         return false;
1997     }
1998     else if (chars_written >= jit_max_expr_size)
1999     {
2000         if (log)
2001             log->Printf("%s - expression too long.", __FUNCTION__);
2002         return false;
2003     }
2004
2005     uint64_t result = 0;
2006     if (!EvalRSExpression(buffer, frame_ptr, &result))
2007         return false;
2008
2009     addr_t mem_ptr = static_cast<lldb::addr_t>(result);
2010     allocation->stride = static_cast<uint32_t>(mem_ptr - *allocation->data_ptr.get());
2011
2012     return true;
2013 }
2014
2015 // JIT all the current runtime info regarding an allocation
2016 bool
2017 RenderScriptRuntime::RefreshAllocation(AllocationDetails *allocation, StackFrame *frame_ptr)
2018 {
2019     // GetOffsetPointer()
2020     if (!JITDataPointer(allocation, frame_ptr))
2021         return false;
2022
2023     // rsaAllocationGetType()
2024     if (!JITTypePointer(allocation, frame_ptr))
2025         return false;
2026
2027     // rsaTypeGetNativeData()
2028     if (!JITTypePacked(allocation, frame_ptr))
2029         return false;
2030
2031     // rsaElementGetNativeData()
2032     if (!JITElementPacked(allocation->element, *allocation->context.get(), frame_ptr))
2033         return false;
2034
2035     // Sets the datum_size member in Element
2036     SetElementSize(allocation->element);
2037
2038     // Use GetOffsetPointer() to infer size of the allocation
2039     if (!JITAllocationSize(allocation, frame_ptr))
2040         return false;
2041
2042     return true;
2043 }
2044
2045 // Function attempts to set the type_name member of the paramaterised Element object.
2046 // This string should be the name of the struct type the Element represents.
2047 // We need this string for pretty printing the Element to users.
2048 void
2049 RenderScriptRuntime::FindStructTypeName(Element &elem, StackFrame *frame_ptr)
2050 {
2051     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2052
2053     if (!elem.type_name.IsEmpty()) // Name already set
2054         return;
2055     else
2056         elem.type_name = Element::GetFallbackStructName(); // Default type name if we don't succeed
2057
2058     // Find all the global variables from the script rs modules
2059     VariableList variable_list;
2060     for (auto module_sp : m_rsmodules)
2061         module_sp->m_module->FindGlobalVariables(RegularExpression("."), true, UINT32_MAX, variable_list);
2062
2063     // Iterate over all the global variables looking for one with a matching type to the Element.
2064     // We make the assumption a match exists since there needs to be a global variable to reflect the
2065     // struct type back into java host code.
2066     for (uint32_t var_index = 0; var_index < variable_list.GetSize(); ++var_index)
2067     {
2068         const VariableSP var_sp(variable_list.GetVariableAtIndex(var_index));
2069         if (!var_sp)
2070             continue;
2071
2072         ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp);
2073         if (!valobj_sp)
2074             continue;
2075
2076         // Find the number of variable fields.
2077         // If it has no fields, or more fields than our Element, then it can't be the struct we're looking for.
2078         // Don't check for equality since RS can add extra struct members for padding.
2079         size_t num_children = valobj_sp->GetNumChildren();
2080         if (num_children > elem.children.size() || num_children == 0)
2081             continue;
2082
2083         // Iterate over children looking for members with matching field names.
2084         // If all the field names match, this is likely the struct we want.
2085         //
2086         //   TODO: This could be made more robust by also checking children data sizes, or array size
2087         bool found = true;
2088         for (size_t child_index = 0; child_index < num_children; ++child_index)
2089         {
2090             ValueObjectSP child = valobj_sp->GetChildAtIndex(child_index, true);
2091             if (!child || (child->GetName() != elem.children[child_index].type_name))
2092             {
2093                 found = false;
2094                 break;
2095             }
2096         }
2097
2098         // RS can add extra struct members for padding in the format '#rs_padding_[0-9]+'
2099         if (found && num_children < elem.children.size())
2100         {
2101             const uint32_t size_diff = elem.children.size() - num_children;
2102             if (log)
2103                 log->Printf("%s - %" PRIu32 " padding struct entries", __FUNCTION__, size_diff);
2104
2105             for (uint32_t padding_index = 0; padding_index < size_diff; ++padding_index)
2106             {
2107                 const ConstString &name = elem.children[num_children + padding_index].type_name;
2108                 if (strcmp(name.AsCString(), "#rs_padding") < 0)
2109                     found = false;
2110             }
2111         }
2112
2113         // We've found a global var with matching type
2114         if (found)
2115         {
2116             // Dereference since our Element type isn't a pointer.
2117             if (valobj_sp->IsPointerType())
2118             {
2119                 Error err;
2120                 ValueObjectSP deref_valobj = valobj_sp->Dereference(err);
2121                 if (!err.Fail())
2122                     valobj_sp = deref_valobj;
2123             }
2124
2125             // Save name of variable in Element.
2126             elem.type_name = valobj_sp->GetTypeName();
2127             if (log)
2128                 log->Printf("%s - element name set to %s", __FUNCTION__, elem.type_name.AsCString());
2129
2130             return;
2131         }
2132     }
2133 }
2134
2135 // Function sets the datum_size member of Element. Representing the size of a single instance including padding.
2136 // Assumes the relevant allocation information has already been jitted.
2137 void
2138 RenderScriptRuntime::SetElementSize(Element &elem)
2139 {
2140     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2141     const Element::DataType type = *elem.type.get();
2142     assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && "Invalid allocation type");
2143
2144     const uint32_t vec_size = *elem.type_vec_size.get();
2145     uint32_t data_size = 0;
2146     uint32_t padding = 0;
2147
2148     // Element is of a struct type, calculate size recursively.
2149     if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0))
2150     {
2151         for (Element &child : elem.children)
2152         {
2153             SetElementSize(child);
2154             const uint32_t array_size = child.array_size.isValid() ? *child.array_size.get() : 1;
2155             data_size += *child.datum_size.get() * array_size;
2156         }
2157     }
2158     // These have been packed already
2159     else if (type == Element::RS_TYPE_UNSIGNED_5_6_5   ||
2160              type == Element::RS_TYPE_UNSIGNED_5_5_5_1 ||
2161              type == Element::RS_TYPE_UNSIGNED_4_4_4_4)
2162     {
2163         data_size = AllocationDetails::RSTypeToFormat[type][eElementSize];
2164     }
2165     else if (type < Element::RS_TYPE_ELEMENT)
2166     {
2167         data_size = vec_size * AllocationDetails::RSTypeToFormat[type][eElementSize];
2168         if (vec_size == 3)
2169             padding = AllocationDetails::RSTypeToFormat[type][eElementSize];
2170     }
2171     else
2172         data_size = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
2173
2174     elem.padding = padding;
2175     elem.datum_size = data_size + padding;
2176     if (log)
2177         log->Printf("%s - element size set to %" PRIu32, __FUNCTION__, data_size + padding);
2178 }
2179
2180 // Given an allocation, this function copies the allocation contents from device into a buffer on the heap.
2181 // Returning a shared pointer to the buffer containing the data.
2182 std::shared_ptr<uint8_t>
2183 RenderScriptRuntime::GetAllocationData(AllocationDetails *allocation, StackFrame *frame_ptr)
2184 {
2185     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2186
2187     // JIT all the allocation details
2188     if (allocation->shouldRefresh())
2189     {
2190         if (log)
2191             log->Printf("%s - allocation details not calculated yet, jitting info", __FUNCTION__);
2192
2193         if (!RefreshAllocation(allocation, frame_ptr))
2194         {
2195             if (log)
2196                 log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
2197             return nullptr;
2198         }
2199     }
2200
2201     assert(allocation->data_ptr.isValid() && allocation->element.type.isValid() &&
2202            allocation->element.type_vec_size.isValid() && allocation->size.isValid() &&
2203            "Allocation information not available");
2204
2205     // Allocate a buffer to copy data into
2206     const uint32_t size = *allocation->size.get();
2207     std::shared_ptr<uint8_t> buffer(new uint8_t[size]);
2208     if (!buffer)
2209     {
2210         if (log)
2211             log->Printf("%s - couldn't allocate a %" PRIu32 " byte buffer", __FUNCTION__, size);
2212         return nullptr;
2213     }
2214
2215     // Read the inferior memory
2216     Error error;
2217     lldb::addr_t data_ptr = *allocation->data_ptr.get();
2218     GetProcess()->ReadMemory(data_ptr, buffer.get(), size, error);
2219     if (error.Fail())
2220     {
2221         if (log)
2222             log->Printf("%s - '%s' Couldn't read %" PRIu32 " bytes of allocation data from 0x%" PRIx64,
2223                         __FUNCTION__, error.AsCString(), size, data_ptr);
2224         return nullptr;
2225     }
2226
2227     return buffer;
2228 }
2229
2230 // Function copies data from a binary file into an allocation.
2231 // There is a header at the start of the file, FileHeader, before the data content itself.
2232 // Information from this header is used to display warnings to the user about incompatabilities
2233 bool
2234 RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr)
2235 {
2236     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2237
2238     // Find allocation with the given id
2239     AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
2240     if (!alloc)
2241         return false;
2242
2243     if (log)
2244         log->Printf("%s - found allocation 0x%" PRIx64, __FUNCTION__, *alloc->address.get());
2245
2246     // JIT all the allocation details
2247     if (alloc->shouldRefresh())
2248     {
2249         if (log)
2250             log->Printf("%s - allocation details not calculated yet, jitting info.", __FUNCTION__);
2251
2252         if (!RefreshAllocation(alloc, frame_ptr))
2253         {
2254             if (log)
2255                 log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
2256             return false;
2257         }
2258     }
2259
2260     assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() &&
2261            alloc->size.isValid() && alloc->element.datum_size.isValid() && "Allocation information not available");
2262
2263     // Check we can read from file
2264     FileSpec file(filename, true);
2265     if (!file.Exists())
2266     {
2267         strm.Printf("Error: File %s does not exist", filename);
2268         strm.EOL();
2269         return false;
2270     }
2271
2272     if (!file.Readable())
2273     {
2274         strm.Printf("Error: File %s does not have readable permissions", filename);
2275         strm.EOL();
2276         return false;
2277     }
2278
2279     // Read file into data buffer
2280     DataBufferSP data_sp(file.ReadFileContents());
2281
2282     // Cast start of buffer to FileHeader and use pointer to read metadata
2283     void *file_buffer = data_sp->GetBytes();
2284     if (file_buffer == nullptr ||
2285         data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) + sizeof(AllocationDetails::ElementHeader)))
2286     {
2287         strm.Printf("Error: File %s does not contain enough data for header", filename);
2288         strm.EOL();
2289         return false;
2290     }
2291     const AllocationDetails::FileHeader *file_header = static_cast<AllocationDetails::FileHeader *>(file_buffer);
2292
2293     // Check file starts with ascii characters "RSAD"
2294     if (memcmp(file_header->ident, "RSAD", 4))
2295     {
2296         strm.Printf("Error: File doesn't contain identifier for an RS allocation dump. Are you sure this is the correct file?");
2297         strm.EOL();
2298         return false;
2299     }
2300
2301     // Look at the type of the root element in the header
2302     AllocationDetails::ElementHeader root_element_header;
2303     memcpy(&root_element_header, static_cast<uint8_t *>(file_buffer) + sizeof(AllocationDetails::FileHeader),
2304            sizeof(AllocationDetails::ElementHeader));
2305
2306     if (log)
2307         log->Printf("%s - header type %" PRIu32 ", element size %" PRIu32, __FUNCTION__,
2308                     root_element_header.type, root_element_header.element_size);
2309
2310     // Check if the target allocation and file both have the same number of bytes for an Element
2311     if (*alloc->element.datum_size.get() != root_element_header.element_size)
2312     {
2313         strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32 " bytes, allocation %" PRIu32 " bytes",
2314                     root_element_header.element_size, *alloc->element.datum_size.get());
2315         strm.EOL();
2316     }
2317
2318     // Check if the target allocation and file both have the same type
2319     const uint32_t alloc_type = static_cast<uint32_t>(*alloc->element.type.get());
2320     const uint32_t file_type = root_element_header.type;
2321
2322     if (file_type > Element::RS_TYPE_FONT)
2323     {
2324         strm.Printf("Warning: File has unknown allocation type");
2325         strm.EOL();
2326     }
2327     else if (alloc_type != file_type)
2328     {
2329         // Enum value isn't monotonous, so doesn't always index RsDataTypeToString array
2330         uint32_t printable_target_type_index = alloc_type;
2331         uint32_t printable_head_type_index = file_type;
2332         if (alloc_type >= Element::RS_TYPE_ELEMENT && alloc_type <= Element::RS_TYPE_FONT)
2333             printable_target_type_index = static_cast<Element::DataType>((alloc_type - Element::RS_TYPE_ELEMENT) +
2334                                                                          Element::RS_TYPE_MATRIX_2X2 + 1);
2335
2336         if (file_type >= Element::RS_TYPE_ELEMENT && file_type <= Element::RS_TYPE_FONT)
2337             printable_head_type_index = static_cast<Element::DataType>((file_type - Element::RS_TYPE_ELEMENT) +
2338                                                                        Element::RS_TYPE_MATRIX_2X2 + 1);
2339
2340         const char *file_type_cstr = AllocationDetails::RsDataTypeToString[printable_head_type_index][0];
2341         const char *target_type_cstr = AllocationDetails::RsDataTypeToString[printable_target_type_index][0];
2342
2343         strm.Printf("Warning: Mismatched Types - file '%s' type, allocation '%s' type", file_type_cstr,
2344                     target_type_cstr);
2345         strm.EOL();
2346     }
2347
2348     // Advance buffer past header
2349     file_buffer = static_cast<uint8_t *>(file_buffer) + file_header->hdr_size;
2350
2351     // Calculate size of allocation data in file
2352     size_t length = data_sp->GetByteSize() - file_header->hdr_size;
2353
2354     // Check if the target allocation and file both have the same total data size.
2355     const uint32_t alloc_size = *alloc->size.get();
2356     if (alloc_size != length)
2357     {
2358         strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64 " bytes, allocation 0x%" PRIx32 " bytes",
2359                     (uint64_t)length, alloc_size);
2360         strm.EOL();
2361         length = alloc_size < length ? alloc_size : length; // Set length to copy to minimum
2362     }
2363
2364     // Copy file data from our buffer into the target allocation.
2365     lldb::addr_t alloc_data = *alloc->data_ptr.get();
2366     Error error;
2367     size_t bytes_written = GetProcess()->WriteMemory(alloc_data, file_buffer, length, error);
2368     if (!error.Success() || bytes_written != length)
2369     {
2370         strm.Printf("Error: Couldn't write data to allocation %s", error.AsCString());
2371         strm.EOL();
2372         return false;
2373     }
2374
2375     strm.Printf("Contents of file '%s' read into allocation %" PRIu32, filename, alloc->id);
2376     strm.EOL();
2377
2378     return true;
2379 }
2380
2381 // Function takes as parameters a byte buffer, which will eventually be written to file as the element header,
2382 // an offset into that buffer, and an Element that will be saved into the buffer at the parametrised offset.
2383 // Return value is the new offset after writing the element into the buffer.
2384 // Elements are saved to the file as the ElementHeader struct followed by offsets to the structs of all the element's
2385 // children.
2386 size_t
2387 RenderScriptRuntime::PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer, size_t offset,
2388                                             const Element &elem)
2389 {
2390     // File struct for an element header with all the relevant details copied from elem.
2391     // We assume members are valid already.
2392     AllocationDetails::ElementHeader elem_header;
2393     elem_header.type = *elem.type.get();
2394     elem_header.kind = *elem.type_kind.get();
2395     elem_header.element_size = *elem.datum_size.get();
2396     elem_header.vector_size = *elem.type_vec_size.get();
2397     elem_header.array_size = elem.array_size.isValid() ? *elem.array_size.get() : 0;
2398     const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader);
2399
2400     // Copy struct into buffer and advance offset
2401     // We assume that header_buffer has been checked for nullptr before this method is called
2402     memcpy(header_buffer.get() + offset, &elem_header, elem_header_size);
2403     offset += elem_header_size;
2404
2405     // Starting offset of child ElementHeader struct
2406     size_t child_offset = offset + ((elem.children.size() + 1) * sizeof(uint32_t));
2407     for (const RenderScriptRuntime::Element &child : elem.children)
2408     {
2409         // Recursively populate the buffer with the element header structs of children.
2410         // Then save the offsets where they were set after the parent element header.
2411         memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t));
2412         offset += sizeof(uint32_t);
2413
2414         child_offset = PopulateElementHeaders(header_buffer, child_offset, child);
2415     }
2416
2417     // Zero indicates no more children
2418     memset(header_buffer.get() + offset, 0, sizeof(uint32_t));
2419
2420     return child_offset;
2421 }
2422
2423 // Given an Element object this function returns the total size needed in the file header to store the element's
2424 // details.
2425 // Taking into account the size of the element header struct, plus the offsets to all the element's children.
2426 // Function is recursive so that the size of all ancestors is taken into account.
2427 size_t
2428 RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem)
2429 {
2430     size_t size = (elem.children.size() + 1) * sizeof(uint32_t); // Offsets to children plus zero terminator
2431     size += sizeof(AllocationDetails::ElementHeader);            // Size of header struct with type details
2432
2433     // Calculate recursively for all descendants
2434     for (const Element &child : elem.children)
2435         size += CalculateElementHeaderSize(child);
2436
2437     return size;
2438 }
2439
2440 // Function copies allocation contents into a binary file.
2441 // This file can then be loaded later into a different allocation.
2442 // There is a header, FileHeader, before the allocation data containing meta-data.
2443 bool
2444 RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr)
2445 {
2446     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2447
2448     // Find allocation with the given id
2449     AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
2450     if (!alloc)
2451         return false;
2452
2453     if (log)
2454         log->Printf("%s - found allocation 0x%" PRIx64 ".", __FUNCTION__, *alloc->address.get());
2455
2456     // JIT all the allocation details
2457     if (alloc->shouldRefresh())
2458     {
2459         if (log)
2460             log->Printf("%s - allocation details not calculated yet, jitting info.", __FUNCTION__);
2461
2462         if (!RefreshAllocation(alloc, frame_ptr))
2463         {
2464             if (log)
2465                 log->Printf("%s - couldn't JIT allocation details.", __FUNCTION__);
2466             return false;
2467         }
2468     }
2469
2470     assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() &&
2471            alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() &&
2472            "Allocation information not available");
2473
2474     // Check we can create writable file
2475     FileSpec file_spec(filename, true);
2476     File file(file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate | File::eOpenOptionTruncate);
2477     if (!file)
2478     {
2479         strm.Printf("Error: Failed to open '%s' for writing", filename);
2480         strm.EOL();
2481         return false;
2482     }
2483
2484     // Read allocation into buffer of heap memory
2485     const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
2486     if (!buffer)
2487     {
2488         strm.Printf("Error: Couldn't read allocation data into buffer");
2489         strm.EOL();
2490         return false;
2491     }
2492
2493     // Create the file header
2494     AllocationDetails::FileHeader head;
2495     memcpy(head.ident, "RSAD", 4);
2496     head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1);
2497     head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2);
2498     head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3);
2499
2500     const size_t element_header_size = CalculateElementHeaderSize(alloc->element);
2501     assert((sizeof(AllocationDetails::FileHeader) + element_header_size) < UINT16_MAX && "Element header too large");
2502     head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) + element_header_size);
2503
2504     // Write the file header
2505     size_t num_bytes = sizeof(AllocationDetails::FileHeader);
2506     if (log)
2507         log->Printf("%s - writing File Header, 0x%" PRIx64 " bytes", __FUNCTION__, (uint64_t)num_bytes);
2508
2509     Error err = file.Write(&head, num_bytes);
2510     if (!err.Success())
2511     {
2512         strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), filename);
2513         strm.EOL();
2514         return false;
2515     }
2516
2517     // Create the headers describing the element type of the allocation.
2518     std::shared_ptr<uint8_t> element_header_buffer(new uint8_t[element_header_size]);
2519     if (element_header_buffer == nullptr)
2520     {
2521         strm.Printf("Internal Error: Couldn't allocate %" PRIu64 " bytes on the heap", (uint64_t)element_header_size);
2522         strm.EOL();
2523         return false;
2524     }
2525
2526     PopulateElementHeaders(element_header_buffer, 0, alloc->element);
2527
2528     // Write headers for allocation element type to file
2529     num_bytes = element_header_size;
2530     if (log)
2531         log->Printf("%s - writing element headers, 0x%" PRIx64 " bytes.", __FUNCTION__, (uint64_t)num_bytes);
2532
2533     err = file.Write(element_header_buffer.get(), num_bytes);
2534     if (!err.Success())
2535     {
2536         strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), filename);
2537         strm.EOL();
2538         return false;
2539     }
2540
2541     // Write allocation data to file
2542     num_bytes = static_cast<size_t>(*alloc->size.get());
2543     if (log)
2544         log->Printf("%s - writing 0x%" PRIx64 " bytes", __FUNCTION__, (uint64_t)num_bytes);
2545
2546     err = file.Write(buffer.get(), num_bytes);
2547     if (!err.Success())
2548     {
2549         strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), filename);
2550         strm.EOL();
2551         return false;
2552     }
2553
2554     strm.Printf("Allocation written to file '%s'", filename);
2555     strm.EOL();
2556     return true;
2557 }
2558
2559 bool
2560 RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp)
2561 {
2562     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2563
2564     if (module_sp)
2565     {
2566         for (const auto &rs_module : m_rsmodules)
2567         {
2568             if (rs_module->m_module == module_sp)
2569             {
2570                 // Check if the user has enabled automatically breaking on
2571                 // all RS kernels.
2572                 if (m_breakAllKernels)
2573                     BreakOnModuleKernels(rs_module);
2574
2575                 return false;
2576             }
2577         }
2578         bool module_loaded = false;
2579         switch (GetModuleKind(module_sp))
2580         {
2581             case eModuleKindKernelObj:
2582             {
2583                 RSModuleDescriptorSP module_desc;
2584                 module_desc.reset(new RSModuleDescriptor(module_sp));
2585                 if (module_desc->ParseRSInfo())
2586                 {
2587                     m_rsmodules.push_back(module_desc);
2588                     module_loaded = true;
2589                 }
2590                 if (module_loaded)
2591                 {
2592                     FixupScriptDetails(module_desc);
2593                 }
2594                 break;
2595             }
2596             case eModuleKindDriver:
2597             {
2598                 if (!m_libRSDriver)
2599                 {
2600                     m_libRSDriver = module_sp;
2601                     LoadRuntimeHooks(m_libRSDriver, RenderScriptRuntime::eModuleKindDriver);
2602                 }
2603                 break;
2604             }
2605             case eModuleKindImpl:
2606             {
2607                 m_libRSCpuRef = module_sp;
2608                 break;
2609             }
2610             case eModuleKindLibRS:
2611             {
2612                 if (!m_libRS)
2613                 {
2614                     m_libRS = module_sp;
2615                     static ConstString gDbgPresentStr("gDebuggerPresent");
2616                     const Symbol *debug_present =
2617                         m_libRS->FindFirstSymbolWithNameAndType(gDbgPresentStr, eSymbolTypeData);
2618                     if (debug_present)
2619                     {
2620                         Error error;
2621                         uint32_t flag = 0x00000001U;
2622                         Target &target = GetProcess()->GetTarget();
2623                         addr_t addr = debug_present->GetLoadAddress(&target);
2624                         GetProcess()->WriteMemory(addr, &flag, sizeof(flag), error);
2625                         if (error.Success())
2626                         {
2627                             if (log)
2628                                 log->Printf("%s - debugger present flag set on debugee.", __FUNCTION__);
2629
2630                             m_debuggerPresentFlagged = true;
2631                         }
2632                         else if (log)
2633                         {
2634                             log->Printf("%s - error writing debugger present flags '%s' ", __FUNCTION__,
2635                                         error.AsCString());
2636                         }
2637                     }
2638                     else if (log)
2639                     {
2640                         log->Printf("%s - error writing debugger present flags - symbol not found", __FUNCTION__);
2641                     }
2642                 }
2643                 break;
2644             }
2645             default:
2646                 break;
2647         }
2648         if (module_loaded)
2649             Update();
2650         return module_loaded;
2651     }
2652     return false;
2653 }
2654
2655 void
2656 RenderScriptRuntime::Update()
2657 {
2658     if (m_rsmodules.size() > 0)
2659     {
2660         if (!m_initiated)
2661         {
2662             Initiate();
2663         }
2664     }
2665 }
2666
2667 // The maximum line length of an .rs.info packet
2668 #define MAXLINE 500
2669 #define STRINGIFY(x) #x
2670 #define MAXLINESTR_(x) "%" STRINGIFY(x) "s"
2671 #define MAXLINESTR MAXLINESTR_(MAXLINE)
2672
2673 // The .rs.info symbol in renderscript modules contains a string which needs to be parsed.
2674 // The string is basic and is parsed on a line by line basis.
2675 bool
2676 RSModuleDescriptor::ParseRSInfo()
2677 {
2678     assert(m_module);
2679     const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData);
2680     if (!info_sym)
2681         return false;
2682
2683     const addr_t addr = info_sym->GetAddressRef().GetFileAddress();
2684     if (addr == LLDB_INVALID_ADDRESS)
2685         return false;
2686
2687     const addr_t size = info_sym->GetByteSize();
2688     const FileSpec fs = m_module->GetFileSpec();
2689
2690     const DataBufferSP buffer = fs.ReadFileContents(addr, size);
2691     if (!buffer)
2692         return false;
2693
2694     // split rs.info. contents into lines
2695     std::vector<std::string> info_lines;
2696     {
2697         const std::string info((const char *)buffer->GetBytes());
2698         for (size_t tail = 0; tail < info.size();)
2699         {
2700             // find next new line or end of string
2701             size_t head = info.find('\n', tail);
2702             head = (head == std::string::npos) ? info.size() : head;
2703             std::string line = info.substr(tail, head - tail);
2704             // add to line list
2705             info_lines.push_back(line);
2706             tail = head + 1;
2707         }
2708     }
2709
2710     std::array<char, MAXLINE> name{{'\0'}};
2711     std::array<char, MAXLINE> value{{'\0'}};
2712
2713     // parse all text lines of .rs.info
2714     for (auto line = info_lines.begin(); line != info_lines.end(); ++line)
2715     {
2716         uint32_t numDefns = 0;
2717         if (sscanf(line->c_str(), "exportVarCount: %" PRIu32 "", &numDefns) == 1)
2718         {
2719             while (numDefns--)
2720                 m_globals.push_back(RSGlobalDescriptor(this, (++line)->c_str()));
2721         }
2722         else if (sscanf(line->c_str(), "exportForEachCount: %" PRIu32 "", &numDefns) == 1)
2723         {
2724             while (numDefns--)
2725             {
2726                 uint32_t slot = 0;
2727                 name[0] = '\0';
2728                 static const char *fmt_s = "%" PRIu32 " - " MAXLINESTR;
2729                 if (sscanf((++line)->c_str(), fmt_s, &slot, name.data()) == 2)
2730                 {
2731                     if (name[0] != '\0')
2732                         m_kernels.push_back(RSKernelDescriptor(this, name.data(), slot));
2733                 }
2734             }
2735         }
2736         else if (sscanf(line->c_str(), "pragmaCount: %" PRIu32 "", &numDefns) == 1)
2737         {
2738             while (numDefns--)
2739             {
2740                 name[0] = value[0] = '\0';
2741                 static const char *fmt_s = MAXLINESTR " - " MAXLINESTR;
2742                 if (sscanf((++line)->c_str(), fmt_s, name.data(), value.data()) != 0)
2743                 {
2744                     if (name[0] != '\0')
2745                         m_pragmas[std::string(name.data())] = value.data();
2746                 }
2747             }
2748         }
2749         else
2750         {
2751             Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2752             if (log)
2753             {
2754                 log->Printf("%s - skipping .rs.info field '%s'", __FUNCTION__, line->c_str());
2755             }
2756         }
2757     }
2758
2759     // 'root' kernel should always be present
2760     return m_kernels.size() > 0;
2761 }
2762
2763 void
2764 RenderScriptRuntime::Status(Stream &strm) const
2765 {
2766     if (m_libRS)
2767     {
2768         strm.Printf("Runtime Library discovered.");
2769         strm.EOL();
2770     }
2771     if (m_libRSDriver)
2772     {
2773         strm.Printf("Runtime Driver discovered.");
2774         strm.EOL();
2775     }
2776     if (m_libRSCpuRef)
2777     {
2778         strm.Printf("CPU Reference Implementation discovered.");
2779         strm.EOL();
2780     }
2781
2782     if (m_runtimeHooks.size())
2783     {
2784         strm.Printf("Runtime functions hooked:");
2785         strm.EOL();
2786         for (auto b : m_runtimeHooks)
2787         {
2788             strm.Indent(b.second->defn->name);
2789             strm.EOL();
2790         }
2791     }
2792     else
2793     {
2794         strm.Printf("Runtime is not hooked.");
2795         strm.EOL();
2796     }
2797 }
2798
2799 void
2800 RenderScriptRuntime::DumpContexts(Stream &strm) const
2801 {
2802     strm.Printf("Inferred RenderScript Contexts:");
2803     strm.EOL();
2804     strm.IndentMore();
2805
2806     std::map<addr_t, uint64_t> contextReferences;
2807
2808     // Iterate over all of the currently discovered scripts.
2809     // Note: We cant push or pop from m_scripts inside this loop or it may invalidate script.
2810     for (const auto &script : m_scripts)
2811     {
2812         if (!script->context.isValid())
2813             continue;
2814         lldb::addr_t context = *script->context;
2815
2816         if (contextReferences.find(context) != contextReferences.end())
2817         {
2818             contextReferences[context]++;
2819         }
2820         else
2821         {
2822             contextReferences[context] = 1;
2823         }
2824     }
2825
2826     for (const auto &cRef : contextReferences)
2827     {
2828         strm.Printf("Context 0x%" PRIx64 ": %" PRIu64 " script instances", cRef.first, cRef.second);
2829         strm.EOL();
2830     }
2831     strm.IndentLess();
2832 }
2833
2834 void
2835 RenderScriptRuntime::DumpKernels(Stream &strm) const
2836 {
2837     strm.Printf("RenderScript Kernels:");
2838     strm.EOL();
2839     strm.IndentMore();
2840     for (const auto &module : m_rsmodules)
2841     {
2842         strm.Printf("Resource '%s':", module->m_resname.c_str());
2843         strm.EOL();
2844         for (const auto &kernel : module->m_kernels)
2845         {
2846             strm.Indent(kernel.m_name.AsCString());
2847             strm.EOL();
2848         }
2849     }
2850     strm.IndentLess();
2851 }
2852
2853 RenderScriptRuntime::AllocationDetails *
2854 RenderScriptRuntime::FindAllocByID(Stream &strm, const uint32_t alloc_id)
2855 {
2856     AllocationDetails *alloc = nullptr;
2857
2858     // See if we can find allocation using id as an index;
2859     if (alloc_id <= m_allocations.size() && alloc_id != 0 && m_allocations[alloc_id - 1]->id == alloc_id)
2860     {
2861         alloc = m_allocations[alloc_id - 1].get();
2862         return alloc;
2863     }
2864
2865     // Fallback to searching
2866     for (const auto &a : m_allocations)
2867     {
2868         if (a->id == alloc_id)
2869         {
2870             alloc = a.get();
2871             break;
2872         }
2873     }
2874
2875     if (alloc == nullptr)
2876     {
2877         strm.Printf("Error: Couldn't find allocation with id matching %" PRIu32, alloc_id);
2878         strm.EOL();
2879     }
2880
2881     return alloc;
2882 }
2883
2884 // Prints the contents of an allocation to the output stream, which may be a file
2885 bool
2886 RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id)
2887 {
2888     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
2889
2890     // Check we can find the desired allocation
2891     AllocationDetails *alloc = FindAllocByID(strm, id);
2892     if (!alloc)
2893         return false; // FindAllocByID() will print error message for us here
2894
2895     if (log)
2896         log->Printf("%s - found allocation 0x%" PRIx64, __FUNCTION__, *alloc->address.get());
2897
2898     // Check we have information about the allocation, if not calculate it
2899     if (alloc->shouldRefresh())
2900     {
2901         if (log)
2902             log->Printf("%s - allocation details not calculated yet, jitting info.", __FUNCTION__);
2903
2904         // JIT all the allocation information
2905         if (!RefreshAllocation(alloc, frame_ptr))
2906         {
2907             strm.Printf("Error: Couldn't JIT allocation details");
2908             strm.EOL();
2909             return false;
2910         }
2911     }
2912
2913     // Establish format and size of each data element
2914     const uint32_t vec_size = *alloc->element.type_vec_size.get();
2915     const Element::DataType type = *alloc->element.type.get();
2916
2917     assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && "Invalid allocation type");
2918
2919     lldb::Format format;
2920     if (type >= Element::RS_TYPE_ELEMENT)
2921         format = eFormatHex;
2922     else
2923         format = vec_size == 1 ? static_cast<lldb::Format>(AllocationDetails::RSTypeToFormat[type][eFormatSingle])
2924                                : static_cast<lldb::Format>(AllocationDetails::RSTypeToFormat[type][eFormatVector]);
2925
2926     const uint32_t data_size = *alloc->element.datum_size.get();
2927
2928     if (log)
2929         log->Printf("%s - element size %" PRIu32 " bytes, including padding", __FUNCTION__, data_size);
2930
2931     // Allocate a buffer to copy data into
2932     std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
2933     if (!buffer)
2934     {
2935         strm.Printf("Error: Couldn't read allocation data");
2936         strm.EOL();
2937         return false;
2938     }
2939
2940     // Calculate stride between rows as there may be padding at end of rows since
2941     // allocated memory is 16-byte aligned
2942     if (!alloc->stride.isValid())
2943     {
2944         if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension
2945             alloc->stride = 0;
2946         else if (!JITAllocationStride(alloc, frame_ptr))
2947         {
2948             strm.Printf("Error: Couldn't calculate allocation row stride");
2949             strm.EOL();
2950             return false;
2951         }
2952     }
2953     const uint32_t stride = *alloc->stride.get();
2954     const uint32_t size = *alloc->size.get(); // Size of whole allocation
2955     const uint32_t padding = alloc->element.padding.isValid() ? *alloc->element.padding.get() : 0;
2956     if (log)
2957         log->Printf("%s - stride %" PRIu32 " bytes, size %" PRIu32 " bytes, padding %" PRIu32,
2958                     __FUNCTION__, stride, size, padding);
2959
2960     // Find dimensions used to index loops, so need to be non-zero
2961     uint32_t dim_x = alloc->dimension.get()->dim_1;
2962     dim_x = dim_x == 0 ? 1 : dim_x;
2963
2964     uint32_t dim_y = alloc->dimension.get()->dim_2;
2965     dim_y = dim_y == 0 ? 1 : dim_y;
2966
2967     uint32_t dim_z = alloc->dimension.get()->dim_3;
2968     dim_z = dim_z == 0 ? 1 : dim_z;
2969
2970     // Use data extractor to format output
2971     const uint32_t archByteSize = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
2972     DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(), archByteSize);
2973
2974     uint32_t offset = 0;   // Offset in buffer to next element to be printed
2975     uint32_t prev_row = 0; // Offset to the start of the previous row
2976
2977     // Iterate over allocation dimensions, printing results to user
2978     strm.Printf("Data (X, Y, Z):");
2979     for (uint32_t z = 0; z < dim_z; ++z)
2980     {
2981         for (uint32_t y = 0; y < dim_y; ++y)
2982         {
2983             // Use stride to index start of next row.
2984             if (!(y == 0 && z == 0))
2985                 offset = prev_row + stride;
2986             prev_row = offset;
2987
2988             // Print each element in the row individually
2989             for (uint32_t x = 0; x < dim_x; ++x)
2990             {
2991                 strm.Printf("\n(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") = ", x, y, z);
2992                 if ((type == Element::RS_TYPE_NONE) && (alloc->element.children.size() > 0) &&
2993                     (alloc->element.type_name != Element::GetFallbackStructName()))
2994                 {
2995                     // Here we are dumping an Element of struct type.
2996                     // This is done using expression evaluation with the name of the struct type and pointer to element.
2997
2998                     // Don't print the name of the resulting expression, since this will be '$[0-9]+'
2999                     DumpValueObjectOptions expr_options;
3000                     expr_options.SetHideName(true);
3001
3002                     // Setup expression as derefrencing a pointer cast to element address.
3003                     char expr_char_buffer[jit_max_expr_size];
3004                     int chars_written = snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64,
3005                                                  alloc->element.type_name.AsCString(), *alloc->data_ptr.get() + offset);
3006
3007                     if (chars_written < 0 || chars_written >= jit_max_expr_size)
3008                     {
3009                         if (log)
3010                             log->Printf("%s - error in snprintf().", __FUNCTION__);
3011                         continue;
3012                     }
3013
3014                     // Evaluate expression
3015                     ValueObjectSP expr_result;
3016                     GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer, frame_ptr, expr_result);
3017
3018                     // Print the results to our stream.
3019                     expr_result->Dump(strm, expr_options);
3020                 }
3021                 else
3022                 {
3023                     alloc_data.Dump(&strm, offset, format, data_size - padding, 1, 1, LLDB_INVALID_ADDRESS, 0, 0);
3024                 }
3025                 offset += data_size;
3026             }
3027         }
3028     }
3029     strm.EOL();
3030
3031     return true;
3032 }
3033
3034 // Function recalculates all our cached information about allocations by jitting the
3035 // RS runtime regarding each allocation we know about.
3036 // Returns true if all allocations could be recomputed, false otherwise.
3037 bool
3038 RenderScriptRuntime::RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr)
3039 {
3040     bool success = true;
3041     for (auto &alloc : m_allocations)
3042     {
3043         // JIT current allocation information
3044         if (!RefreshAllocation(alloc.get(), frame_ptr))
3045         {
3046             strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32 "\n", alloc->id);
3047             success = false;
3048         }
3049     }
3050
3051     if (success)
3052         strm.Printf("All allocations successfully recomputed");
3053     strm.EOL();
3054
3055     return success;
3056 }
3057
3058 // Prints information regarding currently loaded allocations.
3059 // These details are gathered by jitting the runtime, which has as latency.
3060 // Index parameter specifies a single allocation ID to print, or a zero value to print them all
3061 void
3062 RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr, const uint32_t index)
3063 {
3064     strm.Printf("RenderScript Allocations:");
3065     strm.EOL();
3066     strm.IndentMore();
3067
3068     for (auto &alloc : m_allocations)
3069     {
3070         // index will only be zero if we want to print all allocations
3071         if (index != 0 && index != alloc->id)
3072             continue;
3073
3074         // JIT current allocation information
3075         if (alloc->shouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr))
3076         {
3077             strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32, alloc->id);
3078             strm.EOL();
3079             continue;
3080         }
3081
3082         strm.Printf("%" PRIu32 ":", alloc->id);
3083         strm.EOL();
3084         strm.IndentMore();
3085
3086         strm.Indent("Context: ");
3087         if (!alloc->context.isValid())
3088             strm.Printf("unknown\n");
3089         else
3090             strm.Printf("0x%" PRIx64 "\n", *alloc->context.get());
3091
3092         strm.Indent("Address: ");
3093         if (!alloc->address.isValid())
3094             strm.Printf("unknown\n");
3095         else
3096             strm.Printf("0x%" PRIx64 "\n", *alloc->address.get());
3097
3098         strm.Indent("Data pointer: ");
3099         if (!alloc->data_ptr.isValid())
3100             strm.Printf("unknown\n");
3101         else
3102             strm.Printf("0x%" PRIx64 "\n", *alloc->data_ptr.get());
3103
3104         strm.Indent("Dimensions: ");
3105         if (!alloc->dimension.isValid())
3106             strm.Printf("unknown\n");
3107         else
3108             strm.Printf("(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
3109                         alloc->dimension.get()->dim_1, alloc->dimension.get()->dim_2, alloc->dimension.get()->dim_3);
3110
3111         strm.Indent("Data Type: ");
3112         if (!alloc->element.type.isValid() || !alloc->element.type_vec_size.isValid())
3113             strm.Printf("unknown\n");
3114         else
3115         {
3116             const int vector_size = *alloc->element.type_vec_size.get();
3117             Element::DataType type = *alloc->element.type.get();
3118
3119             if (!alloc->element.type_name.IsEmpty())
3120                 strm.Printf("%s\n", alloc->element.type_name.AsCString());
3121             else
3122             {
3123                 // Enum value isn't monotonous, so doesn't always index RsDataTypeToString array
3124                 if (type >= Element::RS_TYPE_ELEMENT && type <= Element::RS_TYPE_FONT)
3125                     type = static_cast<Element::DataType>((type - Element::RS_TYPE_ELEMENT) +
3126                                                           Element::RS_TYPE_MATRIX_2X2 + 1);
3127
3128                 if (type >= (sizeof(AllocationDetails::RsDataTypeToString) /
3129                              sizeof(AllocationDetails::RsDataTypeToString[0])) ||
3130                     vector_size > 4 || vector_size < 1)
3131                     strm.Printf("invalid type\n");
3132                 else
3133                     strm.Printf("%s\n", AllocationDetails::RsDataTypeToString[static_cast<uint32_t>(type)]
3134                                                                              [vector_size - 1]);
3135             }
3136         }
3137
3138         strm.Indent("Data Kind: ");
3139         if (!alloc->element.type_kind.isValid())
3140             strm.Printf("unknown\n");
3141         else
3142         {
3143             const Element::DataKind kind = *alloc->element.type_kind.get();
3144             if (kind < Element::RS_KIND_USER || kind > Element::RS_KIND_PIXEL_YUV)
3145                 strm.Printf("invalid kind\n");
3146             else
3147                 strm.Printf("%s\n", AllocationDetails::RsDataKindToString[static_cast<uint32_t>(kind)]);
3148         }
3149
3150         strm.EOL();
3151         strm.IndentLess();
3152     }
3153     strm.IndentLess();
3154 }
3155
3156 // Set breakpoints on every kernel found in RS module
3157 void
3158 RenderScriptRuntime::BreakOnModuleKernels(const RSModuleDescriptorSP rsmodule_sp)
3159 {
3160     for (const auto &kernel : rsmodule_sp->m_kernels)
3161     {
3162         // Don't set breakpoint on 'root' kernel
3163         if (strcmp(kernel.m_name.AsCString(), "root") == 0)
3164             continue;
3165
3166         CreateKernelBreakpoint(kernel.m_name);
3167     }
3168 }
3169
3170 // Method is internally called by the 'kernel breakpoint all' command to
3171 // enable or disable breaking on all kernels.
3172 //
3173 // When do_break is true we want to enable this functionality.
3174 // When do_break is false we want to disable it.
3175 void
3176 RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target)
3177 {
3178     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
3179
3180     InitSearchFilter(target);
3181
3182     // Set breakpoints on all the kernels
3183     if (do_break && !m_breakAllKernels)
3184     {
3185         m_breakAllKernels = true;
3186
3187         for (const auto &module : m_rsmodules)
3188             BreakOnModuleKernels(module);
3189
3190         if (log)
3191             log->Printf("%s(True) - breakpoints set on all currently loaded kernels.", __FUNCTION__);
3192     }
3193     else if (!do_break && m_breakAllKernels) // Breakpoints won't be set on any new kernels.
3194     {
3195         m_breakAllKernels = false;
3196
3197         if (log)
3198             log->Printf("%s(False) - breakpoints no longer automatically set.", __FUNCTION__);
3199     }
3200 }
3201
3202 // Given the name of a kernel this function creates a breakpoint using our
3203 // own breakpoint resolver, and returns the Breakpoint shared pointer.
3204 BreakpointSP
3205 RenderScriptRuntime::CreateKernelBreakpoint(const ConstString &name)
3206 {
3207     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
3208
3209     if (!m_filtersp)
3210     {
3211         if (log)
3212             log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
3213         return nullptr;
3214     }
3215
3216     BreakpointResolverSP resolver_sp(new RSBreakpointResolver(nullptr, name));
3217     BreakpointSP bp = GetProcess()->GetTarget().CreateBreakpoint(m_filtersp, resolver_sp, false, false, false);
3218
3219     // Give RS breakpoints a specific name, so the user can manipulate them as a group.
3220     Error err;
3221     if (!bp->AddName("RenderScriptKernel", err) && log)
3222         log->Printf("%s - error setting break name, '%s'.", __FUNCTION__, err.AsCString());
3223
3224     return bp;
3225 }
3226
3227 // Given an expression for a variable this function tries to calculate the variable's value.
3228 // If this is possible it returns true and sets the uint64_t parameter to the variables unsigned value.
3229 // Otherwise function returns false.
3230 bool
3231 RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp, const char *var_name, uint64_t &val)
3232 {
3233     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
3234     Error error;
3235     VariableSP var_sp;
3236
3237     // Find variable in stack frame
3238     ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath(
3239         var_name, eNoDynamicValues,
3240         StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
3241         var_sp, error));
3242     if (!error.Success())
3243     {
3244         if (log)
3245             log->Printf("%s - error, couldn't find '%s' in frame", __FUNCTION__, var_name);
3246         return false;
3247     }
3248
3249     // Find the uint32_t value for the variable
3250     bool success = false;
3251     val = value_sp->GetValueAsUnsigned(0, &success);
3252     if (!success)
3253     {
3254         if (log)
3255             log->Printf("%s - error, couldn't parse '%s' as an uint32_t.", __FUNCTION__, var_name);
3256         return false;
3257     }
3258
3259     return true;
3260 }
3261
3262 // Function attempts to find the current coordinate of a kernel invocation by investigating the
3263 // values of frame variables in the .expand function. These coordinates are returned via the coord
3264 // array reference parameter. Returns true if the coordinates could be found, and false otherwise.
3265 bool
3266 RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord, Thread *thread_ptr)
3267 {
3268     static const std::string s_runtimeExpandSuffix(".expand");
3269     static const std::array<const char *, 3> s_runtimeCoordVars{{"rsIndex", "p->current.y", "p->current.z"}};
3270
3271     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
3272
3273     if (!thread_ptr)
3274     {
3275         if (log)
3276             log->Printf("%s - Error, No thread pointer", __FUNCTION__);
3277
3278         return false;
3279     }
3280
3281     // Walk the call stack looking for a function whose name has the suffix '.expand'
3282     // and contains the variables we're looking for.
3283     for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i)
3284     {
3285         if (!thread_ptr->SetSelectedFrameByIndex(i))
3286             continue;
3287
3288         StackFrameSP frame_sp = thread_ptr->GetSelectedFrame();
3289         if (!frame_sp)
3290             continue;
3291
3292         // Find the function name
3293         const SymbolContext sym_ctx = frame_sp->GetSymbolContext(false);
3294         const char *func_name_cstr = sym_ctx.GetFunctionName().AsCString();
3295         if (!func_name_cstr)
3296             continue;
3297
3298         if (log)
3299             log->Printf("%s - Inspecting function '%s'", __FUNCTION__, func_name_cstr);
3300
3301         // Check if function name has .expand suffix
3302         std::string func_name(func_name_cstr);
3303         const int length_difference = func_name.length() - s_runtimeExpandSuffix.length();
3304         if (length_difference <= 0)
3305             continue;
3306
3307         const int32_t has_expand_suffix = func_name.compare(length_difference,
3308                                                             s_runtimeExpandSuffix.length(),
3309                                                             s_runtimeExpandSuffix);
3310
3311         if (has_expand_suffix != 0)
3312             continue;
3313
3314         if (log)
3315             log->Printf("%s - Found .expand function '%s'", __FUNCTION__, func_name_cstr);
3316
3317         // Get values for variables in .expand frame that tell us the current kernel invocation
3318         bool found_coord_variables = true;
3319         assert(s_runtimeCoordVars.size() == coord.size());
3320
3321         for (uint32_t i = 0; i < coord.size(); ++i)
3322         {
3323             uint64_t value = 0;
3324             if (!GetFrameVarAsUnsigned(frame_sp, s_runtimeCoordVars[i], value))
3325             {
3326                 found_coord_variables = false;
3327                 break;
3328             }
3329             coord[i] = value;
3330         }
3331
3332         if (found_coord_variables)
3333             return true;
3334     }
3335     return false;
3336 }
3337
3338 // Callback when a kernel breakpoint hits and we're looking for a specific coordinate.
3339 // Baton parameter contains a pointer to the target coordinate we want to break on.
3340 // Function then checks the .expand frame for the current coordinate and breaks to user if it matches.
3341 // Parameter 'break_id' is the id of the Breakpoint which made the callback.
3342 // Parameter 'break_loc_id' is the id for the BreakpointLocation which was hit,
3343 // a single logical breakpoint can have multiple addresses.
3344 bool
3345 RenderScriptRuntime::KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx, user_id_t break_id,
3346                                          user_id_t break_loc_id)
3347 {
3348     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
3349
3350     assert(baton && "Error: null baton in conditional kernel breakpoint callback");
3351
3352     // Coordinate we want to stop on
3353     const uint32_t *target_coord = static_cast<const uint32_t *>(baton);
3354
3355     if (log)
3356         log->Printf("%s - Break ID %" PRIu64 ", (%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", __FUNCTION__, break_id,
3357                     target_coord[0], target_coord[1], target_coord[2]);
3358
3359     // Select current thread
3360     ExecutionContext context(ctx->exe_ctx_ref);
3361     Thread *thread_ptr = context.GetThreadPtr();
3362     assert(thread_ptr && "Null thread pointer");
3363
3364     // Find current kernel invocation from .expand frame variables
3365     RSCoordinate current_coord{}; // Zero initialise array
3366     if (!GetKernelCoordinate(current_coord, thread_ptr))
3367     {
3368         if (log)
3369             log->Printf("%s - Error, couldn't select .expand stack frame", __FUNCTION__);
3370         return false;
3371     }
3372
3373     if (log)
3374         log->Printf("%s - (%" PRIu32 ",%" PRIu32 ",%" PRIu32 ")", __FUNCTION__, current_coord[0], current_coord[1],
3375                     current_coord[2]);
3376
3377     // Check if the current kernel invocation coordinate matches our target coordinate
3378     if (current_coord[0] == target_coord[0] &&
3379         current_coord[1] == target_coord[1] &&
3380         current_coord[2] == target_coord[2])
3381     {
3382         if (log)
3383             log->Printf("%s, BREAKING (%" PRIu32 ",%" PRIu32 ",%" PRIu32 ")", __FUNCTION__, current_coord[0],
3384                         current_coord[1], current_coord[2]);
3385
3386         BreakpointSP breakpoint_sp = context.GetTargetPtr()->GetBreakpointByID(break_id);
3387         assert(breakpoint_sp != nullptr && "Error: Couldn't find breakpoint matching break id for callback");
3388         breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint should only be hit once.
3389         return true;
3390     }
3391
3392     // No match on coordinate
3393     return false;
3394 }
3395
3396 // Tries to set a breakpoint on the start of a kernel, resolved using the kernel name.
3397 // Argument 'coords', represents a three dimensional coordinate which can be used to specify
3398 // a single kernel instance to break on. If this is set then we add a callback to the breakpoint.
3399 void
3400 RenderScriptRuntime::PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array<int, 3> coords,
3401                                              Error &error, TargetSP target)
3402 {
3403     if (!name)
3404     {
3405         error.SetErrorString("invalid kernel name");
3406         return;
3407     }
3408
3409     InitSearchFilter(target);
3410
3411     ConstString kernel_name(name);
3412     BreakpointSP bp = CreateKernelBreakpoint(kernel_name);
3413
3414     // We have a conditional breakpoint on a specific coordinate
3415     if (coords[0] != -1)
3416     {
3417         strm.Printf("Conditional kernel breakpoint on coordinate %" PRId32 ", %" PRId32 ", %" PRId32,
3418                     coords[0], coords[1], coords[2]);
3419         strm.EOL();
3420
3421         // Allocate memory for the baton, and copy over coordinate
3422         uint32_t *baton = new uint32_t[coords.size()];
3423         baton[0] = coords[0]; baton[1] = coords[1]; baton[2] = coords[2];
3424
3425         // Create a callback that will be invoked everytime the breakpoint is hit.
3426         // The baton object passed to the handler is the target coordinate we want to break on.
3427         bp->SetCallback(KernelBreakpointHit, baton, true);
3428
3429         // Store a shared pointer to the baton, so the memory will eventually be cleaned up after destruction
3430         m_conditional_breaks[bp->GetID()] = std::shared_ptr<uint32_t>(baton);
3431     }
3432
3433     if (bp)
3434         bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false);
3435 }
3436
3437 void
3438 RenderScriptRuntime::DumpModules(Stream &strm) const
3439 {
3440     strm.Printf("RenderScript Modules:");
3441     strm.EOL();
3442     strm.IndentMore();
3443     for (const auto &module : m_rsmodules)
3444     {
3445         module->Dump(strm);
3446     }
3447     strm.IndentLess();
3448 }
3449
3450 RenderScriptRuntime::ScriptDetails *
3451 RenderScriptRuntime::LookUpScript(addr_t address, bool create)
3452 {
3453     for (const auto &s : m_scripts)
3454     {
3455         if (s->script.isValid())
3456             if (*s->script == address)
3457                 return s.get();
3458     }
3459     if (create)
3460     {
3461         std::unique_ptr<ScriptDetails> s(new ScriptDetails);
3462         s->script = address;
3463         m_scripts.push_back(std::move(s));
3464         return m_scripts.back().get();
3465     }
3466     return nullptr;
3467 }
3468
3469 RenderScriptRuntime::AllocationDetails *
3470 RenderScriptRuntime::LookUpAllocation(addr_t address, bool create)
3471 {
3472     for (const auto &a : m_allocations)
3473     {
3474         if (a->address.isValid())
3475             if (*a->address == address)
3476                 return a.get();
3477     }
3478     if (create)
3479     {
3480         std::unique_ptr<AllocationDetails> a(new AllocationDetails);
3481         a->address = address;
3482         m_allocations.push_back(std::move(a));
3483         return m_allocations.back().get();
3484     }
3485     return nullptr;
3486 }
3487
3488 void
3489 RSModuleDescriptor::Dump(Stream &strm) const
3490 {
3491     strm.Indent();
3492     m_module->GetFileSpec().Dump(&strm);
3493     if (m_module->GetNumCompileUnits())
3494     {
3495         strm.Indent("Debug info loaded.");
3496     }
3497     else
3498     {
3499         strm.Indent("Debug info does not exist.");
3500     }
3501     strm.EOL();
3502     strm.IndentMore();
3503     strm.Indent();
3504     strm.Printf("Globals: %" PRIu64, static_cast<uint64_t>(m_globals.size()));
3505     strm.EOL();
3506     strm.IndentMore();
3507     for (const auto &global : m_globals)
3508     {
3509         global.Dump(strm);
3510     }
3511     strm.IndentLess();
3512     strm.Indent();
3513     strm.Printf("Kernels: %" PRIu64, static_cast<uint64_t>(m_kernels.size()));
3514     strm.EOL();
3515     strm.IndentMore();
3516     for (const auto &kernel : m_kernels)
3517     {
3518         kernel.Dump(strm);
3519     }
3520     strm.Printf("Pragmas: %" PRIu64, static_cast<uint64_t>(m_pragmas.size()));
3521     strm.EOL();
3522     strm.IndentMore();
3523     for (const auto &key_val : m_pragmas)
3524     {
3525         strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str());
3526         strm.EOL();
3527     }
3528     strm.IndentLess(4);
3529 }
3530
3531 void
3532 RSGlobalDescriptor::Dump(Stream &strm) const
3533 {
3534     strm.Indent(m_name.AsCString());
3535     VariableList var_list;
3536     m_module->m_module->FindGlobalVariables(m_name, nullptr, true, 1U, var_list);
3537     if (var_list.GetSize() == 1)
3538     {
3539         auto var = var_list.GetVariableAtIndex(0);
3540         auto type = var->GetType();
3541         if (type)
3542         {
3543             strm.Printf(" - ");
3544             type->DumpTypeName(&strm);
3545         }
3546         else
3547         {
3548             strm.Printf(" - Unknown Type");
3549         }
3550     }
3551     else
3552     {
3553         strm.Printf(" - variable identified, but not found in binary");
3554         const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(m_name, eSymbolTypeData);
3555         if (s)
3556         {
3557             strm.Printf(" (symbol exists) ");
3558         }
3559     }
3560
3561     strm.EOL();
3562 }
3563
3564 void
3565 RSKernelDescriptor::Dump(Stream &strm) const
3566 {
3567     strm.Indent(m_name.AsCString());
3568     strm.EOL();
3569 }
3570
3571 class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed
3572 {
3573 public:
3574     CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter)
3575         : CommandObjectParsed(interpreter, "renderscript module dump",
3576                               "Dumps renderscript specific information for all modules.", "renderscript module dump",
3577                               eCommandRequiresProcess | eCommandProcessMustBeLaunched)
3578     {
3579     }
3580
3581     ~CommandObjectRenderScriptRuntimeModuleDump() override = default;
3582
3583     bool
3584     DoExecute(Args &command, CommandReturnObject &result) override
3585     {
3586         RenderScriptRuntime *runtime =
3587             (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
3588         runtime->DumpModules(result.GetOutputStream());
3589         result.SetStatus(eReturnStatusSuccessFinishResult);
3590         return true;
3591     }
3592 };
3593
3594 class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword
3595 {
3596 public:
3597     CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter)
3598         : CommandObjectMultiword(interpreter, "renderscript module", "Commands that deal with RenderScript modules.",
3599                                  nullptr)
3600     {
3601         LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump(interpreter)));
3602     }
3603
3604     ~CommandObjectRenderScriptRuntimeModule() override = default;
3605 };
3606
3607 class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed
3608 {
3609 public:
3610     CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter)
3611         : CommandObjectParsed(interpreter, "renderscript kernel list",
3612                               "Lists renderscript kernel names and associated script resources.",
3613                               "renderscript kernel list", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
3614     {
3615     }
3616
3617     ~CommandObjectRenderScriptRuntimeKernelList() override = default;
3618
3619     bool
3620     DoExecute(Args &command, CommandReturnObject &result) override
3621     {
3622         RenderScriptRuntime *runtime =
3623             (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
3624         runtime->DumpKernels(result.GetOutputStream());
3625         result.SetStatus(eReturnStatusSuccessFinishResult);
3626         return true;
3627     }
3628 };
3629
3630 class CommandObjectRenderScriptRuntimeKernelBreakpointSet : public CommandObjectParsed
3631 {
3632 public:
3633     CommandObjectRenderScriptRuntimeKernelBreakpointSet(CommandInterpreter &interpreter)
3634         : CommandObjectParsed(interpreter, "renderscript kernel breakpoint set",
3635                               "Sets a breakpoint on a renderscript kernel.",
3636                               "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]",
3637                               eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
3638           m_options(interpreter)
3639     {
3640     }
3641
3642     ~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default;
3643
3644     Options *
3645     GetOptions() override
3646     {
3647         return &m_options;
3648     }
3649
3650     class CommandOptions : public Options
3651     {
3652     public:
3653         CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
3654
3655         ~CommandOptions() override = default;
3656
3657         Error
3658         SetOptionValue(uint32_t option_idx, const char *option_arg) override
3659         {
3660             Error error;
3661             const int short_option = m_getopt_table[option_idx].val;
3662
3663             switch (short_option)
3664             {
3665                 case 'c':
3666                     if (!ParseCoordinate(option_arg))
3667                         error.SetErrorStringWithFormat("Couldn't parse coordinate '%s', should be in format 'x,y,z'.",
3668                                                        option_arg);
3669                     break;
3670                 default:
3671                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
3672                     break;
3673             }
3674             return error;
3675         }
3676
3677         // -c takes an argument of the form 'num[,num][,num]'.
3678         // Where 'id_cstr' is this argument with the whitespace trimmed.
3679         // Missing coordinates are defaulted to zero.
3680         bool
3681         ParseCoordinate(const char *id_cstr)
3682         {
3683             RegularExpression regex;
3684             RegularExpression::Match regex_match(3);
3685
3686             bool matched = false;
3687             if (regex.Compile("^([0-9]+),([0-9]+),([0-9]+)$") && regex.Execute(id_cstr, &regex_match))
3688                 matched = true;
3689             else if (regex.Compile("^([0-9]+),([0-9]+)$") && regex.Execute(id_cstr, &regex_match))
3690                 matched = true;
3691             else if (regex.Compile("^([0-9]+)$") && regex.Execute(id_cstr, &regex_match))
3692                 matched = true;
3693             for (uint32_t i = 0; i < 3; i++)
3694             {
3695                 std::string group;
3696                 if (regex_match.GetMatchAtIndex(id_cstr, i + 1, group))
3697                     m_coord[i] = (uint32_t)strtoul(group.c_str(), nullptr, 0);
3698                 else
3699                     m_coord[i] = 0;
3700             }
3701             return matched;
3702         }
3703
3704         void
3705         OptionParsingStarting() override
3706         {
3707             // -1 means the -c option hasn't been set
3708             m_coord[0] = -1;
3709             m_coord[1] = -1;
3710             m_coord[2] = -1;
3711         }
3712
3713         const OptionDefinition *
3714         GetDefinitions() override
3715         {
3716             return g_option_table;
3717         }
3718
3719         static OptionDefinition g_option_table[];
3720         std::array<int, 3> m_coord;
3721     };
3722
3723     bool
3724     DoExecute(Args &command, CommandReturnObject &result) override
3725     {
3726         const size_t argc = command.GetArgumentCount();
3727         if (argc < 1)
3728         {
3729             result.AppendErrorWithFormat("'%s' takes 1 argument of kernel name, and an optional coordinate.",
3730                                          m_cmd_name.c_str());
3731             result.SetStatus(eReturnStatusFailed);
3732             return false;
3733         }
3734
3735         RenderScriptRuntime *runtime =
3736             (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
3737
3738         Error error;
3739         runtime->PlaceBreakpointOnKernel(result.GetOutputStream(), command.GetArgumentAtIndex(0), m_options.m_coord,
3740                                          error, m_exe_ctx.GetTargetSP());
3741
3742         if (error.Success())
3743         {
3744             result.AppendMessage("Breakpoint(s) created");
3745             result.SetStatus(eReturnStatusSuccessFinishResult);
3746             return true;
3747         }
3748         result.SetStatus(eReturnStatusFailed);
3749         result.AppendErrorWithFormat("Error: %s", error.AsCString());
3750         return false;
3751     }
3752
3753 private:
3754     CommandOptions m_options;
3755 };
3756
3757 OptionDefinition CommandObjectRenderScriptRuntimeKernelBreakpointSet::CommandOptions::g_option_table[] = {
3758     {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue,
3759      "Set a breakpoint on a single invocation of the kernel with specified coordinate.\n"
3760      "Coordinate takes the form 'x[,y][,z] where x,y,z are positive integers representing kernel dimensions. "
3761      "Any unset dimensions will be defaulted to zero."},
3762     {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
3763
3764 class CommandObjectRenderScriptRuntimeKernelBreakpointAll : public CommandObjectParsed
3765 {
3766 public:
3767     CommandObjectRenderScriptRuntimeKernelBreakpointAll(CommandInterpreter &interpreter)
3768         : CommandObjectParsed(
3769               interpreter, "renderscript kernel breakpoint all",
3770               "Automatically sets a breakpoint on all renderscript kernels that are or will be loaded.\n"
3771               "Disabling option means breakpoints will no longer be set on any kernels loaded in the future, "
3772               "but does not remove currently set breakpoints.",
3773               "renderscript kernel breakpoint all <enable/disable>",
3774               eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused)
3775     {
3776     }
3777
3778     ~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default;
3779
3780     bool
3781     DoExecute(Args &command, CommandReturnObject &result) override
3782     {
3783         const size_t argc = command.GetArgumentCount();
3784         if (argc != 1)
3785         {
3786             result.AppendErrorWithFormat("'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str());
3787             result.SetStatus(eReturnStatusFailed);
3788             return false;
3789         }
3790
3791         RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
3792             m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
3793
3794         bool do_break = false;
3795         const char *argument = command.GetArgumentAtIndex(0);
3796         if (strcmp(argument, "enable") == 0)
3797         {
3798             do_break = true;
3799             result.AppendMessage("Breakpoints will be set on all kernels.");
3800         }
3801         else if (strcmp(argument, "disable") == 0)
3802         {
3803             do_break = false;
3804             result.AppendMessage("Breakpoints will not be set on any new kernels.");
3805         }
3806         else
3807         {
3808             result.AppendErrorWithFormat("Argument must be either 'enable' or 'disable'");
3809             result.SetStatus(eReturnStatusFailed);
3810             return false;
3811         }
3812
3813         runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP());
3814
3815         result.SetStatus(eReturnStatusSuccessFinishResult);
3816         return true;
3817     }
3818 };
3819
3820 class CommandObjectRenderScriptRuntimeKernelCoordinate : public CommandObjectParsed
3821 {
3822 public:
3823     CommandObjectRenderScriptRuntimeKernelCoordinate(CommandInterpreter &interpreter)
3824         : CommandObjectParsed(interpreter, "renderscript kernel coordinate",
3825                               "Shows the (x,y,z) coordinate of the current kernel invocation.",
3826                               "renderscript kernel coordinate",
3827                               eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused)
3828     {
3829     }
3830
3831     ~CommandObjectRenderScriptRuntimeKernelCoordinate() override = default;
3832
3833     bool
3834     DoExecute(Args &command, CommandReturnObject &result) override
3835     {
3836         RSCoordinate coord{}; // Zero initialize array
3837         bool success = RenderScriptRuntime::GetKernelCoordinate(coord, m_exe_ctx.GetThreadPtr());
3838         Stream &stream = result.GetOutputStream();
3839
3840         if (success)
3841         {
3842             stream.Printf("Coordinate: (%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", coord[0], coord[1], coord[2]);
3843             stream.EOL();
3844             result.SetStatus(eReturnStatusSuccessFinishResult);
3845         }
3846         else
3847         {
3848             stream.Printf("Error: Coordinate could not be found.");
3849             stream.EOL();
3850             result.SetStatus(eReturnStatusFailed);
3851         }
3852         return true;
3853     }
3854 };
3855
3856 class CommandObjectRenderScriptRuntimeKernelBreakpoint : public CommandObjectMultiword
3857 {
3858 public:
3859     CommandObjectRenderScriptRuntimeKernelBreakpoint(CommandInterpreter &interpreter)
3860         : CommandObjectMultiword(interpreter, "renderscript kernel",
3861                                  "Commands that generate breakpoints on renderscript kernels.", nullptr)
3862     {
3863         LoadSubCommand("set", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointSet(interpreter)));
3864         LoadSubCommand("all", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointAll(interpreter)));
3865     }
3866
3867     ~CommandObjectRenderScriptRuntimeKernelBreakpoint() override = default;
3868 };
3869
3870 class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword
3871 {
3872 public:
3873     CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter)
3874         : CommandObjectMultiword(interpreter, "renderscript kernel", "Commands that deal with RenderScript kernels.",
3875                                  nullptr)
3876     {
3877         LoadSubCommand("list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList(interpreter)));
3878         LoadSubCommand("coordinate",
3879                        CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelCoordinate(interpreter)));
3880         LoadSubCommand("breakpoint",
3881                        CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter)));
3882     }
3883
3884     ~CommandObjectRenderScriptRuntimeKernel() override = default;
3885 };
3886
3887 class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed
3888 {
3889 public:
3890     CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter)
3891         : CommandObjectParsed(interpreter, "renderscript context dump", "Dumps renderscript context information.",
3892                               "renderscript context dump", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
3893     {
3894     }
3895
3896     ~CommandObjectRenderScriptRuntimeContextDump() override = default;
3897
3898     bool
3899     DoExecute(Args &command, CommandReturnObject &result) override
3900     {
3901         RenderScriptRuntime *runtime =
3902             (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
3903         runtime->DumpContexts(result.GetOutputStream());
3904         result.SetStatus(eReturnStatusSuccessFinishResult);
3905         return true;
3906     }
3907 };
3908
3909 class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword
3910 {
3911 public:
3912     CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter)
3913         : CommandObjectMultiword(interpreter, "renderscript context", "Commands that deal with RenderScript contexts.",
3914                                  nullptr)
3915     {
3916         LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(interpreter)));
3917     }
3918
3919     ~CommandObjectRenderScriptRuntimeContext() override = default;
3920 };
3921
3922 class CommandObjectRenderScriptRuntimeAllocationDump : public CommandObjectParsed
3923 {
3924 public:
3925     CommandObjectRenderScriptRuntimeAllocationDump(CommandInterpreter &interpreter)
3926         : CommandObjectParsed(interpreter, "renderscript allocation dump",
3927                               "Displays the contents of a particular allocation", "renderscript allocation dump <ID>",
3928                               eCommandRequiresProcess | eCommandProcessMustBeLaunched),
3929           m_options(interpreter)
3930     {
3931     }
3932
3933     ~CommandObjectRenderScriptRuntimeAllocationDump() override = default;
3934
3935     Options *
3936     GetOptions() override
3937     {
3938         return &m_options;
3939     }
3940
3941     class CommandOptions : public Options
3942     {
3943     public:
3944         CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
3945
3946         ~CommandOptions() override = default;
3947
3948         Error
3949         SetOptionValue(uint32_t option_idx, const char *option_arg) override
3950         {
3951             Error error;
3952             const int short_option = m_getopt_table[option_idx].val;
3953
3954             switch (short_option)
3955             {
3956                 case 'f':
3957                     m_outfile.SetFile(option_arg, true);
3958                     if (m_outfile.Exists())
3959                     {
3960                         m_outfile.Clear();
3961                         error.SetErrorStringWithFormat("file already exists: '%s'", option_arg);
3962                     }
3963                     break;
3964                 default:
3965                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
3966                     break;
3967             }
3968             return error;
3969         }
3970
3971         void
3972         OptionParsingStarting() override
3973         {
3974             m_outfile.Clear();
3975         }
3976
3977         const OptionDefinition *
3978         GetDefinitions() override
3979         {
3980             return g_option_table;
3981         }
3982
3983         static OptionDefinition g_option_table[];
3984         FileSpec m_outfile;
3985     };
3986
3987     bool
3988     DoExecute(Args &command, CommandReturnObject &result) override
3989     {
3990         const size_t argc = command.GetArgumentCount();
3991         if (argc < 1)
3992         {
3993             result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. As well as an optional -f argument",
3994                                          m_cmd_name.c_str());
3995             result.SetStatus(eReturnStatusFailed);
3996             return false;
3997         }
3998
3999         RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
4000             m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
4001
4002         const char *id_cstr = command.GetArgumentAtIndex(0);
4003         bool convert_complete = false;
4004         const uint32_t id = StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &convert_complete);
4005         if (!convert_complete)
4006         {
4007             result.AppendErrorWithFormat("invalid allocation id argument '%s'", id_cstr);
4008             result.SetStatus(eReturnStatusFailed);
4009             return false;
4010         }
4011
4012         Stream *output_strm = nullptr;
4013         StreamFile outfile_stream;
4014         const FileSpec &outfile_spec = m_options.m_outfile; // Dump allocation to file instead
4015         if (outfile_spec)
4016         {
4017             // Open output file
4018             char path[256];
4019             outfile_spec.GetPath(path, sizeof(path));
4020             if (outfile_stream.GetFile().Open(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate).Success())
4021             {
4022                 output_strm = &outfile_stream;
4023                 result.GetOutputStream().Printf("Results written to '%s'", path);
4024                 result.GetOutputStream().EOL();
4025             }
4026             else
4027             {
4028                 result.AppendErrorWithFormat("Couldn't open file '%s'", path);
4029                 result.SetStatus(eReturnStatusFailed);
4030                 return false;
4031             }
4032         }
4033         else
4034             output_strm = &result.GetOutputStream();
4035
4036         assert(output_strm != nullptr);
4037         bool success = runtime->DumpAllocation(*output_strm, m_exe_ctx.GetFramePtr(), id);
4038
4039         if (success)
4040             result.SetStatus(eReturnStatusSuccessFinishResult);
4041         else
4042             result.SetStatus(eReturnStatusFailed);
4043
4044         return true;
4045     }
4046
4047 private:
4048     CommandOptions m_options;
4049 };
4050
4051 OptionDefinition CommandObjectRenderScriptRuntimeAllocationDump::CommandOptions::g_option_table[] = {
4052     {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename,
4053      "Print results to specified file instead of command line."},
4054     {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
4055
4056 class CommandObjectRenderScriptRuntimeAllocationList : public CommandObjectParsed
4057 {
4058 public:
4059     CommandObjectRenderScriptRuntimeAllocationList(CommandInterpreter &interpreter)
4060         : CommandObjectParsed(interpreter, "renderscript allocation list",
4061                               "List renderscript allocations and their information.", "renderscript allocation list",
4062                               eCommandRequiresProcess | eCommandProcessMustBeLaunched),
4063           m_options(interpreter)
4064     {
4065     }
4066
4067     ~CommandObjectRenderScriptRuntimeAllocationList() override = default;
4068
4069     Options *
4070     GetOptions() override
4071     {
4072         return &m_options;
4073     }
4074
4075     class CommandOptions : public Options
4076     {
4077     public:
4078         CommandOptions(CommandInterpreter &interpreter) : Options(interpreter), m_id(0) {}
4079
4080         ~CommandOptions() override = default;
4081
4082         Error
4083         SetOptionValue(uint32_t option_idx, const char *option_arg) override
4084         {
4085             Error error;
4086             const int short_option = m_getopt_table[option_idx].val;
4087
4088             switch (short_option)
4089             {
4090                 case 'i':
4091                     bool success;
4092                     m_id = StringConvert::ToUInt32(option_arg, 0, 0, &success);
4093                     if (!success)
4094                         error.SetErrorStringWithFormat("invalid integer value for option '%c'", short_option);
4095                     break;
4096                 default:
4097                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
4098                     break;
4099             }
4100             return error;
4101         }
4102
4103         void
4104         OptionParsingStarting() override
4105         {
4106             m_id = 0;
4107         }
4108
4109         const OptionDefinition *
4110         GetDefinitions() override
4111         {
4112             return g_option_table;
4113         }
4114
4115         static OptionDefinition g_option_table[];
4116         uint32_t m_id;
4117     };
4118
4119     bool
4120     DoExecute(Args &command, CommandReturnObject &result) override
4121     {
4122         RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
4123             m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
4124         runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(), m_options.m_id);
4125         result.SetStatus(eReturnStatusSuccessFinishResult);
4126         return true;
4127     }
4128
4129 private:
4130     CommandOptions m_options;
4131 };
4132
4133 OptionDefinition CommandObjectRenderScriptRuntimeAllocationList::CommandOptions::g_option_table[] = {
4134     {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex,
4135      "Only show details of a single allocation with specified id."},
4136     {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
4137
4138 class CommandObjectRenderScriptRuntimeAllocationLoad : public CommandObjectParsed
4139 {
4140 public:
4141     CommandObjectRenderScriptRuntimeAllocationLoad(CommandInterpreter &interpreter)
4142         : CommandObjectParsed(
4143               interpreter, "renderscript allocation load", "Loads renderscript allocation contents from a file.",
4144               "renderscript allocation load <ID> <filename>", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
4145     {
4146     }
4147
4148     ~CommandObjectRenderScriptRuntimeAllocationLoad() override = default;
4149
4150     bool
4151     DoExecute(Args &command, CommandReturnObject &result) override
4152     {
4153         const size_t argc = command.GetArgumentCount();
4154         if (argc != 2)
4155         {
4156             result.AppendErrorWithFormat("'%s' takes 2 arguments, an allocation ID and filename to read from.",
4157                                          m_cmd_name.c_str());
4158             result.SetStatus(eReturnStatusFailed);
4159             return false;
4160         }
4161
4162         RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
4163             m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
4164
4165         const char *id_cstr = command.GetArgumentAtIndex(0);
4166         bool convert_complete = false;
4167         const uint32_t id = StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &convert_complete);
4168         if (!convert_complete)
4169         {
4170             result.AppendErrorWithFormat("invalid allocation id argument '%s'", id_cstr);
4171             result.SetStatus(eReturnStatusFailed);
4172             return false;
4173         }
4174
4175         const char *filename = command.GetArgumentAtIndex(1);
4176         bool success = runtime->LoadAllocation(result.GetOutputStream(), id, filename, m_exe_ctx.GetFramePtr());
4177
4178         if (success)
4179             result.SetStatus(eReturnStatusSuccessFinishResult);
4180         else
4181             result.SetStatus(eReturnStatusFailed);
4182
4183         return true;
4184     }
4185 };
4186
4187 class CommandObjectRenderScriptRuntimeAllocationSave : public CommandObjectParsed
4188 {
4189 public:
4190     CommandObjectRenderScriptRuntimeAllocationSave(CommandInterpreter &interpreter)
4191         : CommandObjectParsed(
4192               interpreter, "renderscript allocation save", "Write renderscript allocation contents to a file.",
4193               "renderscript allocation save <ID> <filename>", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
4194     {
4195     }
4196
4197     ~CommandObjectRenderScriptRuntimeAllocationSave() override = default;
4198
4199     bool
4200     DoExecute(Args &command, CommandReturnObject &result) override
4201     {
4202         const size_t argc = command.GetArgumentCount();
4203         if (argc != 2)
4204         {
4205             result.AppendErrorWithFormat("'%s' takes 2 arguments, an allocation ID and filename to read from.",
4206                                          m_cmd_name.c_str());
4207             result.SetStatus(eReturnStatusFailed);
4208             return false;
4209         }
4210
4211         RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
4212             m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
4213
4214         const char *id_cstr = command.GetArgumentAtIndex(0);
4215         bool convert_complete = false;
4216         const uint32_t id = StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &convert_complete);
4217         if (!convert_complete)
4218         {
4219             result.AppendErrorWithFormat("invalid allocation id argument '%s'", id_cstr);
4220             result.SetStatus(eReturnStatusFailed);
4221             return false;
4222         }
4223
4224         const char *filename = command.GetArgumentAtIndex(1);
4225         bool success = runtime->SaveAllocation(result.GetOutputStream(), id, filename, m_exe_ctx.GetFramePtr());
4226
4227         if (success)
4228             result.SetStatus(eReturnStatusSuccessFinishResult);
4229         else
4230             result.SetStatus(eReturnStatusFailed);
4231
4232         return true;
4233     }
4234 };
4235
4236 class CommandObjectRenderScriptRuntimeAllocationRefresh : public CommandObjectParsed
4237 {
4238 public:
4239     CommandObjectRenderScriptRuntimeAllocationRefresh(CommandInterpreter &interpreter)
4240         : CommandObjectParsed(interpreter, "renderscript allocation refresh",
4241                               "Recomputes the details of all allocations.", "renderscript allocation refresh",
4242                               eCommandRequiresProcess | eCommandProcessMustBeLaunched)
4243     {
4244     }
4245
4246     ~CommandObjectRenderScriptRuntimeAllocationRefresh() override = default;
4247
4248     bool
4249     DoExecute(Args &command, CommandReturnObject &result) override
4250     {
4251         RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
4252             m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
4253
4254         bool success = runtime->RecomputeAllAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr());
4255
4256         if (success)
4257         {
4258             result.SetStatus(eReturnStatusSuccessFinishResult);
4259             return true;
4260         }
4261         else
4262         {
4263             result.SetStatus(eReturnStatusFailed);
4264             return false;
4265         }
4266     }
4267 };
4268
4269 class CommandObjectRenderScriptRuntimeAllocation : public CommandObjectMultiword
4270 {
4271 public:
4272     CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter)
4273         : CommandObjectMultiword(interpreter, "renderscript allocation",
4274                                  "Commands that deal with RenderScript allocations.", nullptr)
4275     {
4276         LoadSubCommand("list", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationList(interpreter)));
4277         LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationDump(interpreter)));
4278         LoadSubCommand("save", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationSave(interpreter)));
4279         LoadSubCommand("load", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationLoad(interpreter)));
4280         LoadSubCommand("refresh", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationRefresh(interpreter)));
4281     }
4282
4283     ~CommandObjectRenderScriptRuntimeAllocation() override = default;
4284 };
4285
4286 class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed
4287 {
4288 public:
4289     CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter)
4290         : CommandObjectParsed(interpreter, "renderscript status", "Displays current RenderScript runtime status.",
4291                               "renderscript status", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
4292     {
4293     }
4294
4295     ~CommandObjectRenderScriptRuntimeStatus() override = default;
4296
4297     bool
4298     DoExecute(Args &command, CommandReturnObject &result) override
4299     {
4300         RenderScriptRuntime *runtime =
4301             (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
4302         runtime->Status(result.GetOutputStream());
4303         result.SetStatus(eReturnStatusSuccessFinishResult);
4304         return true;
4305     }
4306 };
4307
4308 class CommandObjectRenderScriptRuntime : public CommandObjectMultiword
4309 {
4310 public:
4311     CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter)
4312         : CommandObjectMultiword(interpreter, "renderscript", "Commands for operating on the RenderScript runtime.",
4313                                  "renderscript <subcommand> [<subcommand-options>]")
4314     {
4315         LoadSubCommand("module", CommandObjectSP(new CommandObjectRenderScriptRuntimeModule(interpreter)));
4316         LoadSubCommand("status", CommandObjectSP(new CommandObjectRenderScriptRuntimeStatus(interpreter)));
4317         LoadSubCommand("kernel", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernel(interpreter)));
4318         LoadSubCommand("context", CommandObjectSP(new CommandObjectRenderScriptRuntimeContext(interpreter)));
4319         LoadSubCommand("allocation", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocation(interpreter)));
4320     }
4321
4322     ~CommandObjectRenderScriptRuntime() override = default;
4323 };
4324
4325 void
4326 RenderScriptRuntime::Initiate()
4327 {
4328     assert(!m_initiated);
4329 }
4330
4331 RenderScriptRuntime::RenderScriptRuntime(Process *process)
4332     : lldb_private::CPPLanguageRuntime(process),
4333       m_initiated(false),
4334       m_debuggerPresentFlagged(false),
4335       m_breakAllKernels(false)
4336 {
4337     ModulesDidLoad(process->GetTarget().GetImages());
4338 }
4339
4340 lldb::CommandObjectSP
4341 RenderScriptRuntime::GetCommandObject(lldb_private::CommandInterpreter &interpreter)
4342 {
4343     return CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter));
4344 }
4345
4346 RenderScriptRuntime::~RenderScriptRuntime() = default;