Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release:

MFC r309142 (by emaste):

Add WITH_LLD_AS_LD build knob

If set it installs LLD as /usr/bin/ld.  LLD (as of version 3.9) is not
capable of linking the world and kernel, but can self-host and link many
substantial applications. GNU ld continues to be used for the world and
kernel build, regardless of how this knob is set.

It is on by default for arm64, and off for all other CPU architectures.

Sponsored by:	The FreeBSD Foundation

MFC r310840:

Reapply 310775, now it also builds correctly if lldb is disabled:

Move llvm-objdump from CLANG_EXTRAS to installed by default

We currently install three tools from binutils 2.17.50: as, ld, and
objdump. Work is underway to migrate to a permissively-licensed
tool-chain, with one goal being the retirement of binutils 2.17.50.

LLVM's llvm-objdump is intended to be compatible with GNU objdump
although it is currently missing some options and may have formatting
differences. Enable it by default for testing and further investigation.
It may later be changed to install as /usr/bin/objdump, it becomes a
fully viable replacement.

Reviewed by:	emaste
Differential Revision:	https://reviews.freebsd.org/D8879

MFC r312855 (by emaste):

Rename LLD_AS_LD to LLD_IS_LD, for consistency with CLANG_IS_CC

Reported by:	Dan McGregor <dan.mcgregor usask.ca>

MFC r313559 | glebius | 2017-02-10 18:34:48 +0100 (Fri, 10 Feb 2017) | 5 lines

Don't check struct rtentry on FreeBSD, it is an internal kernel structure.
On other systems it may be API structure for SIOCADDRT/SIOCDELRT.

Reviewed by:	emaste, dim

MFC r314152 (by jkim):

Remove an assembler flag, which is redundant since r309124.  The upstream
took care of it by introducing a macro NO_EXEC_STACK_DIRECTIVE.

http://llvm.org/viewvc/llvm-project?rev=273500&view=rev

Reviewed by:	dim

MFC r314564:

Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
4.0.0 (branches/release_40 296509).  The release will follow soon.

Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11
support to build; see UPDATING for more information.

Also note that as of 4.0.0, lld should be able to link the base system
on amd64 and aarch64.  See the WITH_LLD_IS_LLD setting in src.conf(5).
Though please be aware that this is work in progress.

Release notes for llvm, clang and lld will be available here:
<http://releases.llvm.org/4.0.0/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/clang/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/lld/docs/ReleaseNotes.html>

Thanks to Ed Maste, Jan Beich, Antoine Brodin and Eric Fiselier for
their help.

Relnotes:	yes
Exp-run:	antoine
PR:		215969, 216008

MFC r314708:

For now, revert r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

This commit is the cause of excessive compile times on skein_block.c
(and possibly other files) during kernel builds on amd64.

We never saw the problematic behavior described in this upstream commit,
so for now it is better to revert it.  An upstream bug has been filed
here: https://bugs.llvm.org/show_bug.cgi?id=32142

Reported by:	mjg

MFC r314795:

Reapply r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

Pull in r296992 from upstream llvm trunk (by Sanjoy Das):

  [SCEV] Decrease the recursion threshold for CompareValueComplexity

  Fixes PR32142.

  r287232 accidentally increased the recursion threshold for
  CompareValueComplexity from 2 to 32.  This change reverses that
  change by introducing a separate flag for CompareValueComplexity's
  threshold.

The latter revision fixes the excessive compile times for skein_block.c.

MFC r314907 | mmel | 2017-03-08 12:40:27 +0100 (Wed, 08 Mar 2017) | 7 lines

Unbreak ARMv6 world.

The new compiler_rt library imported with clang 4.0.0 have several fatal
issues (non-functional __udivsi3 for example) with ARM specific instrict
functions. As temporary workaround, until upstream solve these problems,
disable all thumb[1][2] related feature.

MFC r315016:

Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release.
We were already very close to the last release candidate, so this is a
pretty minor update.

Relnotes:	yes

MFC r316005:

Revert r314907, and pull in r298713 from upstream compiler-rt trunk (by
Weiming Zhao):

  builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA.

  Summary:
  Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation
  mode (-mthumb, -marm), it reflect's capability of given CPU.

  Due to this:
   - use  __tbumb__ and __thumb2__ insteand of __ARM_ARCH_ISA_THUMB
   - use '.thumb' directive consistently  in all affected files
   - decorate all thumb functions using
     DEFINE_COMPILERRT_THUMB_FUNCTION()

  ---------
  Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 !

  Reviewers: weimingz, rengolin, compnerd

  Subscribers: aemerson, dim

  Differential Revision: https://reviews.llvm.org/D30938

Discussed with:	mmel

8 files changed, 5601 insertions, 3968 deletions

diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp
new file mode 100644
index 0000000..b056186
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp
@@ -0,0 +1,200 @@
+//===-- RenderScriptExpressionOpts.cpp --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+// C++ Includes
+#include <string>
+
+// Other libraries and framework includes
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+
+#include "clang/Basic/TargetOptions.h"
+
+// Project includes
+#include "lldb/Core/Log.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
+#include "RenderScriptExpressionOpts.h"
+#include "RenderScriptRuntime.h"
+#include "RenderScriptx86ABIFixups.h"
+
+using namespace lldb_private;
+using namespace lldb_renderscript;
+
+// [``slang``](https://android.googlesource.com/platform/frameworks/compile/slang),
+// the compiler frontend for RenderScript embeds an ARM specific triple in IR
+// that is shipped in the app, after
+// generating IR that has some assumptions that an ARM device is the target.
+// As the IR is then compiled on a device of unknown (at time the IR was
+// generated at least) architecture,
+// when calling RenderScript API function as part of debugger expressions, we
+// have to perform a fixup pass that
+// removes those assumptions right before the module is sent to be generated by
+// the llvm backend.
+
+namespace {
+bool registerRSDefaultTargetOpts(clang::TargetOptions &proto,
+                                 const llvm::Triple::ArchType &arch) {
+  switch (arch) {
+  case llvm::Triple::ArchType::x86:
+    proto.Triple = "i686--linux-android";
+    proto.CPU = "atom";
+    proto.Features.push_back("+long64");
+    // Fallthrough for common x86 family features
+    LLVM_FALLTHROUGH;
+  case llvm::Triple::ArchType::x86_64:
+    proto.Features.push_back("+mmx");
+    proto.Features.push_back("+sse");
+    proto.Features.push_back("+sse2");
+    proto.Features.push_back("+sse3");
+    proto.Features.push_back("+ssse3");
+    proto.Features.push_back("+sse4.1");
+    proto.Features.push_back("+sse4.2");
+    break;
+  case llvm::Triple::ArchType::mipsel:
+    // pretend this is `arm' for the front-end
+    proto.Triple = "armv7-none-linux-android";
+    proto.CPU = "";
+    proto.Features.push_back("+long64");
+    break;
+  case llvm::Triple::ArchType::mips64el:
+    // pretend this is `aarch64' for the front-end
+    proto.Triple = "aarch64-none-linux-android";
+    proto.CPU = "";
+    break;
+  default:
+    return false;
+  }
+  return true;
+}
+} // end anonymous namespace
+
+bool RenderScriptRuntimeModulePass::runOnModule(llvm::Module &module) {
+  bool changed_module = false;
+  Log *log(
+      GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_EXPRESSIONS));
+
+  std::string err;
+  llvm::StringRef real_triple =
+      m_process_ptr->GetTarget().GetArchitecture().GetTriple().getTriple();
+  const llvm::Target *target_info =
+      llvm::TargetRegistry::lookupTarget(real_triple, err);
+  if (!target_info) {
+    if (log)
+      log->Warning("couldn't determine real target architecture: '%s'",
+                   err.c_str());
+    return false;
+  }
+
+  llvm::Optional<llvm::Reloc::Model> reloc_model = llvm::None;
+  assert(m_process_ptr && "no available lldb process");
+  switch (m_process_ptr->GetTarget().GetArchitecture().GetMachine()) {
+  case llvm::Triple::ArchType::x86:
+    changed_module |= fixupX86FunctionCalls(module);
+    // For some reason this triple gets totally missed by the backend, and must
+    // be set manually.
+    // There a reference in bcc/Main.cpp about auto feature-detection being
+    // removed from LLVM3.5, but I can't
+    // see that discussion anywhere public.
+    real_triple = "i686--linux-android";
+    break;
+  case llvm::Triple::ArchType::x86_64:
+    changed_module |= fixupX86_64FunctionCalls(module);
+    break;
+  case llvm::Triple::ArchType::mipsel:
+  case llvm::Triple::ArchType::mips64el:
+    // No actual IR fixup pass is needed on MIPS, but the datalayout
+    // and targetmachine do need to be explicitly set.
+
+    // bcc explicitly compiles MIPS code to use the static relocation
+    // model due to an issue with relocations in mclinker.
+    // see libbcc/support/CompilerConfig.cpp for details
+    reloc_model = llvm::Reloc::Static;
+    changed_module = true;
+    break;
+  case llvm::Triple::ArchType::arm:
+  case llvm::Triple::ArchType::aarch64:
+    // ARM subtargets need no fixup passes as they are the initial target as
+    // generated by the
+    // slang compiler frontend.
+    break;
+  default:
+    if (log)
+      log->Warning("Ignoring unknown renderscript target");
+    return false;
+  }
+
+  if (changed_module) {
+    llvm::TargetOptions options;
+    llvm::TargetMachine *target_machine = target_info->createTargetMachine(
+        real_triple, "", "", options, reloc_model);
+    assert(target_machine &&
+           "failed to identify RenderScriptRuntime target machine");
+    // We've been using a triple and datalayout of some ARM variant all along,
+    // so
+    // we need to let the backend know that this is no longer the case.
+    if (log) {
+      log->Printf("%s - Changing RS target triple to '%s'", __FUNCTION__,
+                  real_triple.str().c_str());
+      log->Printf(
+          "%s - Changing RS datalayout to '%s'", __FUNCTION__,
+          target_machine->createDataLayout().getStringRepresentation().c_str());
+    }
+    module.setTargetTriple(real_triple);
+    module.setDataLayout(target_machine->createDataLayout());
+  }
+  return changed_module;
+}
+
+char RenderScriptRuntimeModulePass::ID = 0;
+
+namespace lldb_private {
+
+bool RenderScriptRuntime::GetOverrideExprOptions(clang::TargetOptions &proto) {
+  auto *process = GetProcess();
+  assert(process);
+  return registerRSDefaultTargetOpts(
+      proto, process->GetTarget().GetArchitecture().GetMachine());
+}
+
+bool RenderScriptRuntime::GetIRPasses(LLVMUserExpression::IRPasses &passes) {
+  if (!m_ir_passes)
+    m_ir_passes = new RSIRPasses(GetProcess());
+  assert(m_ir_passes);
+
+  passes.EarlyPasses = m_ir_passes->EarlyPasses;
+  passes.LatePasses = m_ir_passes->LatePasses;
+
+  return true;
+}
+
+namespace lldb_renderscript {
+
+RSIRPasses::RSIRPasses(Process *process) {
+  IRPasses();
+  assert(process);
+
+  EarlyPasses = std::make_shared<llvm::legacy::PassManager>();
+  assert(EarlyPasses);
+  EarlyPasses->add(new RenderScriptRuntimeModulePass(process));
+}
+
+RSIRPasses::~RSIRPasses() {}
+
+} // namespace lldb_renderscript
+} // namespace lldb_private
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h
new file mode 100644
index 0000000..f45ff83
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.h
@@ -0,0 +1,57 @@
+//===-- RenderScriptExpressionOpts.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_RENDERSCRIPT_EXPROPTS_H
+#define LLDB_RENDERSCRIPT_EXPROPTS_H
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+#include "llvm/IR/Module.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+
+// Project includes
+#include "lldb/Target/LanguageRuntime.h"
+#include "lldb/Target/Process.h"
+#include "lldb/lldb-private.h"
+
+#include "RenderScriptRuntime.h"
+#include "RenderScriptx86ABIFixups.h"
+
+// RenderScriptRuntimeModulePass is a simple llvm::ModulesPass that is used
+// during expression evaluation to apply RenderScript-specific fixes for
+// expression evaluation. In particular this is used to make expression IR
+// conformant with the ABI generated by the slang frontend. This ModulePass is
+// executed in ClangExpressionParser::PrepareForExecution whenever an
+// expression's DWARF language is eLanguageTypeExtRenderscript
+
+class RenderScriptRuntimeModulePass : public llvm::ModulePass {
+public:
+  static char ID;
+  RenderScriptRuntimeModulePass(const lldb_private::Process *process)
+      : ModulePass(ID), m_process_ptr(process) {}
+
+  bool runOnModule(llvm::Module &module);
+
+private:
+  const lldb_private::Process *m_process_ptr;
+};
+
+namespace lldb_private {
+namespace lldb_renderscript {
+struct RSIRPasses : public lldb_private::LLVMUserExpression::IRPasses {
+  RSIRPasses(lldb_private::Process *process);
+
+  ~RSIRPasses();
+};
+} // namespace lldb_renderscript
+} // namespace lldb_private
+#endif
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
index 7441fd9..ae907ac 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
@@ -10,8 +10,11 @@
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
+#include "llvm/ADT/StringSwitch.h"
+
 // Project includes
 #include "RenderScriptRuntime.h"
+#include "RenderScriptScriptGroup.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/ConstString.h"
@@ -29,11 +32,13 @@
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
@@ -41,652 +46,661 @@ using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_renderscript;
 
-namespace
-{
+#define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")"
+
+namespace {
 
 // The empirical_type adds a basic level of validation to arbitrary data
-// allowing us to track if data has been discovered and stored or not.
-// An empirical_type will be marked as valid only if it has been explicitly assigned to.
-template <typename type_t> class empirical_type
-{
+// allowing us to track if data has been discovered and stored or not. An
+// empirical_type will be marked as valid only if it has been explicitly
+// assigned to.
+template <typename type_t> class empirical_type {
 public:
-    // Ctor. Contents is invalid when constructed.
-    empirical_type() : valid(false) {}
-
-    // Return true and copy contents to out if valid, else return false.
-    bool
-    get(type_t &out) const
-    {
-        if (valid)
-            out = data;
-        return valid;
-    }
-
-    // Return a pointer to the contents or nullptr if it was not valid.
-    const type_t *
-    get() const
-    {
-        return valid ? &data : nullptr;
-    }
-
-    // Assign data explicitly.
-    void
-    set(const type_t in)
-    {
-        data = in;
-        valid = true;
-    }
-
-    // Mark contents as invalid.
-    void
-    invalidate()
-    {
-        valid = false;
-    }
-
-    // Returns true if this type contains valid data.
-    bool
-    isValid() const
-    {
-        return valid;
-    }
-
-    // Assignment operator.
-    empirical_type<type_t> &
-    operator=(const type_t in)
-    {
-        set(in);
-        return *this;
-    }
-
-    // Dereference operator returns contents.
-    // Warning: Will assert if not valid so use only when you know data is valid.
-    const type_t &operator*() const
-    {
-        assert(valid);
-        return data;
-    }
+  // Ctor. Contents is invalid when constructed.
+  empirical_type() : valid(false) {}
+
+  // Return true and copy contents to out if valid, else return false.
+  bool get(type_t &out) const {
+    if (valid)
+      out = data;
+    return valid;
+  }
+
+  // Return a pointer to the contents or nullptr if it was not valid.
+  const type_t *get() const { return valid ? &data : nullptr; }
+
+  // Assign data explicitly.
+  void set(const type_t in) {
+    data = in;
+    valid = true;
+  }
+
+  // Mark contents as invalid.
+  void invalidate() { valid = false; }
+
+  // Returns true if this type contains valid data.
+  bool isValid() const { return valid; }
+
+  // Assignment operator.
+  empirical_type<type_t> &operator=(const type_t in) {
+    set(in);
+    return *this;
+  }
+
+  // Dereference operator returns contents.
+  // Warning: Will assert if not valid so use only when you know data is valid.
+  const type_t &operator*() const {
+    assert(valid);
+    return data;
+  }
 
 protected:
-    bool valid;
-    type_t data;
+  bool valid;
+  type_t data;
 };
 
-// ArgItem is used by the GetArgs() function when reading function arguments from the target.
-struct ArgItem
-{
-    enum
-    {
-        ePointer,
-        eInt32,
-        eInt64,
-        eLong,
-        eBool
-    } type;
+// ArgItem is used by the GetArgs() function when reading function arguments
+// from the target.
+struct ArgItem {
+  enum { ePointer, eInt32, eInt64, eLong, eBool } type;
 
-    uint64_t value;
+  uint64_t value;
 
-    explicit operator uint64_t() const { return value; }
+  explicit operator uint64_t() const { return value; }
 };
 
-// Context structure to be passed into GetArgsXXX(), argument reading functions below.
-struct GetArgsCtx
-{
-    RegisterContext *reg_ctx;
-    Process *process;
+// Context structure to be passed into GetArgsXXX(), argument reading functions
+// below.
+struct GetArgsCtx {
+  RegisterContext *reg_ctx;
+  Process *process;
 };
 
-bool
-GetArgsX86(const GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
-{
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+bool GetArgsX86(const GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
-    Error error;
+  Error err;
 
-    // get the current stack pointer
-    uint64_t sp = ctx.reg_ctx->GetSP();
+  // get the current stack pointer
+  uint64_t sp = ctx.reg_ctx->GetSP();
 
-    for (size_t i = 0; i < num_args; ++i)
-    {
-        ArgItem &arg = arg_list[i];
-        // advance up the stack by one argument
-        sp += sizeof(uint32_t);
-        // get the argument type size
-        size_t arg_size = sizeof(uint32_t);
-        // read the argument from memory
-        arg.value = 0;
-        Error error;
-        size_t read = ctx.process->ReadMemory(sp, &arg.value, sizeof(uint32_t), error);
-        if (read != arg_size || !error.Success())
-        {
-            if (log)
-                log->Printf("%s - error reading argument: %" PRIu64 " '%s'", __FUNCTION__, uint64_t(i),
-                            error.AsCString());
-            return false;
-        }
-    }
-    return true;
+  for (size_t i = 0; i < num_args; ++i) {
+    ArgItem &arg = arg_list[i];
+    // advance up the stack by one argument
+    sp += sizeof(uint32_t);
+    // get the argument type size
+    size_t arg_size = sizeof(uint32_t);
+    // read the argument from memory
+    arg.value = 0;
+    Error err;
+    size_t read =
+        ctx.process->ReadMemory(sp, &arg.value, sizeof(uint32_t), err);
+    if (read != arg_size || !err.Success()) {
+      if (log)
+        log->Printf("%s - error reading argument: %" PRIu64 " '%s'",
+                    __FUNCTION__, uint64_t(i), err.AsCString());
+      return false;
+    }
+  }
+  return true;
 }
 
-bool
-GetArgsX86_64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
-{
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
-
-    // number of arguments passed in registers
-    static const uint32_t c_args_in_reg = 6;
-    // register passing order
-    static const std::array<const char *, c_args_in_reg> c_reg_names{{"rdi", "rsi", "rdx", "rcx", "r8", "r9"}};
-    // argument type to size mapping
-    static const std::array<size_t, 5> arg_size{{
-        8, // ePointer,
-        4, // eInt32,
-        8, // eInt64,
-        8, // eLong,
-        4, // eBool,
-    }};
-
-    Error error;
-
-    // get the current stack pointer
-    uint64_t sp = ctx.reg_ctx->GetSP();
-    // step over the return address
-    sp += sizeof(uint64_t);
-
-    // check the stack alignment was correct (16 byte aligned)
-    if ((sp & 0xf) != 0x0)
-    {
-        if (log)
-            log->Printf("%s - stack misaligned", __FUNCTION__);
-        return false;
-    }
-
-    // find the start of arguments on the stack
-    uint64_t sp_offset = 0;
-    for (uint32_t i = c_args_in_reg; i < num_args; ++i)
-    {
-        sp_offset += arg_size[arg_list[i].type];
-    }
-    // round up to multiple of 16
-    sp_offset = (sp_offset + 0xf) & 0xf;
-    sp += sp_offset;
-
-    for (size_t i = 0; i < num_args; ++i)
-    {
-        bool success = false;
-        ArgItem &arg = arg_list[i];
-        // arguments passed in registers
-        if (i < c_args_in_reg)
-        {
-            const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoByName(c_reg_names[i]);
-            RegisterValue rVal;
-            if (ctx.reg_ctx->ReadRegister(rArg, rVal))
-                arg.value = rVal.GetAsUInt64(0, &success);
-        }
-        // arguments passed on the stack
-        else
-        {
-            // get the argument type size
-            const size_t size = arg_size[arg_list[i].type];
-            // read the argument from memory
-            arg.value = 0;
-            // note: due to little endian layout reading 4 or 8 bytes will give the correct value.
-            size_t read = ctx.process->ReadMemory(sp, &arg.value, size, error);
-            success = (error.Success() && read==size);
-            // advance past this argument
-            sp -= size;
-        }
-        // fail if we couldn't read this argument
-        if (!success)
-        {
-            if (log)
-                log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
-                            __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
-            return false;
-        }
-    }
-    return true;
+bool GetArgsX86_64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+
+  // number of arguments passed in registers
+  static const uint32_t args_in_reg = 6;
+  // register passing order
+  static const std::array<const char *, args_in_reg> reg_names{
+      {"rdi", "rsi", "rdx", "rcx", "r8", "r9"}};
+  // argument type to size mapping
+  static const std::array<size_t, 5> arg_size{{
+      8, // ePointer,
+      4, // eInt32,
+      8, // eInt64,
+      8, // eLong,
+      4, // eBool,
+  }};
+
+  Error err;
+
+  // get the current stack pointer
+  uint64_t sp = ctx.reg_ctx->GetSP();
+  // step over the return address
+  sp += sizeof(uint64_t);
+
+  // check the stack alignment was correct (16 byte aligned)
+  if ((sp & 0xf) != 0x0) {
+    if (log)
+      log->Printf("%s - stack misaligned", __FUNCTION__);
+    return false;
+  }
+
+  // find the start of arguments on the stack
+  uint64_t sp_offset = 0;
+  for (uint32_t i = args_in_reg; i < num_args; ++i) {
+    sp_offset += arg_size[arg_list[i].type];
+  }
+  // round up to multiple of 16
+  sp_offset = (sp_offset + 0xf) & 0xf;
+  sp += sp_offset;
+
+  for (size_t i = 0; i < num_args; ++i) {
+    bool success = false;
+    ArgItem &arg = arg_list[i];
+    // arguments passed in registers
+    if (i < args_in_reg) {
+      const RegisterInfo *reg =
+          ctx.reg_ctx->GetRegisterInfoByName(reg_names[i]);
+      RegisterValue reg_val;
+      if (ctx.reg_ctx->ReadRegister(reg, reg_val))
+        arg.value = reg_val.GetAsUInt64(0, &success);
+    }
+    // arguments passed on the stack
+    else {
+      // get the argument type size
+      const size_t size = arg_size[arg_list[i].type];
+      // read the argument from memory
+      arg.value = 0;
+      // note: due to little endian layout reading 4 or 8 bytes will give the
+      // correct value.
+      size_t read = ctx.process->ReadMemory(sp, &arg.value, size, err);
+      success = (err.Success() && read == size);
+      // advance past this argument
+      sp -= size;
+    }
+    // fail if we couldn't read this argument
+    if (!success) {
+      if (log)
+        log->Printf("%s - error reading argument: %" PRIu64 ", reason: %s",
+                    __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
+      return false;
+    }
+  }
+  return true;
 }
 
-bool
-GetArgsArm(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
-{
-    // number of arguments passed in registers
-    static const uint32_t c_args_in_reg = 4;
+bool GetArgsArm(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
+  // number of arguments passed in registers
+  static const uint32_t args_in_reg = 4;
 
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
-    Error error;
+  Error err;
 
-    // get the current stack pointer
-    uint64_t sp = ctx.reg_ctx->GetSP();
+  // get the current stack pointer
+  uint64_t sp = ctx.reg_ctx->GetSP();
 
-    for (size_t i = 0; i < num_args; ++i)
-    {
-        bool success = false;
-        ArgItem &arg = arg_list[i];
-        // arguments passed in registers
-        if (i < c_args_in_reg)
-        {
-            const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
-            RegisterValue rVal;
-            if (ctx.reg_ctx->ReadRegister(rArg, rVal))
-                arg.value = rVal.GetAsUInt32(0, &success);
-        }
-        // arguments passed on the stack
-        else
-        {
-            // get the argument type size
-            const size_t arg_size = sizeof(uint32_t);
-            // clear all 64bits
-            arg.value = 0;
-            // read this argument from memory
-            size_t bytes_read = ctx.process->ReadMemory(sp, &arg.value, arg_size, error);
-            success = (error.Success() && bytes_read == arg_size);
-            // advance the stack pointer
-            sp += sizeof(uint32_t);
-        }
-        // fail if we couldn't read this argument
-        if (!success)
-        {
-            if (log)
-                log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
-                            __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
-            return false;
-        }
-    }
-    return true;
+  for (size_t i = 0; i < num_args; ++i) {
+    bool success = false;
+    ArgItem &arg = arg_list[i];
+    // arguments passed in registers
+    if (i < args_in_reg) {
+      const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
+      RegisterValue reg_val;
+      if (ctx.reg_ctx->ReadRegister(reg, reg_val))
+        arg.value = reg_val.GetAsUInt32(0, &success);
+    }
+    // arguments passed on the stack
+    else {
+      // get the argument type size
+      const size_t arg_size = sizeof(uint32_t);
+      // clear all 64bits
+      arg.value = 0;
+      // read this argument from memory
+      size_t bytes_read =
+          ctx.process->ReadMemory(sp, &arg.value, arg_size, err);
+      success = (err.Success() && bytes_read == arg_size);
+      // advance the stack pointer
+      sp += sizeof(uint32_t);
+    }
+    // fail if we couldn't read this argument
+    if (!success) {
+      if (log)
+        log->Printf("%s - error reading argument: %" PRIu64 ", reason: %s",
+                    __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
+      return false;
+    }
+  }
+  return true;
 }
 
-bool
-GetArgsAarch64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
-{
-    // number of arguments passed in registers
-    static const uint32_t c_args_in_reg = 8;
+bool GetArgsAarch64(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
+  // number of arguments passed in registers
+  static const uint32_t args_in_reg = 8;
 
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
-    for (size_t i = 0; i < num_args; ++i)
-    {
-        bool success = false;
-        ArgItem &arg = arg_list[i];
-        // arguments passed in registers
-        if (i < c_args_in_reg)
-        {
-            const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
-            RegisterValue rVal;
-            if (ctx.reg_ctx->ReadRegister(rArg, rVal))
-                arg.value = rVal.GetAsUInt64(0, &success);
-        }
-        // arguments passed on the stack
-        else
-        {
-            if (log)
-                log->Printf("%s - reading arguments spilled to stack not implemented", __FUNCTION__);
-        }
-        // fail if we couldn't read this argument
-        if (!success)
-        {
-            if (log)
-                log->Printf("%s - error reading argument: %" PRIu64, __FUNCTION__,
-                            uint64_t(i));
-            return false;
-        }
-    }
-    return true;
+  for (size_t i = 0; i < num_args; ++i) {
+    bool success = false;
+    ArgItem &arg = arg_list[i];
+    // arguments passed in registers
+    if (i < args_in_reg) {
+      const RegisterInfo *reg = ctx.reg_ctx->GetRegisterInfoAtIndex(i);
+      RegisterValue reg_val;
+      if (ctx.reg_ctx->ReadRegister(reg, reg_val))
+        arg.value = reg_val.GetAsUInt64(0, &success);
+    }
+    // arguments passed on the stack
+    else {
+      if (log)
+        log->Printf("%s - reading arguments spilled to stack not implemented",
+                    __FUNCTION__);
+    }
+    // fail if we couldn't read this argument
+    if (!success) {
+      if (log)
+        log->Printf("%s - error reading argument: %" PRIu64, __FUNCTION__,
+                    uint64_t(i));
+      return false;
+    }
+  }
+  return true;
 }
 
-bool
-GetArgsMipsel(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
-{
-    // number of arguments passed in registers
-    static const uint32_t c_args_in_reg = 4;
-    // register file offset to first argument
-    static const uint32_t c_reg_offset = 4;
+bool GetArgsMipsel(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
+  // number of arguments passed in registers
+  static const uint32_t args_in_reg = 4;
+  // register file offset to first argument
+  static const uint32_t reg_offset = 4;
 
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
-    Error error;
+  Error err;
 
-    // find offset to arguments on the stack (+16 to skip over a0-a3 shadow space)
-    uint64_t sp = ctx.reg_ctx->GetSP() + 16;
+  // find offset to arguments on the stack (+16 to skip over a0-a3 shadow space)
+  uint64_t sp = ctx.reg_ctx->GetSP() + 16;
 
-    for (size_t i = 0; i < num_args; ++i)
-    {
-        bool success = false;
-        ArgItem &arg = arg_list[i];
-        // arguments passed in registers
-        if (i < c_args_in_reg)
-        {
-            const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i + c_reg_offset);
-            RegisterValue rVal;
-            if (ctx.reg_ctx->ReadRegister(rArg, rVal))
-                arg.value = rVal.GetAsUInt64(0, &success);
-        }
-        // arguments passed on the stack
-        else
-        {
-            const size_t arg_size = sizeof(uint32_t);
-            arg.value = 0;
-            size_t bytes_read = ctx.process->ReadMemory(sp, &arg.value, arg_size, error);
-            success = (error.Success() && bytes_read == arg_size);
-            // advance the stack pointer
-            sp += arg_size;
-        }
-        // fail if we couldn't read this argument
-        if (!success)
-        {
-            if (log)
-                log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
-                            __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
-            return false;
-        }
-    }
-    return true;
+  for (size_t i = 0; i < num_args; ++i) {
+    bool success = false;
+    ArgItem &arg = arg_list[i];
+    // arguments passed in registers
+    if (i < args_in_reg) {
+      const RegisterInfo *reg =
+          ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset);
+      RegisterValue reg_val;
+      if (ctx.reg_ctx->ReadRegister(reg, reg_val))
+        arg.value = reg_val.GetAsUInt64(0, &success);
+    }
+    // arguments passed on the stack
+    else {
+      const size_t arg_size = sizeof(uint32_t);
+      arg.value = 0;
+      size_t bytes_read =
+          ctx.process->ReadMemory(sp, &arg.value, arg_size, err);
+      success = (err.Success() && bytes_read == arg_size);
+      // advance the stack pointer
+      sp += arg_size;
+    }
+    // fail if we couldn't read this argument
+    if (!success) {
+      if (log)
+        log->Printf("%s - error reading argument: %" PRIu64 ", reason: %s",
+                    __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
+      return false;
+    }
+  }
+  return true;
 }
 
-bool
-GetArgsMips64el(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args)
-{
-    // number of arguments passed in registers
-    static const uint32_t c_args_in_reg = 8;
-    // register file offset to first argument
-    static const uint32_t c_reg_offset = 4;
+bool GetArgsMips64el(GetArgsCtx &ctx, ArgItem *arg_list, size_t num_args) {
+  // number of arguments passed in registers
+  static const uint32_t args_in_reg = 8;
+  // register file offset to first argument
+  static const uint32_t reg_offset = 4;
 
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
-    Error error;
+  Error err;
 
-    // get the current stack pointer
-    uint64_t sp = ctx.reg_ctx->GetSP();
+  // get the current stack pointer
+  uint64_t sp = ctx.reg_ctx->GetSP();
 
-    for (size_t i = 0; i < num_args; ++i)
-    {
-        bool success = false;
-        ArgItem &arg = arg_list[i];
-        // arguments passed in registers
-        if (i < c_args_in_reg)
-        {
-            const RegisterInfo *rArg = ctx.reg_ctx->GetRegisterInfoAtIndex(i + c_reg_offset);
-            RegisterValue rVal;
-            if (ctx.reg_ctx->ReadRegister(rArg, rVal))
-                arg.value = rVal.GetAsUInt64(0, &success);
-        }
-        // arguments passed on the stack
-        else
-        {
-            // get the argument type size
-            const size_t arg_size = sizeof(uint64_t);
-            // clear all 64bits
-            arg.value = 0;
-            // read this argument from memory
-            size_t bytes_read = ctx.process->ReadMemory(sp, &arg.value, arg_size, error);
-            success = (error.Success() && bytes_read == arg_size);
-            // advance the stack pointer
-            sp += arg_size;
-        }
-        // fail if we couldn't read this argument
-        if (!success)
-        {
-            if (log)
-                log->Printf("%s - error reading argument: %" PRIu64", reason: %s",
-                            __FUNCTION__, uint64_t(i), error.AsCString("n/a"));
-            return false;
-        }
-    }
-    return true;
+  for (size_t i = 0; i < num_args; ++i) {
+    bool success = false;
+    ArgItem &arg = arg_list[i];
+    // arguments passed in registers
+    if (i < args_in_reg) {
+      const RegisterInfo *reg =
+          ctx.reg_ctx->GetRegisterInfoAtIndex(i + reg_offset);
+      RegisterValue reg_val;
+      if (ctx.reg_ctx->ReadRegister(reg, reg_val))
+        arg.value = reg_val.GetAsUInt64(0, &success);
+    }
+    // arguments passed on the stack
+    else {
+      // get the argument type size
+      const size_t arg_size = sizeof(uint64_t);
+      // clear all 64bits
+      arg.value = 0;
+      // read this argument from memory
+      size_t bytes_read =
+          ctx.process->ReadMemory(sp, &arg.value, arg_size, err);
+      success = (err.Success() && bytes_read == arg_size);
+      // advance the stack pointer
+      sp += arg_size;
+    }
+    // fail if we couldn't read this argument
+    if (!success) {
+      if (log)
+        log->Printf("%s - error reading argument: %" PRIu64 ", reason: %s",
+                    __FUNCTION__, uint64_t(i), err.AsCString("n/a"));
+      return false;
+    }
+  }
+  return true;
 }
 
-bool
-GetArgs(ExecutionContext &context, ArgItem *arg_list, size_t num_args)
-{
-    Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+bool GetArgs(ExecutionContext &exe_ctx, ArgItem *arg_list, size_t num_args) {
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
-    // verify that we have a target
-    if (!context.GetTargetPtr())
-    {
-        if (log)
-            log->Printf("%s - invalid target", __FUNCTION__);
-        return false;
-    }
+  // verify that we have a target
+  if (!exe_ctx.GetTargetPtr()) {
+    if (log)
+      log->Printf("%s - invalid target", __FUNCTION__);
+    return false;
+  }
 
-    GetArgsCtx ctx = {context.GetRegisterContext(), context.GetProcessPtr()};
-    assert(ctx.reg_ctx && ctx.process);
+  GetArgsCtx ctx = {exe_ctx.GetRegisterContext(), exe_ctx.GetProcessPtr()};
+  assert(ctx.reg_ctx && ctx.process);
 
-    // dispatch based on architecture
-    switch (context.GetTargetPtr()->GetArchitecture().GetMachine())
-    {
-        case llvm::Triple::ArchType::x86:
-            return GetArgsX86(ctx, arg_list, num_args);
+  // dispatch based on architecture
+  switch (exe_ctx.GetTargetPtr()->GetArchitecture().GetMachine()) {
+  case llvm::Triple::ArchType::x86:
+    return GetArgsX86(ctx, arg_list, num_args);
 
-        case llvm::Triple::ArchType::x86_64:
-            return GetArgsX86_64(ctx, arg_list, num_args);
+  case llvm::Triple::ArchType::x86_64:
+    return GetArgsX86_64(ctx, arg_list, num_args);
 
-        case llvm::Triple::ArchType::arm:
-            return GetArgsArm(ctx, arg_list, num_args);
+  case llvm::Triple::ArchType::arm:
+    return GetArgsArm(ctx, arg_list, num_args);
 
-        case llvm::Triple::ArchType::aarch64:
-            return GetArgsAarch64(ctx, arg_list, num_args);
+  case llvm::Triple::ArchType::aarch64:
+    return GetArgsAarch64(ctx, arg_list, num_args);
 
-        case llvm::Triple::ArchType::mipsel:
-            return GetArgsMipsel(ctx, arg_list, num_args);
+  case llvm::Triple::ArchType::mipsel:
+    return GetArgsMipsel(ctx, arg_list, num_args);
 
-        case llvm::Triple::ArchType::mips64el:
-            return GetArgsMips64el(ctx, arg_list, num_args);
+  case llvm::Triple::ArchType::mips64el:
+    return GetArgsMips64el(ctx, arg_list, num_args);
 
-        default:
-            // unsupported architecture
-            if (log)
-            {
-                log->Printf("%s - architecture not supported: '%s'", __FUNCTION__,
-                            context.GetTargetRef().GetArchitecture().GetArchitectureName());
-            }
-            return false;
+  default:
+    // unsupported architecture
+    if (log) {
+      log->Printf(
+          "%s - architecture not supported: '%s'", __FUNCTION__,
+          exe_ctx.GetTargetRef().GetArchitecture().GetArchitectureName());
     }
+    return false;
+  }
 }
-} // anonymous namespace
 
-// The ScriptDetails class collects data associated with a single script instance.
-struct RenderScriptRuntime::ScriptDetails
-{
-    ~ScriptDetails() = default;
+bool IsRenderScriptScriptModule(ModuleSP module) {
+  if (!module)
+    return false;
+  return module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"),
+                                                eSymbolTypeData) != nullptr;
+}
 
-    enum ScriptType
-    {
-        eScript,
-        eScriptC
-    };
-
-    // The derived type of the script.
-    empirical_type<ScriptType> type;
-    // The name of the original source file.
-    empirical_type<std::string> resName;
-    // Path to script .so file on the device.
-    empirical_type<std::string> scriptDyLib;
-    // Directory where kernel objects are cached on device.
-    empirical_type<std::string> cacheDir;
-    // Pointer to the context which owns this script.
-    empirical_type<lldb::addr_t> context;
-    // Pointer to the script object itself.
-    empirical_type<lldb::addr_t> script;
-};
+bool ParseCoordinate(llvm::StringRef coord_s, RSCoordinate &coord) {
+  // takes an argument of the form 'num[,num][,num]'.
+  // Where 'coord_s' is a comma separated 1,2 or 3-dimensional coordinate
+  // with the whitespace trimmed.
+  // Missing coordinates are defaulted to zero.
+  // If parsing of any elements fails the contents of &coord are undefined
+  // and `false` is returned, `true` otherwise
+
+  RegularExpression regex;
+  RegularExpression::Match regex_match(3);
+
+  bool matched = false;
+  if (regex.Compile(llvm::StringRef("^([0-9]+),([0-9]+),([0-9]+)$")) &&
+      regex.Execute(coord_s, &regex_match))
+    matched = true;
+  else if (regex.Compile(llvm::StringRef("^([0-9]+),([0-9]+)$")) &&
+           regex.Execute(coord_s, &regex_match))
+    matched = true;
+  else if (regex.Compile(llvm::StringRef("^([0-9]+)$")) &&
+           regex.Execute(coord_s, &regex_match))
+    matched = true;
+
+  if (!matched)
+    return false;
 
-// This Element class represents the Element object in RS,
-// defining the type associated with an Allocation.
-struct RenderScriptRuntime::Element
-{
-    // Taken from rsDefines.h
-    enum DataKind
-    {
-        RS_KIND_USER,
-        RS_KIND_PIXEL_L = 7,
-        RS_KIND_PIXEL_A,
-        RS_KIND_PIXEL_LA,
-        RS_KIND_PIXEL_RGB,
-        RS_KIND_PIXEL_RGBA,
-        RS_KIND_PIXEL_DEPTH,
-        RS_KIND_PIXEL_YUV,
-        RS_KIND_INVALID = 100
-    };
-
-    // Taken from rsDefines.h
-    enum DataType
-    {
-        RS_TYPE_NONE = 0,
-        RS_TYPE_FLOAT_16,
-        RS_TYPE_FLOAT_32,
-        RS_TYPE_FLOAT_64,
-        RS_TYPE_SIGNED_8,
-        RS_TYPE_SIGNED_16,
-        RS_TYPE_SIGNED_32,
-        RS_TYPE_SIGNED_64,
-        RS_TYPE_UNSIGNED_8,
-        RS_TYPE_UNSIGNED_16,
-        RS_TYPE_UNSIGNED_32,
-        RS_TYPE_UNSIGNED_64,
-        RS_TYPE_BOOLEAN,
-
-        RS_TYPE_UNSIGNED_5_6_5,
-        RS_TYPE_UNSIGNED_5_5_5_1,
-        RS_TYPE_UNSIGNED_4_4_4_4,
-
-        RS_TYPE_MATRIX_4X4,
-        RS_TYPE_MATRIX_3X3,
-        RS_TYPE_MATRIX_2X2,
-
-        RS_TYPE_ELEMENT = 1000,
-        RS_TYPE_TYPE,
-        RS_TYPE_ALLOCATION,
-        RS_TYPE_SAMPLER,
-        RS_TYPE_SCRIPT,
-        RS_TYPE_MESH,
-        RS_TYPE_PROGRAM_FRAGMENT,
-        RS_TYPE_PROGRAM_VERTEX,
-        RS_TYPE_PROGRAM_RASTER,
-        RS_TYPE_PROGRAM_STORE,
-        RS_TYPE_FONT,
-
-        RS_TYPE_INVALID = 10000
-    };
-
-    std::vector<Element> children;            // Child Element fields for structs
-    empirical_type<lldb::addr_t> element_ptr; // Pointer to the RS Element of the Type
-    empirical_type<DataType> type;            // Type of each data pointer stored by the allocation
-    empirical_type<DataKind> type_kind;       // Defines pixel type if Allocation is created from an image
-    empirical_type<uint32_t> type_vec_size;   // Vector size of each data point, e.g '4' for uchar4
-    empirical_type<uint32_t> field_count;     // Number of Subelements
-    empirical_type<uint32_t> datum_size;      // Size of a single Element with padding
-    empirical_type<uint32_t> padding;         // Number of padding bytes
-    empirical_type<uint32_t> array_size;      // Number of items in array, only needed for strucrs
-    ConstString type_name;                    // Name of type, only needed for structs
-
-    static const ConstString &
-    GetFallbackStructName(); // Print this as the type name of a struct Element
-                             // If we can't resolve the actual struct name
-
-    bool
-    shouldRefresh() const
-    {
-        const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
-        const bool valid_type = type.isValid() && type_vec_size.isValid() && type_kind.isValid();
-        return !valid_ptr || !valid_type || !datum_size.isValid();
+  auto get_index = [&](int idx, uint32_t &i) -> bool {
+    std::string group;
+    errno = 0;
+    if (regex_match.GetMatchAtIndex(coord_s.str().c_str(), idx + 1, group))
+      return !llvm::StringRef(group).getAsInteger<uint32_t>(10, i);
+    return true;
+  };
+
+  return get_index(0, coord.x) && get_index(1, coord.y) &&
+         get_index(2, coord.z);
+}
+
+bool SkipPrologue(lldb::ModuleSP &module, Address &addr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  SymbolContext sc;
+  uint32_t resolved_flags =
+      module->ResolveSymbolContextForAddress(addr, eSymbolContextFunction, sc);
+  if (resolved_flags & eSymbolContextFunction) {
+    if (sc.function) {
+      const uint32_t offset = sc.function->GetPrologueByteSize();
+      ConstString name = sc.GetFunctionName();
+      if (offset)
+        addr.Slide(offset);
+      if (log)
+        log->Printf("%s: Prologue offset for %s is %" PRIu32, __FUNCTION__,
+                    name.AsCString(), offset);
     }
+    return true;
+  } else
+    return false;
+}
+} // anonymous namespace
+
+// The ScriptDetails class collects data associated with a single script
+// instance.
+struct RenderScriptRuntime::ScriptDetails {
+  ~ScriptDetails() = default;
+
+  enum ScriptType { eScript, eScriptC };
+
+  // The derived type of the script.
+  empirical_type<ScriptType> type;
+  // The name of the original source file.
+  empirical_type<std::string> res_name;
+  // Path to script .so file on the device.
+  empirical_type<std::string> shared_lib;
+  // Directory where kernel objects are cached on device.
+  empirical_type<std::string> cache_dir;
+  // Pointer to the context which owns this script.
+  empirical_type<lldb::addr_t> context;
+  // Pointer to the script object itself.
+  empirical_type<lldb::addr_t> script;
+};
+
+// This Element class represents the Element object in RS, defining the type
+// associated with an Allocation.
+struct RenderScriptRuntime::Element {
+  // Taken from rsDefines.h
+  enum DataKind {
+    RS_KIND_USER,
+    RS_KIND_PIXEL_L = 7,
+    RS_KIND_PIXEL_A,
+    RS_KIND_PIXEL_LA,
+    RS_KIND_PIXEL_RGB,
+    RS_KIND_PIXEL_RGBA,
+    RS_KIND_PIXEL_DEPTH,
+    RS_KIND_PIXEL_YUV,
+    RS_KIND_INVALID = 100
+  };
+
+  // Taken from rsDefines.h
+  enum DataType {
+    RS_TYPE_NONE = 0,
+    RS_TYPE_FLOAT_16,
+    RS_TYPE_FLOAT_32,
+    RS_TYPE_FLOAT_64,
+    RS_TYPE_SIGNED_8,
+    RS_TYPE_SIGNED_16,
+    RS_TYPE_SIGNED_32,
+    RS_TYPE_SIGNED_64,
+    RS_TYPE_UNSIGNED_8,
+    RS_TYPE_UNSIGNED_16,
+    RS_TYPE_UNSIGNED_32,
+    RS_TYPE_UNSIGNED_64,
+    RS_TYPE_BOOLEAN,
+
+    RS_TYPE_UNSIGNED_5_6_5,
+    RS_TYPE_UNSIGNED_5_5_5_1,
+    RS_TYPE_UNSIGNED_4_4_4_4,
+
+    RS_TYPE_MATRIX_4X4,
+    RS_TYPE_MATRIX_3X3,
+    RS_TYPE_MATRIX_2X2,
+
+    RS_TYPE_ELEMENT = 1000,
+    RS_TYPE_TYPE,
+    RS_TYPE_ALLOCATION,
+    RS_TYPE_SAMPLER,
+    RS_TYPE_SCRIPT,
+    RS_TYPE_MESH,
+    RS_TYPE_PROGRAM_FRAGMENT,
+    RS_TYPE_PROGRAM_VERTEX,
+    RS_TYPE_PROGRAM_RASTER,
+    RS_TYPE_PROGRAM_STORE,
+    RS_TYPE_FONT,
+
+    RS_TYPE_INVALID = 10000
+  };
+
+  std::vector<Element> children; // Child Element fields for structs
+  empirical_type<lldb::addr_t>
+      element_ptr; // Pointer to the RS Element of the Type
+  empirical_type<DataType>
+      type; // Type of each data pointer stored by the allocation
+  empirical_type<DataKind>
+      type_kind; // Defines pixel type if Allocation is created from an image
+  empirical_type<uint32_t>
+      type_vec_size; // Vector size of each data point, e.g '4' for uchar4
+  empirical_type<uint32_t> field_count; // Number of Subelements
+  empirical_type<uint32_t> datum_size;  // Size of a single Element with padding
+  empirical_type<uint32_t> padding;     // Number of padding bytes
+  empirical_type<uint32_t>
+      array_size;        // Number of items in array, only needed for strucrs
+  ConstString type_name; // Name of type, only needed for structs
+
+  static const ConstString &
+  GetFallbackStructName(); // Print this as the type name of a struct Element
+                           // If we can't resolve the actual struct name
+
+  bool ShouldRefresh() const {
+    const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
+    const bool valid_type =
+        type.isValid() && type_vec_size.isValid() && type_kind.isValid();
+    return !valid_ptr || !valid_type || !datum_size.isValid();
+  }
 };
 
 // This AllocationDetails class collects data associated with a single
 // allocation instance.
-struct RenderScriptRuntime::AllocationDetails
-{
-    struct Dimension
-    {
-        uint32_t dim_1;
-        uint32_t dim_2;
-        uint32_t dim_3;
-        uint32_t cubeMap;
-
-        Dimension()
-        {
-            dim_1 = 0;
-            dim_2 = 0;
-            dim_3 = 0;
-            cubeMap = 0;
-        }
-    };
-
-    // The FileHeader struct specifies the header we use for writing allocations to a binary file.
-    // Our format begins with the ASCII characters "RSAD", identifying the file as an allocation dump.
-    // Member variables dims and hdr_size are then written consecutively, immediately followed by an instance of
-    // the ElementHeader struct. Because Elements can contain subelements, there may be more than one instance
-    // of the ElementHeader struct. With this first instance being the root element, and the other instances being
-    // the root's descendants. To identify which instances are an ElementHeader's children, each struct
-    // is immediately followed by a sequence of consecutive offsets to the start of its child structs.
-    // These offsets are 4 bytes in size, and the 0 offset signifies no more children.
-    struct FileHeader
-    {
-        uint8_t ident[4];  // ASCII 'RSAD' identifying the file
-        uint32_t dims[3];  // Dimensions
-        uint16_t hdr_size; // Header size in bytes, including all element headers
-    };
-
-    struct ElementHeader
-    {
-        uint16_t type;         // DataType enum
-        uint32_t kind;         // DataKind enum
-        uint32_t element_size; // Size of a single element, including padding
-        uint16_t vector_size;  // Vector width
-        uint32_t array_size;   // Number of elements in array
-    };
-
-    // Monotonically increasing from 1
-    static uint32_t ID;
-
-    // Maps Allocation DataType enum and vector size to printable strings
-    // using mapping from RenderScript numerical types summary documentation
-    static const char *RsDataTypeToString[][4];
-
-    // Maps Allocation DataKind enum to printable strings
-    static const char *RsDataKindToString[];
-
-    // Maps allocation types to format sizes for printing.
-    static const uint32_t RSTypeToFormat[][3];
-
-    // Give each allocation an ID as a way
-    // for commands to reference it.
-    const uint32_t id;
-
-    RenderScriptRuntime::Element element;  // Allocation Element type
-    empirical_type<Dimension> dimension;   // Dimensions of the Allocation
-    empirical_type<lldb::addr_t> address;  // Pointer to address of the RS Allocation
-    empirical_type<lldb::addr_t> data_ptr; // Pointer to the data held by the Allocation
-    empirical_type<lldb::addr_t> type_ptr; // Pointer to the RS Type of the Allocation
-    empirical_type<lldb::addr_t> context;  // Pointer to the RS Context of the Allocation
-    empirical_type<uint32_t> size;         // Size of the allocation
-    empirical_type<uint32_t> stride;       // Stride between rows of the allocation
-
-    // Give each allocation an id, so we can reference it in user commands.
-    AllocationDetails() : id(ID++) {}
-
-    bool
-    shouldRefresh() const
-    {
-        bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0;
-        valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0;
-        return !valid_ptrs || !dimension.isValid() || !size.isValid() || element.shouldRefresh();
-    }
+struct RenderScriptRuntime::AllocationDetails {
+  struct Dimension {
+    uint32_t dim_1;
+    uint32_t dim_2;
+    uint32_t dim_3;
+    uint32_t cube_map;
+
+    Dimension() {
+      dim_1 = 0;
+      dim_2 = 0;
+      dim_3 = 0;
+      cube_map = 0;
+    }
+  };
+
+  // The FileHeader struct specifies the header we use for writing allocations
+  // to a binary file. Our format begins with the ASCII characters "RSAD",
+  // identifying the file as an allocation dump. Member variables dims and
+  // hdr_size are then written consecutively, immediately followed by an
+  // instance of the ElementHeader struct. Because Elements can contain
+  // subelements, there may be more than one instance of the ElementHeader
+  // struct. With this first instance being the root element, and the other
+  // instances being the root's descendants. To identify which instances are an
+  // ElementHeader's children, each struct is immediately followed by a sequence
+  // of consecutive offsets to the start of its child structs. These offsets are
+  // 4 bytes in size, and the 0 offset signifies no more children.
+  struct FileHeader {
+    uint8_t ident[4];  // ASCII 'RSAD' identifying the file
+    uint32_t dims[3];  // Dimensions
+    uint16_t hdr_size; // Header size in bytes, including all element headers
+  };
+
+  struct ElementHeader {
+    uint16_t type;         // DataType enum
+    uint32_t kind;         // DataKind enum
+    uint32_t element_size; // Size of a single element, including padding
+    uint16_t vector_size;  // Vector width
+    uint32_t array_size;   // Number of elements in array
+  };
+
+  // Monotonically increasing from 1
+  static uint32_t ID;
+
+  // Maps Allocation DataType enum and vector size to printable strings
+  // using mapping from RenderScript numerical types summary documentation
+  static const char *RsDataTypeToString[][4];
+
+  // Maps Allocation DataKind enum to printable strings
+  static const char *RsDataKindToString[];
+
+  // Maps allocation types to format sizes for printing.
+  static const uint32_t RSTypeToFormat[][3];
+
+  // Give each allocation an ID as a way
+  // for commands to reference it.
+  const uint32_t id;
+
+  // Allocation Element type
+  RenderScriptRuntime::Element element;
+  // Dimensions of the Allocation
+  empirical_type<Dimension> dimension;
+  // Pointer to address of the RS Allocation
+  empirical_type<lldb::addr_t> address;
+  // Pointer to the data held by the Allocation
+  empirical_type<lldb::addr_t> data_ptr;
+  // Pointer to the RS Type of the Allocation
+  empirical_type<lldb::addr_t> type_ptr;
+  // Pointer to the RS Context of the Allocation
+  empirical_type<lldb::addr_t> context;
+  // Size of the allocation
+  empirical_type<uint32_t> size;
+  // Stride between rows of the allocation
+  empirical_type<uint32_t> stride;
+
+  // Give each allocation an id, so we can reference it in user commands.
+  AllocationDetails() : id(ID++) {}
+
+  bool ShouldRefresh() const {
+    bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0;
+    valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0;
+    return !valid_ptrs || !dimension.isValid() || !size.isValid() ||
+           element.ShouldRefresh();
+  }
 };
 
-const ConstString &
-RenderScriptRuntime::Element::GetFallbackStructName()
-{
-    static const ConstString FallbackStructName("struct");
-    return FallbackStructName;
+const ConstString &RenderScriptRuntime::Element::GetFallbackStructName() {
+  static const ConstString FallbackStructName("struct");
+  return FallbackStructName;
 }
 
 uint32_t RenderScriptRuntime::AllocationDetails::ID = 1;
 
 const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = {
-    "User",
-    "Undefined",  "Undefined",   "Undefined", "Undefined", "Undefined",  "Undefined", // Enum jumps from 0 to 7
+    "User",       "Undefined",   "Undefined", "Undefined",
+    "Undefined",  "Undefined",   "Undefined", // Enum jumps from 0 to 7
     "L Pixel",    "A Pixel",     "LA Pixel",  "RGB Pixel",
     "RGBA Pixel", "Pixel Depth", "YUV Pixel"};
 
@@ -720,3627 +734,4319 @@ const char *RenderScriptRuntime::AllocationDetails::RsDataTypeToString[][4] = {
 
     // Deprecated
     {"RS Mesh", "RS Mesh", "RS Mesh", "RS Mesh"},
-    {"RS Program Fragment", "RS Program Fragment", "RS Program Fragment", "RS Program Fragment"},
-    {"RS Program Vertex", "RS Program Vertex", "RS Program Vertex", "RS Program Vertex"},
-    {"RS Program Raster", "RS Program Raster", "RS Program Raster", "RS Program Raster"},
-    {"RS Program Store", "RS Program Store", "RS Program Store", "RS Program Store"},
+    {"RS Program Fragment", "RS Program Fragment", "RS Program Fragment",
+     "RS Program Fragment"},
+    {"RS Program Vertex", "RS Program Vertex", "RS Program Vertex",
+     "RS Program Vertex"},
+    {"RS Program Raster", "RS Program Raster", "RS Program Raster",
+     "RS Program Raster"},
+    {"RS Program Store", "RS Program Store", "RS Program Store",
+     "RS Program Store"},
     {"RS Font", "RS Font", "RS Font", "RS Font"}};
 
 // Used as an index into the RSTypeToFormat array elements
-enum TypeToFormatIndex
-{
-    eFormatSingle = 0,
-    eFormatVector,
-    eElementSize
-};
+enum TypeToFormatIndex { eFormatSingle = 0, eFormatVector, eElementSize };
 
-// { format enum of single element, format enum of element vector, size of element}
+// { format enum of single element, format enum of element vector, size of
+// element}
 const uint32_t RenderScriptRuntime::AllocationDetails::RSTypeToFormat[][3] = {
-    {eFormatHex, eFormatHex, 1},                                          // RS_TYPE_NONE
-    {eFormatFloat, eFormatVectorOfFloat16, 2},                            // RS_TYPE_FLOAT_16
-    {eFormatFloat, eFormatVectorOfFloat32, sizeof(float)},                // RS_TYPE_FLOAT_32
-    {eFormatFloat, eFormatVectorOfFloat64, sizeof(double)},               // RS_TYPE_FLOAT_64
-    {eFormatDecimal, eFormatVectorOfSInt8, sizeof(int8_t)},               // RS_TYPE_SIGNED_8
-    {eFormatDecimal, eFormatVectorOfSInt16, sizeof(int16_t)},             // RS_TYPE_SIGNED_16
-    {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)},             // RS_TYPE_SIGNED_32
-    {eFormatDecimal, eFormatVectorOfSInt64, sizeof(int64_t)},             // RS_TYPE_SIGNED_64
-    {eFormatDecimal, eFormatVectorOfUInt8, sizeof(uint8_t)},              // RS_TYPE_UNSIGNED_8
-    {eFormatDecimal, eFormatVectorOfUInt16, sizeof(uint16_t)},            // RS_TYPE_UNSIGNED_16
-    {eFormatDecimal, eFormatVectorOfUInt32, sizeof(uint32_t)},            // RS_TYPE_UNSIGNED_32
-    {eFormatDecimal, eFormatVectorOfUInt64, sizeof(uint64_t)},            // RS_TYPE_UNSIGNED_64
-    {eFormatBoolean, eFormatBoolean, 1},                                  // RS_TYPE_BOOL
-    {eFormatHex, eFormatHex, sizeof(uint16_t)},                           // RS_TYPE_UNSIGNED_5_6_5
-    {eFormatHex, eFormatHex, sizeof(uint16_t)},                           // RS_TYPE_UNSIGNED_5_5_5_1
-    {eFormatHex, eFormatHex, sizeof(uint16_t)},                           // RS_TYPE_UNSIGNED_4_4_4_4
-    {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 16}, // RS_TYPE_MATRIX_4X4
-    {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 9},  // RS_TYPE_MATRIX_3X3
-    {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 4}   // RS_TYPE_MATRIX_2X2
-};
+    // RS_TYPE_NONE
+    {eFormatHex, eFormatHex, 1},
+    // RS_TYPE_FLOAT_16
+    {eFormatFloat, eFormatVectorOfFloat16, 2},
+    // RS_TYPE_FLOAT_32
+    {eFormatFloat, eFormatVectorOfFloat32, sizeof(float)},
+    // RS_TYPE_FLOAT_64
+    {eFormatFloat, eFormatVectorOfFloat64, sizeof(double)},
+    // RS_TYPE_SIGNED_8
+    {eFormatDecimal, eFormatVectorOfSInt8, sizeof(int8_t)},
+    // RS_TYPE_SIGNED_16
+    {eFormatDecimal, eFormatVectorOfSInt16, sizeof(int16_t)},
+    // RS_TYPE_SIGNED_32
+    {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)},
+    // RS_TYPE_SIGNED_64
+    {eFormatDecimal, eFormatVectorOfSInt64, sizeof(int64_t)},
+    // RS_TYPE_UNSIGNED_8
+    {eFormatDecimal, eFormatVectorOfUInt8, sizeof(uint8_t)},
+    // RS_TYPE_UNSIGNED_16
+    {eFormatDecimal, eFormatVectorOfUInt16, sizeof(uint16_t)},
+    // RS_TYPE_UNSIGNED_32
+    {eFormatDecimal, eFormatVectorOfUInt32, sizeof(uint32_t)},
+    // RS_TYPE_UNSIGNED_64
+    {eFormatDecimal, eFormatVectorOfUInt64, sizeof(uint64_t)},
+    // RS_TYPE_BOOL
+    {eFormatBoolean, eFormatBoolean, 1},
+    // RS_TYPE_UNSIGNED_5_6_5
+    {eFormatHex, eFormatHex, sizeof(uint16_t)},
+    // RS_TYPE_UNSIGNED_5_5_5_1
+    {eFormatHex, eFormatHex, sizeof(uint16_t)},
+    // RS_TYPE_UNSIGNED_4_4_4_4
+    {eFormatHex, eFormatHex, sizeof(uint16_t)},
+    // RS_TYPE_MATRIX_4X4
+    {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 16},
+    // RS_TYPE_MATRIX_3X3
+    {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 9},
+    // RS_TYPE_MATRIX_2X2
+    {eFormatVectorOfFloat32, eFormatVectorOfFloat32, sizeof(float) * 4}};
 
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 LanguageRuntime *
-RenderScriptRuntime::CreateInstance(Process *process, lldb::LanguageType language)
-{
+RenderScriptRuntime::CreateInstance(Process *process,
+                                    lldb::LanguageType language) {
 
-    if (language == eLanguageTypeExtRenderScript)
-        return new RenderScriptRuntime(process);
-    else
-        return nullptr;
+  if (language == eLanguageTypeExtRenderScript)
+    return new RenderScriptRuntime(process);
+  else
+    return nullptr;
 }
 
-// Callback with a module to search for matching symbols.
-// We first check that the module contains RS kernels.
-// Then look for a symbol which matches our kernel name.
-// The breakpoint address is finally set using the address of this symbol.
+// Callback with a module to search for matching symbols. We first check that
+// the module contains RS kernels. Then look for a symbol which matches our
+// kernel name. The breakpoint address is finally set using the address of this
+// symbol.
 Searcher::CallbackReturn
-RSBreakpointResolver::SearchCallback(SearchFilter &filter, SymbolContext &context, Address *, bool)
-{
-    ModuleSP module = context.module_sp;
+RSBreakpointResolver::SearchCallback(SearchFilter &filter,
+                                     SymbolContext &context, Address *, bool) {
+  ModuleSP module = context.module_sp;
 
-    if (!module)
-        return Searcher::eCallbackReturnContinue;
+  if (!module || !IsRenderScriptScriptModule(module))
+    return Searcher::eCallbackReturnContinue;
 
-    // Is this a module containing renderscript kernels?
-    if (nullptr == module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData))
-        return Searcher::eCallbackReturnContinue;
+  // Attempt to set a breakpoint on the kernel name symbol within the module
+  // library. If it's not found, it's likely debug info is unavailable - try to
+  // set a breakpoint on <name>.expand.
+  const Symbol *kernel_sym =
+      module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
+  if (!kernel_sym) {
+    std::string kernel_name_expanded(m_kernel_name.AsCString());
+    kernel_name_expanded.append(".expand");
+    kernel_sym = module->FindFirstSymbolWithNameAndType(
+        ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode);
+  }
+
+  if (kernel_sym) {
+    Address bp_addr = kernel_sym->GetAddress();
+    if (filter.AddressPasses(bp_addr))
+      m_breakpoint->AddLocation(bp_addr);
+  }
+
+  return Searcher::eCallbackReturnContinue;
+}
 
-    // Attempt to set a breakpoint on the kernel name symbol within the module library.
-    // If it's not found, it's likely debug info is unavailable - try to set a
-    // breakpoint on <name>.expand.
+Searcher::CallbackReturn
+RSReduceBreakpointResolver::SearchCallback(lldb_private::SearchFilter &filter,
+                                           lldb_private::SymbolContext &context,
+                                           Address *, bool) {
+  // We need to have access to the list of reductions currently parsed, as
+  // reduce names don't actually exist as
+  // symbols in a module. They are only identifiable by parsing the .rs.info
+  // packet, or finding the expand symbol. We
+  // therefore need access to the list of parsed rs modules to properly resolve
+  // reduction names.
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+  ModuleSP module = context.module_sp;
+
+  if (!module || !IsRenderScriptScriptModule(module))
+    return Searcher::eCallbackReturnContinue;
 
-    const Symbol *kernel_sym = module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
-    if (!kernel_sym)
-    {
-        std::string kernel_name_expanded(m_kernel_name.AsCString());
-        kernel_name_expanded.append(".expand");
-        kernel_sym = module->FindFirstSymbolWithNameAndType(ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode);
-    }
+  if (!m_rsmodules)
+    return Searcher::eCallbackReturnContinue;
 
-    if (kernel_sym)
-    {
-        Address bp_addr = kernel_sym->GetAddress();
-        if (filter.AddressPasses(bp_addr))
-            m_breakpoint->AddLocation(bp_addr);
+  for (const auto &module_desc : *m_rsmodules) {
+    if (module_desc->m_module != module)
+      continue;
+
+    for (const auto &reduction : module_desc->m_reductions) {
+      if (reduction.m_reduce_name != m_reduce_name)
+        continue;
+
+      std::array<std::pair<ConstString, int>, 5> funcs{
+          {{reduction.m_init_name, eKernelTypeInit},
+           {reduction.m_accum_name, eKernelTypeAccum},
+           {reduction.m_comb_name, eKernelTypeComb},
+           {reduction.m_outc_name, eKernelTypeOutC},
+           {reduction.m_halter_name, eKernelTypeHalter}}};
+
+      for (const auto &kernel : funcs) {
+        // Skip constituent functions that don't match our spec
+        if (!(m_kernel_types & kernel.second))
+          continue;
+
+        const auto kernel_name = kernel.first;
+        const auto symbol = module->FindFirstSymbolWithNameAndType(
+            kernel_name, eSymbolTypeCode);
+        if (!symbol)
+          continue;
+
+        auto address = symbol->GetAddress();
+        if (filter.AddressPasses(address)) {
+          bool new_bp;
+          if (!SkipPrologue(module, address)) {
+            if (log)
+              log->Printf("%s: Error trying to skip prologue", __FUNCTION__);
+          }
+          m_breakpoint->AddLocation(address, &new_bp);
+          if (log)
+            log->Printf("%s: %s reduction breakpoint on %s in %s", __FUNCTION__,
+                        new_bp ? "new" : "existing", kernel_name.GetCString(),
+                        address.GetModule()->GetFileSpec().GetCString());
+        }
+      }
     }
+  }
+  return eCallbackReturnContinue;
+}
+
+Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback(
+    SearchFilter &filter, SymbolContext &context, Address *addr,
+    bool containing) {
+
+  if (!m_breakpoint)
+    return eCallbackReturnContinue;
+
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+  ModuleSP &module = context.module_sp;
 
+  if (!module || !IsRenderScriptScriptModule(module))
     return Searcher::eCallbackReturnContinue;
+
+  std::vector<std::string> names;
+  m_breakpoint->GetNames(names);
+  if (names.empty())
+    return eCallbackReturnContinue;
+
+  for (auto &name : names) {
+    const RSScriptGroupDescriptorSP sg = FindScriptGroup(ConstString(name));
+    if (!sg) {
+      if (log)
+        log->Printf("%s: could not find script group for %s", __FUNCTION__,
+                    name.c_str());
+      continue;
+    }
+
+    if (log)
+      log->Printf("%s: Found ScriptGroup for %s", __FUNCTION__, name.c_str());
+
+    for (const RSScriptGroupDescriptor::Kernel &k : sg->m_kernels) {
+      if (log) {
+        log->Printf("%s: Adding breakpoint for %s", __FUNCTION__,
+                    k.m_name.AsCString());
+        log->Printf("%s: Kernel address 0x%" PRIx64, __FUNCTION__, k.m_addr);
+      }
+
+      const lldb_private::Symbol *sym =
+          module->FindFirstSymbolWithNameAndType(k.m_name, eSymbolTypeCode);
+      if (!sym) {
+        if (log)
+          log->Printf("%s: Unable to find symbol for %s", __FUNCTION__,
+                      k.m_name.AsCString());
+        continue;
+      }
+
+      if (log) {
+        log->Printf("%s: Found symbol name is %s", __FUNCTION__,
+                    sym->GetName().AsCString());
+      }
+
+      auto address = sym->GetAddress();
+      if (!SkipPrologue(module, address)) {
+        if (log)
+          log->Printf("%s: Error trying to skip prologue", __FUNCTION__);
+      }
+
+      bool new_bp;
+      m_breakpoint->AddLocation(address, &new_bp);
+
+      if (log)
+        log->Printf("%s: Placed %sbreakpoint on %s", __FUNCTION__,
+                    new_bp ? "new " : "", k.m_name.AsCString());
+
+      // exit after placing the first breakpoint if we do not intend to stop
+      // on all kernels making up this script group
+      if (!m_stop_on_all)
+        break;
+    }
+  }
+
+  return eCallbackReturnContinue;
 }
 
-void
-RenderScriptRuntime::Initialize()
-{
-    PluginManager::RegisterPlugin(GetPluginNameStatic(), "RenderScript language support", CreateInstance,
-                                  GetCommandObject);
+void RenderScriptRuntime::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                "RenderScript language support", CreateInstance,
+                                GetCommandObject);
 }
 
-void
-RenderScriptRuntime::Terminate()
-{
-    PluginManager::UnregisterPlugin(CreateInstance);
+void RenderScriptRuntime::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-lldb_private::ConstString
-RenderScriptRuntime::GetPluginNameStatic()
-{
-    static ConstString g_name("renderscript");
-    return g_name;
+lldb_private::ConstString RenderScriptRuntime::GetPluginNameStatic() {
+  static ConstString plugin_name("renderscript");
+  return plugin_name;
 }
 
 RenderScriptRuntime::ModuleKind
-RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp)
-{
-    if (module_sp)
-    {
-        // Is this a module containing renderscript kernels?
-        const Symbol *info_sym = module_sp->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData);
-        if (info_sym)
-        {
-            return eModuleKindKernelObj;
-        }
+RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp) {
+  if (module_sp) {
+    if (IsRenderScriptScriptModule(module_sp))
+      return eModuleKindKernelObj;
 
-        // Is this the main RS runtime library
-        const ConstString rs_lib("libRS.so");
-        if (module_sp->GetFileSpec().GetFilename() == rs_lib)
-        {
-            return eModuleKindLibRS;
-        }
+    // Is this the main RS runtime library
+    const ConstString rs_lib("libRS.so");
+    if (module_sp->GetFileSpec().GetFilename() == rs_lib) {
+      return eModuleKindLibRS;
+    }
 
-        const ConstString rs_driverlib("libRSDriver.so");
-        if (module_sp->GetFileSpec().GetFilename() == rs_driverlib)
-        {
-            return eModuleKindDriver;
-        }
+    const ConstString rs_driverlib("libRSDriver.so");
+    if (module_sp->GetFileSpec().GetFilename() == rs_driverlib) {
+      return eModuleKindDriver;
+    }
 
-        const ConstString rs_cpureflib("libRSCpuRef.so");
-        if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib)
-        {
-            return eModuleKindImpl;
-        }
+    const ConstString rs_cpureflib("libRSCpuRef.so");
+    if (module_sp->GetFileSpec().GetFilename() == rs_cpureflib) {
+      return eModuleKindImpl;
     }
-    return eModuleKindIgnored;
+  }
+  return eModuleKindIgnored;
 }
 
-bool
-RenderScriptRuntime::IsRenderScriptModule(const lldb::ModuleSP &module_sp)
-{
-    return GetModuleKind(module_sp) != eModuleKindIgnored;
+bool RenderScriptRuntime::IsRenderScriptModule(
+    const lldb::ModuleSP &module_sp) {
+  return GetModuleKind(module_sp) != eModuleKindIgnored;
 }
 
-void
-RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list)
-{
-    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
+void RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list) {
+  std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
 
-    size_t num_modules = module_list.GetSize();
-    for (size_t i = 0; i < num_modules; i++)
-    {
-        auto mod = module_list.GetModuleAtIndex(i);
-        if (IsRenderScriptModule(mod))
-        {
-            LoadModule(mod);
-        }
+  size_t num_modules = module_list.GetSize();
+  for (size_t i = 0; i < num_modules; i++) {
+    auto mod = module_list.GetModuleAtIndex(i);
+    if (IsRenderScriptModule(mod)) {
+      LoadModule(mod);
     }
+  }
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
-lldb_private::ConstString
-RenderScriptRuntime::GetPluginName()
-{
-    return GetPluginNameStatic();
+lldb_private::ConstString RenderScriptRuntime::GetPluginName() {
+  return GetPluginNameStatic();
 }
 
-uint32_t
-RenderScriptRuntime::GetPluginVersion()
-{
-    return 1;
-}
+uint32_t RenderScriptRuntime::GetPluginVersion() { return 1; }
 
-bool
-RenderScriptRuntime::IsVTableName(const char *name)
-{
-    return false;
-}
+bool RenderScriptRuntime::IsVTableName(const char *name) { return false; }
 
-bool
-RenderScriptRuntime::GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic,
-                                              TypeAndOrName &class_type_or_name, Address &address,
-                                              Value::ValueType &value_type)
-{
-    return false;
+bool RenderScriptRuntime::GetDynamicTypeAndAddress(
+    ValueObject &in_value, lldb::DynamicValueType use_dynamic,
+    TypeAndOrName &class_type_or_name, Address &address,
+    Value::ValueType &value_type) {
+  return false;
 }
 
 TypeAndOrName
-RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value)
-{
-    return type_and_or_name;
+RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
+                                      ValueObject &static_value) {
+  return type_and_or_name;
 }
 
-bool
-RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value)
-{
-    return false;
+bool RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
+  return false;
 }
 
 lldb::BreakpointResolverSP
-RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp)
-{
-    BreakpointResolverSP resolver_sp;
-    return resolver_sp;
+RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bp, bool catch_bp,
+                                             bool throw_bp) {
+  BreakpointResolverSP resolver_sp;
+  return resolver_sp;
 }
 
-const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] = {
-    // rsdScript
-    {
-        "rsdScriptInit",
-        "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_7ScriptCEPKcS7_PKhjj",
-        "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_7ScriptCEPKcS7_PKhmj",
-        0,
-        RenderScriptRuntime::eModuleKindDriver,
-        &lldb_private::RenderScriptRuntime::CaptureScriptInit
-    },
-    {
-        "rsdScriptInvokeForEachMulti",
-        "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall",
-        "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0_6ScriptEjPPKNS0_10AllocationEmPS6_PKvmPK12RsScriptCall",
-        0,
-        RenderScriptRuntime::eModuleKindDriver,
-        &lldb_private::RenderScriptRuntime::CaptureScriptInvokeForEachMulti
-    },
-    {
-        "rsdScriptSetGlobalVar",
-        "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_6ScriptEjPvj",
-        "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_6ScriptEjPvm",
-        0,
-        RenderScriptRuntime::eModuleKindDriver,
-        &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar
-    },
-
-    // rsdAllocation
-    {
-        "rsdAllocationInit",
-        "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_10AllocationEb",
-        "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_10AllocationEb",
-        0,
-        RenderScriptRuntime::eModuleKindDriver,
-        &lldb_private::RenderScriptRuntime::CaptureAllocationInit
-    },
-    {
-        "rsdAllocationRead2D",
-        "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_10AllocationEjjj23RsAllocationCubemapFacejjPvjj",
-        "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_10AllocationEjjj23RsAllocationCubemapFacejjPvmm",
-        0,
-        RenderScriptRuntime::eModuleKindDriver,
-        nullptr
-    },
-    {
-        "rsdAllocationDestroy",
-        "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_10AllocationE",
-        "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_10AllocationE",
-        0,
-        RenderScriptRuntime::eModuleKindDriver,
-        &lldb_private::RenderScriptRuntime::CaptureAllocationDestroy
-    },
-};
-
-const size_t RenderScriptRuntime::s_runtimeHookCount = sizeof(s_runtimeHookDefns) / sizeof(s_runtimeHookDefns[0]);
-
-bool
-RenderScriptRuntime::HookCallback(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id,
-                                  lldb::user_id_t break_loc_id)
-{
-    RuntimeHook *hook_info = (RuntimeHook *)baton;
-    ExecutionContext context(ctx->exe_ctx_ref);
-
-    RenderScriptRuntime *lang_rt =
-        (RenderScriptRuntime *)context.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
-
-    lang_rt->HookCallback(hook_info, context);
-
-    return false;
+const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] =
+    {
+        // rsdScript
+        {"rsdScriptInit", "_Z13rsdScriptInitPKN7android12renderscript7ContextEP"
+                          "NS0_7ScriptCEPKcS7_PKhjj",
+         "_Z13rsdScriptInitPKN7android12renderscript7ContextEPNS0_"
+         "7ScriptCEPKcS7_PKhmj",
+         0, RenderScriptRuntime::eModuleKindDriver,
+         &lldb_private::RenderScriptRuntime::CaptureScriptInit},
+        {"rsdScriptInvokeForEachMulti",
+         "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0"
+         "_6ScriptEjPPKNS0_10AllocationEjPS6_PKvjPK12RsScriptCall",
+         "_Z27rsdScriptInvokeForEachMultiPKN7android12renderscript7ContextEPNS0"
+         "_6ScriptEjPPKNS0_10AllocationEmPS6_PKvmPK12RsScriptCall",
+         0, RenderScriptRuntime::eModuleKindDriver,
+         &lldb_private::RenderScriptRuntime::CaptureScriptInvokeForEachMulti},
+        {"rsdScriptSetGlobalVar", "_Z21rsdScriptSetGlobalVarPKN7android12render"
+                                  "script7ContextEPKNS0_6ScriptEjPvj",
+         "_Z21rsdScriptSetGlobalVarPKN7android12renderscript7ContextEPKNS0_"
+         "6ScriptEjPvm",
+         0, RenderScriptRuntime::eModuleKindDriver,
+         &lldb_private::RenderScriptRuntime::CaptureSetGlobalVar},
+
+        // rsdAllocation
+        {"rsdAllocationInit", "_Z17rsdAllocationInitPKN7android12renderscript7C"
+                              "ontextEPNS0_10AllocationEb",
+         "_Z17rsdAllocationInitPKN7android12renderscript7ContextEPNS0_"
+         "10AllocationEb",
+         0, RenderScriptRuntime::eModuleKindDriver,
+         &lldb_private::RenderScriptRuntime::CaptureAllocationInit},
+        {"rsdAllocationRead2D",
+         "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_"
+         "10AllocationEjjj23RsAllocationCubemapFacejjPvjj",
+         "_Z19rsdAllocationRead2DPKN7android12renderscript7ContextEPKNS0_"
+         "10AllocationEjjj23RsAllocationCubemapFacejjPvmm",
+         0, RenderScriptRuntime::eModuleKindDriver, nullptr},
+        {"rsdAllocationDestroy", "_Z20rsdAllocationDestroyPKN7android12rendersc"
+                                 "ript7ContextEPNS0_10AllocationE",
+         "_Z20rsdAllocationDestroyPKN7android12renderscript7ContextEPNS0_"
+         "10AllocationE",
+         0, RenderScriptRuntime::eModuleKindDriver,
+         &lldb_private::RenderScriptRuntime::CaptureAllocationDestroy},
+
+        // renderscript script groups
+        {"rsdDebugHintScriptGroup2", "_ZN7android12renderscript21debugHintScrip"
+                                     "tGroup2EPKcjPKPFvPK24RsExpandKernelDriver"
+                                     "InfojjjEj",
+         "_ZN7android12renderscript21debugHintScriptGroup2EPKcjPKPFvPK24RsExpan"
+         "dKernelDriverInfojjjEj",
+         0, RenderScriptRuntime::eModuleKindImpl,
+         &lldb_private::RenderScriptRuntime::CaptureDebugHintScriptGroup2}};
+
+const size_t RenderScriptRuntime::s_runtimeHookCount =
+    sizeof(s_runtimeHookDefns) / sizeof(s_runtimeHookDefns[0]);
+
+bool RenderScriptRuntime::HookCallback(void *baton,
+                                       StoppointCallbackContext *ctx,
+                                       lldb::user_id_t break_id,
+                                       lldb::user_id_t break_loc_id) {
+  RuntimeHook *hook = (RuntimeHook *)baton;
+  ExecutionContext exe_ctx(ctx->exe_ctx_ref);
+
+  RenderScriptRuntime *lang_rt =
+      (RenderScriptRuntime *)exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+          eLanguageTypeExtRenderScript);
+
+  lang_rt->HookCallback(hook, exe_ctx);
+
+  return false;
 }
 
-void
-RenderScriptRuntime::HookCallback(RuntimeHook *hook_info, ExecutionContext &context)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+void RenderScriptRuntime::HookCallback(RuntimeHook *hook,
+                                       ExecutionContext &exe_ctx) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    if (log)
-        log->Printf("%s - '%s'", __FUNCTION__, hook_info->defn->name);
+  if (log)
+    log->Printf("%s - '%s'", __FUNCTION__, hook->defn->name);
 
-    if (hook_info->defn->grabber)
-    {
-        (this->*(hook_info->defn->grabber))(hook_info, context);
-    }
+  if (hook->defn->grabber) {
+    (this->*(hook->defn->grabber))(hook, exe_ctx);
+  }
 }
 
-void
-RenderScriptRuntime::CaptureScriptInvokeForEachMulti(RuntimeHook* hook_info,
-                                                     ExecutionContext& context)
-{
-    Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    enum
-    {
-        eRsContext = 0,
-        eRsScript,
-        eRsSlot,
-        eRsAIns,
-        eRsInLen,
-        eRsAOut,
-        eRsUsr,
-        eRsUsrLen,
-        eRsSc,
-    };
-
-    std::array<ArgItem, 9> args{{
-        ArgItem{ArgItem::ePointer, 0}, // const Context       *rsc
-        ArgItem{ArgItem::ePointer, 0}, // Script              *s
-        ArgItem{ArgItem::eInt32, 0},   // uint32_t             slot
-        ArgItem{ArgItem::ePointer, 0}, // const Allocation   **aIns
-        ArgItem{ArgItem::eInt32, 0},   // size_t               inLen
-        ArgItem{ArgItem::ePointer, 0}, // Allocation          *aout
-        ArgItem{ArgItem::ePointer, 0}, // const void          *usr
-        ArgItem{ArgItem::eInt32, 0},   // size_t               usrLen
-        ArgItem{ArgItem::ePointer, 0}, // const RsScriptCall  *sc
-    }};
-
-    bool success = GetArgs(context, &args[0], args.size());
-    if (!success)
-    {
-        if (log)
-            log->Printf("%s - Error while reading the function parameters", __FUNCTION__);
-        return;
-    }
-
-    const uint32_t target_ptr_size = m_process->GetAddressByteSize();
-    Error error;
-    std::vector<uint64_t> allocs;
-
-    // traverse allocation list
-    for (uint64_t i = 0; i < uint64_t(args[eRsInLen]); ++i)
-    {
-        // calculate offest to allocation pointer
-        const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size;
-
-        // Note: due to little endian layout, reading 32bits or 64bits into res64 will
-        //       give the correct results.
-
-        uint64_t res64 = 0;
-        size_t read = m_process->ReadMemory(addr, &res64, target_ptr_size, error);
-        if (read != target_ptr_size || !error.Success())
-        {
-            if (log)
-                log->Printf("%s - Error while reading allocation list argument %" PRIu64, __FUNCTION__, i);
-        }
-        else
-        {
-            allocs.push_back(res64);
-        }
-    }
-
-    // if there is an output allocation track it
-    if (uint64_t aOut = uint64_t(args[eRsAOut]))
-    {
-        allocs.push_back(aOut);
+void RenderScriptRuntime::CaptureDebugHintScriptGroup2(
+    RuntimeHook *hook_info, ExecutionContext &context) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  enum {
+    eGroupName = 0,
+    eGroupNameSize,
+    eKernel,
+    eKernelCount,
+  };
+
+  std::array<ArgItem, 4> args{{
+      {ArgItem::ePointer, 0}, // const char         *groupName
+      {ArgItem::eInt32, 0},   // const uint32_t      groupNameSize
+      {ArgItem::ePointer, 0}, // const ExpandFuncTy *kernel
+      {ArgItem::eInt32, 0},   // const uint32_t      kernelCount
+  }};
+
+  if (!GetArgs(context, args.data(), args.size())) {
+    if (log)
+      log->Printf("%s - Error while reading the function parameters",
+                  __FUNCTION__);
+    return;
+  } else if (log) {
+    log->Printf("%s - groupName    : 0x%" PRIx64, __FUNCTION__,
+                addr_t(args[eGroupName]));
+    log->Printf("%s - groupNameSize: %" PRIu64, __FUNCTION__,
+                uint64_t(args[eGroupNameSize]));
+    log->Printf("%s - kernel       : 0x%" PRIx64, __FUNCTION__,
+                addr_t(args[eKernel]));
+    log->Printf("%s - kernelCount  : %" PRIu64, __FUNCTION__,
+                uint64_t(args[eKernelCount]));
+  }
+
+  // parse script group name
+  ConstString group_name;
+  {
+    Error err;
+    const uint64_t len = uint64_t(args[eGroupNameSize]);
+    std::unique_ptr<char[]> buffer(new char[uint32_t(len + 1)]);
+    m_process->ReadMemory(addr_t(args[eGroupName]), buffer.get(), len, err);
+    buffer.get()[len] = '\0';
+    if (!err.Success()) {
+      if (log)
+        log->Printf("Error reading scriptgroup name from target");
+      return;
+    } else {
+      if (log)
+        log->Printf("Extracted scriptgroup name %s", buffer.get());
+    }
+    // write back the script group name
+    group_name.SetCString(buffer.get());
+  }
+
+  // create or access existing script group
+  RSScriptGroupDescriptorSP group;
+  {
+    // search for existing script group
+    for (auto sg : m_scriptGroups) {
+      if (sg->m_name == group_name) {
+        group = sg;
+        break;
+      }
+    }
+    if (!group) {
+      group.reset(new RSScriptGroupDescriptor);
+      group->m_name = group_name;
+      m_scriptGroups.push_back(group);
+    } else {
+      // already have this script group
+      if (log)
+        log->Printf("Attempt to add duplicate script group %s",
+                    group_name.AsCString());
+      return;
+    }
+  }
+  assert(group);
+
+  const uint32_t target_ptr_size = m_process->GetAddressByteSize();
+  std::vector<addr_t> kernels;
+  // parse kernel addresses in script group
+  for (uint64_t i = 0; i < uint64_t(args[eKernelCount]); ++i) {
+    RSScriptGroupDescriptor::Kernel kernel;
+    // extract script group kernel addresses from the target
+    const addr_t ptr_addr = addr_t(args[eKernel]) + i * target_ptr_size;
+    uint64_t kernel_addr = 0;
+    Error err;
+    size_t read =
+        m_process->ReadMemory(ptr_addr, &kernel_addr, target_ptr_size, err);
+    if (!err.Success() || read != target_ptr_size) {
+      if (log)
+        log->Printf("Error parsing kernel address %" PRIu64 " in script group",
+                    i);
+      return;
     }
-
-    // for all allocations we have found
-    for (const uint64_t alloc_addr : allocs)
-    {
-        AllocationDetails* alloc = LookUpAllocation(alloc_addr, true);
-        if (alloc)
-        {
-            // save the allocation address
-            if (alloc->address.isValid())
-            {
-                // check the allocation address we already have matches
-                assert(*alloc->address.get() == alloc_addr);
-            }
-            else
-            {
-                alloc->address = alloc_addr;
-            }
-
-            // save the context
-            if (log)
-            {
-                if (alloc->context.isValid() && *alloc->context.get() != addr_t(args[eRsContext]))
-                    log->Printf("%s - Allocation used by multiple contexts", __FUNCTION__);
-            }
-            alloc->context = addr_t(args[eRsContext]);
+    if (log)
+      log->Printf("Extracted scriptgroup kernel address - 0x%" PRIx64,
+                  kernel_addr);
+    kernel.m_addr = kernel_addr;
+
+    // try to resolve the associated kernel name
+    if (!ResolveKernelName(kernel.m_addr, kernel.m_name)) {
+      if (log)
+        log->Printf("Parsed scriptgroup kernel %" PRIu64 " - 0x%" PRIx64, i,
+                    kernel_addr);
+      return;
+    }
+
+    // try to find the non '.expand' function
+    {
+      const llvm::StringRef expand(".expand");
+      const llvm::StringRef name_ref = kernel.m_name.GetStringRef();
+      if (name_ref.endswith(expand)) {
+        const ConstString base_kernel(name_ref.drop_back(expand.size()));
+        // verify this function is a valid kernel
+        if (IsKnownKernel(base_kernel)) {
+          kernel.m_name = base_kernel;
+          if (log)
+            log->Printf("%s - found non expand version '%s'", __FUNCTION__,
+                        base_kernel.GetCString());
         }
+      }
     }
+    // add to a list of script group kernels we know about
+    group->m_kernels.push_back(kernel);
+  }
 
-    // make sure we track this script object
-    if (lldb_private::RenderScriptRuntime::ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true))
-    {
-        if (log)
-        {
-            if (script->context.isValid() && *script->context.get() != addr_t(args[eRsContext]))
-                log->Printf("%s - Script used by multiple contexts", __FUNCTION__);
+  // Resolve any pending scriptgroup breakpoints
+  {
+    Target &target = m_process->GetTarget();
+    const BreakpointList &list = target.GetBreakpointList();
+    const size_t num_breakpoints = list.GetSize();
+    if (log)
+      log->Printf("Resolving %zu breakpoints", num_breakpoints);
+    for (size_t i = 0; i < num_breakpoints; ++i) {
+      const BreakpointSP bp = list.GetBreakpointAtIndex(i);
+      if (bp) {
+        if (bp->MatchesName(group_name.AsCString())) {
+          if (log)
+            log->Printf("Found breakpoint with name %s",
+                        group_name.AsCString());
+          bp->ResolveBreakpoint();
         }
-        script->context = addr_t(args[eRsContext]);
+      }
     }
+  }
 }
 
-void
-RenderScriptRuntime::CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    enum
-    {
-        eRsContext,
-        eRsScript,
-        eRsId,
-        eRsData,
-        eRsLength,
-    };
-
-    std::array<ArgItem, 5> args{{
-        ArgItem{ArgItem::ePointer, 0}, // eRsContext
-        ArgItem{ArgItem::ePointer, 0}, // eRsScript
-        ArgItem{ArgItem::eInt32, 0},   // eRsId
-        ArgItem{ArgItem::ePointer, 0}, // eRsData
-        ArgItem{ArgItem::eInt32, 0},   // eRsLength
-    }};
-
-    bool success = GetArgs(context, &args[0], args.size());
-    if (!success)
-    {
-        if (log)
-            log->Printf("%s - error reading the function parameters.", __FUNCTION__);
-        return;
-    }
-
+void RenderScriptRuntime::CaptureScriptInvokeForEachMulti(
+    RuntimeHook *hook, ExecutionContext &exe_ctx) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  enum {
+    eRsContext = 0,
+    eRsScript,
+    eRsSlot,
+    eRsAIns,
+    eRsInLen,
+    eRsAOut,
+    eRsUsr,
+    eRsUsrLen,
+    eRsSc,
+  };
+
+  std::array<ArgItem, 9> args{{
+      ArgItem{ArgItem::ePointer, 0}, // const Context       *rsc
+      ArgItem{ArgItem::ePointer, 0}, // Script              *s
+      ArgItem{ArgItem::eInt32, 0},   // uint32_t             slot
+      ArgItem{ArgItem::ePointer, 0}, // const Allocation   **aIns
+      ArgItem{ArgItem::eInt32, 0},   // size_t               inLen
+      ArgItem{ArgItem::ePointer, 0}, // Allocation          *aout
+      ArgItem{ArgItem::ePointer, 0}, // const void          *usr
+      ArgItem{ArgItem::eInt32, 0},   // size_t               usrLen
+      ArgItem{ArgItem::ePointer, 0}, // const RsScriptCall  *sc
+  }};
+
+  bool success = GetArgs(exe_ctx, &args[0], args.size());
+  if (!success) {
     if (log)
-    {
-        log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 " slot %" PRIu64 " = 0x%" PRIx64 ":%" PRIu64 "bytes.", __FUNCTION__,
-                    uint64_t(args[eRsContext]), uint64_t(args[eRsScript]), uint64_t(args[eRsId]),
-                    uint64_t(args[eRsData]), uint64_t(args[eRsLength]));
-
-        addr_t script_addr = addr_t(args[eRsScript]);
-        if (m_scriptMappings.find(script_addr) != m_scriptMappings.end())
-        {
-            auto rsm = m_scriptMappings[script_addr];
-            if (uint64_t(args[eRsId]) < rsm->m_globals.size())
-            {
-                auto rsg = rsm->m_globals[uint64_t(args[eRsId])];
-                log->Printf("%s - Setting of '%s' within '%s' inferred", __FUNCTION__, rsg.m_name.AsCString(),
-                            rsm->m_module->GetFileSpec().GetFilename().AsCString());
-            }
-        }
-    }
+      log->Printf("%s - Error while reading the function parameters",
+                  __FUNCTION__);
+    return;
+  }
+
+  const uint32_t target_ptr_size = m_process->GetAddressByteSize();
+  Error err;
+  std::vector<uint64_t> allocs;
+
+  // traverse allocation list
+  for (uint64_t i = 0; i < uint64_t(args[eRsInLen]); ++i) {
+    // calculate offest to allocation pointer
+    const addr_t addr = addr_t(args[eRsAIns]) + i * target_ptr_size;
+
+    // Note: due to little endian layout, reading 32bits or 64bits into res
+    // will give the correct results.
+    uint64_t result = 0;
+    size_t read = m_process->ReadMemory(addr, &result, target_ptr_size, err);
+    if (read != target_ptr_size || !err.Success()) {
+      if (log)
+        log->Printf(
+            "%s - Error while reading allocation list argument %" PRIu64,
+            __FUNCTION__, i);
+    } else {
+      allocs.push_back(result);
+    }
+  }
+
+  // if there is an output allocation track it
+  if (uint64_t alloc_out = uint64_t(args[eRsAOut])) {
+    allocs.push_back(alloc_out);
+  }
+
+  // for all allocations we have found
+  for (const uint64_t alloc_addr : allocs) {
+    AllocationDetails *alloc = LookUpAllocation(alloc_addr);
+    if (!alloc)
+      alloc = CreateAllocation(alloc_addr);
+
+    if (alloc) {
+      // save the allocation address
+      if (alloc->address.isValid()) {
+        // check the allocation address we already have matches
+        assert(*alloc->address.get() == alloc_addr);
+      } else {
+        alloc->address = alloc_addr;
+      }
+
+      // save the context
+      if (log) {
+        if (alloc->context.isValid() &&
+            *alloc->context.get() != addr_t(args[eRsContext]))
+          log->Printf("%s - Allocation used by multiple contexts",
+                      __FUNCTION__);
+      }
+      alloc->context = addr_t(args[eRsContext]);
+    }
+  }
+
+  // make sure we track this script object
+  if (lldb_private::RenderScriptRuntime::ScriptDetails *script =
+          LookUpScript(addr_t(args[eRsScript]), true)) {
+    if (log) {
+      if (script->context.isValid() &&
+          *script->context.get() != addr_t(args[eRsContext]))
+        log->Printf("%s - Script used by multiple contexts", __FUNCTION__);
+    }
+    script->context = addr_t(args[eRsContext]);
+  }
 }
 
-void
-RenderScriptRuntime::CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    enum
-    {
-        eRsContext,
-        eRsAlloc,
-        eRsForceZero
-    };
-
-    std::array<ArgItem, 3> args{{
-        ArgItem{ArgItem::ePointer, 0}, // eRsContext
-        ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
-        ArgItem{ArgItem::eBool, 0},    // eRsForceZero
-    }};
-
-    bool success = GetArgs(context, &args[0], args.size());
-    if (!success) // error case
-    {
-        if (log)
-            log->Printf("%s - error while reading the function parameters", __FUNCTION__);
-        return; // abort
-    }
-
+void RenderScriptRuntime::CaptureSetGlobalVar(RuntimeHook *hook,
+                                              ExecutionContext &context) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  enum {
+    eRsContext,
+    eRsScript,
+    eRsId,
+    eRsData,
+    eRsLength,
+  };
+
+  std::array<ArgItem, 5> args{{
+      ArgItem{ArgItem::ePointer, 0}, // eRsContext
+      ArgItem{ArgItem::ePointer, 0}, // eRsScript
+      ArgItem{ArgItem::eInt32, 0},   // eRsId
+      ArgItem{ArgItem::ePointer, 0}, // eRsData
+      ArgItem{ArgItem::eInt32, 0},   // eRsLength
+  }};
+
+  bool success = GetArgs(context, &args[0], args.size());
+  if (!success) {
     if (log)
-        log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 ",0x%" PRIx64 " .", __FUNCTION__, uint64_t(args[eRsContext]),
-                    uint64_t(args[eRsAlloc]), uint64_t(args[eRsForceZero]));
-
-    AllocationDetails *alloc = LookUpAllocation(uint64_t(args[eRsAlloc]), true);
-    if (alloc)
-        alloc->context = uint64_t(args[eRsContext]);
+      log->Printf("%s - error reading the function parameters.", __FUNCTION__);
+    return;
+  }
+
+  if (log) {
+    log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 " slot %" PRIu64 " = 0x%" PRIx64
+                ":%" PRIu64 "bytes.",
+                __FUNCTION__, uint64_t(args[eRsContext]),
+                uint64_t(args[eRsScript]), uint64_t(args[eRsId]),
+                uint64_t(args[eRsData]), uint64_t(args[eRsLength]));
+
+    addr_t script_addr = addr_t(args[eRsScript]);
+    if (m_scriptMappings.find(script_addr) != m_scriptMappings.end()) {
+      auto rsm = m_scriptMappings[script_addr];
+      if (uint64_t(args[eRsId]) < rsm->m_globals.size()) {
+        auto rsg = rsm->m_globals[uint64_t(args[eRsId])];
+        log->Printf("%s - Setting of '%s' within '%s' inferred", __FUNCTION__,
+                    rsg.m_name.AsCString(),
+                    rsm->m_module->GetFileSpec().GetFilename().AsCString());
+      }
+    }
+  }
 }
 
-void
-RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook_info, ExecutionContext &context)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+void RenderScriptRuntime::CaptureAllocationInit(RuntimeHook *hook,
+                                                ExecutionContext &exe_ctx) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    enum
-    {
-        eRsContext,
-        eRsAlloc,
-    };
+  enum { eRsContext, eRsAlloc, eRsForceZero };
 
-    std::array<ArgItem, 2> args{{
-        ArgItem{ArgItem::ePointer, 0}, // eRsContext
-        ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
-    }};
-
-    bool success = GetArgs(context, &args[0], args.size());
-    if (!success)
-    {
-        if (log)
-            log->Printf("%s - error while reading the function parameters.", __FUNCTION__);
-        return;
-    }
+  std::array<ArgItem, 3> args{{
+      ArgItem{ArgItem::ePointer, 0}, // eRsContext
+      ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
+      ArgItem{ArgItem::eBool, 0},    // eRsForceZero
+  }};
 
+  bool success = GetArgs(exe_ctx, &args[0], args.size());
+  if (!success) {
     if (log)
-        log->Printf("%s - 0x%" PRIx64 ", 0x%" PRIx64 ".", __FUNCTION__, uint64_t(args[eRsContext]),
-                    uint64_t(args[eRsAlloc]));
-
-    for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter)
-    {
-        auto &allocation_ap = *iter; // get the unique pointer
-        if (allocation_ap->address.isValid() && *allocation_ap->address.get() == addr_t(args[eRsAlloc]))
-        {
-            m_allocations.erase(iter);
-            if (log)
-                log->Printf("%s - deleted allocation entry.", __FUNCTION__);
-            return;
-        }
-    }
-
-    if (log)
-        log->Printf("%s - couldn't find destroyed allocation.", __FUNCTION__);
+      log->Printf("%s - error while reading the function parameters",
+                  __FUNCTION__);
+    return;
+  }
+
+  if (log)
+    log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 ",0x%" PRIx64 " .",
+                __FUNCTION__, uint64_t(args[eRsContext]),
+                uint64_t(args[eRsAlloc]), uint64_t(args[eRsForceZero]));
+
+  AllocationDetails *alloc = CreateAllocation(uint64_t(args[eRsAlloc]));
+  if (alloc)
+    alloc->context = uint64_t(args[eRsContext]);
 }
 
-void
-RenderScriptRuntime::CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+void RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook,
+                                                   ExecutionContext &exe_ctx) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    Error error;
-    Process *process = context.GetProcessPtr();
+  enum {
+    eRsContext,
+    eRsAlloc,
+  };
 
-    enum
-    {
-        eRsContext,
-        eRsScript,
-        eRsResNamePtr,
-        eRsCachedDirPtr
-    };
-
-    std::array<ArgItem, 4> args{{ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0},
-                                 ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}}};
-    bool success = GetArgs(context, &args[0], args.size());
-    if (!success)
-    {
-        if (log)
-            log->Printf("%s - error while reading the function parameters.", __FUNCTION__);
-        return;
-    }
+  std::array<ArgItem, 2> args{{
+      ArgItem{ArgItem::ePointer, 0}, // eRsContext
+      ArgItem{ArgItem::ePointer, 0}, // eRsAlloc
+  }};
 
-    std::string resname;
-    process->ReadCStringFromMemory(addr_t(args[eRsResNamePtr]), resname, error);
-    if (error.Fail())
-    {
-        if (log)
-            log->Printf("%s - error reading resname: %s.", __FUNCTION__, error.AsCString());
-    }
+  bool success = GetArgs(exe_ctx, &args[0], args.size());
+  if (!success) {
+    if (log)
+      log->Printf("%s - error while reading the function parameters.",
+                  __FUNCTION__);
+    return;
+  }
+
+  if (log)
+    log->Printf("%s - 0x%" PRIx64 ", 0x%" PRIx64 ".", __FUNCTION__,
+                uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc]));
+
+  for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter) {
+    auto &allocation_ap = *iter; // get the unique pointer
+    if (allocation_ap->address.isValid() &&
+        *allocation_ap->address.get() == addr_t(args[eRsAlloc])) {
+      m_allocations.erase(iter);
+      if (log)
+        log->Printf("%s - deleted allocation entry.", __FUNCTION__);
+      return;
+    }
+  }
+
+  if (log)
+    log->Printf("%s - couldn't find destroyed allocation.", __FUNCTION__);
+}
 
-    std::string cachedir;
-    process->ReadCStringFromMemory(addr_t(args[eRsCachedDirPtr]), cachedir, error);
-    if (error.Fail())
-    {
-        if (log)
-            log->Printf("%s - error reading cachedir: %s.", __FUNCTION__, error.AsCString());
-    }
+void RenderScriptRuntime::CaptureScriptInit(RuntimeHook *hook,
+                                            ExecutionContext &exe_ctx) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    if (log)
-        log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 " => '%s' at '%s' .", __FUNCTION__, uint64_t(args[eRsContext]),
-                    uint64_t(args[eRsScript]), resname.c_str(), cachedir.c_str());
+  Error err;
+  Process *process = exe_ctx.GetProcessPtr();
 
-    if (resname.size() > 0)
-    {
-        StreamString strm;
-        strm.Printf("librs.%s.so", resname.c_str());
-
-        ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true);
-        if (script)
-        {
-            script->type = ScriptDetails::eScriptC;
-            script->cacheDir = cachedir;
-            script->resName = resname;
-            script->scriptDyLib = strm.GetData();
-            script->context = addr_t(args[eRsContext]);
-        }
+  enum { eRsContext, eRsScript, eRsResNamePtr, eRsCachedDirPtr };
 
-        if (log)
-            log->Printf("%s - '%s' tagged with context 0x%" PRIx64 " and script 0x%" PRIx64 ".", __FUNCTION__,
-                        strm.GetData(), uint64_t(args[eRsContext]), uint64_t(args[eRsScript]));
-    }
-    else if (log)
-    {
-        log->Printf("%s - resource name invalid, Script not tagged.", __FUNCTION__);
-    }
-}
+  std::array<ArgItem, 4> args{
+      {ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0},
+       ArgItem{ArgItem::ePointer, 0}, ArgItem{ArgItem::ePointer, 0}}};
+  bool success = GetArgs(exe_ctx, &args[0], args.size());
+  if (!success) {
+    if (log)
+      log->Printf("%s - error while reading the function parameters.",
+                  __FUNCTION__);
+    return;
+  }
+
+  std::string res_name;
+  process->ReadCStringFromMemory(addr_t(args[eRsResNamePtr]), res_name, err);
+  if (err.Fail()) {
+    if (log)
+      log->Printf("%s - error reading res_name: %s.", __FUNCTION__,
+                  err.AsCString());
+  }
 
-void
-RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  std::string cache_dir;
+  process->ReadCStringFromMemory(addr_t(args[eRsCachedDirPtr]), cache_dir, err);
+  if (err.Fail()) {
+    if (log)
+      log->Printf("%s - error reading cache_dir: %s.", __FUNCTION__,
+                  err.AsCString());
+  }
 
-    if (!module)
-    {
-        return;
-    }
+  if (log)
+    log->Printf("%s - 0x%" PRIx64 ",0x%" PRIx64 " => '%s' at '%s' .",
+                __FUNCTION__, uint64_t(args[eRsContext]),
+                uint64_t(args[eRsScript]), res_name.c_str(), cache_dir.c_str());
 
-    Target &target = GetProcess()->GetTarget();
-    llvm::Triple::ArchType targetArchType = target.GetArchitecture().GetMachine();
+  if (res_name.size() > 0) {
+    StreamString strm;
+    strm.Printf("librs.%s.so", res_name.c_str());
 
-    if (targetArchType != llvm::Triple::ArchType::x86 &&
-        targetArchType != llvm::Triple::ArchType::arm &&
-        targetArchType != llvm::Triple::ArchType::aarch64 &&
-        targetArchType != llvm::Triple::ArchType::mipsel &&
-        targetArchType != llvm::Triple::ArchType::mips64el &&
-        targetArchType != llvm::Triple::ArchType::x86_64)
-    {
-        if (log)
-            log->Printf("%s - unable to hook runtime functions.", __FUNCTION__);
-        return;
+    ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true);
+    if (script) {
+      script->type = ScriptDetails::eScriptC;
+      script->cache_dir = cache_dir;
+      script->res_name = res_name;
+      script->shared_lib = strm.GetString();
+      script->context = addr_t(args[eRsContext]);
     }
 
-    uint32_t archByteSize = target.GetArchitecture().GetAddressByteSize();
-
-    for (size_t idx = 0; idx < s_runtimeHookCount; idx++)
-    {
-        const HookDefn *hook_defn = &s_runtimeHookDefns[idx];
-        if (hook_defn->kind != kind)
-        {
-            continue;
-        }
+    if (log)
+      log->Printf("%s - '%s' tagged with context 0x%" PRIx64
+                  " and script 0x%" PRIx64 ".",
+                  __FUNCTION__, strm.GetData(), uint64_t(args[eRsContext]),
+                  uint64_t(args[eRsScript]));
+  } else if (log) {
+    log->Printf("%s - resource name invalid, Script not tagged.", __FUNCTION__);
+  }
+}
 
-        const char *symbol_name = (archByteSize == 4) ? hook_defn->symbol_name_m32 : hook_defn->symbol_name_m64;
+void RenderScriptRuntime::LoadRuntimeHooks(lldb::ModuleSP module,
+                                           ModuleKind kind) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-        const Symbol *sym = module->FindFirstSymbolWithNameAndType(ConstString(symbol_name), eSymbolTypeCode);
-        if (!sym)
-        {
-            if (log)
-            {
-                log->Printf("%s - symbol '%s' related to the function %s not found",
-                            __FUNCTION__, symbol_name, hook_defn->name);
-            }
-            continue;
-        }
+  if (!module) {
+    return;
+  }
 
-        addr_t addr = sym->GetLoadAddress(&target);
-        if (addr == LLDB_INVALID_ADDRESS)
-        {
-            if (log)
-                log->Printf("%s - unable to resolve the address of hook function '%s' with symbol '%s'.",
-                            __FUNCTION__, hook_defn->name, symbol_name);
-            continue;
-        }
-        else
-        {
-            if (log)
-                log->Printf("%s - function %s, address resolved at 0x%" PRIx64,
-                            __FUNCTION__, hook_defn->name, addr);
-        }
+  Target &target = GetProcess()->GetTarget();
+  const llvm::Triple::ArchType machine = target.GetArchitecture().GetMachine();
 
-        RuntimeHookSP hook(new RuntimeHook());
-        hook->address = addr;
-        hook->defn = hook_defn;
-        hook->bp_sp = target.CreateBreakpoint(addr, true, false);
-        hook->bp_sp->SetCallback(HookCallback, hook.get(), true);
-        m_runtimeHooks[addr] = hook;
-        if (log)
-        {
-            log->Printf("%s - successfully hooked '%s' in '%s' version %" PRIu64 " at 0x%" PRIx64 ".",
-                        __FUNCTION__, hook_defn->name, module->GetFileSpec().GetFilename().AsCString(),
-                        (uint64_t)hook_defn->version, (uint64_t)addr);
-        }
-    }
+  if (machine != llvm::Triple::ArchType::x86 &&
+      machine != llvm::Triple::ArchType::arm &&
+      machine != llvm::Triple::ArchType::aarch64 &&
+      machine != llvm::Triple::ArchType::mipsel &&
+      machine != llvm::Triple::ArchType::mips64el &&
+      machine != llvm::Triple::ArchType::x86_64) {
+    if (log)
+      log->Printf("%s - unable to hook runtime functions.", __FUNCTION__);
+    return;
+  }
+
+  const uint32_t target_ptr_size =
+      target.GetArchitecture().GetAddressByteSize();
+
+  std::array<bool, s_runtimeHookCount> hook_placed;
+  hook_placed.fill(false);
+
+  for (size_t idx = 0; idx < s_runtimeHookCount; idx++) {
+    const HookDefn *hook_defn = &s_runtimeHookDefns[idx];
+    if (hook_defn->kind != kind) {
+      continue;
+    }
+
+    const char *symbol_name = (target_ptr_size == 4)
+                                  ? hook_defn->symbol_name_m32
+                                  : hook_defn->symbol_name_m64;
+
+    const Symbol *sym = module->FindFirstSymbolWithNameAndType(
+        ConstString(symbol_name), eSymbolTypeCode);
+    if (!sym) {
+      if (log) {
+        log->Printf("%s - symbol '%s' related to the function %s not found",
+                    __FUNCTION__, symbol_name, hook_defn->name);
+      }
+      continue;
+    }
+
+    addr_t addr = sym->GetLoadAddress(&target);
+    if (addr == LLDB_INVALID_ADDRESS) {
+      if (log)
+        log->Printf("%s - unable to resolve the address of hook function '%s' "
+                    "with symbol '%s'.",
+                    __FUNCTION__, hook_defn->name, symbol_name);
+      continue;
+    } else {
+      if (log)
+        log->Printf("%s - function %s, address resolved at 0x%" PRIx64,
+                    __FUNCTION__, hook_defn->name, addr);
+    }
+
+    RuntimeHookSP hook(new RuntimeHook());
+    hook->address = addr;
+    hook->defn = hook_defn;
+    hook->bp_sp = target.CreateBreakpoint(addr, true, false);
+    hook->bp_sp->SetCallback(HookCallback, hook.get(), true);
+    m_runtimeHooks[addr] = hook;
+    if (log) {
+      log->Printf("%s - successfully hooked '%s' in '%s' version %" PRIu64
+                  " at 0x%" PRIx64 ".",
+                  __FUNCTION__, hook_defn->name,
+                  module->GetFileSpec().GetFilename().AsCString(),
+                  (uint64_t)hook_defn->version, (uint64_t)addr);
+    }
+    hook_placed[idx] = true;
+  }
+
+  // log any unhooked function
+  if (log) {
+    for (size_t i = 0; i < hook_placed.size(); ++i) {
+      if (hook_placed[i])
+        continue;
+      const HookDefn &hook_defn = s_runtimeHookDefns[i];
+      if (hook_defn.kind != kind)
+        continue;
+      log->Printf("%s - function %s was not hooked", __FUNCTION__,
+                  hook_defn.name);
+    }
+  }
 }
 
-void
-RenderScriptRuntime::FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp)
-{
-    if (!rsmodule_sp)
-        return;
+void RenderScriptRuntime::FixupScriptDetails(RSModuleDescriptorSP rsmodule_sp) {
+  if (!rsmodule_sp)
+    return;
 
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    const ModuleSP module = rsmodule_sp->m_module;
-    const FileSpec &file = module->GetPlatformFileSpec();
+  const ModuleSP module = rsmodule_sp->m_module;
+  const FileSpec &file = module->GetPlatformFileSpec();
 
-    // Iterate over all of the scripts that we currently know of.
-    // Note: We cant push or pop to m_scripts here or it may invalidate rs_script.
-    for (const auto &rs_script : m_scripts)
-    {
-        // Extract the expected .so file path for this script.
-        std::string dylib;
-        if (!rs_script->scriptDyLib.get(dylib))
-            continue;
+  // Iterate over all of the scripts that we currently know of.
+  // Note: We cant push or pop to m_scripts here or it may invalidate rs_script.
+  for (const auto &rs_script : m_scripts) {
+    // Extract the expected .so file path for this script.
+    std::string shared_lib;
+    if (!rs_script->shared_lib.get(shared_lib))
+      continue;
 
-        // Only proceed if the module that has loaded corresponds to this script.
-        if (file.GetFilename() != ConstString(dylib.c_str()))
-            continue;
+    // Only proceed if the module that has loaded corresponds to this script.
+    if (file.GetFilename() != ConstString(shared_lib.c_str()))
+      continue;
 
-        // Obtain the script address which we use as a key.
-        lldb::addr_t script;
-        if (!rs_script->script.get(script))
-            continue;
+    // Obtain the script address which we use as a key.
+    lldb::addr_t script;
+    if (!rs_script->script.get(script))
+      continue;
 
-        // If we have a script mapping for the current script.
-        if (m_scriptMappings.find(script) != m_scriptMappings.end())
-        {
-            // if the module we have stored is different to the one we just received.
-            if (m_scriptMappings[script] != rsmodule_sp)
-            {
-                if (log)
-                    log->Printf("%s - script %" PRIx64 " wants reassigned to new rsmodule '%s'.", __FUNCTION__,
-                                (uint64_t)script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
-            }
-        }
-        // We don't have a script mapping for the current script.
-        else
-        {
-            // Obtain the script resource name.
-            std::string resName;
-            if (rs_script->resName.get(resName))
-                // Set the modules resource name.
-                rsmodule_sp->m_resname = resName;
-            // Add Script/Module pair to map.
-            m_scriptMappings[script] = rsmodule_sp;
-            if (log)
-                log->Printf("%s - script %" PRIx64 " associated with rsmodule '%s'.", __FUNCTION__,
-                            (uint64_t)script, rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
-        }
-    }
+    // If we have a script mapping for the current script.
+    if (m_scriptMappings.find(script) != m_scriptMappings.end()) {
+      // if the module we have stored is different to the one we just received.
+      if (m_scriptMappings[script] != rsmodule_sp) {
+        if (log)
+          log->Printf(
+              "%s - script %" PRIx64 " wants reassigned to new rsmodule '%s'.",
+              __FUNCTION__, (uint64_t)script,
+              rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
+      }
+    }
+    // We don't have a script mapping for the current script.
+    else {
+      // Obtain the script resource name.
+      std::string res_name;
+      if (rs_script->res_name.get(res_name))
+        // Set the modules resource name.
+        rsmodule_sp->m_resname = res_name;
+      // Add Script/Module pair to map.
+      m_scriptMappings[script] = rsmodule_sp;
+      if (log)
+        log->Printf(
+            "%s - script %" PRIx64 " associated with rsmodule '%s'.",
+            __FUNCTION__, (uint64_t)script,
+            rsmodule_sp->m_module->GetFileSpec().GetFilename().AsCString());
+    }
+  }
 }
 
-// Uses the Target API to evaluate the expression passed as a parameter to the function
-// The result of that expression is returned an unsigned 64 bit int, via the result* paramter.
-// Function returns true on success, and false on failure
-bool
-RenderScriptRuntime::EvalRSExpression(const char *expression, StackFrame *frame_ptr, uint64_t *result)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+// Uses the Target API to evaluate the expression passed as a parameter to the
+// function The result of that expression is returned an unsigned 64 bit int,
+// via the result* parameter. Function returns true on success, and false on
+// failure
+bool RenderScriptRuntime::EvalRSExpression(const char *expr,
+                                           StackFrame *frame_ptr,
+                                           uint64_t *result) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  if (log)
+    log->Printf("%s(%s)", __FUNCTION__, expr);
+
+  ValueObjectSP expr_result;
+  EvaluateExpressionOptions options;
+  options.SetLanguage(lldb::eLanguageTypeC_plus_plus);
+  // Perform the actual expression evaluation
+  auto &target = GetProcess()->GetTarget();
+  target.EvaluateExpression(expr, frame_ptr, expr_result, options);
+
+  if (!expr_result) {
     if (log)
-        log->Printf("%s(%s)", __FUNCTION__, expression);
+      log->Printf("%s: couldn't evaluate expression.", __FUNCTION__);
+    return false;
+  }
 
-    ValueObjectSP expr_result;
-    EvaluateExpressionOptions options;
-    options.SetLanguage(lldb::eLanguageTypeC_plus_plus);
-    // Perform the actual expression evaluation
-    GetProcess()->GetTarget().EvaluateExpression(expression, frame_ptr, expr_result, options);
+  // The result of the expression is invalid
+  if (!expr_result->GetError().Success()) {
+    Error err = expr_result->GetError();
+    // Expression returned is void, so this is actually a success
+    if (err.GetError() == UserExpression::kNoResult) {
+      if (log)
+        log->Printf("%s - expression returned void.", __FUNCTION__);
 
-    if (!expr_result)
-    {
-        if (log)
-            log->Printf("%s: couldn't evaluate expression.", __FUNCTION__);
-        return false;
+      result = nullptr;
+      return true;
     }
 
-    // The result of the expression is invalid
-    if (!expr_result->GetError().Success())
-    {
-        Error err = expr_result->GetError();
-        if (err.GetError() == UserExpression::kNoResult) // Expression returned void, so this is actually a success
-        {
-            if (log)
-                log->Printf("%s - expression returned void.", __FUNCTION__);
-
-            result = nullptr;
-            return true;
-        }
-
-        if (log)
-            log->Printf("%s - error evaluating expression result: %s", __FUNCTION__,
-                        err.AsCString());
-        return false;
-    }
+    if (log)
+      log->Printf("%s - error evaluating expression result: %s", __FUNCTION__,
+                  err.AsCString());
+    return false;
+  }
 
-    bool success = false;
-    *result = expr_result->GetValueAsUnsigned(0, &success); // We only read the result as an uint32_t.
+  bool success = false;
+  // We only read the result as an uint32_t.
+  *result = expr_result->GetValueAsUnsigned(0, &success);
 
-    if (!success)
-    {
-        if (log)
-            log->Printf("%s - couldn't convert expression result to uint32_t", __FUNCTION__);
-        return false;
-    }
+  if (!success) {
+    if (log)
+      log->Printf("%s - couldn't convert expression result to uint32_t",
+                  __FUNCTION__);
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
-namespace
-{
+namespace {
 // Used to index expression format strings
-enum ExpressionStrings
-{
-   eExprGetOffsetPtr = 0,
-   eExprAllocGetType,
-   eExprTypeDimX,
-   eExprTypeDimY,
-   eExprTypeDimZ,
-   eExprTypeElemPtr,
-   eExprElementType,
-   eExprElementKind,
-   eExprElementVec,
-   eExprElementFieldCount,
-   eExprSubelementsId,
-   eExprSubelementsName,
-   eExprSubelementsArrSize,
-
-   _eExprLast // keep at the end, implicit size of the array runtimeExpressions
+enum ExpressionStrings {
+  eExprGetOffsetPtr = 0,
+  eExprAllocGetType,
+  eExprTypeDimX,
+  eExprTypeDimY,
+  eExprTypeDimZ,
+  eExprTypeElemPtr,
+  eExprElementType,
+  eExprElementKind,
+  eExprElementVec,
+  eExprElementFieldCount,
+  eExprSubelementsId,
+  eExprSubelementsName,
+  eExprSubelementsArrSize,
+
+  _eExprLast // keep at the end, implicit size of the array runtime_expressions
 };
 
 // max length of an expanded expression
 const int jit_max_expr_size = 512;
 
 // Retrieve the string to JIT for the given expression
-const char*
-JITTemplate(ExpressionStrings e)
-{
-    // Format strings containing the expressions we may need to evaluate.
-    static std::array<const char*, _eExprLast> runtimeExpressions = {{
-     // Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap)
-     "(int*)_Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocationCubemapFace"
-     "(0x%" PRIx64 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", 0, 0)",
-
-     // Type* rsaAllocationGetType(Context*, Allocation*)
-     "(void*)rsaAllocationGetType(0x%" PRIx64 ", 0x%" PRIx64 ")",
-
-     // rsaTypeGetNativeData(Context*, Type*, void* typeData, size)
-     // Pack the data in the following way mHal.state.dimX; mHal.state.dimY; mHal.state.dimZ;
-     // mHal.state.lodCount; mHal.state.faces; mElement; into typeData
-     // Need to specify 32 or 64 bit for uint_t since this differs between devices
-     "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[0]", // X dim
-     "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[1]", // Y dim
-     "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[2]", // Z dim
-     "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 6); data[5]", // Element ptr
-
-     // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
-     // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into elemData
-     "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[0]", // Type
-     "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[1]", // Kind
-     "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[3]", // Vector Size
-     "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64 ", 0x%" PRIx64 ", data, 5); data[4]", // Field Count
-
-     // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t *ids, const char **names,
-     // size_t *arraySizes, uint32_t dataSize)
-     // Needed for Allocations of structs to gather details about fields/Subelements
-     // Element* of field
-     "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 "]; size_t arr_size[%" PRIu32 "];"
-     "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64 ", ids, names, arr_size, %" PRIu32 "); ids[%" PRIu32 "]",
-
-     // Name of field
-     "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 "]; size_t arr_size[%" PRIu32 "];"
-     "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64 ", ids, names, arr_size, %" PRIu32 "); names[%" PRIu32 "]",
-
-     // Array size of field
-     "void* ids[%" PRIu32 "]; const char* names[%" PRIu32 "]; size_t arr_size[%" PRIu32 "];"
-     "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64 ", ids, names, arr_size, %" PRIu32 "); arr_size[%" PRIu32 "]"
-    }};
-
-    return runtimeExpressions[e];
+const char *JITTemplate(ExpressionStrings e) {
+  // Format strings containing the expressions we may need to evaluate.
+  static std::array<const char *, _eExprLast> runtime_expressions = {
+      {// Mangled GetOffsetPointer(Allocation*, xoff, yoff, zoff, lod, cubemap)
+       "(int*)_"
+       "Z12GetOffsetPtrPKN7android12renderscript10AllocationEjjjj23RsAllocation"
+       "CubemapFace"
+       "(0x%" PRIx64 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", 0, 0)",
+
+       // Type* rsaAllocationGetType(Context*, Allocation*)
+       "(void*)rsaAllocationGetType(0x%" PRIx64 ", 0x%" PRIx64 ")",
+
+       // rsaTypeGetNativeData(Context*, Type*, void* typeData, size) Pack the
+       // data in the following way mHal.state.dimX; mHal.state.dimY;
+       // mHal.state.dimZ; mHal.state.lodCount; mHal.state.faces; mElement; into
+       // typeData Need to specify 32 or 64 bit for uint_t since this differs
+       // between devices
+       "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 6); data[0]", // X dim
+       "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 6); data[1]", // Y dim
+       "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 6); data[2]", // Z dim
+       "uint%" PRIu32 "_t data[6]; (void*)rsaTypeGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 6); data[5]", // Element ptr
+
+       // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
+       // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into
+       // elemData
+       "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 5); data[0]", // Type
+       "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 5); data[1]", // Kind
+       "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 5); data[3]", // Vector Size
+       "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%" PRIx64
+       ", 0x%" PRIx64 ", data, 5); data[4]", // Field Count
+
+       // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t
+       // *ids, const char **names, size_t *arraySizes, uint32_t dataSize)
+       // Needed for Allocations of structs to gather details about
+       // fields/Subelements Element* of field
+       "void* ids[%" PRIu32 "]; const char* names[%" PRIu32
+       "]; size_t arr_size[%" PRIu32 "];"
+       "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64
+       ", ids, names, arr_size, %" PRIu32 "); ids[%" PRIu32 "]",
+
+       // Name of field
+       "void* ids[%" PRIu32 "]; const char* names[%" PRIu32
+       "]; size_t arr_size[%" PRIu32 "];"
+       "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64
+       ", ids, names, arr_size, %" PRIu32 "); names[%" PRIu32 "]",
+
+       // Array size of field
+       "void* ids[%" PRIu32 "]; const char* names[%" PRIu32
+       "]; size_t arr_size[%" PRIu32 "];"
+       "(void*)rsaElementGetSubElements(0x%" PRIx64 ", 0x%" PRIx64
+       ", ids, names, arr_size, %" PRIu32 "); arr_size[%" PRIu32 "]"}};
+
+  return runtime_expressions[e];
 }
 } // end of the anonymous namespace
 
+// JITs the RS runtime for the internal data pointer of an allocation. Is passed
+// x,y,z coordinates for the pointer to a specific element. Then sets the
+// data_ptr member in Allocation with the result. Returns true on success, false
+// otherwise
+bool RenderScriptRuntime::JITDataPointer(AllocationDetails *alloc,
+                                         StackFrame *frame_ptr, uint32_t x,
+                                         uint32_t y, uint32_t z) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-// JITs the RS runtime for the internal data pointer of an allocation.
-// Is passed x,y,z coordinates for the pointer to a specific element.
-// Then sets the data_ptr member in Allocation with the result.
-// Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITDataPointer(AllocationDetails *allocation, StackFrame *frame_ptr, uint32_t x,
-                                    uint32_t y, uint32_t z)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    if (!allocation->address.isValid())
-    {
-        if (log)
-            log->Printf("%s - failed to find allocation details.", __FUNCTION__);
-        return false;
-    }
+  if (!alloc->address.isValid()) {
+    if (log)
+      log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
 
-    const char *expr_cstr = JITTemplate(eExprGetOffsetPtr);
-    char buffer[jit_max_expr_size];
+  const char *fmt_str = JITTemplate(eExprGetOffsetPtr);
+  char expr_buf[jit_max_expr_size];
 
-    int chars_written = snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->address.get(), x, y, z);
-    if (chars_written < 0)
-    {
-        if (log)
-            log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-        return false;
-    }
-    else if (chars_written >= jit_max_expr_size)
-    {
-        if (log)
-            log->Printf("%s - expression too long.", __FUNCTION__);
-        return false;
-    }
+  int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
+                         *alloc->address.get(), x, y, z);
+  if (written < 0) {
+    if (log)
+      log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
+    return false;
+  } else if (written >= jit_max_expr_size) {
+    if (log)
+      log->Printf("%s - expression too long.", __FUNCTION__);
+    return false;
+  }
 
-    uint64_t result = 0;
-    if (!EvalRSExpression(buffer, frame_ptr, &result))
-        return false;
+  uint64_t result = 0;
+  if (!EvalRSExpression(expr_buf, frame_ptr, &result))
+    return false;
 
-    addr_t mem_ptr = static_cast<lldb::addr_t>(result);
-    allocation->data_ptr = mem_ptr;
+  addr_t data_ptr = static_cast<lldb::addr_t>(result);
+  alloc->data_ptr = data_ptr;
 
-    return true;
+  return true;
 }
 
 // JITs the RS runtime for the internal pointer to the RS Type of an allocation
-// Then sets the type_ptr member in Allocation with the result.
-// Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITTypePointer(AllocationDetails *allocation, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+// Then sets the type_ptr member in Allocation with the result. Returns true on
+// success, false otherwise
+bool RenderScriptRuntime::JITTypePointer(AllocationDetails *alloc,
+                                         StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    if (!allocation->address.isValid() || !allocation->context.isValid())
-    {
-        if (log)
-            log->Printf("%s - failed to find allocation details.", __FUNCTION__);
-        return false;
-    }
+  if (!alloc->address.isValid() || !alloc->context.isValid()) {
+    if (log)
+      log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
 
-    const char *expr_cstr = JITTemplate(eExprAllocGetType);
-    char buffer[jit_max_expr_size];
+  const char *fmt_str = JITTemplate(eExprAllocGetType);
+  char expr_buf[jit_max_expr_size];
 
-    int chars_written =
-        snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->context.get(), *allocation->address.get());
-    if (chars_written < 0)
-    {
-        if (log)
-            log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-        return false;
-    }
-    else if (chars_written >= jit_max_expr_size)
-    {
-        if (log)
-            log->Printf("%s - expression too long.", __FUNCTION__);
-        return false;
-    }
+  int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
+                         *alloc->context.get(), *alloc->address.get());
+  if (written < 0) {
+    if (log)
+      log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
+    return false;
+  } else if (written >= jit_max_expr_size) {
+    if (log)
+      log->Printf("%s - expression too long.", __FUNCTION__);
+    return false;
+  }
 
-    uint64_t result = 0;
-    if (!EvalRSExpression(buffer, frame_ptr, &result))
-        return false;
+  uint64_t result = 0;
+  if (!EvalRSExpression(expr_buf, frame_ptr, &result))
+    return false;
 
-    addr_t type_ptr = static_cast<lldb::addr_t>(result);
-    allocation->type_ptr = type_ptr;
+  addr_t type_ptr = static_cast<lldb::addr_t>(result);
+  alloc->type_ptr = type_ptr;
 
-    return true;
+  return true;
 }
 
-// JITs the RS runtime for information about the dimensions and type of an allocation
-// Then sets dimension and element_ptr members in Allocation with the result.
-// Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITTypePacked(AllocationDetails *allocation, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    if (!allocation->type_ptr.isValid() || !allocation->context.isValid())
-    {
-        if (log)
-            log->Printf("%s - Failed to find allocation details.", __FUNCTION__);
-        return false;
-    }
-
-    // Expression is different depending on if device is 32 or 64 bit
-    uint32_t archByteSize = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
-    const uint32_t bits = archByteSize == 4 ? 32 : 64;
-
-    // We want 4 elements from packed data
-    const uint32_t num_exprs = 4;
-    assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) && "Invalid number of expressions");
-
-    char buffer[num_exprs][jit_max_expr_size];
-    uint64_t results[num_exprs];
-
-    for (uint32_t i = 0; i < num_exprs; ++i)
-    {
-        const char *expr_cstr = JITTemplate(ExpressionStrings(eExprTypeDimX + i));
-        int chars_written = snprintf(buffer[i], jit_max_expr_size, expr_cstr, bits, *allocation->context.get(),
-                                     *allocation->type_ptr.get());
-        if (chars_written < 0)
-        {
-            if (log)
-                log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-            return false;
-        }
-        else if (chars_written >= jit_max_expr_size)
-        {
-            if (log)
-                log->Printf("%s - expression too long.", __FUNCTION__);
-            return false;
-        }
-
-        // Perform expression evaluation
-        if (!EvalRSExpression(buffer[i], frame_ptr, &results[i]))
-            return false;
-    }
-
-    // Assign results to allocation members
-    AllocationDetails::Dimension dims;
-    dims.dim_1 = static_cast<uint32_t>(results[0]);
-    dims.dim_2 = static_cast<uint32_t>(results[1]);
-    dims.dim_3 = static_cast<uint32_t>(results[2]);
-    allocation->dimension = dims;
-
-    addr_t elem_ptr = static_cast<lldb::addr_t>(results[3]);
-    allocation->element.element_ptr = elem_ptr;
+// JITs the RS runtime for information about the dimensions and type of an
+// allocation Then sets dimension and element_ptr members in Allocation with the
+// result. Returns true on success, false otherwise
+bool RenderScriptRuntime::JITTypePacked(AllocationDetails *alloc,
+                                        StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
+  if (!alloc->type_ptr.isValid() || !alloc->context.isValid()) {
     if (log)
-        log->Printf("%s - dims (%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") Element*: 0x%" PRIx64 ".", __FUNCTION__,
-                    dims.dim_1, dims.dim_2, dims.dim_3, elem_ptr);
-
-    return true;
+      log->Printf("%s - Failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
+
+  // Expression is different depending on if device is 32 or 64 bit
+  uint32_t target_ptr_size =
+      GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
+  const uint32_t bits = target_ptr_size == 4 ? 32 : 64;
+
+  // We want 4 elements from packed data
+  const uint32_t num_exprs = 4;
+  assert(num_exprs == (eExprTypeElemPtr - eExprTypeDimX + 1) &&
+         "Invalid number of expressions");
+
+  char expr_bufs[num_exprs][jit_max_expr_size];
+  uint64_t results[num_exprs];
+
+  for (uint32_t i = 0; i < num_exprs; ++i) {
+    const char *fmt_str = JITTemplate(ExpressionStrings(eExprTypeDimX + i));
+    int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, bits,
+                           *alloc->context.get(), *alloc->type_ptr.get());
+    if (written < 0) {
+      if (log)
+        log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
+      return false;
+    } else if (written >= jit_max_expr_size) {
+      if (log)
+        log->Printf("%s - expression too long.", __FUNCTION__);
+      return false;
+    }
+
+    // Perform expression evaluation
+    if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i]))
+      return false;
+  }
+
+  // Assign results to allocation members
+  AllocationDetails::Dimension dims;
+  dims.dim_1 = static_cast<uint32_t>(results[0]);
+  dims.dim_2 = static_cast<uint32_t>(results[1]);
+  dims.dim_3 = static_cast<uint32_t>(results[2]);
+  alloc->dimension = dims;
+
+  addr_t element_ptr = static_cast<lldb::addr_t>(results[3]);
+  alloc->element.element_ptr = element_ptr;
+
+  if (log)
+    log->Printf("%s - dims (%" PRIu32 ", %" PRIu32 ", %" PRIu32
+                ") Element*: 0x%" PRIx64 ".",
+                __FUNCTION__, dims.dim_1, dims.dim_2, dims.dim_3, element_ptr);
+
+  return true;
 }
 
-// JITs the RS runtime for information about the Element of an allocation
-// Then sets type, type_vec_size, field_count and type_kind members in Element with the result.
-// Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITElementPacked(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    if (!elem.element_ptr.isValid())
-    {
-        if (log)
-            log->Printf("%s - failed to find allocation details.", __FUNCTION__);
-        return false;
-    }
-
-    // We want 4 elements from packed data
-    const uint32_t num_exprs = 4;
-    assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1) && "Invalid number of expressions");
-
-    char buffer[num_exprs][jit_max_expr_size];
-    uint64_t results[num_exprs];
-
-    for (uint32_t i = 0; i < num_exprs; i++)
-    {
-        const char *expr_cstr = JITTemplate(ExpressionStrings(eExprElementType + i));
-        int chars_written = snprintf(buffer[i], jit_max_expr_size, expr_cstr, context, *elem.element_ptr.get());
-        if (chars_written < 0)
-        {
-            if (log)
-                log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-            return false;
-        }
-        else if (chars_written >= jit_max_expr_size)
-        {
-            if (log)
-                log->Printf("%s - expression too long.", __FUNCTION__);
-            return false;
-        }
-
-        // Perform expression evaluation
-        if (!EvalRSExpression(buffer[i], frame_ptr, &results[i]))
-            return false;
-    }
-
-    // Assign results to allocation members
-    elem.type = static_cast<RenderScriptRuntime::Element::DataType>(results[0]);
-    elem.type_kind = static_cast<RenderScriptRuntime::Element::DataKind>(results[1]);
-    elem.type_vec_size = static_cast<uint32_t>(results[2]);
-    elem.field_count = static_cast<uint32_t>(results[3]);
+// JITs the RS runtime for information about the Element of an allocation Then
+// sets type, type_vec_size, field_count and type_kind members in Element with
+// the result. Returns true on success, false otherwise
+bool RenderScriptRuntime::JITElementPacked(Element &elem,
+                                           const lldb::addr_t context,
+                                           StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
+  if (!elem.element_ptr.isValid()) {
     if (log)
-        log->Printf("%s - data type %" PRIu32 ", pixel type %" PRIu32 ", vector size %" PRIu32 ", field count %" PRIu32,
-                    __FUNCTION__, *elem.type.get(), *elem.type_kind.get(), *elem.type_vec_size.get(), *elem.field_count.get());
-
-    // If this Element has subelements then JIT rsaElementGetSubElements() for details about its fields
-    if (*elem.field_count.get() > 0 && !JITSubelements(elem, context, frame_ptr))
-        return false;
+      log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
+
+  // We want 4 elements from packed data
+  const uint32_t num_exprs = 4;
+  assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1) &&
+         "Invalid number of expressions");
+
+  char expr_bufs[num_exprs][jit_max_expr_size];
+  uint64_t results[num_exprs];
+
+  for (uint32_t i = 0; i < num_exprs; i++) {
+    const char *fmt_str = JITTemplate(ExpressionStrings(eExprElementType + i));
+    int written = snprintf(expr_bufs[i], jit_max_expr_size, fmt_str, context,
+                           *elem.element_ptr.get());
+    if (written < 0) {
+      if (log)
+        log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
+      return false;
+    } else if (written >= jit_max_expr_size) {
+      if (log)
+        log->Printf("%s - expression too long.", __FUNCTION__);
+      return false;
+    }
+
+    // Perform expression evaluation
+    if (!EvalRSExpression(expr_bufs[i], frame_ptr, &results[i]))
+      return false;
+  }
+
+  // Assign results to allocation members
+  elem.type = static_cast<RenderScriptRuntime::Element::DataType>(results[0]);
+  elem.type_kind =
+      static_cast<RenderScriptRuntime::Element::DataKind>(results[1]);
+  elem.type_vec_size = static_cast<uint32_t>(results[2]);
+  elem.field_count = static_cast<uint32_t>(results[3]);
+
+  if (log)
+    log->Printf("%s - data type %" PRIu32 ", pixel type %" PRIu32
+                ", vector size %" PRIu32 ", field count %" PRIu32,
+                __FUNCTION__, *elem.type.get(), *elem.type_kind.get(),
+                *elem.type_vec_size.get(), *elem.field_count.get());
+
+  // If this Element has subelements then JIT rsaElementGetSubElements() for
+  // details about its fields
+  if (*elem.field_count.get() > 0 && !JITSubelements(elem, context, frame_ptr))
+    return false;
 
-    return true;
+  return true;
 }
 
-// JITs the RS runtime for information about the subelements/fields of a struct allocation
-// This is necessary for infering the struct type so we can pretty print the allocation's contents.
-// Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITSubelements(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+// JITs the RS runtime for information about the subelements/fields of a struct
+// allocation This is necessary for infering the struct type so we can pretty
+// print the allocation's contents. Returns true on success, false otherwise
+bool RenderScriptRuntime::JITSubelements(Element &elem,
+                                         const lldb::addr_t context,
+                                         StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    if (!elem.element_ptr.isValid() || !elem.field_count.isValid())
-    {
+  if (!elem.element_ptr.isValid() || !elem.field_count.isValid()) {
+    if (log)
+      log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
+
+  const short num_exprs = 3;
+  assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1) &&
+         "Invalid number of expressions");
+
+  char expr_buffer[jit_max_expr_size];
+  uint64_t results;
+
+  // Iterate over struct fields.
+  const uint32_t field_count = *elem.field_count.get();
+  for (uint32_t field_index = 0; field_index < field_count; ++field_index) {
+    Element child;
+    for (uint32_t expr_index = 0; expr_index < num_exprs; ++expr_index) {
+      const char *fmt_str =
+          JITTemplate(ExpressionStrings(eExprSubelementsId + expr_index));
+      int written = snprintf(expr_buffer, jit_max_expr_size, fmt_str,
+                             field_count, field_count, field_count, context,
+                             *elem.element_ptr.get(), field_count, field_index);
+      if (written < 0) {
         if (log)
-            log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+          log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
         return false;
-    }
-
-    const short num_exprs = 3;
-    assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId + 1) && "Invalid number of expressions");
-
-    char expr_buffer[jit_max_expr_size];
-    uint64_t results;
+      } else if (written >= jit_max_expr_size) {
+        if (log)
+          log->Printf("%s - expression too long.", __FUNCTION__);
+        return false;
+      }
 
-    // Iterate over struct fields.
-    const uint32_t field_count = *elem.field_count.get();
-    for (uint32_t field_index = 0; field_index < field_count; ++field_index)
-    {
-        Element child;
-        for (uint32_t expr_index = 0; expr_index < num_exprs; ++expr_index)
-        {
-            const char *expr_cstr = JITTemplate(ExpressionStrings(eExprSubelementsId + expr_index));
-            int chars_written = snprintf(expr_buffer, jit_max_expr_size, expr_cstr,
-                                         field_count, field_count, field_count,
-                                         context, *elem.element_ptr.get(), field_count, field_index);
-            if (chars_written < 0)
-            {
-                if (log)
-                    log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-                return false;
-            }
-            else if (chars_written >= jit_max_expr_size)
-            {
-                if (log)
-                    log->Printf("%s - expression too long.", __FUNCTION__);
-                return false;
-            }
-
-            // Perform expression evaluation
-            if (!EvalRSExpression(expr_buffer, frame_ptr, &results))
-                return false;
+      // Perform expression evaluation
+      if (!EvalRSExpression(expr_buffer, frame_ptr, &results))
+        return false;
 
-            if (log)
-                log->Printf("%s - expr result 0x%" PRIx64 ".", __FUNCTION__, results);
-
-            switch (expr_index)
-            {
-                case 0: // Element* of child
-                    child.element_ptr = static_cast<addr_t>(results);
-                    break;
-                case 1: // Name of child
-                {
-                    lldb::addr_t address = static_cast<addr_t>(results);
-                    Error err;
-                    std::string name;
-                    GetProcess()->ReadCStringFromMemory(address, name, err);
-                    if (!err.Fail())
-                        child.type_name = ConstString(name);
-                    else
-                    {
-                        if (log)
-                            log->Printf("%s - warning: Couldn't read field name.", __FUNCTION__);
-                    }
-                    break;
-                }
-                case 2: // Array size of child
-                    child.array_size = static_cast<uint32_t>(results);
-                    break;
-            }
+      if (log)
+        log->Printf("%s - expr result 0x%" PRIx64 ".", __FUNCTION__, results);
+
+      switch (expr_index) {
+      case 0: // Element* of child
+        child.element_ptr = static_cast<addr_t>(results);
+        break;
+      case 1: // Name of child
+      {
+        lldb::addr_t address = static_cast<addr_t>(results);
+        Error err;
+        std::string name;
+        GetProcess()->ReadCStringFromMemory(address, name, err);
+        if (!err.Fail())
+          child.type_name = ConstString(name);
+        else {
+          if (log)
+            log->Printf("%s - warning: Couldn't read field name.",
+                        __FUNCTION__);
         }
-
-        // We need to recursively JIT each Element field of the struct since
-        // structs can be nested inside structs.
-        if (!JITElementPacked(child, context, frame_ptr))
-            return false;
-        elem.children.push_back(child);
-    }
-
-    // Try to infer the name of the struct type so we can pretty print the allocation contents.
-    FindStructTypeName(elem, frame_ptr);
-
-    return true;
+        break;
+      }
+      case 2: // Array size of child
+        child.array_size = static_cast<uint32_t>(results);
+        break;
+      }
+    }
+
+    // We need to recursively JIT each Element field of the struct since
+    // structs can be nested inside structs.
+    if (!JITElementPacked(child, context, frame_ptr))
+      return false;
+    elem.children.push_back(child);
+  }
+
+  // Try to infer the name of the struct type so we can pretty print the
+  // allocation contents.
+  FindStructTypeName(elem, frame_ptr);
+
+  return true;
 }
 
 // JITs the RS runtime for the address of the last element in the allocation.
-// The `elem_size` paramter represents the size of a single element, including padding.
-// Which is needed as an offset from the last element pointer.
-// Using this offset minus the starting address we can calculate the size of the allocation.
-// Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITAllocationSize(AllocationDetails *allocation, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    if (!allocation->address.isValid() || !allocation->dimension.isValid() || !allocation->data_ptr.isValid() ||
-        !allocation->element.datum_size.isValid())
-    {
-        if (log)
-            log->Printf("%s - failed to find allocation details.", __FUNCTION__);
-        return false;
-    }
-
-    // Find dimensions
-    uint32_t dim_x = allocation->dimension.get()->dim_1;
-    uint32_t dim_y = allocation->dimension.get()->dim_2;
-    uint32_t dim_z = allocation->dimension.get()->dim_3;
-
-    // Our plan of jitting the last element address doesn't seem to work for struct Allocations
-    // Instead try to infer the size ourselves without any inter element padding.
-    if (allocation->element.children.size() > 0)
-    {
-        if (dim_x == 0) dim_x = 1;
-        if (dim_y == 0) dim_y = 1;
-        if (dim_z == 0) dim_z = 1;
-
-        allocation->size = dim_x * dim_y * dim_z * *allocation->element.datum_size.get();
+// The `elem_size` parameter represents the size of a single element, including
+// padding. Which is needed as an offset from the last element pointer. Using
+// this offset minus the starting address we can calculate the size of the
+// allocation. Returns true on success, false otherwise
+bool RenderScriptRuntime::JITAllocationSize(AllocationDetails *alloc,
+                                            StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  if (!alloc->address.isValid() || !alloc->dimension.isValid() ||
+      !alloc->data_ptr.isValid() || !alloc->element.datum_size.isValid()) {
+    if (log)
+      log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
+
+  // Find dimensions
+  uint32_t dim_x = alloc->dimension.get()->dim_1;
+  uint32_t dim_y = alloc->dimension.get()->dim_2;
+  uint32_t dim_z = alloc->dimension.get()->dim_3;
+
+  // Our plan of jitting the last element address doesn't seem to work for
+  // struct Allocations` Instead try to infer the size ourselves without any
+  // inter element padding.
+  if (alloc->element.children.size() > 0) {
+    if (dim_x == 0)
+      dim_x = 1;
+    if (dim_y == 0)
+      dim_y = 1;
+    if (dim_z == 0)
+      dim_z = 1;
+
+    alloc->size = dim_x * dim_y * dim_z * *alloc->element.datum_size.get();
 
-        if (log)
-            log->Printf("%s - infered size of struct allocation %" PRIu32 ".", __FUNCTION__,
-                        *allocation->size.get());
-        return true;
-    }
+    if (log)
+      log->Printf("%s - inferred size of struct allocation %" PRIu32 ".",
+                  __FUNCTION__, *alloc->size.get());
+    return true;
+  }
 
-    const char *expr_cstr = JITTemplate(eExprGetOffsetPtr);
-    char buffer[jit_max_expr_size];
+  const char *fmt_str = JITTemplate(eExprGetOffsetPtr);
+  char expr_buf[jit_max_expr_size];
 
-    // Calculate last element
-    dim_x = dim_x == 0 ? 0 : dim_x - 1;
-    dim_y = dim_y == 0 ? 0 : dim_y - 1;
-    dim_z = dim_z == 0 ? 0 : dim_z - 1;
+  // Calculate last element
+  dim_x = dim_x == 0 ? 0 : dim_x - 1;
+  dim_y = dim_y == 0 ? 0 : dim_y - 1;
+  dim_z = dim_z == 0 ? 0 : dim_z - 1;
 
-    int chars_written = snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->address.get(), dim_x, dim_y, dim_z);
-    if (chars_written < 0)
-    {
-        if (log)
-            log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-        return false;
-    }
-    else if (chars_written >= jit_max_expr_size)
-    {
-        if (log)
-            log->Printf("%s - expression too long.", __FUNCTION__);
-        return false;
-    }
+  int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
+                         *alloc->address.get(), dim_x, dim_y, dim_z);
+  if (written < 0) {
+    if (log)
+      log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
+    return false;
+  } else if (written >= jit_max_expr_size) {
+    if (log)
+      log->Printf("%s - expression too long.", __FUNCTION__);
+    return false;
+  }
 
-    uint64_t result = 0;
-    if (!EvalRSExpression(buffer, frame_ptr, &result))
-        return false;
+  uint64_t result = 0;
+  if (!EvalRSExpression(expr_buf, frame_ptr, &result))
+    return false;
 
-    addr_t mem_ptr = static_cast<lldb::addr_t>(result);
-    // Find pointer to last element and add on size of an element
-    allocation->size =
-        static_cast<uint32_t>(mem_ptr - *allocation->data_ptr.get()) + *allocation->element.datum_size.get();
+  addr_t mem_ptr = static_cast<lldb::addr_t>(result);
+  // Find pointer to last element and add on size of an element
+  alloc->size = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get()) +
+                *alloc->element.datum_size.get();
 
-    return true;
+  return true;
 }
 
-// JITs the RS runtime for information about the stride between rows in the allocation.
-// This is done to detect padding, since allocated memory is 16-byte aligned.
+// JITs the RS runtime for information about the stride between rows in the
+// allocation. This is done to detect padding, since allocated memory is 16-byte
+// aligned.
 // Returns true on success, false otherwise
-bool
-RenderScriptRuntime::JITAllocationStride(AllocationDetails *allocation, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+bool RenderScriptRuntime::JITAllocationStride(AllocationDetails *alloc,
+                                              StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    if (!allocation->address.isValid() || !allocation->data_ptr.isValid())
-    {
-        if (log)
-            log->Printf("%s - failed to find allocation details.", __FUNCTION__);
-        return false;
-    }
+  if (!alloc->address.isValid() || !alloc->data_ptr.isValid()) {
+    if (log)
+      log->Printf("%s - failed to find allocation details.", __FUNCTION__);
+    return false;
+  }
 
-    const char *expr_cstr = JITTemplate(eExprGetOffsetPtr);
-    char buffer[jit_max_expr_size];
+  const char *fmt_str = JITTemplate(eExprGetOffsetPtr);
+  char expr_buf[jit_max_expr_size];
 
-    int chars_written = snprintf(buffer, jit_max_expr_size, expr_cstr, *allocation->address.get(), 0, 1, 0);
-    if (chars_written < 0)
-    {
-        if (log)
-            log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
-        return false;
-    }
-    else if (chars_written >= jit_max_expr_size)
-    {
-        if (log)
-            log->Printf("%s - expression too long.", __FUNCTION__);
-        return false;
-    }
+  int written = snprintf(expr_buf, jit_max_expr_size, fmt_str,
+                         *alloc->address.get(), 0, 1, 0);
+  if (written < 0) {
+    if (log)
+      log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
+    return false;
+  } else if (written >= jit_max_expr_size) {
+    if (log)
+      log->Printf("%s - expression too long.", __FUNCTION__);
+    return false;
+  }
 
-    uint64_t result = 0;
-    if (!EvalRSExpression(buffer, frame_ptr, &result))
-        return false;
+  uint64_t result = 0;
+  if (!EvalRSExpression(expr_buf, frame_ptr, &result))
+    return false;
 
-    addr_t mem_ptr = static_cast<lldb::addr_t>(result);
-    allocation->stride = static_cast<uint32_t>(mem_ptr - *allocation->data_ptr.get());
+  addr_t mem_ptr = static_cast<lldb::addr_t>(result);
+  alloc->stride = static_cast<uint32_t>(mem_ptr - *alloc->data_ptr.get());
 
-    return true;
+  return true;
 }
 
 // JIT all the current runtime info regarding an allocation
-bool
-RenderScriptRuntime::RefreshAllocation(AllocationDetails *allocation, StackFrame *frame_ptr)
-{
-    // GetOffsetPointer()
-    if (!JITDataPointer(allocation, frame_ptr))
-        return false;
+bool RenderScriptRuntime::RefreshAllocation(AllocationDetails *alloc,
+                                            StackFrame *frame_ptr) {
+  // GetOffsetPointer()
+  if (!JITDataPointer(alloc, frame_ptr))
+    return false;
 
-    // rsaAllocationGetType()
-    if (!JITTypePointer(allocation, frame_ptr))
-        return false;
+  // rsaAllocationGetType()
+  if (!JITTypePointer(alloc, frame_ptr))
+    return false;
 
-    // rsaTypeGetNativeData()
-    if (!JITTypePacked(allocation, frame_ptr))
-        return false;
+  // rsaTypeGetNativeData()
+  if (!JITTypePacked(alloc, frame_ptr))
+    return false;
 
-    // rsaElementGetNativeData()
-    if (!JITElementPacked(allocation->element, *allocation->context.get(), frame_ptr))
-        return false;
+  // rsaElementGetNativeData()
+  if (!JITElementPacked(alloc->element, *alloc->context.get(), frame_ptr))
+    return false;
 
-    // Sets the datum_size member in Element
-    SetElementSize(allocation->element);
+  // Sets the datum_size member in Element
+  SetElementSize(alloc->element);
 
-    // Use GetOffsetPointer() to infer size of the allocation
-    if (!JITAllocationSize(allocation, frame_ptr))
-        return false;
+  // Use GetOffsetPointer() to infer size of the allocation
+  if (!JITAllocationSize(alloc, frame_ptr))
+    return false;
 
-    return true;
+  return true;
 }
 
-// Function attempts to set the type_name member of the paramaterised Element object.
+// Function attempts to set the type_name member of the paramaterised Element
+// object.
 // This string should be the name of the struct type the Element represents.
 // We need this string for pretty printing the Element to users.
-void
-RenderScriptRuntime::FindStructTypeName(Element &elem, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    if (!elem.type_name.IsEmpty()) // Name already set
-        return;
-    else
-        elem.type_name = Element::GetFallbackStructName(); // Default type name if we don't succeed
-
-    // Find all the global variables from the script rs modules
-    VariableList variable_list;
-    for (auto module_sp : m_rsmodules)
-        module_sp->m_module->FindGlobalVariables(RegularExpression("."), true, UINT32_MAX, variable_list);
-
-    // Iterate over all the global variables looking for one with a matching type to the Element.
-    // We make the assumption a match exists since there needs to be a global variable to reflect the
-    // struct type back into java host code.
-    for (uint32_t var_index = 0; var_index < variable_list.GetSize(); ++var_index)
-    {
-        const VariableSP var_sp(variable_list.GetVariableAtIndex(var_index));
-        if (!var_sp)
-            continue;
-
-        ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp);
-        if (!valobj_sp)
-            continue;
-
-        // Find the number of variable fields.
-        // If it has no fields, or more fields than our Element, then it can't be the struct we're looking for.
-        // Don't check for equality since RS can add extra struct members for padding.
-        size_t num_children = valobj_sp->GetNumChildren();
-        if (num_children > elem.children.size() || num_children == 0)
-            continue;
-
-        // Iterate over children looking for members with matching field names.
-        // If all the field names match, this is likely the struct we want.
-        //
-        //   TODO: This could be made more robust by also checking children data sizes, or array size
-        bool found = true;
-        for (size_t child_index = 0; child_index < num_children; ++child_index)
-        {
-            ValueObjectSP child = valobj_sp->GetChildAtIndex(child_index, true);
-            if (!child || (child->GetName() != elem.children[child_index].type_name))
-            {
-                found = false;
-                break;
-            }
-        }
-
-        // RS can add extra struct members for padding in the format '#rs_padding_[0-9]+'
-        if (found && num_children < elem.children.size())
-        {
-            const uint32_t size_diff = elem.children.size() - num_children;
-            if (log)
-                log->Printf("%s - %" PRIu32 " padding struct entries", __FUNCTION__, size_diff);
-
-            for (uint32_t padding_index = 0; padding_index < size_diff; ++padding_index)
-            {
-                const ConstString &name = elem.children[num_children + padding_index].type_name;
-                if (strcmp(name.AsCString(), "#rs_padding") < 0)
-                    found = false;
-            }
-        }
-
-        // We've found a global var with matching type
-        if (found)
-        {
-            // Dereference since our Element type isn't a pointer.
-            if (valobj_sp->IsPointerType())
-            {
-                Error err;
-                ValueObjectSP deref_valobj = valobj_sp->Dereference(err);
-                if (!err.Fail())
-                    valobj_sp = deref_valobj;
-            }
-
-            // Save name of variable in Element.
-            elem.type_name = valobj_sp->GetTypeName();
-            if (log)
-                log->Printf("%s - element name set to %s", __FUNCTION__, elem.type_name.AsCString());
-
-            return;
-        }
-    }
+void RenderScriptRuntime::FindStructTypeName(Element &elem,
+                                             StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  if (!elem.type_name.IsEmpty()) // Name already set
+    return;
+  else
+    elem.type_name = Element::GetFallbackStructName(); // Default type name if
+                                                       // we don't succeed
+
+  // Find all the global variables from the script rs modules
+  VariableList var_list;
+  for (auto module_sp : m_rsmodules)
+    module_sp->m_module->FindGlobalVariables(
+        RegularExpression(llvm::StringRef(".")), true, UINT32_MAX, var_list);
+
+  // Iterate over all the global variables looking for one with a matching type
+  // to the Element.
+  // We make the assumption a match exists since there needs to be a global
+  // variable to reflect the struct type back into java host code.
+  for (uint32_t i = 0; i < var_list.GetSize(); ++i) {
+    const VariableSP var_sp(var_list.GetVariableAtIndex(i));
+    if (!var_sp)
+      continue;
+
+    ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr, var_sp);
+    if (!valobj_sp)
+      continue;
+
+    // Find the number of variable fields.
+    // If it has no fields, or more fields than our Element, then it can't be
+    // the struct we're looking for.
+    // Don't check for equality since RS can add extra struct members for
+    // padding.
+    size_t num_children = valobj_sp->GetNumChildren();
+    if (num_children > elem.children.size() || num_children == 0)
+      continue;
+
+    // Iterate over children looking for members with matching field names.
+    // If all the field names match, this is likely the struct we want.
+    //   TODO: This could be made more robust by also checking children data
+    //   sizes, or array size
+    bool found = true;
+    for (size_t i = 0; i < num_children; ++i) {
+      ValueObjectSP child = valobj_sp->GetChildAtIndex(i, true);
+      if (!child || (child->GetName() != elem.children[i].type_name)) {
+        found = false;
+        break;
+      }
+    }
+
+    // RS can add extra struct members for padding in the format
+    // '#rs_padding_[0-9]+'
+    if (found && num_children < elem.children.size()) {
+      const uint32_t size_diff = elem.children.size() - num_children;
+      if (log)
+        log->Printf("%s - %" PRIu32 " padding struct entries", __FUNCTION__,
+                    size_diff);
+
+      for (uint32_t i = 0; i < size_diff; ++i) {
+        const ConstString &name = elem.children[num_children + i].type_name;
+        if (strcmp(name.AsCString(), "#rs_padding") < 0)
+          found = false;
+      }
+    }
+
+    // We've found a global variable with matching type
+    if (found) {
+      // Dereference since our Element type isn't a pointer.
+      if (valobj_sp->IsPointerType()) {
+        Error err;
+        ValueObjectSP deref_valobj = valobj_sp->Dereference(err);
+        if (!err.Fail())
+          valobj_sp = deref_valobj;
+      }
+
+      // Save name of variable in Element.
+      elem.type_name = valobj_sp->GetTypeName();
+      if (log)
+        log->Printf("%s - element name set to %s", __FUNCTION__,
+                    elem.type_name.AsCString());
+
+      return;
+    }
+  }
 }
 
-// Function sets the datum_size member of Element. Representing the size of a single instance including padding.
+// Function sets the datum_size member of Element. Representing the size of a
+// single instance including padding.
 // Assumes the relevant allocation information has already been jitted.
-void
-RenderScriptRuntime::SetElementSize(Element &elem)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-    const Element::DataType type = *elem.type.get();
-    assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && "Invalid allocation type");
-
-    const uint32_t vec_size = *elem.type_vec_size.get();
-    uint32_t data_size = 0;
-    uint32_t padding = 0;
-
-    // Element is of a struct type, calculate size recursively.
-    if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0))
-    {
-        for (Element &child : elem.children)
-        {
-            SetElementSize(child);
-            const uint32_t array_size = child.array_size.isValid() ? *child.array_size.get() : 1;
-            data_size += *child.datum_size.get() * array_size;
-        }
-    }
-    // These have been packed already
-    else if (type == Element::RS_TYPE_UNSIGNED_5_6_5   ||
-             type == Element::RS_TYPE_UNSIGNED_5_5_5_1 ||
-             type == Element::RS_TYPE_UNSIGNED_4_4_4_4)
-    {
-        data_size = AllocationDetails::RSTypeToFormat[type][eElementSize];
-    }
-    else if (type < Element::RS_TYPE_ELEMENT)
-    {
-        data_size = vec_size * AllocationDetails::RSTypeToFormat[type][eElementSize];
-        if (vec_size == 3)
-            padding = AllocationDetails::RSTypeToFormat[type][eElementSize];
-    }
-    else
-        data_size = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
-
-    elem.padding = padding;
-    elem.datum_size = data_size + padding;
-    if (log)
-        log->Printf("%s - element size set to %" PRIu32, __FUNCTION__, data_size + padding);
+void RenderScriptRuntime::SetElementSize(Element &elem) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  const Element::DataType type = *elem.type.get();
+  assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT &&
+         "Invalid allocation type");
+
+  const uint32_t vec_size = *elem.type_vec_size.get();
+  uint32_t data_size = 0;
+  uint32_t padding = 0;
+
+  // Element is of a struct type, calculate size recursively.
+  if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0)) {
+    for (Element &child : elem.children) {
+      SetElementSize(child);
+      const uint32_t array_size =
+          child.array_size.isValid() ? *child.array_size.get() : 1;
+      data_size += *child.datum_size.get() * array_size;
+    }
+  }
+  // These have been packed already
+  else if (type == Element::RS_TYPE_UNSIGNED_5_6_5 ||
+           type == Element::RS_TYPE_UNSIGNED_5_5_5_1 ||
+           type == Element::RS_TYPE_UNSIGNED_4_4_4_4) {
+    data_size = AllocationDetails::RSTypeToFormat[type][eElementSize];
+  } else if (type < Element::RS_TYPE_ELEMENT) {
+    data_size =
+        vec_size * AllocationDetails::RSTypeToFormat[type][eElementSize];
+    if (vec_size == 3)
+      padding = AllocationDetails::RSTypeToFormat[type][eElementSize];
+  } else
+    data_size =
+        GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
+
+  elem.padding = padding;
+  elem.datum_size = data_size + padding;
+  if (log)
+    log->Printf("%s - element size set to %" PRIu32, __FUNCTION__,
+                data_size + padding);
 }
 
-// Given an allocation, this function copies the allocation contents from device into a buffer on the heap.
+// Given an allocation, this function copies the allocation contents from device
+// into a buffer on the heap.
 // Returning a shared pointer to the buffer containing the data.
 std::shared_ptr<uint8_t>
-RenderScriptRuntime::GetAllocationData(AllocationDetails *allocation, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+RenderScriptRuntime::GetAllocationData(AllocationDetails *alloc,
+                                       StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    // JIT all the allocation details
-    if (allocation->shouldRefresh())
-    {
-        if (log)
-            log->Printf("%s - allocation details not calculated yet, jitting info", __FUNCTION__);
+  // JIT all the allocation details
+  if (alloc->ShouldRefresh()) {
+    if (log)
+      log->Printf("%s - allocation details not calculated yet, jitting info",
+                  __FUNCTION__);
 
-        if (!RefreshAllocation(allocation, frame_ptr))
-        {
-            if (log)
-                log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
-            return nullptr;
-        }
+    if (!RefreshAllocation(alloc, frame_ptr)) {
+      if (log)
+        log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
+      return nullptr;
     }
+  }
 
-    assert(allocation->data_ptr.isValid() && allocation->element.type.isValid() &&
-           allocation->element.type_vec_size.isValid() && allocation->size.isValid() &&
-           "Allocation information not available");
+  assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
+         alloc->element.type_vec_size.isValid() && alloc->size.isValid() &&
+         "Allocation information not available");
 
-    // Allocate a buffer to copy data into
-    const uint32_t size = *allocation->size.get();
-    std::shared_ptr<uint8_t> buffer(new uint8_t[size]);
-    if (!buffer)
-    {
-        if (log)
-            log->Printf("%s - couldn't allocate a %" PRIu32 " byte buffer", __FUNCTION__, size);
-        return nullptr;
-    }
+  // Allocate a buffer to copy data into
+  const uint32_t size = *alloc->size.get();
+  std::shared_ptr<uint8_t> buffer(new uint8_t[size]);
+  if (!buffer) {
+    if (log)
+      log->Printf("%s - couldn't allocate a %" PRIu32 " byte buffer",
+                  __FUNCTION__, size);
+    return nullptr;
+  }
 
-    // Read the inferior memory
-    Error error;
-    lldb::addr_t data_ptr = *allocation->data_ptr.get();
-    GetProcess()->ReadMemory(data_ptr, buffer.get(), size, error);
-    if (error.Fail())
-    {
-        if (log)
-            log->Printf("%s - '%s' Couldn't read %" PRIu32 " bytes of allocation data from 0x%" PRIx64,
-                        __FUNCTION__, error.AsCString(), size, data_ptr);
-        return nullptr;
-    }
+  // Read the inferior memory
+  Error err;
+  lldb::addr_t data_ptr = *alloc->data_ptr.get();
+  GetProcess()->ReadMemory(data_ptr, buffer.get(), size, err);
+  if (err.Fail()) {
+    if (log)
+      log->Printf("%s - '%s' Couldn't read %" PRIu32
+                  " bytes of allocation data from 0x%" PRIx64,
+                  __FUNCTION__, err.AsCString(), size, data_ptr);
+    return nullptr;
+  }
 
-    return buffer;
+  return buffer;
 }
 
 // Function copies data from a binary file into an allocation.
-// There is a header at the start of the file, FileHeader, before the data content itself.
-// Information from this header is used to display warnings to the user about incompatabilities
-bool
-RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    // Find allocation with the given id
-    AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
-    if (!alloc)
-        return false;
+// There is a header at the start of the file, FileHeader, before the data
+// content itself.
+// Information from this header is used to display warnings to the user about
+// incompatibilities
+bool RenderScriptRuntime::LoadAllocation(Stream &strm, const uint32_t alloc_id,
+                                         const char *path,
+                                         StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  // Find allocation with the given id
+  AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
+  if (!alloc)
+    return false;
 
-    if (log)
-        log->Printf("%s - found allocation 0x%" PRIx64, __FUNCTION__, *alloc->address.get());
+  if (log)
+    log->Printf("%s - found allocation 0x%" PRIx64, __FUNCTION__,
+                *alloc->address.get());
 
-    // JIT all the allocation details
-    if (alloc->shouldRefresh())
-    {
-        if (log)
-            log->Printf("%s - allocation details not calculated yet, jitting info.", __FUNCTION__);
+  // JIT all the allocation details
+  if (alloc->ShouldRefresh()) {
+    if (log)
+      log->Printf("%s - allocation details not calculated yet, jitting info.",
+                  __FUNCTION__);
 
-        if (!RefreshAllocation(alloc, frame_ptr))
-        {
-            if (log)
-                log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
-            return false;
-        }
+    if (!RefreshAllocation(alloc, frame_ptr)) {
+      if (log)
+        log->Printf("%s - couldn't JIT allocation details", __FUNCTION__);
+      return false;
     }
+  }
 
-    assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() &&
-           alloc->size.isValid() && alloc->element.datum_size.isValid() && "Allocation information not available");
+  assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
+         alloc->element.type_vec_size.isValid() && alloc->size.isValid() &&
+         alloc->element.datum_size.isValid() &&
+         "Allocation information not available");
 
-    // Check we can read from file
-    FileSpec file(filename, true);
-    if (!file.Exists())
-    {
-        strm.Printf("Error: File %s does not exist", filename);
-        strm.EOL();
-        return false;
-    }
+  // Check we can read from file
+  FileSpec file(path, true);
+  if (!file.Exists()) {
+    strm.Printf("Error: File %s does not exist", path);
+    strm.EOL();
+    return false;
+  }
 
-    if (!file.Readable())
-    {
-        strm.Printf("Error: File %s does not have readable permissions", filename);
-        strm.EOL();
-        return false;
-    }
+  if (!file.Readable()) {
+    strm.Printf("Error: File %s does not have readable permissions", path);
+    strm.EOL();
+    return false;
+  }
 
-    // Read file into data buffer
-    DataBufferSP data_sp(file.ReadFileContents());
+  // Read file into data buffer
+  DataBufferSP data_sp(file.ReadFileContents());
 
-    // Cast start of buffer to FileHeader and use pointer to read metadata
-    void *file_buffer = data_sp->GetBytes();
-    if (file_buffer == nullptr ||
-        data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) + sizeof(AllocationDetails::ElementHeader)))
-    {
-        strm.Printf("Error: File %s does not contain enough data for header", filename);
-        strm.EOL();
-        return false;
-    }
-    const AllocationDetails::FileHeader *file_header = static_cast<AllocationDetails::FileHeader *>(file_buffer);
+  // Cast start of buffer to FileHeader and use pointer to read metadata
+  void *file_buf = data_sp->GetBytes();
+  if (file_buf == nullptr ||
+      data_sp->GetByteSize() < (sizeof(AllocationDetails::FileHeader) +
+                                sizeof(AllocationDetails::ElementHeader))) {
+    strm.Printf("Error: File %s does not contain enough data for header", path);
+    strm.EOL();
+    return false;
+  }
+  const AllocationDetails::FileHeader *file_header =
+      static_cast<AllocationDetails::FileHeader *>(file_buf);
+
+  // Check file starts with ascii characters "RSAD"
+  if (memcmp(file_header->ident, "RSAD", 4)) {
+    strm.Printf("Error: File doesn't contain identifier for an RS allocation "
+                "dump. Are you sure this is the correct file?");
+    strm.EOL();
+    return false;
+  }
+
+  // Look at the type of the root element in the header
+  AllocationDetails::ElementHeader root_el_hdr;
+  memcpy(&root_el_hdr, static_cast<uint8_t *>(file_buf) +
+                           sizeof(AllocationDetails::FileHeader),
+         sizeof(AllocationDetails::ElementHeader));
+
+  if (log)
+    log->Printf("%s - header type %" PRIu32 ", element size %" PRIu32,
+                __FUNCTION__, root_el_hdr.type, root_el_hdr.element_size);
+
+  // Check if the target allocation and file both have the same number of bytes
+  // for an Element
+  if (*alloc->element.datum_size.get() != root_el_hdr.element_size) {
+    strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32
+                " bytes, allocation %" PRIu32 " bytes",
+                root_el_hdr.element_size, *alloc->element.datum_size.get());
+    strm.EOL();
+  }
 
-    // Check file starts with ascii characters "RSAD"
-    if (memcmp(file_header->ident, "RSAD", 4))
-    {
-        strm.Printf("Error: File doesn't contain identifier for an RS allocation dump. Are you sure this is the correct file?");
-        strm.EOL();
-        return false;
-    }
+  // Check if the target allocation and file both have the same type
+  const uint32_t alloc_type = static_cast<uint32_t>(*alloc->element.type.get());
+  const uint32_t file_type = root_el_hdr.type;
 
-    // Look at the type of the root element in the header
-    AllocationDetails::ElementHeader root_element_header;
-    memcpy(&root_element_header, static_cast<uint8_t *>(file_buffer) + sizeof(AllocationDetails::FileHeader),
-           sizeof(AllocationDetails::ElementHeader));
+  if (file_type > Element::RS_TYPE_FONT) {
+    strm.Printf("Warning: File has unknown allocation type");
+    strm.EOL();
+  } else if (alloc_type != file_type) {
+    // Enum value isn't monotonous, so doesn't always index RsDataTypeToString
+    // array
+    uint32_t target_type_name_idx = alloc_type;
+    uint32_t head_type_name_idx = file_type;
+    if (alloc_type >= Element::RS_TYPE_ELEMENT &&
+        alloc_type <= Element::RS_TYPE_FONT)
+      target_type_name_idx = static_cast<Element::DataType>(
+          (alloc_type - Element::RS_TYPE_ELEMENT) +
+          Element::RS_TYPE_MATRIX_2X2 + 1);
+
+    if (file_type >= Element::RS_TYPE_ELEMENT &&
+        file_type <= Element::RS_TYPE_FONT)
+      head_type_name_idx = static_cast<Element::DataType>(
+          (file_type - Element::RS_TYPE_ELEMENT) + Element::RS_TYPE_MATRIX_2X2 +
+          1);
+
+    const char *head_type_name =
+        AllocationDetails::RsDataTypeToString[head_type_name_idx][0];
+    const char *target_type_name =
+        AllocationDetails::RsDataTypeToString[target_type_name_idx][0];
+
+    strm.Printf(
+        "Warning: Mismatched Types - file '%s' type, allocation '%s' type",
+        head_type_name, target_type_name);
+    strm.EOL();
+  }
 
-    if (log)
-        log->Printf("%s - header type %" PRIu32 ", element size %" PRIu32, __FUNCTION__,
-                    root_element_header.type, root_element_header.element_size);
+  // Advance buffer past header
+  file_buf = static_cast<uint8_t *>(file_buf) + file_header->hdr_size;
 
-    // Check if the target allocation and file both have the same number of bytes for an Element
-    if (*alloc->element.datum_size.get() != root_element_header.element_size)
-    {
-        strm.Printf("Warning: Mismatched Element sizes - file %" PRIu32 " bytes, allocation %" PRIu32 " bytes",
-                    root_element_header.element_size, *alloc->element.datum_size.get());
-        strm.EOL();
-    }
+  // Calculate size of allocation data in file
+  size_t size = data_sp->GetByteSize() - file_header->hdr_size;
 
-    // Check if the target allocation and file both have the same type
-    const uint32_t alloc_type = static_cast<uint32_t>(*alloc->element.type.get());
-    const uint32_t file_type = root_element_header.type;
+  // Check if the target allocation and file both have the same total data size.
+  const uint32_t alloc_size = *alloc->size.get();
+  if (alloc_size != size) {
+    strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64
+                " bytes, allocation 0x%" PRIx32 " bytes",
+                (uint64_t)size, alloc_size);
+    strm.EOL();
+    // Set length to copy to minimum
+    size = alloc_size < size ? alloc_size : size;
+  }
+
+  // Copy file data from our buffer into the target allocation.
+  lldb::addr_t alloc_data = *alloc->data_ptr.get();
+  Error err;
+  size_t written = GetProcess()->WriteMemory(alloc_data, file_buf, size, err);
+  if (!err.Success() || written != size) {
+    strm.Printf("Error: Couldn't write data to allocation %s", err.AsCString());
+    strm.EOL();
+    return false;
+  }
 
-    if (file_type > Element::RS_TYPE_FONT)
-    {
-        strm.Printf("Warning: File has unknown allocation type");
-        strm.EOL();
-    }
-    else if (alloc_type != file_type)
-    {
-        // Enum value isn't monotonous, so doesn't always index RsDataTypeToString array
-        uint32_t printable_target_type_index = alloc_type;
-        uint32_t printable_head_type_index = file_type;
-        if (alloc_type >= Element::RS_TYPE_ELEMENT && alloc_type <= Element::RS_TYPE_FONT)
-            printable_target_type_index = static_cast<Element::DataType>((alloc_type - Element::RS_TYPE_ELEMENT) +
-                                                                         Element::RS_TYPE_MATRIX_2X2 + 1);
-
-        if (file_type >= Element::RS_TYPE_ELEMENT && file_type <= Element::RS_TYPE_FONT)
-            printable_head_type_index = static_cast<Element::DataType>((file_type - Element::RS_TYPE_ELEMENT) +
-                                                                       Element::RS_TYPE_MATRIX_2X2 + 1);
-
-        const char *file_type_cstr = AllocationDetails::RsDataTypeToString[printable_head_type_index][0];
-        const char *target_type_cstr = AllocationDetails::RsDataTypeToString[printable_target_type_index][0];
-
-        strm.Printf("Warning: Mismatched Types - file '%s' type, allocation '%s' type", file_type_cstr,
-                    target_type_cstr);
-        strm.EOL();
-    }
+  strm.Printf("Contents of file '%s' read into allocation %" PRIu32, path,
+              alloc->id);
+  strm.EOL();
 
-    // Advance buffer past header
-    file_buffer = static_cast<uint8_t *>(file_buffer) + file_header->hdr_size;
+  return true;
+}
 
-    // Calculate size of allocation data in file
-    size_t length = data_sp->GetByteSize() - file_header->hdr_size;
+// Function takes as parameters a byte buffer, which will eventually be written
+// to file as the element header, an offset into that buffer, and an Element
+// that will be saved into the buffer at the parametrised offset.
+// Return value is the new offset after writing the element into the buffer.
+// Elements are saved to the file as the ElementHeader struct followed by
+// offsets to the structs of all the element's children.
+size_t RenderScriptRuntime::PopulateElementHeaders(
+    const std::shared_ptr<uint8_t> header_buffer, size_t offset,
+    const Element &elem) {
+  // File struct for an element header with all the relevant details copied from
+  // elem. We assume members are valid already.
+  AllocationDetails::ElementHeader elem_header;
+  elem_header.type = *elem.type.get();
+  elem_header.kind = *elem.type_kind.get();
+  elem_header.element_size = *elem.datum_size.get();
+  elem_header.vector_size = *elem.type_vec_size.get();
+  elem_header.array_size =
+      elem.array_size.isValid() ? *elem.array_size.get() : 0;
+  const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader);
+
+  // Copy struct into buffer and advance offset
+  // We assume that header_buffer has been checked for nullptr before this
+  // method is called
+  memcpy(header_buffer.get() + offset, &elem_header, elem_header_size);
+  offset += elem_header_size;
+
+  // Starting offset of child ElementHeader struct
+  size_t child_offset =
+      offset + ((elem.children.size() + 1) * sizeof(uint32_t));
+  for (const RenderScriptRuntime::Element &child : elem.children) {
+    // Recursively populate the buffer with the element header structs of
+    // children. Then save the offsets where they were set after the parent
+    // element header.
+    memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t));
+    offset += sizeof(uint32_t);
+
+    child_offset = PopulateElementHeaders(header_buffer, child_offset, child);
+  }
+
+  // Zero indicates no more children
+  memset(header_buffer.get() + offset, 0, sizeof(uint32_t));
+
+  return child_offset;
+}
 
-    // Check if the target allocation and file both have the same total data size.
-    const uint32_t alloc_size = *alloc->size.get();
-    if (alloc_size != length)
-    {
-        strm.Printf("Warning: Mismatched allocation sizes - file 0x%" PRIx64 " bytes, allocation 0x%" PRIx32 " bytes",
-                    (uint64_t)length, alloc_size);
-        strm.EOL();
-        length = alloc_size < length ? alloc_size : length; // Set length to copy to minimum
-    }
+// Given an Element object this function returns the total size needed in the
+// file header to store the element's details. Taking into account the size of
+// the element header struct, plus the offsets to all the element's children.
+// Function is recursive so that the size of all ancestors is taken into
+// account.
+size_t RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem) {
+  // Offsets to children plus zero terminator
+  size_t size = (elem.children.size() + 1) * sizeof(uint32_t);
+  // Size of header struct with type details
+  size += sizeof(AllocationDetails::ElementHeader);
+
+  // Calculate recursively for all descendants
+  for (const Element &child : elem.children)
+    size += CalculateElementHeaderSize(child);
+
+  return size;
+}
 
-    // Copy file data from our buffer into the target allocation.
-    lldb::addr_t alloc_data = *alloc->data_ptr.get();
-    Error error;
-    size_t bytes_written = GetProcess()->WriteMemory(alloc_data, file_buffer, length, error);
-    if (!error.Success() || bytes_written != length)
-    {
-        strm.Printf("Error: Couldn't write data to allocation %s", error.AsCString());
-        strm.EOL();
-        return false;
-    }
+// Function copies allocation contents into a binary file. This file can then be
+// loaded later into a different allocation. There is a header, FileHeader,
+// before the allocation data containing meta-data.
+bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id,
+                                         const char *path,
+                                         StackFrame *frame_ptr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+
+  // Find allocation with the given id
+  AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
+  if (!alloc)
+    return false;
 
-    strm.Printf("Contents of file '%s' read into allocation %" PRIu32, filename, alloc->id);
-    strm.EOL();
+  if (log)
+    log->Printf("%s - found allocation 0x%" PRIx64 ".", __FUNCTION__,
+                *alloc->address.get());
 
-    return true;
-}
+  // JIT all the allocation details
+  if (alloc->ShouldRefresh()) {
+    if (log)
+      log->Printf("%s - allocation details not calculated yet, jitting info.",
+                  __FUNCTION__);
+
+    if (!RefreshAllocation(alloc, frame_ptr)) {
+      if (log)
+        log->Printf("%s - couldn't JIT allocation details.", __FUNCTION__);
+      return false;
+    }
+  }
+
+  assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
+         alloc->element.type_vec_size.isValid() &&
+         alloc->element.datum_size.get() &&
+         alloc->element.type_kind.isValid() && alloc->dimension.isValid() &&
+         "Allocation information not available");
+
+  // Check we can create writable file
+  FileSpec file_spec(path, true);
+  File file(file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate |
+                           File::eOpenOptionTruncate);
+  if (!file) {
+    strm.Printf("Error: Failed to open '%s' for writing", path);
+    strm.EOL();
+    return false;
+  }
 
-// Function takes as parameters a byte buffer, which will eventually be written to file as the element header,
-// an offset into that buffer, and an Element that will be saved into the buffer at the parametrised offset.
-// Return value is the new offset after writing the element into the buffer.
-// Elements are saved to the file as the ElementHeader struct followed by offsets to the structs of all the element's
-// children.
-size_t
-RenderScriptRuntime::PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer, size_t offset,
-                                            const Element &elem)
-{
-    // File struct for an element header with all the relevant details copied from elem.
-    // We assume members are valid already.
-    AllocationDetails::ElementHeader elem_header;
-    elem_header.type = *elem.type.get();
-    elem_header.kind = *elem.type_kind.get();
-    elem_header.element_size = *elem.datum_size.get();
-    elem_header.vector_size = *elem.type_vec_size.get();
-    elem_header.array_size = elem.array_size.isValid() ? *elem.array_size.get() : 0;
-    const size_t elem_header_size = sizeof(AllocationDetails::ElementHeader);
-
-    // Copy struct into buffer and advance offset
-    // We assume that header_buffer has been checked for nullptr before this method is called
-    memcpy(header_buffer.get() + offset, &elem_header, elem_header_size);
-    offset += elem_header_size;
-
-    // Starting offset of child ElementHeader struct
-    size_t child_offset = offset + ((elem.children.size() + 1) * sizeof(uint32_t));
-    for (const RenderScriptRuntime::Element &child : elem.children)
-    {
-        // Recursively populate the buffer with the element header structs of children.
-        // Then save the offsets where they were set after the parent element header.
-        memcpy(header_buffer.get() + offset, &child_offset, sizeof(uint32_t));
-        offset += sizeof(uint32_t);
+  // Read allocation into buffer of heap memory
+  const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
+  if (!buffer) {
+    strm.Printf("Error: Couldn't read allocation data into buffer");
+    strm.EOL();
+    return false;
+  }
+
+  // Create the file header
+  AllocationDetails::FileHeader head;
+  memcpy(head.ident, "RSAD", 4);
+  head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1);
+  head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2);
+  head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3);
+
+  const size_t element_header_size = CalculateElementHeaderSize(alloc->element);
+  assert((sizeof(AllocationDetails::FileHeader) + element_header_size) <
+             UINT16_MAX &&
+         "Element header too large");
+  head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) +
+                                        element_header_size);
+
+  // Write the file header
+  size_t num_bytes = sizeof(AllocationDetails::FileHeader);
+  if (log)
+    log->Printf("%s - writing File Header, 0x%" PRIx64 " bytes", __FUNCTION__,
+                (uint64_t)num_bytes);
+
+  Error err = file.Write(&head, num_bytes);
+  if (!err.Success()) {
+    strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
+    strm.EOL();
+    return false;
+  }
+
+  // Create the headers describing the element type of the allocation.
+  std::shared_ptr<uint8_t> element_header_buffer(
+      new uint8_t[element_header_size]);
+  if (element_header_buffer == nullptr) {
+    strm.Printf("Internal Error: Couldn't allocate %" PRIu64
+                " bytes on the heap",
+                (uint64_t)element_header_size);
+    strm.EOL();
+    return false;
+  }
 
-        child_offset = PopulateElementHeaders(header_buffer, child_offset, child);
-    }
+  PopulateElementHeaders(element_header_buffer, 0, alloc->element);
 
-    // Zero indicates no more children
-    memset(header_buffer.get() + offset, 0, sizeof(uint32_t));
+  // Write headers for allocation element type to file
+  num_bytes = element_header_size;
+  if (log)
+    log->Printf("%s - writing element headers, 0x%" PRIx64 " bytes.",
+                __FUNCTION__, (uint64_t)num_bytes);
 
-    return child_offset;
-}
+  err = file.Write(element_header_buffer.get(), num_bytes);
+  if (!err.Success()) {
+    strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
+    strm.EOL();
+    return false;
+  }
 
-// Given an Element object this function returns the total size needed in the file header to store the element's
-// details.
-// Taking into account the size of the element header struct, plus the offsets to all the element's children.
-// Function is recursive so that the size of all ancestors is taken into account.
-size_t
-RenderScriptRuntime::CalculateElementHeaderSize(const Element &elem)
-{
-    size_t size = (elem.children.size() + 1) * sizeof(uint32_t); // Offsets to children plus zero terminator
-    size += sizeof(AllocationDetails::ElementHeader);            // Size of header struct with type details
-
-    // Calculate recursively for all descendants
-    for (const Element &child : elem.children)
-        size += CalculateElementHeaderSize(child);
-
-    return size;
-}
+  // Write allocation data to file
+  num_bytes = static_cast<size_t>(*alloc->size.get());
+  if (log)
+    log->Printf("%s - writing 0x%" PRIx64 " bytes", __FUNCTION__,
+                (uint64_t)num_bytes);
 
-// Function copies allocation contents into a binary file.
-// This file can then be loaded later into a different allocation.
-// There is a header, FileHeader, before the allocation data containing meta-data.
-bool
-RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  err = file.Write(buffer.get(), num_bytes);
+  if (!err.Success()) {
+    strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
+    strm.EOL();
+    return false;
+  }
 
-    // Find allocation with the given id
-    AllocationDetails *alloc = FindAllocByID(strm, alloc_id);
-    if (!alloc)
-        return false;
+  strm.Printf("Allocation written to file '%s'", path);
+  strm.EOL();
+  return true;
+}
 
-    if (log)
-        log->Printf("%s - found allocation 0x%" PRIx64 ".", __FUNCTION__, *alloc->address.get());
+bool RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    // JIT all the allocation details
-    if (alloc->shouldRefresh())
-    {
-        if (log)
-            log->Printf("%s - allocation details not calculated yet, jitting info.", __FUNCTION__);
+  if (module_sp) {
+    for (const auto &rs_module : m_rsmodules) {
+      if (rs_module->m_module == module_sp) {
+        // Check if the user has enabled automatically breaking on
+        // all RS kernels.
+        if (m_breakAllKernels)
+          BreakOnModuleKernels(rs_module);
 
-        if (!RefreshAllocation(alloc, frame_ptr))
-        {
+        return false;
+      }
+    }
+    bool module_loaded = false;
+    switch (GetModuleKind(module_sp)) {
+    case eModuleKindKernelObj: {
+      RSModuleDescriptorSP module_desc;
+      module_desc.reset(new RSModuleDescriptor(module_sp));
+      if (module_desc->ParseRSInfo()) {
+        m_rsmodules.push_back(module_desc);
+        module_desc->WarnIfVersionMismatch(GetProcess()
+                                               ->GetTarget()
+                                               .GetDebugger()
+                                               .GetAsyncOutputStream()
+                                               .get());
+        module_loaded = true;
+      }
+      if (module_loaded) {
+        FixupScriptDetails(module_desc);
+      }
+      break;
+    }
+    case eModuleKindDriver: {
+      if (!m_libRSDriver) {
+        m_libRSDriver = module_sp;
+        LoadRuntimeHooks(m_libRSDriver, RenderScriptRuntime::eModuleKindDriver);
+      }
+      break;
+    }
+    case eModuleKindImpl: {
+      if (!m_libRSCpuRef) {
+        m_libRSCpuRef = module_sp;
+        LoadRuntimeHooks(m_libRSCpuRef, RenderScriptRuntime::eModuleKindImpl);
+      }
+      break;
+    }
+    case eModuleKindLibRS: {
+      if (!m_libRS) {
+        m_libRS = module_sp;
+        static ConstString gDbgPresentStr("gDebuggerPresent");
+        const Symbol *debug_present = m_libRS->FindFirstSymbolWithNameAndType(
+            gDbgPresentStr, eSymbolTypeData);
+        if (debug_present) {
+          Error err;
+          uint32_t flag = 0x00000001U;
+          Target &target = GetProcess()->GetTarget();
+          addr_t addr = debug_present->GetLoadAddress(&target);
+          GetProcess()->WriteMemory(addr, &flag, sizeof(flag), err);
+          if (err.Success()) {
             if (log)
-                log->Printf("%s - couldn't JIT allocation details.", __FUNCTION__);
-            return false;
+              log->Printf("%s - debugger present flag set on debugee.",
+                          __FUNCTION__);
+
+            m_debuggerPresentFlagged = true;
+          } else if (log) {
+            log->Printf("%s - error writing debugger present flags '%s' ",
+                        __FUNCTION__, err.AsCString());
+          }
+        } else if (log) {
+          log->Printf(
+              "%s - error writing debugger present flags - symbol not found",
+              __FUNCTION__);
         }
+      }
+      break;
     }
-
-    assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() && alloc->element.type_vec_size.isValid() &&
-           alloc->element.datum_size.get() && alloc->element.type_kind.isValid() && alloc->dimension.isValid() &&
-           "Allocation information not available");
-
-    // Check we can create writable file
-    FileSpec file_spec(filename, true);
-    File file(file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate | File::eOpenOptionTruncate);
-    if (!file)
-    {
-        strm.Printf("Error: Failed to open '%s' for writing", filename);
-        strm.EOL();
-        return false;
+    default:
+      break;
     }
+    if (module_loaded)
+      Update();
+    return module_loaded;
+  }
+  return false;
+}
 
-    // Read allocation into buffer of heap memory
-    const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
-    if (!buffer)
-    {
-        strm.Printf("Error: Couldn't read allocation data into buffer");
-        strm.EOL();
-        return false;
+void RenderScriptRuntime::Update() {
+  if (m_rsmodules.size() > 0) {
+    if (!m_initiated) {
+      Initiate();
     }
+  }
+}
 
-    // Create the file header
-    AllocationDetails::FileHeader head;
-    memcpy(head.ident, "RSAD", 4);
-    head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1);
-    head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2);
-    head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3);
-
-    const size_t element_header_size = CalculateElementHeaderSize(alloc->element);
-    assert((sizeof(AllocationDetails::FileHeader) + element_header_size) < UINT16_MAX && "Element header too large");
-    head.hdr_size = static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader) + element_header_size);
+void RSModuleDescriptor::WarnIfVersionMismatch(lldb_private::Stream *s) const {
+  if (!s)
+    return;
+
+  if (m_slang_version.empty() || m_bcc_version.empty()) {
+    s->PutCString("WARNING: Unknown bcc or slang (llvm-rs-cc) version; debug "
+                  "experience may be unreliable");
+    s->EOL();
+  } else if (m_slang_version != m_bcc_version) {
+    s->Printf("WARNING: The debug info emitted by the slang frontend "
+              "(llvm-rs-cc) used to build this module (%s) does not match the "
+              "version of bcc used to generate the debug information (%s). "
+              "This is an unsupported configuration and may result in a poor "
+              "debugging experience; proceed with caution",
+              m_slang_version.c_str(), m_bcc_version.c_str());
+    s->EOL();
+  }
+}
 
-    // Write the file header
-    size_t num_bytes = sizeof(AllocationDetails::FileHeader);
-    if (log)
-        log->Printf("%s - writing File Header, 0x%" PRIx64 " bytes", __FUNCTION__, (uint64_t)num_bytes);
+bool RSModuleDescriptor::ParsePragmaCount(llvm::StringRef *lines,
+                                          size_t n_lines) {
+  // Skip the pragma prototype line
+  ++lines;
+  for (; n_lines--; ++lines) {
+    const auto kv_pair = lines->split(" - ");
+    m_pragmas[kv_pair.first.trim().str()] = kv_pair.second.trim().str();
+  }
+  return true;
+}
 
-    Error err = file.Write(&head, num_bytes);
-    if (!err.Success())
-    {
-        strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), filename);
-        strm.EOL();
+bool RSModuleDescriptor::ParseExportReduceCount(llvm::StringRef *lines,
+                                                size_t n_lines) {
+  // The list of reduction kernels in the `.rs.info` symbol is of the form
+  // "signature - accumulatordatasize - reduction_name - initializer_name -
+  // accumulator_name - combiner_name -
+  // outconverter_name - halter_name"
+  // Where a function is not explicitly named by the user, or is not generated
+  // by the compiler, it is named "." so the
+  // dash separated list should always be 8 items long
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+  // Skip the exportReduceCount line
+  ++lines;
+  for (; n_lines--; ++lines) {
+    llvm::SmallVector<llvm::StringRef, 8> spec;
+    lines->split(spec, " - ");
+    if (spec.size() != 8) {
+      if (spec.size() < 8) {
+        if (log)
+          log->Error("Error parsing RenderScript reduction spec. wrong number "
+                     "of fields");
         return false;
+      } else if (log)
+        log->Warning("Extraneous members in reduction spec: '%s'",
+                     lines->str().c_str());
     }
 
-    // Create the headers describing the element type of the allocation.
-    std::shared_ptr<uint8_t> element_header_buffer(new uint8_t[element_header_size]);
-    if (element_header_buffer == nullptr)
-    {
-        strm.Printf("Internal Error: Couldn't allocate %" PRIu64 " bytes on the heap", (uint64_t)element_header_size);
-        strm.EOL();
-        return false;
+    const auto sig_s = spec[0];
+    uint32_t sig;
+    if (sig_s.getAsInteger(10, sig)) {
+      if (log)
+        log->Error("Error parsing Renderscript reduction spec: invalid kernel "
+                   "signature: '%s'",
+                   sig_s.str().c_str());
+      return false;
     }
 
-    PopulateElementHeaders(element_header_buffer, 0, alloc->element);
-
-    // Write headers for allocation element type to file
-    num_bytes = element_header_size;
-    if (log)
-        log->Printf("%s - writing element headers, 0x%" PRIx64 " bytes.", __FUNCTION__, (uint64_t)num_bytes);
-
-    err = file.Write(element_header_buffer.get(), num_bytes);
-    if (!err.Success())
-    {
-        strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), filename);
-        strm.EOL();
-        return false;
+    const auto accum_data_size_s = spec[1];
+    uint32_t accum_data_size;
+    if (accum_data_size_s.getAsInteger(10, accum_data_size)) {
+      if (log)
+        log->Error("Error parsing Renderscript reduction spec: invalid "
+                   "accumulator data size %s",
+                   accum_data_size_s.str().c_str());
+      return false;
     }
 
-    // Write allocation data to file
-    num_bytes = static_cast<size_t>(*alloc->size.get());
     if (log)
-        log->Printf("%s - writing 0x%" PRIx64 " bytes", __FUNCTION__, (uint64_t)num_bytes);
+      log->Printf("Found RenderScript reduction '%s'", spec[2].str().c_str());
 
-    err = file.Write(buffer.get(), num_bytes);
-    if (!err.Success())
-    {
-        strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), filename);
-        strm.EOL();
-        return false;
-    }
-
-    strm.Printf("Allocation written to file '%s'", filename);
-    strm.EOL();
-    return true;
+    m_reductions.push_back(RSReductionDescriptor(this, sig, accum_data_size,
+                                                 spec[2], spec[3], spec[4],
+                                                 spec[5], spec[6], spec[7]));
+  }
+  return true;
 }
 
-bool
-RenderScriptRuntime::LoadModule(const lldb::ModuleSP &module_sp)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    if (module_sp)
-    {
-        for (const auto &rs_module : m_rsmodules)
-        {
-            if (rs_module->m_module == module_sp)
-            {
-                // Check if the user has enabled automatically breaking on
-                // all RS kernels.
-                if (m_breakAllKernels)
-                    BreakOnModuleKernels(rs_module);
-
-                return false;
-            }
-        }
-        bool module_loaded = false;
-        switch (GetModuleKind(module_sp))
-        {
-            case eModuleKindKernelObj:
-            {
-                RSModuleDescriptorSP module_desc;
-                module_desc.reset(new RSModuleDescriptor(module_sp));
-                if (module_desc->ParseRSInfo())
-                {
-                    m_rsmodules.push_back(module_desc);
-                    module_loaded = true;
-                }
-                if (module_loaded)
-                {
-                    FixupScriptDetails(module_desc);
-                }
-                break;
-            }
-            case eModuleKindDriver:
-            {
-                if (!m_libRSDriver)
-                {
-                    m_libRSDriver = module_sp;
-                    LoadRuntimeHooks(m_libRSDriver, RenderScriptRuntime::eModuleKindDriver);
-                }
-                break;
-            }
-            case eModuleKindImpl:
-            {
-                m_libRSCpuRef = module_sp;
-                break;
-            }
-            case eModuleKindLibRS:
-            {
-                if (!m_libRS)
-                {
-                    m_libRS = module_sp;
-                    static ConstString gDbgPresentStr("gDebuggerPresent");
-                    const Symbol *debug_present =
-                        m_libRS->FindFirstSymbolWithNameAndType(gDbgPresentStr, eSymbolTypeData);
-                    if (debug_present)
-                    {
-                        Error error;
-                        uint32_t flag = 0x00000001U;
-                        Target &target = GetProcess()->GetTarget();
-                        addr_t addr = debug_present->GetLoadAddress(&target);
-                        GetProcess()->WriteMemory(addr, &flag, sizeof(flag), error);
-                        if (error.Success())
-                        {
-                            if (log)
-                                log->Printf("%s - debugger present flag set on debugee.", __FUNCTION__);
-
-                            m_debuggerPresentFlagged = true;
-                        }
-                        else if (log)
-                        {
-                            log->Printf("%s - error writing debugger present flags '%s' ", __FUNCTION__,
-                                        error.AsCString());
-                        }
-                    }
-                    else if (log)
-                    {
-                        log->Printf("%s - error writing debugger present flags - symbol not found", __FUNCTION__);
-                    }
-                }
-                break;
-            }
-            default:
-                break;
-        }
-        if (module_loaded)
-            Update();
-        return module_loaded;
-    }
-    return false;
+bool RSModuleDescriptor::ParseVersionInfo(llvm::StringRef *lines,
+                                          size_t n_lines) {
+  // Skip the versionInfo line
+  ++lines;
+  for (; n_lines--; ++lines) {
+    // We're only interested in bcc and slang versions, and ignore all other
+    // versionInfo lines
+    const auto kv_pair = lines->split(" - ");
+    if (kv_pair.first == "slang")
+      m_slang_version = kv_pair.second.str();
+    else if (kv_pair.first == "bcc")
+      m_bcc_version = kv_pair.second.str();
+  }
+  return true;
 }
 
-void
-RenderScriptRuntime::Update()
-{
-    if (m_rsmodules.size() > 0)
-    {
-        if (!m_initiated)
-        {
-            Initiate();
-        }
-    }
+bool RSModuleDescriptor::ParseExportForeachCount(llvm::StringRef *lines,
+                                                 size_t n_lines) {
+  // Skip the exportForeachCount line
+  ++lines;
+  for (; n_lines--; ++lines) {
+    uint32_t slot;
+    // `forEach` kernels are listed in the `.rs.info` packet as a "slot - name"
+    // pair per line
+    const auto kv_pair = lines->split(" - ");
+    if (kv_pair.first.getAsInteger(10, slot))
+      return false;
+    m_kernels.push_back(RSKernelDescriptor(this, kv_pair.second, slot));
+  }
+  return true;
 }
 
-// The maximum line length of an .rs.info packet
-#define MAXLINE 500
-#define STRINGIFY(x) #x
-#define MAXLINESTR_(x) "%" STRINGIFY(x) "s"
-#define MAXLINESTR MAXLINESTR_(MAXLINE)
+bool RSModuleDescriptor::ParseExportVarCount(llvm::StringRef *lines,
+                                             size_t n_lines) {
+  // Skip the ExportVarCount line
+  ++lines;
+  for (; n_lines--; ++lines)
+    m_globals.push_back(RSGlobalDescriptor(this, *lines));
+  return true;
+}
 
-// The .rs.info symbol in renderscript modules contains a string which needs to be parsed.
+// The .rs.info symbol in renderscript modules contains a string which needs to
+// be parsed.
 // The string is basic and is parsed on a line by line basis.
-bool
-RSModuleDescriptor::ParseRSInfo()
-{
-    assert(m_module);
-    const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData);
-    if (!info_sym)
-        return false;
-
-    const addr_t addr = info_sym->GetAddressRef().GetFileAddress();
-    if (addr == LLDB_INVALID_ADDRESS)
-        return false;
+bool RSModuleDescriptor::ParseRSInfo() {
+  assert(m_module);
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(
+      ConstString(".rs.info"), eSymbolTypeData);
+  if (!info_sym)
+    return false;
 
-    const addr_t size = info_sym->GetByteSize();
-    const FileSpec fs = m_module->GetFileSpec();
+  const addr_t addr = info_sym->GetAddressRef().GetFileAddress();
+  if (addr == LLDB_INVALID_ADDRESS)
+    return false;
 
-    const DataBufferSP buffer = fs.ReadFileContents(addr, size);
-    if (!buffer)
-        return false;
+  const addr_t size = info_sym->GetByteSize();
+  const FileSpec fs = m_module->GetFileSpec();
 
-    // split rs.info. contents into lines
-    std::vector<std::string> info_lines;
-    {
-        const std::string info((const char *)buffer->GetBytes());
-        for (size_t tail = 0; tail < info.size();)
-        {
-            // find next new line or end of string
-            size_t head = info.find('\n', tail);
-            head = (head == std::string::npos) ? info.size() : head;
-            std::string line = info.substr(tail, head - tail);
-            // add to line list
-            info_lines.push_back(line);
-            tail = head + 1;
-        }
-    }
+  const DataBufferSP buffer = fs.ReadFileContents(addr, size);
+  if (!buffer)
+    return false;
 
-    std::array<char, MAXLINE> name{{'\0'}};
-    std::array<char, MAXLINE> value{{'\0'}};
+  // split rs.info. contents into lines
+  llvm::SmallVector<llvm::StringRef, 128> info_lines;
+  {
+    const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes());
+    raw_rs_info.split(info_lines, '\n');
+    if (log)
+      log->Printf("'.rs.info symbol for '%s':\n%s",
+                  m_module->GetFileSpec().GetCString(),
+                  raw_rs_info.str().c_str());
+  }
+
+  enum {
+    eExportVar,
+    eExportForEach,
+    eExportReduce,
+    ePragma,
+    eBuildChecksum,
+    eObjectSlot,
+    eVersionInfo,
+  };
+
+  const auto rs_info_handler = [](llvm::StringRef name) -> int {
+    return llvm::StringSwitch<int>(name)
+        // The number of visible global variables in the script
+        .Case("exportVarCount", eExportVar)
+        // The number of RenderScrip `forEach` kernels __attribute__((kernel))
+        .Case("exportForEachCount", eExportForEach)
+        // The number of generalreductions: This marked in the script by
+        // `#pragma reduce()`
+        .Case("exportReduceCount", eExportReduce)
+        // Total count of all RenderScript specific `#pragmas` used in the
+        // script
+        .Case("pragmaCount", ePragma)
+        .Case("objectSlotCount", eObjectSlot)
+        .Case("versionInfo", eVersionInfo)
+        .Default(-1);
+  };
+
+  // parse all text lines of .rs.info
+  for (auto line = info_lines.begin(); line != info_lines.end(); ++line) {
+    const auto kv_pair = line->split(": ");
+    const auto key = kv_pair.first;
+    const auto val = kv_pair.second.trim();
+
+    const auto handler = rs_info_handler(key);
+    if (handler == -1)
+      continue;
+    // getAsInteger returns `true` on an error condition - we're only interested
+    // in numeric fields at the moment
+    uint64_t n_lines;
+    if (val.getAsInteger(10, n_lines)) {
+      if (log)
+        log->Debug("Failed to parse non-numeric '.rs.info' section %s",
+                   line->str().c_str());
+      continue;
+    }
+    if (info_lines.end() - (line + 1) < (ptrdiff_t)n_lines)
+      return false;
 
-    // parse all text lines of .rs.info
-    for (auto line = info_lines.begin(); line != info_lines.end(); ++line)
-    {
-        uint32_t numDefns = 0;
-        if (sscanf(line->c_str(), "exportVarCount: %" PRIu32 "", &numDefns) == 1)
-        {
-            while (numDefns--)
-                m_globals.push_back(RSGlobalDescriptor(this, (++line)->c_str()));
-        }
-        else if (sscanf(line->c_str(), "exportForEachCount: %" PRIu32 "", &numDefns) == 1)
-        {
-            while (numDefns--)
-            {
-                uint32_t slot = 0;
-                name[0] = '\0';
-                static const char *fmt_s = "%" PRIu32 " - " MAXLINESTR;
-                if (sscanf((++line)->c_str(), fmt_s, &slot, name.data()) == 2)
-                {
-                    if (name[0] != '\0')
-                        m_kernels.push_back(RSKernelDescriptor(this, name.data(), slot));
-                }
-            }
-        }
-        else if (sscanf(line->c_str(), "pragmaCount: %" PRIu32 "", &numDefns) == 1)
-        {
-            while (numDefns--)
-            {
-                name[0] = value[0] = '\0';
-                static const char *fmt_s = MAXLINESTR " - " MAXLINESTR;
-                if (sscanf((++line)->c_str(), fmt_s, name.data(), value.data()) != 0)
-                {
-                    if (name[0] != '\0')
-                        m_pragmas[std::string(name.data())] = value.data();
-                }
-            }
-        }
-        else
-        {
-            Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-            if (log)
-            {
-                log->Printf("%s - skipping .rs.info field '%s'", __FUNCTION__, line->c_str());
-            }
-        }
+    bool success = false;
+    switch (handler) {
+    case eExportVar:
+      success = ParseExportVarCount(line, n_lines);
+      break;
+    case eExportForEach:
+      success = ParseExportForeachCount(line, n_lines);
+      break;
+    case eExportReduce:
+      success = ParseExportReduceCount(line, n_lines);
+      break;
+    case ePragma:
+      success = ParsePragmaCount(line, n_lines);
+      break;
+    case eVersionInfo:
+      success = ParseVersionInfo(line, n_lines);
+      break;
+    default: {
+      if (log)
+        log->Printf("%s - skipping .rs.info field '%s'", __FUNCTION__,
+                    line->str().c_str());
+      continue;
     }
-
-    // 'root' kernel should always be present
-    return m_kernels.size() > 0;
+    }
+    if (!success)
+      return false;
+    line += n_lines;
+  }
+  return info_lines.size() > 0;
 }
 
-void
-RenderScriptRuntime::Status(Stream &strm) const
-{
-    if (m_libRS)
-    {
-        strm.Printf("Runtime Library discovered.");
-        strm.EOL();
-    }
-    if (m_libRSDriver)
-    {
-        strm.Printf("Runtime Driver discovered.");
-        strm.EOL();
-    }
-    if (m_libRSCpuRef)
-    {
-        strm.Printf("CPU Reference Implementation discovered.");
-        strm.EOL();
-    }
+void RenderScriptRuntime::Status(Stream &strm) const {
+  if (m_libRS) {
+    strm.Printf("Runtime Library discovered.");
+    strm.EOL();
+  }
+  if (m_libRSDriver) {
+    strm.Printf("Runtime Driver discovered.");
+    strm.EOL();
+  }
+  if (m_libRSCpuRef) {
+    strm.Printf("CPU Reference Implementation discovered.");
+    strm.EOL();
+  }
 
-    if (m_runtimeHooks.size())
-    {
-        strm.Printf("Runtime functions hooked:");
-        strm.EOL();
-        for (auto b : m_runtimeHooks)
-        {
-            strm.Indent(b.second->defn->name);
-            strm.EOL();
-        }
-    }
-    else
-    {
-        strm.Printf("Runtime is not hooked.");
-        strm.EOL();
+  if (m_runtimeHooks.size()) {
+    strm.Printf("Runtime functions hooked:");
+    strm.EOL();
+    for (auto b : m_runtimeHooks) {
+      strm.Indent(b.second->defn->name);
+      strm.EOL();
     }
+  } else {
+    strm.Printf("Runtime is not hooked.");
+    strm.EOL();
+  }
 }
 
-void
-RenderScriptRuntime::DumpContexts(Stream &strm) const
-{
-    strm.Printf("Inferred RenderScript Contexts:");
-    strm.EOL();
-    strm.IndentMore();
+void RenderScriptRuntime::DumpContexts(Stream &strm) const {
+  strm.Printf("Inferred RenderScript Contexts:");
+  strm.EOL();
+  strm.IndentMore();
 
-    std::map<addr_t, uint64_t> contextReferences;
+  std::map<addr_t, uint64_t> contextReferences;
 
-    // Iterate over all of the currently discovered scripts.
-    // Note: We cant push or pop from m_scripts inside this loop or it may invalidate script.
-    for (const auto &script : m_scripts)
-    {
-        if (!script->context.isValid())
-            continue;
-        lldb::addr_t context = *script->context;
+  // Iterate over all of the currently discovered scripts.
+  // Note: We cant push or pop from m_scripts inside this loop or it may
+  // invalidate script.
+  for (const auto &script : m_scripts) {
+    if (!script->context.isValid())
+      continue;
+    lldb::addr_t context = *script->context;
 
-        if (contextReferences.find(context) != contextReferences.end())
-        {
-            contextReferences[context]++;
-        }
-        else
-        {
-            contextReferences[context] = 1;
-        }
+    if (contextReferences.find(context) != contextReferences.end()) {
+      contextReferences[context]++;
+    } else {
+      contextReferences[context] = 1;
     }
+  }
 
-    for (const auto &cRef : contextReferences)
-    {
-        strm.Printf("Context 0x%" PRIx64 ": %" PRIu64 " script instances", cRef.first, cRef.second);
-        strm.EOL();
-    }
-    strm.IndentLess();
+  for (const auto &cRef : contextReferences) {
+    strm.Printf("Context 0x%" PRIx64 ": %" PRIu64 " script instances",
+                cRef.first, cRef.second);
+    strm.EOL();
+  }
+  strm.IndentLess();
 }
 
-void
-RenderScriptRuntime::DumpKernels(Stream &strm) const
-{
-    strm.Printf("RenderScript Kernels:");
+void RenderScriptRuntime::DumpKernels(Stream &strm) const {
+  strm.Printf("RenderScript Kernels:");
+  strm.EOL();
+  strm.IndentMore();
+  for (const auto &module : m_rsmodules) {
+    strm.Printf("Resource '%s':", module->m_resname.c_str());
     strm.EOL();
-    strm.IndentMore();
-    for (const auto &module : m_rsmodules)
-    {
-        strm.Printf("Resource '%s':", module->m_resname.c_str());
-        strm.EOL();
-        for (const auto &kernel : module->m_kernels)
-        {
-            strm.Indent(kernel.m_name.AsCString());
-            strm.EOL();
-        }
+    for (const auto &kernel : module->m_kernels) {
+      strm.Indent(kernel.m_name.AsCString());
+      strm.EOL();
     }
-    strm.IndentLess();
+  }
+  strm.IndentLess();
 }
 
 RenderScriptRuntime::AllocationDetails *
-RenderScriptRuntime::FindAllocByID(Stream &strm, const uint32_t alloc_id)
-{
-    AllocationDetails *alloc = nullptr;
-
-    // See if we can find allocation using id as an index;
-    if (alloc_id <= m_allocations.size() && alloc_id != 0 && m_allocations[alloc_id - 1]->id == alloc_id)
-    {
-        alloc = m_allocations[alloc_id - 1].get();
-        return alloc;
-    }
-
-    // Fallback to searching
-    for (const auto &a : m_allocations)
-    {
-        if (a->id == alloc_id)
-        {
-            alloc = a.get();
-            break;
-        }
-    }
-
-    if (alloc == nullptr)
-    {
-        strm.Printf("Error: Couldn't find allocation with id matching %" PRIu32, alloc_id);
-        strm.EOL();
-    }
+RenderScriptRuntime::FindAllocByID(Stream &strm, const uint32_t alloc_id) {
+  AllocationDetails *alloc = nullptr;
 
+  // See if we can find allocation using id as an index;
+  if (alloc_id <= m_allocations.size() && alloc_id != 0 &&
+      m_allocations[alloc_id - 1]->id == alloc_id) {
+    alloc = m_allocations[alloc_id - 1].get();
     return alloc;
-}
-
-// Prints the contents of an allocation to the output stream, which may be a file
-bool
-RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id)
-{
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-
-    // Check we can find the desired allocation
-    AllocationDetails *alloc = FindAllocByID(strm, id);
-    if (!alloc)
-        return false; // FindAllocByID() will print error message for us here
+  }
 
-    if (log)
-        log->Printf("%s - found allocation 0x%" PRIx64, __FUNCTION__, *alloc->address.get());
-
-    // Check we have information about the allocation, if not calculate it
-    if (alloc->shouldRefresh())
-    {
-        if (log)
-            log->Printf("%s - allocation details not calculated yet, jitting info.", __FUNCTION__);
-
-        // JIT all the allocation information
-        if (!RefreshAllocation(alloc, frame_ptr))
-        {
-            strm.Printf("Error: Couldn't JIT allocation details");
-            strm.EOL();
-            return false;
-        }
+  // Fallback to searching
+  for (const auto &a : m_allocations) {
+    if (a->id == alloc_id) {
+      alloc = a.get();
+      break;
     }
+  }
 
-    // Establish format and size of each data element
-    const uint32_t vec_size = *alloc->element.type_vec_size.get();
-    const Element::DataType type = *alloc->element.type.get();
-
-    assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT && "Invalid allocation type");
+  if (alloc == nullptr) {
+    strm.Printf("Error: Couldn't find allocation with id matching %" PRIu32,
+                alloc_id);
+    strm.EOL();
+  }
 
-    lldb::Format format;
-    if (type >= Element::RS_TYPE_ELEMENT)
-        format = eFormatHex;
-    else
-        format = vec_size == 1 ? static_cast<lldb::Format>(AllocationDetails::RSTypeToFormat[type][eFormatSingle])
-                               : static_cast<lldb::Format>(AllocationDetails::RSTypeToFormat[type][eFormatVector]);
+  return alloc;
+}
 
-    const uint32_t data_size = *alloc->element.datum_size.get();
+// Prints the contents of an allocation to the output stream, which may be a
+// file
+bool RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr,
+                                         const uint32_t id) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-    if (log)
-        log->Printf("%s - element size %" PRIu32 " bytes, including padding", __FUNCTION__, data_size);
+  // Check we can find the desired allocation
+  AllocationDetails *alloc = FindAllocByID(strm, id);
+  if (!alloc)
+    return false; // FindAllocByID() will print error message for us here
 
-    // Allocate a buffer to copy data into
-    std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
-    if (!buffer)
-    {
-        strm.Printf("Error: Couldn't read allocation data");
-        strm.EOL();
-        return false;
-    }
+  if (log)
+    log->Printf("%s - found allocation 0x%" PRIx64, __FUNCTION__,
+                *alloc->address.get());
 
-    // Calculate stride between rows as there may be padding at end of rows since
-    // allocated memory is 16-byte aligned
-    if (!alloc->stride.isValid())
-    {
-        if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension
-            alloc->stride = 0;
-        else if (!JITAllocationStride(alloc, frame_ptr))
-        {
-            strm.Printf("Error: Couldn't calculate allocation row stride");
-            strm.EOL();
-            return false;
-        }
-    }
-    const uint32_t stride = *alloc->stride.get();
-    const uint32_t size = *alloc->size.get(); // Size of whole allocation
-    const uint32_t padding = alloc->element.padding.isValid() ? *alloc->element.padding.get() : 0;
+  // Check we have information about the allocation, if not calculate it
+  if (alloc->ShouldRefresh()) {
     if (log)
-        log->Printf("%s - stride %" PRIu32 " bytes, size %" PRIu32 " bytes, padding %" PRIu32,
-                    __FUNCTION__, stride, size, padding);
-
-    // Find dimensions used to index loops, so need to be non-zero
-    uint32_t dim_x = alloc->dimension.get()->dim_1;
-    dim_x = dim_x == 0 ? 1 : dim_x;
-
-    uint32_t dim_y = alloc->dimension.get()->dim_2;
-    dim_y = dim_y == 0 ? 1 : dim_y;
-
-    uint32_t dim_z = alloc->dimension.get()->dim_3;
-    dim_z = dim_z == 0 ? 1 : dim_z;
-
-    // Use data extractor to format output
-    const uint32_t archByteSize = GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
-    DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(), archByteSize);
-
-    uint32_t offset = 0;   // Offset in buffer to next element to be printed
-    uint32_t prev_row = 0; // Offset to the start of the previous row
-
-    // Iterate over allocation dimensions, printing results to user
-    strm.Printf("Data (X, Y, Z):");
-    for (uint32_t z = 0; z < dim_z; ++z)
-    {
-        for (uint32_t y = 0; y < dim_y; ++y)
-        {
-            // Use stride to index start of next row.
-            if (!(y == 0 && z == 0))
-                offset = prev_row + stride;
-            prev_row = offset;
-
-            // Print each element in the row individually
-            for (uint32_t x = 0; x < dim_x; ++x)
-            {
-                strm.Printf("\n(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") = ", x, y, z);
-                if ((type == Element::RS_TYPE_NONE) && (alloc->element.children.size() > 0) &&
-                    (alloc->element.type_name != Element::GetFallbackStructName()))
-                {
-                    // Here we are dumping an Element of struct type.
-                    // This is done using expression evaluation with the name of the struct type and pointer to element.
-
-                    // Don't print the name of the resulting expression, since this will be '$[0-9]+'
-                    DumpValueObjectOptions expr_options;
-                    expr_options.SetHideName(true);
-
-                    // Setup expression as derefrencing a pointer cast to element address.
-                    char expr_char_buffer[jit_max_expr_size];
-                    int chars_written = snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64,
-                                                 alloc->element.type_name.AsCString(), *alloc->data_ptr.get() + offset);
-
-                    if (chars_written < 0 || chars_written >= jit_max_expr_size)
-                    {
-                        if (log)
-                            log->Printf("%s - error in snprintf().", __FUNCTION__);
-                        continue;
-                    }
-
-                    // Evaluate expression
-                    ValueObjectSP expr_result;
-                    GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer, frame_ptr, expr_result);
-
-                    // Print the results to our stream.
-                    expr_result->Dump(strm, expr_options);
-                }
-                else
-                {
-                    alloc_data.Dump(&strm, offset, format, data_size - padding, 1, 1, LLDB_INVALID_ADDRESS, 0, 0);
-                }
-                offset += data_size;
-            }
-        }
-    }
+      log->Printf("%s - allocation details not calculated yet, jitting info.",
+                  __FUNCTION__);
+
+    // JIT all the allocation information
+    if (!RefreshAllocation(alloc, frame_ptr)) {
+      strm.Printf("Error: Couldn't JIT allocation details");
+      strm.EOL();
+      return false;
+    }
+  }
+
+  // Establish format and size of each data element
+  const uint32_t vec_size = *alloc->element.type_vec_size.get();
+  const Element::DataType type = *alloc->element.type.get();
+
+  assert(type >= Element::RS_TYPE_NONE && type <= Element::RS_TYPE_FONT &&
+         "Invalid allocation type");
+
+  lldb::Format format;
+  if (type >= Element::RS_TYPE_ELEMENT)
+    format = eFormatHex;
+  else
+    format = vec_size == 1
+                 ? static_cast<lldb::Format>(
+                       AllocationDetails::RSTypeToFormat[type][eFormatSingle])
+                 : static_cast<lldb::Format>(
+                       AllocationDetails::RSTypeToFormat[type][eFormatVector]);
+
+  const uint32_t data_size = *alloc->element.datum_size.get();
+
+  if (log)
+    log->Printf("%s - element size %" PRIu32 " bytes, including padding",
+                __FUNCTION__, data_size);
+
+  // Allocate a buffer to copy data into
+  std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
+  if (!buffer) {
+    strm.Printf("Error: Couldn't read allocation data");
     strm.EOL();
-
-    return true;
-}
-
-// Function recalculates all our cached information about allocations by jitting the
-// RS runtime regarding each allocation we know about.
-// Returns true if all allocations could be recomputed, false otherwise.
-bool
-RenderScriptRuntime::RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr)
-{
-    bool success = true;
-    for (auto &alloc : m_allocations)
-    {
-        // JIT current allocation information
-        if (!RefreshAllocation(alloc.get(), frame_ptr))
-        {
-            strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32 "\n", alloc->id);
-            success = false;
+    return false;
+  }
+
+  // Calculate stride between rows as there may be padding at end of rows since
+  // allocated memory is 16-byte aligned
+  if (!alloc->stride.isValid()) {
+    if (alloc->dimension.get()->dim_2 == 0) // We only have one dimension
+      alloc->stride = 0;
+    else if (!JITAllocationStride(alloc, frame_ptr)) {
+      strm.Printf("Error: Couldn't calculate allocation row stride");
+      strm.EOL();
+      return false;
+    }
+  }
+  const uint32_t stride = *alloc->stride.get();
+  const uint32_t size = *alloc->size.get(); // Size of whole allocation
+  const uint32_t padding =
+      alloc->element.padding.isValid() ? *alloc->element.padding.get() : 0;
+  if (log)
+    log->Printf("%s - stride %" PRIu32 " bytes, size %" PRIu32
+                " bytes, padding %" PRIu32,
+                __FUNCTION__, stride, size, padding);
+
+  // Find dimensions used to index loops, so need to be non-zero
+  uint32_t dim_x = alloc->dimension.get()->dim_1;
+  dim_x = dim_x == 0 ? 1 : dim_x;
+
+  uint32_t dim_y = alloc->dimension.get()->dim_2;
+  dim_y = dim_y == 0 ? 1 : dim_y;
+
+  uint32_t dim_z = alloc->dimension.get()->dim_3;
+  dim_z = dim_z == 0 ? 1 : dim_z;
+
+  // Use data extractor to format output
+  const uint32_t target_ptr_size =
+      GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
+  DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(),
+                           target_ptr_size);
+
+  uint32_t offset = 0;   // Offset in buffer to next element to be printed
+  uint32_t prev_row = 0; // Offset to the start of the previous row
+
+  // Iterate over allocation dimensions, printing results to user
+  strm.Printf("Data (X, Y, Z):");
+  for (uint32_t z = 0; z < dim_z; ++z) {
+    for (uint32_t y = 0; y < dim_y; ++y) {
+      // Use stride to index start of next row.
+      if (!(y == 0 && z == 0))
+        offset = prev_row + stride;
+      prev_row = offset;
+
+      // Print each element in the row individually
+      for (uint32_t x = 0; x < dim_x; ++x) {
+        strm.Printf("\n(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ") = ", x, y, z);
+        if ((type == Element::RS_TYPE_NONE) &&
+            (alloc->element.children.size() > 0) &&
+            (alloc->element.type_name != Element::GetFallbackStructName())) {
+          // Here we are dumping an Element of struct type.
+          // This is done using expression evaluation with the name of the
+          // struct type and pointer to element.
+          // Don't print the name of the resulting expression, since this will
+          // be '$[0-9]+'
+          DumpValueObjectOptions expr_options;
+          expr_options.SetHideName(true);
+
+          // Setup expression as derefrencing a pointer cast to element address.
+          char expr_char_buffer[jit_max_expr_size];
+          int written =
+              snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64,
+                       alloc->element.type_name.AsCString(),
+                       *alloc->data_ptr.get() + offset);
+
+          if (written < 0 || written >= jit_max_expr_size) {
+            if (log)
+              log->Printf("%s - error in snprintf().", __FUNCTION__);
+            continue;
+          }
+
+          // Evaluate expression
+          ValueObjectSP expr_result;
+          GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer,
+                                                       frame_ptr, expr_result);
+
+          // Print the results to our stream.
+          expr_result->Dump(strm, expr_options);
+        } else {
+          alloc_data.Dump(&strm, offset, format, data_size - padding, 1, 1,
+                          LLDB_INVALID_ADDRESS, 0, 0);
         }
+        offset += data_size;
+      }
     }
+  }
+  strm.EOL();
 
-    if (success)
-        strm.Printf("All allocations successfully recomputed");
-    strm.EOL();
+  return true;
+}
 
-    return success;
+// Function recalculates all our cached information about allocations by jitting
+// the RS runtime regarding each allocation we know about. Returns true if all
+// allocations could be recomputed, false otherwise.
+bool RenderScriptRuntime::RecomputeAllAllocations(Stream &strm,
+                                                  StackFrame *frame_ptr) {
+  bool success = true;
+  for (auto &alloc : m_allocations) {
+    // JIT current allocation information
+    if (!RefreshAllocation(alloc.get(), frame_ptr)) {
+      strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32
+                  "\n",
+                  alloc->id);
+      success = false;
+    }
+  }
+
+  if (success)
+    strm.Printf("All allocations successfully recomputed");
+  strm.EOL();
+
+  return success;
 }
 
-// Prints information regarding currently loaded allocations.
-// These details are gathered by jitting the runtime, which has as latency.
-// Index parameter specifies a single allocation ID to print, or a zero value to print them all
-void
-RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr, const uint32_t index)
-{
-    strm.Printf("RenderScript Allocations:");
+// Prints information regarding currently loaded allocations. These details are
+// gathered by jitting the runtime, which has as latency. Index parameter
+// specifies a single allocation ID to print, or a zero value to print them all
+void RenderScriptRuntime::ListAllocations(Stream &strm, StackFrame *frame_ptr,
+                                          const uint32_t index) {
+  strm.Printf("RenderScript Allocations:");
+  strm.EOL();
+  strm.IndentMore();
+
+  for (auto &alloc : m_allocations) {
+    // index will only be zero if we want to print all allocations
+    if (index != 0 && index != alloc->id)
+      continue;
+
+    // JIT current allocation information
+    if (alloc->ShouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr)) {
+      strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32,
+                  alloc->id);
+      strm.EOL();
+      continue;
+    }
+
+    strm.Printf("%" PRIu32 ":", alloc->id);
     strm.EOL();
     strm.IndentMore();
 
-    for (auto &alloc : m_allocations)
-    {
-        // index will only be zero if we want to print all allocations
-        if (index != 0 && index != alloc->id)
-            continue;
-
-        // JIT current allocation information
-        if (alloc->shouldRefresh() && !RefreshAllocation(alloc.get(), frame_ptr))
-        {
-            strm.Printf("Error: Couldn't evaluate details for allocation %" PRIu32, alloc->id);
-            strm.EOL();
-            continue;
-        }
-
-        strm.Printf("%" PRIu32 ":", alloc->id);
-        strm.EOL();
-        strm.IndentMore();
-
-        strm.Indent("Context: ");
-        if (!alloc->context.isValid())
-            strm.Printf("unknown\n");
-        else
-            strm.Printf("0x%" PRIx64 "\n", *alloc->context.get());
-
-        strm.Indent("Address: ");
-        if (!alloc->address.isValid())
-            strm.Printf("unknown\n");
-        else
-            strm.Printf("0x%" PRIx64 "\n", *alloc->address.get());
-
-        strm.Indent("Data pointer: ");
-        if (!alloc->data_ptr.isValid())
-            strm.Printf("unknown\n");
-        else
-            strm.Printf("0x%" PRIx64 "\n", *alloc->data_ptr.get());
+    strm.Indent("Context: ");
+    if (!alloc->context.isValid())
+      strm.Printf("unknown\n");
+    else
+      strm.Printf("0x%" PRIx64 "\n", *alloc->context.get());
 
-        strm.Indent("Dimensions: ");
-        if (!alloc->dimension.isValid())
-            strm.Printf("unknown\n");
-        else
-            strm.Printf("(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
-                        alloc->dimension.get()->dim_1, alloc->dimension.get()->dim_2, alloc->dimension.get()->dim_3);
+    strm.Indent("Address: ");
+    if (!alloc->address.isValid())
+      strm.Printf("unknown\n");
+    else
+      strm.Printf("0x%" PRIx64 "\n", *alloc->address.get());
 
-        strm.Indent("Data Type: ");
-        if (!alloc->element.type.isValid() || !alloc->element.type_vec_size.isValid())
-            strm.Printf("unknown\n");
-        else
-        {
-            const int vector_size = *alloc->element.type_vec_size.get();
-            Element::DataType type = *alloc->element.type.get();
-
-            if (!alloc->element.type_name.IsEmpty())
-                strm.Printf("%s\n", alloc->element.type_name.AsCString());
-            else
-            {
-                // Enum value isn't monotonous, so doesn't always index RsDataTypeToString array
-                if (type >= Element::RS_TYPE_ELEMENT && type <= Element::RS_TYPE_FONT)
-                    type = static_cast<Element::DataType>((type - Element::RS_TYPE_ELEMENT) +
-                                                          Element::RS_TYPE_MATRIX_2X2 + 1);
-
-                if (type >= (sizeof(AllocationDetails::RsDataTypeToString) /
-                             sizeof(AllocationDetails::RsDataTypeToString[0])) ||
-                    vector_size > 4 || vector_size < 1)
-                    strm.Printf("invalid type\n");
-                else
-                    strm.Printf("%s\n", AllocationDetails::RsDataTypeToString[static_cast<uint32_t>(type)]
-                                                                             [vector_size - 1]);
-            }
-        }
+    strm.Indent("Data pointer: ");
+    if (!alloc->data_ptr.isValid())
+      strm.Printf("unknown\n");
+    else
+      strm.Printf("0x%" PRIx64 "\n", *alloc->data_ptr.get());
 
-        strm.Indent("Data Kind: ");
-        if (!alloc->element.type_kind.isValid())
-            strm.Printf("unknown\n");
+    strm.Indent("Dimensions: ");
+    if (!alloc->dimension.isValid())
+      strm.Printf("unknown\n");
+    else
+      strm.Printf("(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
+                  alloc->dimension.get()->dim_1, alloc->dimension.get()->dim_2,
+                  alloc->dimension.get()->dim_3);
+
+    strm.Indent("Data Type: ");
+    if (!alloc->element.type.isValid() ||
+        !alloc->element.type_vec_size.isValid())
+      strm.Printf("unknown\n");
+    else {
+      const int vector_size = *alloc->element.type_vec_size.get();
+      Element::DataType type = *alloc->element.type.get();
+
+      if (!alloc->element.type_name.IsEmpty())
+        strm.Printf("%s\n", alloc->element.type_name.AsCString());
+      else {
+        // Enum value isn't monotonous, so doesn't always index
+        // RsDataTypeToString array
+        if (type >= Element::RS_TYPE_ELEMENT && type <= Element::RS_TYPE_FONT)
+          type =
+              static_cast<Element::DataType>((type - Element::RS_TYPE_ELEMENT) +
+                                             Element::RS_TYPE_MATRIX_2X2 + 1);
+
+        if (type >= (sizeof(AllocationDetails::RsDataTypeToString) /
+                     sizeof(AllocationDetails::RsDataTypeToString[0])) ||
+            vector_size > 4 || vector_size < 1)
+          strm.Printf("invalid type\n");
         else
-        {
-            const Element::DataKind kind = *alloc->element.type_kind.get();
-            if (kind < Element::RS_KIND_USER || kind > Element::RS_KIND_PIXEL_YUV)
-                strm.Printf("invalid kind\n");
-            else
-                strm.Printf("%s\n", AllocationDetails::RsDataKindToString[static_cast<uint32_t>(kind)]);
-        }
-
-        strm.EOL();
-        strm.IndentLess();
+          strm.Printf(
+              "%s\n",
+              AllocationDetails::RsDataTypeToString[static_cast<uint32_t>(type)]
+                                                   [vector_size - 1]);
+      }
+    }
+
+    strm.Indent("Data Kind: ");
+    if (!alloc->element.type_kind.isValid())
+      strm.Printf("unknown\n");
+    else {
+      const Element::DataKind kind = *alloc->element.type_kind.get();
+      if (kind < Element::RS_KIND_USER || kind > Element::RS_KIND_PIXEL_YUV)
+        strm.Printf("invalid kind\n");
+      else
+        strm.Printf(
+            "%s\n",
+            AllocationDetails::RsDataKindToString[static_cast<uint32_t>(kind)]);
     }
+
+    strm.EOL();
     strm.IndentLess();
+  }
+  strm.IndentLess();
 }
 
 // Set breakpoints on every kernel found in RS module
-void
-RenderScriptRuntime::BreakOnModuleKernels(const RSModuleDescriptorSP rsmodule_sp)
-{
-    for (const auto &kernel : rsmodule_sp->m_kernels)
-    {
-        // Don't set breakpoint on 'root' kernel
-        if (strcmp(kernel.m_name.AsCString(), "root") == 0)
-            continue;
-
-        CreateKernelBreakpoint(kernel.m_name);
-    }
+void RenderScriptRuntime::BreakOnModuleKernels(
+    const RSModuleDescriptorSP rsmodule_sp) {
+  for (const auto &kernel : rsmodule_sp->m_kernels) {
+    // Don't set breakpoint on 'root' kernel
+    if (strcmp(kernel.m_name.AsCString(), "root") == 0)
+      continue;
+
+    CreateKernelBreakpoint(kernel.m_name);
+  }
 }
 
-// Method is internally called by the 'kernel breakpoint all' command to
-// enable or disable breaking on all kernels.
-//
-// When do_break is true we want to enable this functionality.
-// When do_break is false we want to disable it.
-void
-RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
+// Method is internally called by the 'kernel breakpoint all' command to enable
+// or disable breaking on all kernels. When do_break is true we want to enable
+// this functionality. When do_break is false we want to disable it.
+void RenderScriptRuntime::SetBreakAllKernels(bool do_break, TargetSP target) {
+  Log *log(
+      GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
 
-    InitSearchFilter(target);
+  InitSearchFilter(target);
 
-    // Set breakpoints on all the kernels
-    if (do_break && !m_breakAllKernels)
-    {
-        m_breakAllKernels = true;
+  // Set breakpoints on all the kernels
+  if (do_break && !m_breakAllKernels) {
+    m_breakAllKernels = true;
 
-        for (const auto &module : m_rsmodules)
-            BreakOnModuleKernels(module);
+    for (const auto &module : m_rsmodules)
+      BreakOnModuleKernels(module);
 
-        if (log)
-            log->Printf("%s(True) - breakpoints set on all currently loaded kernels.", __FUNCTION__);
-    }
-    else if (!do_break && m_breakAllKernels) // Breakpoints won't be set on any new kernels.
-    {
-        m_breakAllKernels = false;
+    if (log)
+      log->Printf("%s(True) - breakpoints set on all currently loaded kernels.",
+                  __FUNCTION__);
+  } else if (!do_break &&
+             m_breakAllKernels) // Breakpoints won't be set on any new kernels.
+  {
+    m_breakAllKernels = false;
 
-        if (log)
-            log->Printf("%s(False) - breakpoints no longer automatically set.", __FUNCTION__);
-    }
+    if (log)
+      log->Printf("%s(False) - breakpoints no longer automatically set.",
+                  __FUNCTION__);
+  }
 }
 
 // Given the name of a kernel this function creates a breakpoint using our
 // own breakpoint resolver, and returns the Breakpoint shared pointer.
 BreakpointSP
-RenderScriptRuntime::CreateKernelBreakpoint(const ConstString &name)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
+RenderScriptRuntime::CreateKernelBreakpoint(const ConstString &name) {
+  Log *log(
+      GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
 
-    if (!m_filtersp)
-    {
-        if (log)
-            log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
-        return nullptr;
-    }
+  if (!m_filtersp) {
+    if (log)
+      log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
+    return nullptr;
+  }
 
-    BreakpointResolverSP resolver_sp(new RSBreakpointResolver(nullptr, name));
-    BreakpointSP bp = GetProcess()->GetTarget().CreateBreakpoint(m_filtersp, resolver_sp, false, false, false);
+  BreakpointResolverSP resolver_sp(new RSBreakpointResolver(nullptr, name));
+  BreakpointSP bp = GetProcess()->GetTarget().CreateBreakpoint(
+      m_filtersp, resolver_sp, false, false, false);
 
-    // Give RS breakpoints a specific name, so the user can manipulate them as a group.
-    Error err;
-    if (!bp->AddName("RenderScriptKernel", err) && log)
-        log->Printf("%s - error setting break name, '%s'.", __FUNCTION__, err.AsCString());
+  // Give RS breakpoints a specific name, so the user can manipulate them as a
+  // group.
+  Error err;
+  if (!bp->AddName("RenderScriptKernel", err))
+    if (log)
+      log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
+                  err.AsCString());
 
-    return bp;
+  return bp;
 }
 
-// Given an expression for a variable this function tries to calculate the variable's value.
-// If this is possible it returns true and sets the uint64_t parameter to the variables unsigned value.
-// Otherwise function returns false.
-bool
-RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp, const char *var_name, uint64_t &val)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
-    Error error;
-    VariableSP var_sp;
-
-    // Find variable in stack frame
-    ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath(
-        var_name, eNoDynamicValues,
-        StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
-        var_sp, error));
-    if (!error.Success())
-    {
-        if (log)
-            log->Printf("%s - error, couldn't find '%s' in frame", __FUNCTION__, var_name);
-        return false;
-    }
+BreakpointSP
+RenderScriptRuntime::CreateReductionBreakpoint(const ConstString &name,
+                                               int kernel_types) {
+  Log *log(
+      GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
 
-    // Find the uint32_t value for the variable
-    bool success = false;
-    val = value_sp->GetValueAsUnsigned(0, &success);
-    if (!success)
-    {
-        if (log)
-            log->Printf("%s - error, couldn't parse '%s' as an uint32_t.", __FUNCTION__, var_name);
-        return false;
-    }
+  if (!m_filtersp) {
+    if (log)
+      log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
+    return nullptr;
+  }
 
-    return true;
+  BreakpointResolverSP resolver_sp(new RSReduceBreakpointResolver(
+      nullptr, name, &m_rsmodules, kernel_types));
+  BreakpointSP bp = GetProcess()->GetTarget().CreateBreakpoint(
+      m_filtersp, resolver_sp, false, false, false);
+
+  // Give RS breakpoints a specific name, so the user can manipulate them as a
+  // group.
+  Error err;
+  if (!bp->AddName("RenderScriptReduction", err))
+    if (log)
+      log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
+                  err.AsCString());
+
+  return bp;
 }
 
-// Function attempts to find the current coordinate of a kernel invocation by investigating the
-// values of frame variables in the .expand function. These coordinates are returned via the coord
-// array reference parameter. Returns true if the coordinates could be found, and false otherwise.
-bool
-RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord, Thread *thread_ptr)
-{
-    static const std::string s_runtimeExpandSuffix(".expand");
-    static const std::array<const char *, 3> s_runtimeCoordVars{{"rsIndex", "p->current.y", "p->current.z"}};
+// Given an expression for a variable this function tries to calculate the
+// variable's value. If this is possible it returns true and sets the uint64_t
+// parameter to the variables unsigned value. Otherwise function returns false.
+bool RenderScriptRuntime::GetFrameVarAsUnsigned(const StackFrameSP frame_sp,
+                                                const char *var_name,
+                                                uint64_t &val) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  Error err;
+  VariableSP var_sp;
+
+  // Find variable in stack frame
+  ValueObjectSP value_sp(frame_sp->GetValueForVariableExpressionPath(
+      var_name, eNoDynamicValues,
+      StackFrame::eExpressionPathOptionCheckPtrVsMember |
+          StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
+      var_sp, err));
+  if (!err.Success()) {
+    if (log)
+      log->Printf("%s - error, couldn't find '%s' in frame", __FUNCTION__,
+                  var_name);
+    return false;
+  }
 
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
+  // Find the uint32_t value for the variable
+  bool success = false;
+  val = value_sp->GetValueAsUnsigned(0, &success);
+  if (!success) {
+    if (log)
+      log->Printf("%s - error, couldn't parse '%s' as an uint32_t.",
+                  __FUNCTION__, var_name);
+    return false;
+  }
 
-    if (!thread_ptr)
-    {
-        if (log)
-            log->Printf("%s - Error, No thread pointer", __FUNCTION__);
+  return true;
+}
 
-        return false;
-    }
+// Function attempts to find the current coordinate of a kernel invocation by
+// investigating the values of frame variables in the .expand function. These
+// coordinates are returned via the coord array reference parameter. Returns
+// true if the coordinates could be found, and false otherwise.
+bool RenderScriptRuntime::GetKernelCoordinate(RSCoordinate &coord,
+                                              Thread *thread_ptr) {
+  static const char *const x_expr = "rsIndex";
+  static const char *const y_expr = "p->current.y";
+  static const char *const z_expr = "p->current.z";
 
-    // Walk the call stack looking for a function whose name has the suffix '.expand'
-    // and contains the variables we're looking for.
-    for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i)
-    {
-        if (!thread_ptr->SetSelectedFrameByIndex(i))
-            continue;
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
-        StackFrameSP frame_sp = thread_ptr->GetSelectedFrame();
-        if (!frame_sp)
-            continue;
+  if (!thread_ptr) {
+    if (log)
+      log->Printf("%s - Error, No thread pointer", __FUNCTION__);
 
-        // Find the function name
-        const SymbolContext sym_ctx = frame_sp->GetSymbolContext(false);
-        const char *func_name_cstr = sym_ctx.GetFunctionName().AsCString();
-        if (!func_name_cstr)
-            continue;
+    return false;
+  }
 
-        if (log)
-            log->Printf("%s - Inspecting function '%s'", __FUNCTION__, func_name_cstr);
+  // Walk the call stack looking for a function whose name has the suffix
+  // '.expand' and contains the variables we're looking for.
+  for (uint32_t i = 0; i < thread_ptr->GetStackFrameCount(); ++i) {
+    if (!thread_ptr->SetSelectedFrameByIndex(i))
+      continue;
 
-        // Check if function name has .expand suffix
-        std::string func_name(func_name_cstr);
-        const int length_difference = func_name.length() - s_runtimeExpandSuffix.length();
-        if (length_difference <= 0)
-            continue;
+    StackFrameSP frame_sp = thread_ptr->GetSelectedFrame();
+    if (!frame_sp)
+      continue;
 
-        const int32_t has_expand_suffix = func_name.compare(length_difference,
-                                                            s_runtimeExpandSuffix.length(),
-                                                            s_runtimeExpandSuffix);
+    // Find the function name
+    const SymbolContext sym_ctx = frame_sp->GetSymbolContext(false);
+    const ConstString func_name = sym_ctx.GetFunctionName();
+    if (!func_name)
+      continue;
 
-        if (has_expand_suffix != 0)
-            continue;
+    if (log)
+      log->Printf("%s - Inspecting function '%s'", __FUNCTION__,
+                  func_name.GetCString());
 
-        if (log)
-            log->Printf("%s - Found .expand function '%s'", __FUNCTION__, func_name_cstr);
-
-        // Get values for variables in .expand frame that tell us the current kernel invocation
-        bool found_coord_variables = true;
-        assert(s_runtimeCoordVars.size() == coord.size());
-
-        for (uint32_t i = 0; i < coord.size(); ++i)
-        {
-            uint64_t value = 0;
-            if (!GetFrameVarAsUnsigned(frame_sp, s_runtimeCoordVars[i], value))
-            {
-                found_coord_variables = false;
-                break;
-            }
-            coord[i] = value;
-        }
+    // Check if function name has .expand suffix
+    if (!func_name.GetStringRef().endswith(".expand"))
+      continue;
 
-        if (found_coord_variables)
-            return true;
-    }
-    return false;
+    if (log)
+      log->Printf("%s - Found .expand function '%s'", __FUNCTION__,
+                  func_name.GetCString());
+
+    // Get values for variables in .expand frame that tell us the current kernel
+    // invocation
+    uint64_t x, y, z;
+    bool found = GetFrameVarAsUnsigned(frame_sp, x_expr, x) &&
+                 GetFrameVarAsUnsigned(frame_sp, y_expr, y) &&
+                 GetFrameVarAsUnsigned(frame_sp, z_expr, z);
+
+    if (found) {
+      // The RenderScript runtime uses uint32_t for these vars. If they're not
+      // within bounds, our frame parsing is garbage
+      assert(x <= UINT32_MAX && y <= UINT32_MAX && z <= UINT32_MAX);
+      coord.x = (uint32_t)x;
+      coord.y = (uint32_t)y;
+      coord.z = (uint32_t)z;
+      return true;
+    }
+  }
+  return false;
 }
 
-// Callback when a kernel breakpoint hits and we're looking for a specific coordinate.
-// Baton parameter contains a pointer to the target coordinate we want to break on.
-// Function then checks the .expand frame for the current coordinate and breaks to user if it matches.
+// Callback when a kernel breakpoint hits and we're looking for a specific
+// coordinate. Baton parameter contains a pointer to the target coordinate we
+// want to break on.
+// Function then checks the .expand frame for the current coordinate and breaks
+// to user if it matches.
 // Parameter 'break_id' is the id of the Breakpoint which made the callback.
 // Parameter 'break_loc_id' is the id for the BreakpointLocation which was hit,
 // a single logical breakpoint can have multiple addresses.
-bool
-RenderScriptRuntime::KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx, user_id_t break_id,
-                                         user_id_t break_loc_id)
-{
-    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
-
-    assert(baton && "Error: null baton in conditional kernel breakpoint callback");
+bool RenderScriptRuntime::KernelBreakpointHit(void *baton,
+                                              StoppointCallbackContext *ctx,
+                                              user_id_t break_id,
+                                              user_id_t break_loc_id) {
+  Log *log(
+      GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
+
+  assert(baton &&
+         "Error: null baton in conditional kernel breakpoint callback");
+
+  // Coordinate we want to stop on
+  RSCoordinate target_coord = *static_cast<RSCoordinate *>(baton);
+
+  if (log)
+    log->Printf("%s - Break ID %" PRIu64 ", " FMT_COORD, __FUNCTION__, break_id,
+                target_coord.x, target_coord.y, target_coord.z);
+
+  // Select current thread
+  ExecutionContext context(ctx->exe_ctx_ref);
+  Thread *thread_ptr = context.GetThreadPtr();
+  assert(thread_ptr && "Null thread pointer");
+
+  // Find current kernel invocation from .expand frame variables
+  RSCoordinate current_coord{};
+  if (!GetKernelCoordinate(current_coord, thread_ptr)) {
+    if (log)
+      log->Printf("%s - Error, couldn't select .expand stack frame",
+                  __FUNCTION__);
+    return false;
+  }
 
-    // Coordinate we want to stop on
-    const uint32_t *target_coord = static_cast<const uint32_t *>(baton);
+  if (log)
+    log->Printf("%s - " FMT_COORD, __FUNCTION__, current_coord.x,
+                current_coord.y, current_coord.z);
 
+  // Check if the current kernel invocation coordinate matches our target
+  // coordinate
+  if (target_coord == current_coord) {
     if (log)
-        log->Printf("%s - Break ID %" PRIu64 ", (%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", __FUNCTION__, break_id,
-                    target_coord[0], target_coord[1], target_coord[2]);
+      log->Printf("%s, BREAKING " FMT_COORD, __FUNCTION__, current_coord.x,
+                  current_coord.y, current_coord.z);
+
+    BreakpointSP breakpoint_sp =
+        context.GetTargetPtr()->GetBreakpointByID(break_id);
+    assert(breakpoint_sp != nullptr &&
+           "Error: Couldn't find breakpoint matching break id for callback");
+    breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint
+                                      // should only be hit once.
+    return true;
+  }
 
-    // Select current thread
-    ExecutionContext context(ctx->exe_ctx_ref);
-    Thread *thread_ptr = context.GetThreadPtr();
-    assert(thread_ptr && "Null thread pointer");
+  // No match on coordinate
+  return false;
+}
 
-    // Find current kernel invocation from .expand frame variables
-    RSCoordinate current_coord{}; // Zero initialise array
-    if (!GetKernelCoordinate(current_coord, thread_ptr))
-    {
-        if (log)
-            log->Printf("%s - Error, couldn't select .expand stack frame", __FUNCTION__);
-        return false;
-    }
+void RenderScriptRuntime::SetConditional(BreakpointSP bp, Stream &messages,
+                                         const RSCoordinate &coord) {
+  messages.Printf("Conditional kernel breakpoint on coordinate " FMT_COORD,
+                  coord.x, coord.y, coord.z);
+  messages.EOL();
 
-    if (log)
-        log->Printf("%s - (%" PRIu32 ",%" PRIu32 ",%" PRIu32 ")", __FUNCTION__, current_coord[0], current_coord[1],
-                    current_coord[2]);
+  // Allocate memory for the baton, and copy over coordinate
+  RSCoordinate *baton = new RSCoordinate(coord);
 
-    // Check if the current kernel invocation coordinate matches our target coordinate
-    if (current_coord[0] == target_coord[0] &&
-        current_coord[1] == target_coord[1] &&
-        current_coord[2] == target_coord[2])
-    {
-        if (log)
-            log->Printf("%s, BREAKING (%" PRIu32 ",%" PRIu32 ",%" PRIu32 ")", __FUNCTION__, current_coord[0],
-                        current_coord[1], current_coord[2]);
+  // Create a callback that will be invoked every time the breakpoint is hit.
+  // The baton object passed to the handler is the target coordinate we want to
+  // break on.
+  bp->SetCallback(KernelBreakpointHit, baton, true);
 
-        BreakpointSP breakpoint_sp = context.GetTargetPtr()->GetBreakpointByID(break_id);
-        assert(breakpoint_sp != nullptr && "Error: Couldn't find breakpoint matching break id for callback");
-        breakpoint_sp->SetEnabled(false); // Optimise since conditional breakpoint should only be hit once.
-        return true;
-    }
+  // Store a shared pointer to the baton, so the memory will eventually be
+  // cleaned up after destruction
+  m_conditional_breaks[bp->GetID()] = std::unique_ptr<RSCoordinate>(baton);
+}
 
-    // No match on coordinate
+// Tries to set a breakpoint on the start of a kernel, resolved using the kernel
+// name. Argument 'coords', represents a three dimensional coordinate which can
+// be
+// used to specify a single kernel instance to break on. If this is set then we
+// add a callback
+// to the breakpoint.
+bool RenderScriptRuntime::PlaceBreakpointOnKernel(TargetSP target,
+                                                  Stream &messages,
+                                                  const char *name,
+                                                  const RSCoordinate *coord) {
+  if (!name)
     return false;
+
+  InitSearchFilter(target);
+
+  ConstString kernel_name(name);
+  BreakpointSP bp = CreateKernelBreakpoint(kernel_name);
+  if (!bp)
+    return false;
+
+  // We have a conditional breakpoint on a specific coordinate
+  if (coord)
+    SetConditional(bp, messages, *coord);
+
+  bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);
+
+  return true;
 }
 
-// Tries to set a breakpoint on the start of a kernel, resolved using the kernel name.
-// Argument 'coords', represents a three dimensional coordinate which can be used to specify
-// a single kernel instance to break on. If this is set then we add a callback to the breakpoint.
-void
-RenderScriptRuntime::PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array<int, 3> coords,
-                                             Error &error, TargetSP target)
-{
-    if (!name)
-    {
-        error.SetErrorString("invalid kernel name");
-        return;
-    }
+BreakpointSP
+RenderScriptRuntime::CreateScriptGroupBreakpoint(const ConstString &name,
+                                                 bool stop_on_all) {
+  Log *log(
+      GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
 
-    InitSearchFilter(target);
+  if (!m_filtersp) {
+    if (log)
+      log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
+    return nullptr;
+  }
+
+  BreakpointResolverSP resolver_sp(new RSScriptGroupBreakpointResolver(
+      nullptr, name, m_scriptGroups, stop_on_all));
+  BreakpointSP bp = GetProcess()->GetTarget().CreateBreakpoint(
+      m_filtersp, resolver_sp, false, false, false);
+  // Give RS breakpoints a specific name, so the user can manipulate them as a
+  // group.
+  Error err;
+  if (!bp->AddName(name.AsCString(), err))
+    if (log)
+      log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
+                  err.AsCString());
+  // ask the breakpoint to resolve itself
+  bp->ResolveBreakpoint();
+  return bp;
+}
 
-    ConstString kernel_name(name);
-    BreakpointSP bp = CreateKernelBreakpoint(kernel_name);
+bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target,
+                                                       Stream &strm,
+                                                       const ConstString &name,
+                                                       bool multi) {
+  InitSearchFilter(target);
+  BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi);
+  if (bp)
+    bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false);
+  return bool(bp);
+}
 
-    // We have a conditional breakpoint on a specific coordinate
-    if (coords[0] != -1)
-    {
-        strm.Printf("Conditional kernel breakpoint on coordinate %" PRId32 ", %" PRId32 ", %" PRId32,
-                    coords[0], coords[1], coords[2]);
-        strm.EOL();
+bool RenderScriptRuntime::PlaceBreakpointOnReduction(TargetSP target,
+                                                     Stream &messages,
+                                                     const char *reduce_name,
+                                                     const RSCoordinate *coord,
+                                                     int kernel_types) {
+  if (!reduce_name)
+    return false;
 
-        // Allocate memory for the baton, and copy over coordinate
-        uint32_t *baton = new uint32_t[coords.size()];
-        baton[0] = coords[0]; baton[1] = coords[1]; baton[2] = coords[2];
+  InitSearchFilter(target);
+  BreakpointSP bp =
+      CreateReductionBreakpoint(ConstString(reduce_name), kernel_types);
+  if (!bp)
+    return false;
 
-        // Create a callback that will be invoked everytime the breakpoint is hit.
-        // The baton object passed to the handler is the target coordinate we want to break on.
-        bp->SetCallback(KernelBreakpointHit, baton, true);
+  if (coord)
+    SetConditional(bp, messages, *coord);
 
-        // Store a shared pointer to the baton, so the memory will eventually be cleaned up after destruction
-        m_conditional_breaks[bp->GetID()] = std::shared_ptr<uint32_t>(baton);
-    }
+  bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);
 
-    if (bp)
-        bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false);
+  return true;
 }
 
-void
-RenderScriptRuntime::DumpModules(Stream &strm) const
-{
-    strm.Printf("RenderScript Modules:");
-    strm.EOL();
-    strm.IndentMore();
-    for (const auto &module : m_rsmodules)
-    {
-        module->Dump(strm);
-    }
-    strm.IndentLess();
+void RenderScriptRuntime::DumpModules(Stream &strm) const {
+  strm.Printf("RenderScript Modules:");
+  strm.EOL();
+  strm.IndentMore();
+  for (const auto &module : m_rsmodules) {
+    module->Dump(strm);
+  }
+  strm.IndentLess();
 }
 
 RenderScriptRuntime::ScriptDetails *
-RenderScriptRuntime::LookUpScript(addr_t address, bool create)
-{
-    for (const auto &s : m_scripts)
-    {
-        if (s->script.isValid())
-            if (*s->script == address)
-                return s.get();
-    }
-    if (create)
-    {
-        std::unique_ptr<ScriptDetails> s(new ScriptDetails);
-        s->script = address;
-        m_scripts.push_back(std::move(s));
-        return m_scripts.back().get();
-    }
-    return nullptr;
+RenderScriptRuntime::LookUpScript(addr_t address, bool create) {
+  for (const auto &s : m_scripts) {
+    if (s->script.isValid())
+      if (*s->script == address)
+        return s.get();
+  }
+  if (create) {
+    std::unique_ptr<ScriptDetails> s(new ScriptDetails);
+    s->script = address;
+    m_scripts.push_back(std::move(s));
+    return m_scripts.back().get();
+  }
+  return nullptr;
 }
 
 RenderScriptRuntime::AllocationDetails *
-RenderScriptRuntime::LookUpAllocation(addr_t address, bool create)
-{
-    for (const auto &a : m_allocations)
-    {
-        if (a->address.isValid())
-            if (*a->address == address)
-                return a.get();
-    }
-    if (create)
-    {
-        std::unique_ptr<AllocationDetails> a(new AllocationDetails);
-        a->address = address;
-        m_allocations.push_back(std::move(a));
-        return m_allocations.back().get();
-    }
-    return nullptr;
+RenderScriptRuntime::LookUpAllocation(addr_t address) {
+  for (const auto &a : m_allocations) {
+    if (a->address.isValid())
+      if (*a->address == address)
+        return a.get();
+  }
+  return nullptr;
 }
 
-void
-RSModuleDescriptor::Dump(Stream &strm) const
-{
-    strm.Indent();
-    m_module->GetFileSpec().Dump(&strm);
-    if (m_module->GetNumCompileUnits())
-    {
-        strm.Indent("Debug info loaded.");
-    }
-    else
-    {
-        strm.Indent("Debug info does not exist.");
-    }
-    strm.EOL();
-    strm.IndentMore();
-    strm.Indent();
-    strm.Printf("Globals: %" PRIu64, static_cast<uint64_t>(m_globals.size()));
-    strm.EOL();
-    strm.IndentMore();
-    for (const auto &global : m_globals)
-    {
-        global.Dump(strm);
-    }
-    strm.IndentLess();
-    strm.Indent();
-    strm.Printf("Kernels: %" PRIu64, static_cast<uint64_t>(m_kernels.size()));
-    strm.EOL();
-    strm.IndentMore();
-    for (const auto &kernel : m_kernels)
-    {
-        kernel.Dump(strm);
-    }
-    strm.Printf("Pragmas: %" PRIu64, static_cast<uint64_t>(m_pragmas.size()));
-    strm.EOL();
-    strm.IndentMore();
-    for (const auto &key_val : m_pragmas)
-    {
-        strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str());
-        strm.EOL();
-    }
-    strm.IndentLess(4);
+RenderScriptRuntime::AllocationDetails *
+RenderScriptRuntime::CreateAllocation(addr_t address) {
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
+
+  // Remove any previous allocation which contains the same address
+  auto it = m_allocations.begin();
+  while (it != m_allocations.end()) {
+    if (*((*it)->address) == address) {
+      if (log)
+        log->Printf("%s - Removing allocation id: %d, address: 0x%" PRIx64,
+                    __FUNCTION__, (*it)->id, address);
+
+      it = m_allocations.erase(it);
+    } else {
+      it++;
+    }
+  }
+
+  std::unique_ptr<AllocationDetails> a(new AllocationDetails);
+  a->address = address;
+  m_allocations.push_back(std::move(a));
+  return m_allocations.back().get();
 }
 
-void
-RSGlobalDescriptor::Dump(Stream &strm) const
-{
-    strm.Indent(m_name.AsCString());
-    VariableList var_list;
-    m_module->m_module->FindGlobalVariables(m_name, nullptr, true, 1U, var_list);
-    if (var_list.GetSize() == 1)
-    {
-        auto var = var_list.GetVariableAtIndex(0);
-        auto type = var->GetType();
-        if (type)
-        {
-            strm.Printf(" - ");
-            type->DumpTypeName(&strm);
-        }
-        else
-        {
-            strm.Printf(" - Unknown Type");
-        }
-    }
-    else
-    {
-        strm.Printf(" - variable identified, but not found in binary");
-        const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(m_name, eSymbolTypeData);
-        if (s)
-        {
-            strm.Printf(" (symbol exists) ");
-        }
-    }
+bool RenderScriptRuntime::ResolveKernelName(lldb::addr_t kernel_addr,
+                                            ConstString &name) {
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS);
 
-    strm.EOL();
+  Target &target = GetProcess()->GetTarget();
+  Address resolved;
+  // RenderScript module
+  if (!target.GetSectionLoadList().ResolveLoadAddress(kernel_addr, resolved)) {
+    if (log)
+      log->Printf("%s: unable to resolve 0x%" PRIx64 " to a loaded symbol",
+                  __FUNCTION__, kernel_addr);
+    return false;
+  }
+
+  Symbol *sym = resolved.CalculateSymbolContextSymbol();
+  if (!sym)
+    return false;
+
+  name = sym->GetName();
+  assert(IsRenderScriptModule(resolved.CalculateSymbolContextModule()));
+  if (log)
+    log->Printf("%s: 0x%" PRIx64 " resolved to the symbol '%s'", __FUNCTION__,
+                kernel_addr, name.GetCString());
+  return true;
 }
 
-void
-RSKernelDescriptor::Dump(Stream &strm) const
-{
-    strm.Indent(m_name.AsCString());
+void RSModuleDescriptor::Dump(Stream &strm) const {
+  int indent = strm.GetIndentLevel();
+
+  strm.Indent();
+  m_module->GetFileSpec().Dump(&strm);
+  strm.Indent(m_module->GetNumCompileUnits() ? "Debug info loaded."
+                                             : "Debug info does not exist.");
+  strm.EOL();
+  strm.IndentMore();
+
+  strm.Indent();
+  strm.Printf("Globals: %" PRIu64, static_cast<uint64_t>(m_globals.size()));
+  strm.EOL();
+  strm.IndentMore();
+  for (const auto &global : m_globals) {
+    global.Dump(strm);
+  }
+  strm.IndentLess();
+
+  strm.Indent();
+  strm.Printf("Kernels: %" PRIu64, static_cast<uint64_t>(m_kernels.size()));
+  strm.EOL();
+  strm.IndentMore();
+  for (const auto &kernel : m_kernels) {
+    kernel.Dump(strm);
+  }
+  strm.IndentLess();
+
+  strm.Indent();
+  strm.Printf("Pragmas: %" PRIu64, static_cast<uint64_t>(m_pragmas.size()));
+  strm.EOL();
+  strm.IndentMore();
+  for (const auto &key_val : m_pragmas) {
+    strm.Indent();
+    strm.Printf("%s: %s", key_val.first.c_str(), key_val.second.c_str());
     strm.EOL();
+  }
+  strm.IndentLess();
+
+  strm.Indent();
+  strm.Printf("Reductions: %" PRIu64,
+              static_cast<uint64_t>(m_reductions.size()));
+  strm.EOL();
+  strm.IndentMore();
+  for (const auto &reduction : m_reductions) {
+    reduction.Dump(strm);
+  }
+
+  strm.SetIndentLevel(indent);
 }
 
-class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed
-{
-public:
-    CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript module dump",
-                              "Dumps renderscript specific information for all modules.", "renderscript module dump",
-                              eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
-    }
+void RSGlobalDescriptor::Dump(Stream &strm) const {
+  strm.Indent(m_name.AsCString());
+  VariableList var_list;
+  m_module->m_module->FindGlobalVariables(m_name, nullptr, true, 1U, var_list);
+  if (var_list.GetSize() == 1) {
+    auto var = var_list.GetVariableAtIndex(0);
+    auto type = var->GetType();
+    if (type) {
+      strm.Printf(" - ");
+      type->DumpTypeName(&strm);
+    } else {
+      strm.Printf(" - Unknown Type");
+    }
+  } else {
+    strm.Printf(" - variable identified, but not found in binary");
+    const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(
+        m_name, eSymbolTypeData);
+    if (s) {
+      strm.Printf(" (symbol exists) ");
+    }
+  }
+
+  strm.EOL();
+}
 
-    ~CommandObjectRenderScriptRuntimeModuleDump() override = default;
+void RSKernelDescriptor::Dump(Stream &strm) const {
+  strm.Indent(m_name.AsCString());
+  strm.EOL();
+}
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RenderScriptRuntime *runtime =
-            (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
-        runtime->DumpModules(result.GetOutputStream());
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return true;
-    }
-};
+void RSReductionDescriptor::Dump(lldb_private::Stream &stream) const {
+  stream.Indent(m_reduce_name.AsCString());
+  stream.IndentMore();
+  stream.EOL();
+  stream.Indent();
+  stream.Printf("accumulator: %s", m_accum_name.AsCString());
+  stream.EOL();
+  stream.Indent();
+  stream.Printf("initializer: %s", m_init_name.AsCString());
+  stream.EOL();
+  stream.Indent();
+  stream.Printf("combiner: %s", m_comb_name.AsCString());
+  stream.EOL();
+  stream.Indent();
+  stream.Printf("outconverter: %s", m_outc_name.AsCString());
+  stream.EOL();
+  // XXX This is currently unspecified by RenderScript, and unused
+  // stream.Indent();
+  // stream.Printf("halter: '%s'", m_init_name.AsCString());
+  // stream.EOL();
+  stream.IndentLess();
+}
 
-class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword
-{
+class CommandObjectRenderScriptRuntimeModuleDump : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter)
-        : CommandObjectMultiword(interpreter, "renderscript module", "Commands that deal with RenderScript modules.",
-                                 nullptr)
-    {
-        LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump(interpreter)));
-    }
-
-    ~CommandObjectRenderScriptRuntimeModule() override = default;
+  CommandObjectRenderScriptRuntimeModuleDump(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript module dump",
+            "Dumps renderscript specific information for all modules.",
+            "renderscript module dump",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeModuleDump() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RenderScriptRuntime *runtime =
+        (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript);
+    runtime->DumpModules(result.GetOutputStream());
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
 };
 
-class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeModule : public CommandObjectMultiword {
 public:
-    CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript kernel list",
-                              "Lists renderscript kernel names and associated script resources.",
-                              "renderscript kernel list", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeKernelList() override = default;
-
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RenderScriptRuntime *runtime =
-            (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
-        runtime->DumpKernels(result.GetOutputStream());
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return true;
-    }
+  CommandObjectRenderScriptRuntimeModule(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(interpreter, "renderscript module",
+                               "Commands that deal with RenderScript modules.",
+                               nullptr) {
+    LoadSubCommand(
+        "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeModuleDump(
+                    interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntimeModule() override = default;
 };
 
-class CommandObjectRenderScriptRuntimeKernelBreakpointSet : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeKernelList : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeKernelBreakpointSet(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript kernel breakpoint set",
-                              "Sets a breakpoint on a renderscript kernel.",
-                              "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]",
-                              eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
-          m_options(interpreter)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default;
-
-    Options *
-    GetOptions() override
-    {
-        return &m_options;
-    }
-
-    class CommandOptions : public Options
-    {
-    public:
-        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
-
-        ~CommandOptions() override = default;
-
-        Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
-        {
-            Error error;
-            const int short_option = m_getopt_table[option_idx].val;
-
-            switch (short_option)
-            {
-                case 'c':
-                    if (!ParseCoordinate(option_arg))
-                        error.SetErrorStringWithFormat("Couldn't parse coordinate '%s', should be in format 'x,y,z'.",
-                                                       option_arg);
-                    break;
-                default:
-                    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-                    break;
-            }
-            return error;
-        }
-
-        // -c takes an argument of the form 'num[,num][,num]'.
-        // Where 'id_cstr' is this argument with the whitespace trimmed.
-        // Missing coordinates are defaulted to zero.
-        bool
-        ParseCoordinate(const char *id_cstr)
-        {
-            RegularExpression regex;
-            RegularExpression::Match regex_match(3);
-
-            bool matched = false;
-            if (regex.Compile("^([0-9]+),([0-9]+),([0-9]+)$") && regex.Execute(id_cstr, &regex_match))
-                matched = true;
-            else if (regex.Compile("^([0-9]+),([0-9]+)$") && regex.Execute(id_cstr, &regex_match))
-                matched = true;
-            else if (regex.Compile("^([0-9]+)$") && regex.Execute(id_cstr, &regex_match))
-                matched = true;
-            for (uint32_t i = 0; i < 3; i++)
-            {
-                std::string group;
-                if (regex_match.GetMatchAtIndex(id_cstr, i + 1, group))
-                    m_coord[i] = (uint32_t)strtoul(group.c_str(), nullptr, 0);
-                else
-                    m_coord[i] = 0;
-            }
-            return matched;
-        }
-
-        void
-        OptionParsingStarting() override
-        {
-            // -1 means the -c option hasn't been set
-            m_coord[0] = -1;
-            m_coord[1] = -1;
-            m_coord[2] = -1;
-        }
-
-        const OptionDefinition *
-        GetDefinitions() override
-        {
-            return g_option_table;
-        }
-
-        static OptionDefinition g_option_table[];
-        std::array<int, 3> m_coord;
-    };
+  CommandObjectRenderScriptRuntimeKernelList(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript kernel list",
+            "Lists renderscript kernel names and associated script resources.",
+            "renderscript kernel list",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeKernelList() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RenderScriptRuntime *runtime =
+        (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript);
+    runtime->DumpKernels(result.GetOutputStream());
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
+};
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        if (argc < 1)
-        {
-            result.AppendErrorWithFormat("'%s' takes 1 argument of kernel name, and an optional coordinate.",
-                                         m_cmd_name.c_str());
-            result.SetStatus(eReturnStatusFailed);
-            return false;
+static OptionDefinition g_renderscript_reduction_bp_set_options[] = {
+    {LLDB_OPT_SET_1, false, "function-role", 't',
+     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOneLiner,
+     "Break on a comma separated set of reduction kernel types "
+     "(accumulator,outcoverter,combiner,initializer"},
+    {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument,
+     nullptr, nullptr, 0, eArgTypeValue,
+     "Set a breakpoint on a single invocation of the kernel with specified "
+     "coordinate.\n"
+     "Coordinate takes the form 'x[,y][,z] where x,y,z are positive "
+     "integers representing kernel dimensions. "
+     "Any unset dimensions will be defaulted to zero."}};
+
+class CommandObjectRenderScriptRuntimeReductionBreakpointSet
+    : public CommandObjectParsed {
+public:
+  CommandObjectRenderScriptRuntimeReductionBreakpointSet(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript reduction breakpoint set",
+            "Set a breakpoint on named RenderScript general reductions",
+            "renderscript reduction breakpoint set  <kernel_name> [-t "
+            "<reduction_kernel_type,...>]",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched |
+                eCommandProcessMustBePaused),
+        m_options(){};
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions()
+        : Options(),
+          m_kernel_types(RSReduceBreakpointResolver::eKernelTypeAll) {}
+
+    ~CommandOptions() override = default;
+
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                         ExecutionContext *exe_ctx) override {
+      Error err;
+      StreamString err_str;
+      const int short_option = m_getopt_table[option_idx].val;
+      switch (short_option) {
+      case 't':
+        if (!ParseReductionTypes(option_arg, err_str))
+          err.SetErrorStringWithFormat(
+              "Unable to deduce reduction types for %s: %s",
+              option_arg.str().c_str(), err_str.GetData());
+        break;
+      case 'c': {
+        auto coord = RSCoordinate{};
+        if (!ParseCoordinate(option_arg, coord))
+          err.SetErrorStringWithFormat("unable to parse coordinate for %s",
+                                       option_arg.str().c_str());
+        else {
+          m_have_coord = true;
+          m_coord = coord;
         }
+        break;
+      }
+      default:
+        err.SetErrorStringWithFormat("Invalid option '-%c'", short_option);
+      }
+      return err;
+    }
+
+    void OptionParsingStarting(ExecutionContext *exe_ctx) override {
+      m_have_coord = false;
+    }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_renderscript_reduction_bp_set_options);
+    }
+
+    bool ParseReductionTypes(llvm::StringRef option_val,
+                             StreamString &err_str) {
+      m_kernel_types = RSReduceBreakpointResolver::eKernelTypeNone;
+      const auto reduce_name_to_type = [](llvm::StringRef name) -> int {
+        return llvm::StringSwitch<int>(name)
+            .Case("accumulator", RSReduceBreakpointResolver::eKernelTypeAccum)
+            .Case("initializer", RSReduceBreakpointResolver::eKernelTypeInit)
+            .Case("outconverter", RSReduceBreakpointResolver::eKernelTypeOutC)
+            .Case("combiner", RSReduceBreakpointResolver::eKernelTypeComb)
+            .Case("all", RSReduceBreakpointResolver::eKernelTypeAll)
+            // Currently not exposed by the runtime
+            // .Case("halter", RSReduceBreakpointResolver::eKernelTypeHalter)
+            .Default(0);
+      };
+
+      // Matching a comma separated list of known words is fairly
+      // straightforward with PCRE, but we're
+      // using ERE, so we end up with a little ugliness...
+      RegularExpression::Match match(/* max_matches */ 5);
+      RegularExpression match_type_list(
+          llvm::StringRef("^([[:alpha:]]+)(,[[:alpha:]]+){0,4}$"));
+
+      assert(match_type_list.IsValid());
+
+      if (!match_type_list.Execute(option_val, &match)) {
+        err_str.PutCString(
+            "a comma-separated list of kernel types is required");
+        return false;
+      }
 
-        RenderScriptRuntime *runtime =
-            (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
-
-        Error error;
-        runtime->PlaceBreakpointOnKernel(result.GetOutputStream(), command.GetArgumentAtIndex(0), m_options.m_coord,
-                                         error, m_exe_ctx.GetTargetSP());
+      // splitting on commas is much easier with llvm::StringRef than regex
+      llvm::SmallVector<llvm::StringRef, 5> type_names;
+      llvm::StringRef(option_val).split(type_names, ',');
 
-        if (error.Success())
-        {
-            result.AppendMessage("Breakpoint(s) created");
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-            return true;
+      for (const auto &name : type_names) {
+        const int type = reduce_name_to_type(name);
+        if (!type) {
+          err_str.Printf("unknown kernel type name %s", name.str().c_str());
+          return false;
         }
-        result.SetStatus(eReturnStatusFailed);
-        result.AppendErrorWithFormat("Error: %s", error.AsCString());
-        return false;
-    }
+        m_kernel_types |= type;
+      }
+
+      return true;
+    }
+
+    int m_kernel_types;
+    llvm::StringRef m_reduce_name;
+    RSCoordinate m_coord;
+    bool m_have_coord;
+  };
+
+  Options *GetOptions() override { return &m_options; }
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const size_t argc = command.GetArgumentCount();
+    if (argc < 1) {
+      result.AppendErrorWithFormat("'%s' takes 1 argument of reduction name, "
+                                   "and an optional kernel type list",
+                                   m_cmd_name.c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+
+    auto &outstream = result.GetOutputStream();
+    auto name = command.GetArgumentAtIndex(0);
+    auto &target = m_exe_ctx.GetTargetSP();
+    auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr;
+    if (!runtime->PlaceBreakpointOnReduction(target, outstream, name, coord,
+                                             m_options.m_kernel_types)) {
+      result.SetStatus(eReturnStatusFailed);
+      result.AppendError("Error: unable to place breakpoint on reduction");
+      return false;
+    }
+    result.AppendMessage("Breakpoint(s) created");
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
 
 private:
-    CommandOptions m_options;
+  CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectRenderScriptRuntimeKernelBreakpointSet::CommandOptions::g_option_table[] = {
-    {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue,
-     "Set a breakpoint on a single invocation of the kernel with specified coordinate.\n"
-     "Coordinate takes the form 'x[,y][,z] where x,y,z are positive integers representing kernel dimensions. "
-     "Any unset dimensions will be defaulted to zero."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
-
-class CommandObjectRenderScriptRuntimeKernelBreakpointAll : public CommandObjectParsed
-{
+static OptionDefinition g_renderscript_kernel_bp_set_options[] = {
+    {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument,
+     nullptr, nullptr, 0, eArgTypeValue,
+     "Set a breakpoint on a single invocation of the kernel with specified "
+     "coordinate.\n"
+     "Coordinate takes the form 'x[,y][,z] where x,y,z are positive "
+     "integers representing kernel dimensions. "
+     "Any unset dimensions will be defaulted to zero."}};
+
+class CommandObjectRenderScriptRuntimeKernelBreakpointSet
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeKernelBreakpointAll(CommandInterpreter &interpreter)
-        : CommandObjectParsed(
-              interpreter, "renderscript kernel breakpoint all",
-              "Automatically sets a breakpoint on all renderscript kernels that are or will be loaded.\n"
-              "Disabling option means breakpoints will no longer be set on any kernels loaded in the future, "
-              "but does not remove currently set breakpoints.",
-              "renderscript kernel breakpoint all <enable/disable>",
-              eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default;
-
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        if (argc != 1)
-        {
-            result.AppendErrorWithFormat("'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str());
-            result.SetStatus(eReturnStatusFailed);
-            return false;
+  CommandObjectRenderScriptRuntimeKernelBreakpointSet(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript kernel breakpoint set",
+            "Sets a breakpoint on a renderscript kernel.",
+            "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched |
+                eCommandProcessMustBePaused),
+        m_options() {}
+
+  ~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() {}
+
+    ~CommandOptions() override = default;
+
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                         ExecutionContext *exe_ctx) override {
+      Error err;
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+      case 'c': {
+        auto coord = RSCoordinate{};
+        if (!ParseCoordinate(option_arg, coord))
+          err.SetErrorStringWithFormat(
+              "Couldn't parse coordinate '%s', should be in format 'x,y,z'.",
+              option_arg.str().c_str());
+        else {
+          m_have_coord = true;
+          m_coord = coord;
         }
+        break;
+      }
+      default:
+        err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
+        break;
+      }
+      return err;
+    }
 
-        RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
-            m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
+    void OptionParsingStarting(ExecutionContext *exe_ctx) override {
+      m_have_coord = false;
+    }
 
-        bool do_break = false;
-        const char *argument = command.GetArgumentAtIndex(0);
-        if (strcmp(argument, "enable") == 0)
-        {
-            do_break = true;
-            result.AppendMessage("Breakpoints will be set on all kernels.");
-        }
-        else if (strcmp(argument, "disable") == 0)
-        {
-            do_break = false;
-            result.AppendMessage("Breakpoints will not be set on any new kernels.");
-        }
-        else
-        {
-            result.AppendErrorWithFormat("Argument must be either 'enable' or 'disable'");
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_renderscript_kernel_bp_set_options);
+    }
 
-        runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP());
+    RSCoordinate m_coord;
+    bool m_have_coord;
+  };
 
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return true;
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const size_t argc = command.GetArgumentCount();
+    if (argc < 1) {
+      result.AppendErrorWithFormat(
+          "'%s' takes 1 argument of kernel name, and an optional coordinate.",
+          m_cmd_name.c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return false;
     }
-};
 
-class CommandObjectRenderScriptRuntimeKernelCoordinate : public CommandObjectParsed
-{
-public:
-    CommandObjectRenderScriptRuntimeKernelCoordinate(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript kernel coordinate",
-                              "Shows the (x,y,z) coordinate of the current kernel invocation.",
-                              "renderscript kernel coordinate",
-                              eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused)
-    {
+    RenderScriptRuntime *runtime =
+        (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript);
+
+    auto &outstream = result.GetOutputStream();
+    auto &target = m_exe_ctx.GetTargetSP();
+    auto name = command.GetArgumentAtIndex(0);
+    auto coord = m_options.m_have_coord ? &m_options.m_coord : nullptr;
+    if (!runtime->PlaceBreakpointOnKernel(target, outstream, name, coord)) {
+      result.SetStatus(eReturnStatusFailed);
+      result.AppendErrorWithFormat(
+          "Error: unable to set breakpoint on kernel '%s'", name);
+      return false;
     }
 
-    ~CommandObjectRenderScriptRuntimeKernelCoordinate() override = default;
+    result.AppendMessage("Breakpoint(s) created");
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RSCoordinate coord{}; // Zero initialize array
-        bool success = RenderScriptRuntime::GetKernelCoordinate(coord, m_exe_ctx.GetThreadPtr());
-        Stream &stream = result.GetOutputStream();
-
-        if (success)
-        {
-            stream.Printf("Coordinate: (%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", coord[0], coord[1], coord[2]);
-            stream.EOL();
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-        }
-        else
-        {
-            stream.Printf("Error: Coordinate could not be found.");
-            stream.EOL();
-            result.SetStatus(eReturnStatusFailed);
-        }
-        return true;
-    }
+private:
+  CommandOptions m_options;
 };
 
-class CommandObjectRenderScriptRuntimeKernelBreakpoint : public CommandObjectMultiword
-{
+class CommandObjectRenderScriptRuntimeKernelBreakpointAll
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeKernelBreakpoint(CommandInterpreter &interpreter)
-        : CommandObjectMultiword(interpreter, "renderscript kernel",
-                                 "Commands that generate breakpoints on renderscript kernels.", nullptr)
-    {
-        LoadSubCommand("set", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointSet(interpreter)));
-        LoadSubCommand("all", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointAll(interpreter)));
-    }
-
-    ~CommandObjectRenderScriptRuntimeKernelBreakpoint() override = default;
+  CommandObjectRenderScriptRuntimeKernelBreakpointAll(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript kernel breakpoint all",
+            "Automatically sets a breakpoint on all renderscript kernels that "
+            "are or will be loaded.\n"
+            "Disabling option means breakpoints will no longer be set on any "
+            "kernels loaded in the future, "
+            "but does not remove currently set breakpoints.",
+            "renderscript kernel breakpoint all <enable/disable>",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched |
+                eCommandProcessMustBePaused) {}
+
+  ~CommandObjectRenderScriptRuntimeKernelBreakpointAll() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const size_t argc = command.GetArgumentCount();
+    if (argc != 1) {
+      result.AppendErrorWithFormat(
+          "'%s' takes 1 argument of 'enable' or 'disable'", m_cmd_name.c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+
+    bool do_break = false;
+    const char *argument = command.GetArgumentAtIndex(0);
+    if (strcmp(argument, "enable") == 0) {
+      do_break = true;
+      result.AppendMessage("Breakpoints will be set on all kernels.");
+    } else if (strcmp(argument, "disable") == 0) {
+      do_break = false;
+      result.AppendMessage("Breakpoints will not be set on any new kernels.");
+    } else {
+      result.AppendErrorWithFormat(
+          "Argument must be either 'enable' or 'disable'");
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    runtime->SetBreakAllKernels(do_break, m_exe_ctx.GetTargetSP());
+
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
 };
 
-class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword
-{
+class CommandObjectRenderScriptRuntimeReductionBreakpoint
+    : public CommandObjectMultiword {
 public:
-    CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter)
-        : CommandObjectMultiword(interpreter, "renderscript kernel", "Commands that deal with RenderScript kernels.",
-                                 nullptr)
-    {
-        LoadSubCommand("list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList(interpreter)));
-        LoadSubCommand("coordinate",
-                       CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelCoordinate(interpreter)));
-        LoadSubCommand("breakpoint",
-                       CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter)));
-    }
-
-    ~CommandObjectRenderScriptRuntimeKernel() override = default;
+  CommandObjectRenderScriptRuntimeReductionBreakpoint(
+      CommandInterpreter &interpreter)
+      : CommandObjectMultiword(interpreter, "renderscript reduction breakpoint",
+                               "Commands that manipulate breakpoints on "
+                               "renderscript general reductions.",
+                               nullptr) {
+    LoadSubCommand(
+        "set", CommandObjectSP(
+                   new CommandObjectRenderScriptRuntimeReductionBreakpointSet(
+                       interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntimeReductionBreakpoint() override = default;
 };
 
-class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeKernelCoordinate
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript context dump", "Dumps renderscript context information.",
-                              "renderscript context dump", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeContextDump() override = default;
-
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RenderScriptRuntime *runtime =
-            (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
-        runtime->DumpContexts(result.GetOutputStream());
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return true;
+  CommandObjectRenderScriptRuntimeKernelCoordinate(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript kernel coordinate",
+            "Shows the (x,y,z) coordinate of the current kernel invocation.",
+            "renderscript kernel coordinate",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched |
+                eCommandProcessMustBePaused) {}
+
+  ~CommandObjectRenderScriptRuntimeKernelCoordinate() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RSCoordinate coord{};
+    bool success = RenderScriptRuntime::GetKernelCoordinate(
+        coord, m_exe_ctx.GetThreadPtr());
+    Stream &stream = result.GetOutputStream();
+
+    if (success) {
+      stream.Printf("Coordinate: " FMT_COORD, coord.x, coord.y, coord.z);
+      stream.EOL();
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+    } else {
+      stream.Printf("Error: Coordinate could not be found.");
+      stream.EOL();
+      result.SetStatus(eReturnStatusFailed);
     }
+    return true;
+  }
 };
 
-class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword
-{
+class CommandObjectRenderScriptRuntimeKernelBreakpoint
+    : public CommandObjectMultiword {
 public:
-    CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter)
-        : CommandObjectMultiword(interpreter, "renderscript context", "Commands that deal with RenderScript contexts.",
-                                 nullptr)
-    {
-        LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(interpreter)));
-    }
-
-    ~CommandObjectRenderScriptRuntimeContext() override = default;
+  CommandObjectRenderScriptRuntimeKernelBreakpoint(
+      CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "renderscript kernel",
+            "Commands that generate breakpoints on renderscript kernels.",
+            nullptr) {
+    LoadSubCommand(
+        "set",
+        CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointSet(
+            interpreter)));
+    LoadSubCommand(
+        "all",
+        CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelBreakpointAll(
+            interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntimeKernelBreakpoint() override = default;
 };
 
-class CommandObjectRenderScriptRuntimeAllocationDump : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeKernel : public CommandObjectMultiword {
 public:
-    CommandObjectRenderScriptRuntimeAllocationDump(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript allocation dump",
-                              "Displays the contents of a particular allocation", "renderscript allocation dump <ID>",
-                              eCommandRequiresProcess | eCommandProcessMustBeLaunched),
-          m_options(interpreter)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeAllocationDump() override = default;
-
-    Options *
-    GetOptions() override
-    {
-        return &m_options;
-    }
-
-    class CommandOptions : public Options
-    {
-    public:
-        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
-
-        ~CommandOptions() override = default;
-
-        Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
-        {
-            Error error;
-            const int short_option = m_getopt_table[option_idx].val;
-
-            switch (short_option)
-            {
-                case 'f':
-                    m_outfile.SetFile(option_arg, true);
-                    if (m_outfile.Exists())
-                    {
-                        m_outfile.Clear();
-                        error.SetErrorStringWithFormat("file already exists: '%s'", option_arg);
-                    }
-                    break;
-                default:
-                    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-                    break;
-            }
-            return error;
-        }
-
-        void
-        OptionParsingStarting() override
-        {
-            m_outfile.Clear();
-        }
-
-        const OptionDefinition *
-        GetDefinitions() override
-        {
-            return g_option_table;
-        }
+  CommandObjectRenderScriptRuntimeKernel(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(interpreter, "renderscript kernel",
+                               "Commands that deal with RenderScript kernels.",
+                               nullptr) {
+    LoadSubCommand(
+        "list", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernelList(
+                    interpreter)));
+    LoadSubCommand(
+        "coordinate",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeKernelCoordinate(interpreter)));
+    LoadSubCommand(
+        "breakpoint",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeKernelBreakpoint(interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntimeKernel() override = default;
+};
 
-        static OptionDefinition g_option_table[];
-        FileSpec m_outfile;
-    };
+class CommandObjectRenderScriptRuntimeContextDump : public CommandObjectParsed {
+public:
+  CommandObjectRenderScriptRuntimeContextDump(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "renderscript context dump",
+                            "Dumps renderscript context information.",
+                            "renderscript context dump",
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeContextDump() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RenderScriptRuntime *runtime =
+        (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript);
+    runtime->DumpContexts(result.GetOutputStream());
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
+};
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        if (argc < 1)
-        {
-            result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. As well as an optional -f argument",
-                                         m_cmd_name.c_str());
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
+static OptionDefinition g_renderscript_runtime_alloc_dump_options[] = {
+    {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument,
+     nullptr, nullptr, 0, eArgTypeFilename,
+     "Print results to specified file instead of command line."}};
 
-        RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
-            m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
-
-        const char *id_cstr = command.GetArgumentAtIndex(0);
-        bool convert_complete = false;
-        const uint32_t id = StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &convert_complete);
-        if (!convert_complete)
-        {
-            result.AppendErrorWithFormat("invalid allocation id argument '%s'", id_cstr);
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
+class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword {
+public:
+  CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(interpreter, "renderscript context",
+                               "Commands that deal with RenderScript contexts.",
+                               nullptr) {
+    LoadSubCommand(
+        "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(
+                    interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntimeContext() override = default;
+};
 
-        Stream *output_strm = nullptr;
-        StreamFile outfile_stream;
-        const FileSpec &outfile_spec = m_options.m_outfile; // Dump allocation to file instead
-        if (outfile_spec)
-        {
-            // Open output file
-            char path[256];
-            outfile_spec.GetPath(path, sizeof(path));
-            if (outfile_stream.GetFile().Open(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate).Success())
-            {
-                output_strm = &outfile_stream;
-                result.GetOutputStream().Printf("Results written to '%s'", path);
-                result.GetOutputStream().EOL();
-            }
-            else
-            {
-                result.AppendErrorWithFormat("Couldn't open file '%s'", path);
-                result.SetStatus(eReturnStatusFailed);
-                return false;
-            }
+class CommandObjectRenderScriptRuntimeAllocationDump
+    : public CommandObjectParsed {
+public:
+  CommandObjectRenderScriptRuntimeAllocationDump(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "renderscript allocation dump",
+                            "Displays the contents of a particular allocation",
+                            "renderscript allocation dump <ID>",
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched),
+        m_options() {}
+
+  ~CommandObjectRenderScriptRuntimeAllocationDump() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() {}
+
+    ~CommandOptions() override = default;
+
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                         ExecutionContext *exe_ctx) override {
+      Error err;
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+      case 'f':
+        m_outfile.SetFile(option_arg, true);
+        if (m_outfile.Exists()) {
+          m_outfile.Clear();
+          err.SetErrorStringWithFormat("file already exists: '%s'",
+                                       option_arg.str().c_str());
         }
-        else
-            output_strm = &result.GetOutputStream();
-
-        assert(output_strm != nullptr);
-        bool success = runtime->DumpAllocation(*output_strm, m_exe_ctx.GetFramePtr(), id);
-
-        if (success)
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-        else
-            result.SetStatus(eReturnStatusFailed);
-
-        return true;
+        break;
+      default:
+        err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
+        break;
+      }
+      return err;
     }
 
-private:
-    CommandOptions m_options;
-};
-
-OptionDefinition CommandObjectRenderScriptRuntimeAllocationDump::CommandOptions::g_option_table[] = {
-    {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename,
-     "Print results to specified file instead of command line."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
+    void OptionParsingStarting(ExecutionContext *exe_ctx) override {
+      m_outfile.Clear();
+    }
 
-class CommandObjectRenderScriptRuntimeAllocationList : public CommandObjectParsed
-{
-public:
-    CommandObjectRenderScriptRuntimeAllocationList(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript allocation list",
-                              "List renderscript allocations and their information.", "renderscript allocation list",
-                              eCommandRequiresProcess | eCommandProcessMustBeLaunched),
-          m_options(interpreter)
-    {
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_renderscript_runtime_alloc_dump_options);
     }
 
-    ~CommandObjectRenderScriptRuntimeAllocationList() override = default;
+    FileSpec m_outfile;
+  };
 
-    Options *
-    GetOptions() override
-    {
-        return &m_options;
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const size_t argc = command.GetArgumentCount();
+    if (argc < 1) {
+      result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. "
+                                   "As well as an optional -f argument",
+                                   m_cmd_name.c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return false;
     }
 
-    class CommandOptions : public Options
-    {
-    public:
-        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter), m_id(0) {}
-
-        ~CommandOptions() override = default;
-
-        Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
-        {
-            Error error;
-            const int short_option = m_getopt_table[option_idx].val;
-
-            switch (short_option)
-            {
-                case 'i':
-                    bool success;
-                    m_id = StringConvert::ToUInt32(option_arg, 0, 0, &success);
-                    if (!success)
-                        error.SetErrorStringWithFormat("invalid integer value for option '%c'", short_option);
-                    break;
-                default:
-                    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
-                    break;
-            }
-            return error;
-        }
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
 
-        void
-        OptionParsingStarting() override
-        {
-            m_id = 0;
-        }
+    const char *id_cstr = command.GetArgumentAtIndex(0);
+    bool success = false;
+    const uint32_t id =
+        StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
+    if (!success) {
+      result.AppendErrorWithFormat("invalid allocation id argument '%s'",
+                                   id_cstr);
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    Stream *output_strm = nullptr;
+    StreamFile outfile_stream;
+    const FileSpec &outfile_spec =
+        m_options.m_outfile; // Dump allocation to file instead
+    if (outfile_spec) {
+      // Open output file
+      char path[256];
+      outfile_spec.GetPath(path, sizeof(path));
+      if (outfile_stream.GetFile()
+              .Open(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate)
+              .Success()) {
+        output_strm = &outfile_stream;
+        result.GetOutputStream().Printf("Results written to '%s'", path);
+        result.GetOutputStream().EOL();
+      } else {
+        result.AppendErrorWithFormat("Couldn't open file '%s'", path);
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+    } else
+      output_strm = &result.GetOutputStream();
 
-        const OptionDefinition *
-        GetDefinitions() override
-        {
-            return g_option_table;
-        }
+    assert(output_strm != nullptr);
+    bool dumped =
+        runtime->DumpAllocation(*output_strm, m_exe_ctx.GetFramePtr(), id);
 
-        static OptionDefinition g_option_table[];
-        uint32_t m_id;
-    };
+    if (dumped)
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+    else
+      result.SetStatus(eReturnStatusFailed);
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
-            m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
-        runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(), m_options.m_id);
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return true;
-    }
+    return true;
+  }
 
 private:
-    CommandOptions m_options;
+  CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectRenderScriptRuntimeAllocationList::CommandOptions::g_option_table[] = {
-    {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex,
-     "Only show details of a single allocation with specified id."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
+static OptionDefinition g_renderscript_runtime_alloc_list_options[] = {
+    {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument, nullptr,
+     nullptr, 0, eArgTypeIndex,
+     "Only show details of a single allocation with specified id."}};
 
-class CommandObjectRenderScriptRuntimeAllocationLoad : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeAllocationList
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeAllocationLoad(CommandInterpreter &interpreter)
-        : CommandObjectParsed(
-              interpreter, "renderscript allocation load", "Loads renderscript allocation contents from a file.",
-              "renderscript allocation load <ID> <filename>", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeAllocationLoad() override = default;
-
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        if (argc != 2)
-        {
-            result.AppendErrorWithFormat("'%s' takes 2 arguments, an allocation ID and filename to read from.",
-                                         m_cmd_name.c_str());
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
-
-        RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
-            m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
-
-        const char *id_cstr = command.GetArgumentAtIndex(0);
-        bool convert_complete = false;
-        const uint32_t id = StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &convert_complete);
-        if (!convert_complete)
-        {
-            result.AppendErrorWithFormat("invalid allocation id argument '%s'", id_cstr);
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
-
-        const char *filename = command.GetArgumentAtIndex(1);
-        bool success = runtime->LoadAllocation(result.GetOutputStream(), id, filename, m_exe_ctx.GetFramePtr());
-
-        if (success)
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-        else
-            result.SetStatus(eReturnStatusFailed);
+  CommandObjectRenderScriptRuntimeAllocationList(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript allocation list",
+            "List renderscript allocations and their information.",
+            "renderscript allocation list",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched),
+        m_options() {}
+
+  ~CommandObjectRenderScriptRuntimeAllocationList() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options(), m_id(0) {}
+
+    ~CommandOptions() override = default;
+
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                         ExecutionContext *exe_ctx) override {
+      Error err;
+      const int short_option = m_getopt_table[option_idx].val;
+
+      switch (short_option) {
+      case 'i':
+        if (option_arg.getAsInteger(0, m_id))
+          err.SetErrorStringWithFormat("invalid integer value for option '%c'",
+                                       short_option);
+        break;
+      default:
+        err.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
+        break;
+      }
+      return err;
+    }
+
+    void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; }
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_renderscript_runtime_alloc_list_options);
+    }
+
+    uint32_t m_id;
+  };
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+    runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(),
+                             m_options.m_id);
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
 
-        return true;
-    }
+private:
+  CommandOptions m_options;
 };
 
-class CommandObjectRenderScriptRuntimeAllocationSave : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeAllocationLoad
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeAllocationSave(CommandInterpreter &interpreter)
-        : CommandObjectParsed(
-              interpreter, "renderscript allocation save", "Write renderscript allocation contents to a file.",
-              "renderscript allocation save <ID> <filename>", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
+  CommandObjectRenderScriptRuntimeAllocationLoad(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript allocation load",
+            "Loads renderscript allocation contents from a file.",
+            "renderscript allocation load <ID> <filename>",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeAllocationLoad() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const size_t argc = command.GetArgumentCount();
+    if (argc != 2) {
+      result.AppendErrorWithFormat(
+          "'%s' takes 2 arguments, an allocation ID and filename to read from.",
+          m_cmd_name.c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+
+    const char *id_cstr = command.GetArgumentAtIndex(0);
+    bool success = false;
+    const uint32_t id =
+        StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
+    if (!success) {
+      result.AppendErrorWithFormat("invalid allocation id argument '%s'",
+                                   id_cstr);
+      result.SetStatus(eReturnStatusFailed);
+      return false;
     }
 
-    ~CommandObjectRenderScriptRuntimeAllocationSave() override = default;
+    const char *path = command.GetArgumentAtIndex(1);
+    bool loaded = runtime->LoadAllocation(result.GetOutputStream(), id, path,
+                                          m_exe_ctx.GetFramePtr());
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        const size_t argc = command.GetArgumentCount();
-        if (argc != 2)
-        {
-            result.AppendErrorWithFormat("'%s' takes 2 arguments, an allocation ID and filename to read from.",
-                                         m_cmd_name.c_str());
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
-
-        RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
-            m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
-
-        const char *id_cstr = command.GetArgumentAtIndex(0);
-        bool convert_complete = false;
-        const uint32_t id = StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &convert_complete);
-        if (!convert_complete)
-        {
-            result.AppendErrorWithFormat("invalid allocation id argument '%s'", id_cstr);
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
-
-        const char *filename = command.GetArgumentAtIndex(1);
-        bool success = runtime->SaveAllocation(result.GetOutputStream(), id, filename, m_exe_ctx.GetFramePtr());
-
-        if (success)
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-        else
-            result.SetStatus(eReturnStatusFailed);
+    if (loaded)
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+    else
+      result.SetStatus(eReturnStatusFailed);
 
-        return true;
-    }
+    return true;
+  }
 };
 
-class CommandObjectRenderScriptRuntimeAllocationRefresh : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeAllocationSave
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeAllocationRefresh(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript allocation refresh",
-                              "Recomputes the details of all allocations.", "renderscript allocation refresh",
-                              eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
+  CommandObjectRenderScriptRuntimeAllocationSave(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "renderscript allocation save",
+                            "Write renderscript allocation contents to a file.",
+                            "renderscript allocation save <ID> <filename>",
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeAllocationSave() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const size_t argc = command.GetArgumentCount();
+    if (argc != 2) {
+      result.AppendErrorWithFormat(
+          "'%s' takes 2 arguments, an allocation ID and filename to read from.",
+          m_cmd_name.c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+
+    const char *id_cstr = command.GetArgumentAtIndex(0);
+    bool success = false;
+    const uint32_t id =
+        StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
+    if (!success) {
+      result.AppendErrorWithFormat("invalid allocation id argument '%s'",
+                                   id_cstr);
+      result.SetStatus(eReturnStatusFailed);
+      return false;
     }
 
-    ~CommandObjectRenderScriptRuntimeAllocationRefresh() override = default;
-
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
-            m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript));
+    const char *path = command.GetArgumentAtIndex(1);
+    bool saved = runtime->SaveAllocation(result.GetOutputStream(), id, path,
+                                         m_exe_ctx.GetFramePtr());
 
-        bool success = runtime->RecomputeAllAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr());
+    if (saved)
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+    else
+      result.SetStatus(eReturnStatusFailed);
 
-        if (success)
-        {
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-            return true;
-        }
-        else
-        {
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-        }
-    }
+    return true;
+  }
 };
 
-class CommandObjectRenderScriptRuntimeAllocation : public CommandObjectMultiword
-{
+class CommandObjectRenderScriptRuntimeAllocationRefresh
+    : public CommandObjectParsed {
 public:
-    CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter)
-        : CommandObjectMultiword(interpreter, "renderscript allocation",
-                                 "Commands that deal with RenderScript allocations.", nullptr)
-    {
-        LoadSubCommand("list", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationList(interpreter)));
-        LoadSubCommand("dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationDump(interpreter)));
-        LoadSubCommand("save", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationSave(interpreter)));
-        LoadSubCommand("load", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationLoad(interpreter)));
-        LoadSubCommand("refresh", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationRefresh(interpreter)));
-    }
-
-    ~CommandObjectRenderScriptRuntimeAllocation() override = default;
+  CommandObjectRenderScriptRuntimeAllocationRefresh(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "renderscript allocation refresh",
+                            "Recomputes the details of all allocations.",
+                            "renderscript allocation refresh",
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeAllocationRefresh() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+
+    bool success = runtime->RecomputeAllAllocations(result.GetOutputStream(),
+                                                    m_exe_ctx.GetFramePtr());
+
+    if (success) {
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    } else {
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+  }
 };
 
-class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed
-{
+class CommandObjectRenderScriptRuntimeAllocation
+    : public CommandObjectMultiword {
 public:
-    CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter)
-        : CommandObjectParsed(interpreter, "renderscript status", "Displays current RenderScript runtime status.",
-                              "renderscript status", eCommandRequiresProcess | eCommandProcessMustBeLaunched)
-    {
-    }
-
-    ~CommandObjectRenderScriptRuntimeStatus() override = default;
+  CommandObjectRenderScriptRuntimeAllocation(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "renderscript allocation",
+            "Commands that deal with RenderScript allocations.", nullptr) {
+    LoadSubCommand(
+        "list",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeAllocationList(interpreter)));
+    LoadSubCommand(
+        "dump",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeAllocationDump(interpreter)));
+    LoadSubCommand(
+        "save",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeAllocationSave(interpreter)));
+    LoadSubCommand(
+        "load",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeAllocationLoad(interpreter)));
+    LoadSubCommand(
+        "refresh",
+        CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocationRefresh(
+            interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntimeAllocation() override = default;
+};
 
-    bool
-    DoExecute(Args &command, CommandReturnObject &result) override
-    {
-        RenderScriptRuntime *runtime =
-            (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(eLanguageTypeExtRenderScript);
-        runtime->Status(result.GetOutputStream());
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-        return true;
-    }
+class CommandObjectRenderScriptRuntimeStatus : public CommandObjectParsed {
+public:
+  CommandObjectRenderScriptRuntimeStatus(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "renderscript status",
+                            "Displays current RenderScript runtime status.",
+                            "renderscript status",
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptRuntimeStatus() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    RenderScriptRuntime *runtime =
+        (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript);
+    runtime->Status(result.GetOutputStream());
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
 };
 
-class CommandObjectRenderScriptRuntime : public CommandObjectMultiword
-{
+class CommandObjectRenderScriptRuntimeReduction
+    : public CommandObjectMultiword {
 public:
-    CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter)
-        : CommandObjectMultiword(interpreter, "renderscript", "Commands for operating on the RenderScript runtime.",
-                                 "renderscript <subcommand> [<subcommand-options>]")
-    {
-        LoadSubCommand("module", CommandObjectSP(new CommandObjectRenderScriptRuntimeModule(interpreter)));
-        LoadSubCommand("status", CommandObjectSP(new CommandObjectRenderScriptRuntimeStatus(interpreter)));
-        LoadSubCommand("kernel", CommandObjectSP(new CommandObjectRenderScriptRuntimeKernel(interpreter)));
-        LoadSubCommand("context", CommandObjectSP(new CommandObjectRenderScriptRuntimeContext(interpreter)));
-        LoadSubCommand("allocation", CommandObjectSP(new CommandObjectRenderScriptRuntimeAllocation(interpreter)));
-    }
+  CommandObjectRenderScriptRuntimeReduction(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(interpreter, "renderscript reduction",
+                               "Commands that handle general reduction kernels",
+                               nullptr) {
+    LoadSubCommand(
+        "breakpoint",
+        CommandObjectSP(new CommandObjectRenderScriptRuntimeReductionBreakpoint(
+            interpreter)));
+  }
+  ~CommandObjectRenderScriptRuntimeReduction() override = default;
+};
 
-    ~CommandObjectRenderScriptRuntime() override = default;
+class CommandObjectRenderScriptRuntime : public CommandObjectMultiword {
+public:
+  CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "renderscript",
+            "Commands for operating on the RenderScript runtime.",
+            "renderscript <subcommand> [<subcommand-options>]") {
+    LoadSubCommand(
+        "module", CommandObjectSP(
+                      new CommandObjectRenderScriptRuntimeModule(interpreter)));
+    LoadSubCommand(
+        "status", CommandObjectSP(
+                      new CommandObjectRenderScriptRuntimeStatus(interpreter)));
+    LoadSubCommand(
+        "kernel", CommandObjectSP(
+                      new CommandObjectRenderScriptRuntimeKernel(interpreter)));
+    LoadSubCommand("context",
+                   CommandObjectSP(new CommandObjectRenderScriptRuntimeContext(
+                       interpreter)));
+    LoadSubCommand(
+        "allocation",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeAllocation(interpreter)));
+    LoadSubCommand("scriptgroup",
+                   NewCommandObjectRenderScriptScriptGroup(interpreter));
+    LoadSubCommand(
+        "reduction",
+        CommandObjectSP(
+            new CommandObjectRenderScriptRuntimeReduction(interpreter)));
+  }
+
+  ~CommandObjectRenderScriptRuntime() override = default;
 };
 
-void
-RenderScriptRuntime::Initiate()
-{
-    assert(!m_initiated);
-}
+void RenderScriptRuntime::Initiate() { assert(!m_initiated); }
 
 RenderScriptRuntime::RenderScriptRuntime(Process *process)
-    : lldb_private::CPPLanguageRuntime(process),
-      m_initiated(false),
-      m_debuggerPresentFlagged(false),
-      m_breakAllKernels(false)
-{
-    ModulesDidLoad(process->GetTarget().GetImages());
+    : lldb_private::CPPLanguageRuntime(process), m_initiated(false),
+      m_debuggerPresentFlagged(false), m_breakAllKernels(false),
+      m_ir_passes(nullptr) {
+  ModulesDidLoad(process->GetTarget().GetImages());
 }
 
-lldb::CommandObjectSP
-RenderScriptRuntime::GetCommandObject(lldb_private::CommandInterpreter &interpreter)
-{
-    return CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter));
+lldb::CommandObjectSP RenderScriptRuntime::GetCommandObject(
+    lldb_private::CommandInterpreter &interpreter) {
+  return CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter));
 }
 
 RenderScriptRuntime::~RenderScriptRuntime() = default;
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
index 2a0839a..5b2bb57 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
@@ -19,397 +19,567 @@
 #include <vector>
 
 // Other libraries and framework includes
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 // Project includes
 #include "lldb/Core/Module.h"
+#include "lldb/Expression/LLVMUserExpression.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
-namespace lldb_private
-{
-namespace lldb_renderscript
-{
+namespace lldb_private {
+namespace lldb_renderscript {
 
 typedef uint32_t RSSlot;
 class RSModuleDescriptor;
 struct RSGlobalDescriptor;
 struct RSKernelDescriptor;
+struct RSReductionDescriptor;
+struct RSScriptGroupDescriptor;
 
 typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP;
 typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP;
 typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP;
-typedef std::array<uint32_t, 3> RSCoordinate;
+typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP;
 
-// Breakpoint Resolvers decide where a breakpoint is placed,
-// so having our own allows us to limit the search scope to RS kernel modules.
-// As well as check for .expand kernels as a fallback.
-class RSBreakpointResolver : public BreakpointResolver
-{
+struct RSCoordinate {
+  uint32_t x, y, z;
+
+  RSCoordinate() : x(), y(), z(){};
+
+  bool operator==(const lldb_renderscript::RSCoordinate &rhs) {
+    return x == rhs.x && y == rhs.y && z == rhs.z;
+  }
+};
+
+// Breakpoint Resolvers decide where a breakpoint is placed, so having our own
+// allows us to limit the search scope to RS kernel modules. As well as check
+// for .expand kernels as a fallback.
+class RSBreakpointResolver : public BreakpointResolver {
 public:
-    RSBreakpointResolver(Breakpoint *bkpt, ConstString name)
-        : BreakpointResolver(bkpt, BreakpointResolver::NameResolver), m_kernel_name(name)
-    {
-    }
+  RSBreakpointResolver(Breakpoint *bp, ConstString name)
+      : BreakpointResolver(bp, BreakpointResolver::NameResolver),
+        m_kernel_name(name) {}
 
-    void
-    GetDescription(Stream *strm) override
-    {
-        if (strm)
-            strm->Printf("RenderScript kernel breakpoint for '%s'", m_kernel_name.AsCString());
-    }
+  void GetDescription(Stream *strm) override {
+    if (strm)
+      strm->Printf("RenderScript kernel breakpoint for '%s'",
+                   m_kernel_name.AsCString());
+  }
 
-    void
-    Dump(Stream *s) const override
-    {
-    }
+  void Dump(Stream *s) const override {}
 
-    Searcher::CallbackReturn
-    SearchCallback(SearchFilter &filter, SymbolContext &context, Address *addr, bool containing) override;
+  Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
+                                          SymbolContext &context, Address *addr,
+                                          bool containing) override;
 
-    Searcher::Depth
-    GetDepth() override
-    {
-        return Searcher::eDepthModule;
-    }
+  Searcher::Depth GetDepth() override { return Searcher::eDepthModule; }
 
-    lldb::BreakpointResolverSP
-    CopyForBreakpoint(Breakpoint &breakpoint) override
-    {
-        lldb::BreakpointResolverSP ret_sp(new RSBreakpointResolver(&breakpoint, m_kernel_name));
-        return ret_sp;
-    }
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(Breakpoint &breakpoint) override {
+    lldb::BreakpointResolverSP ret_sp(
+        new RSBreakpointResolver(&breakpoint, m_kernel_name));
+    return ret_sp;
+  }
 
 protected:
-    ConstString m_kernel_name;
+  ConstString m_kernel_name;
 };
 
-struct RSKernelDescriptor
-{
+class RSReduceBreakpointResolver : public BreakpointResolver {
 public:
-    RSKernelDescriptor(const RSModuleDescriptor *module, const char *name, uint32_t slot)
-        : m_module(module), m_name(name), m_slot(slot)
-    {
-    }
+  enum ReduceKernelTypeFlags {
+    eKernelTypeAll = ~(0),
+    eKernelTypeNone = 0,
+    eKernelTypeAccum = (1 << 0),
+    eKernelTypeInit = (1 << 1),
+    eKernelTypeComb = (1 << 2),
+    eKernelTypeOutC = (1 << 3),
+    eKernelTypeHalter = (1 << 4)
+  };
+
+  RSReduceBreakpointResolver(
+      Breakpoint *breakpoint, ConstString reduce_name,
+      std::vector<lldb_renderscript::RSModuleDescriptorSP> *rs_modules,
+      int kernel_types = eKernelTypeAll)
+      : BreakpointResolver(breakpoint, BreakpointResolver::NameResolver),
+        m_reduce_name(reduce_name), m_rsmodules(rs_modules),
+        m_kernel_types(kernel_types) {
+    // The reduce breakpoint resolver handles adding breakpoints for named
+    // reductions.
+    // Breakpoints will be resolved for all constituent kernels in the named
+    // reduction
+  }
+
+  void GetDescription(Stream *strm) override {
+    if (strm)
+      strm->Printf("RenderScript reduce breakpoint for '%s'",
+                   m_reduce_name.AsCString());
+  }
+
+  void Dump(Stream *s) const override {}
+
+  Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
+                                          SymbolContext &context, Address *addr,
+                                          bool containing) override;
+
+  Searcher::Depth GetDepth() override { return Searcher::eDepthModule; }
+
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(Breakpoint &breakpoint) override {
+    lldb::BreakpointResolverSP ret_sp(new RSReduceBreakpointResolver(
+        &breakpoint, m_reduce_name, m_rsmodules, m_kernel_types));
+    return ret_sp;
+  }
 
-    void
-    Dump(Stream &strm) const;
+private:
+  ConstString m_reduce_name; // The name of the reduction
+  std::vector<lldb_renderscript::RSModuleDescriptorSP> *m_rsmodules;
+  int m_kernel_types;
+};
 
-    const RSModuleDescriptor *m_module;
-    ConstString m_name;
-    RSSlot m_slot;
+struct RSKernelDescriptor {
+public:
+  RSKernelDescriptor(const RSModuleDescriptor *module, llvm::StringRef name,
+                     uint32_t slot)
+      : m_module(module), m_name(name), m_slot(slot) {}
+
+  void Dump(Stream &strm) const;
+
+  const RSModuleDescriptor *m_module;
+  ConstString m_name;
+  RSSlot m_slot;
 };
 
-struct RSGlobalDescriptor
-{
+struct RSGlobalDescriptor {
 public:
-    RSGlobalDescriptor(const RSModuleDescriptor *module, const char *name) : m_module(module), m_name(name) {}
+  RSGlobalDescriptor(const RSModuleDescriptor *module, llvm::StringRef name)
+      : m_module(module), m_name(name) {}
 
-    void
-    Dump(Stream &strm) const;
+  void Dump(Stream &strm) const;
 
-    const RSModuleDescriptor *m_module;
-    ConstString m_name;
+  const RSModuleDescriptor *m_module;
+  ConstString m_name;
 };
 
-class RSModuleDescriptor
-{
+struct RSReductionDescriptor {
+  RSReductionDescriptor(const RSModuleDescriptor *module, uint32_t sig,
+                        uint32_t accum_data_size, llvm::StringRef name,
+                        llvm::StringRef init_name, llvm::StringRef accum_name,
+                        llvm::StringRef comb_name, llvm::StringRef outc_name,
+                        llvm::StringRef halter_name = ".")
+      : m_module(module), m_reduce_name(name), m_init_name(init_name),
+        m_accum_name(accum_name), m_comb_name(comb_name),
+        m_outc_name(outc_name), m_halter_name(halter_name) {
+    // TODO Check whether the combiner is an autogenerated name, and track
+    // this
+  }
+
+  void Dump(Stream &strm) const;
+
+  const RSModuleDescriptor *m_module;
+  ConstString m_reduce_name; // This is the name given to the general reduction
+                             // as a group as passed to pragma
+  // reduce(m_reduce_name). There is no kernel function with this name
+  ConstString m_init_name;  // The name of the initializer name. "." if no
+                            // initializer given
+  ConstString m_accum_name; // The accumulator function name. "." if not given
+  ConstString m_comb_name; // The name of the combiner function. If this was not
+                           // given, a name is generated by the
+                           // compiler. TODO
+  ConstString m_outc_name; // The name of the outconverter
+
+  ConstString m_halter_name; // The name of the halter function. XXX This is not
+                             // yet specified by the RenderScript
+  // compiler or runtime, and its semantics and existence is still under
+  // discussion by the
+  // RenderScript Contributors
+  RSSlot m_accum_sig; // metatdata signature for this reduction (bitwise mask of
+                      // type information (see
+                      // libbcc/include/bcinfo/MetadataExtractor.h
+  uint32_t m_accum_data_size; // Data size of the accumulator function input
+  bool m_comb_name_generated; // Was the combiner name generated by the compiler
+};
+
+class RSModuleDescriptor {
+  std::string m_slang_version;
+  std::string m_bcc_version;
+
+  bool ParseVersionInfo(llvm::StringRef *, size_t n_lines);
+
+  bool ParseExportForeachCount(llvm::StringRef *, size_t n_lines);
+
+  bool ParseExportVarCount(llvm::StringRef *, size_t n_lines);
+
+  bool ParseExportReduceCount(llvm::StringRef *, size_t n_lines);
+
+  bool ParseBuildChecksum(llvm::StringRef *, size_t n_lines);
+
+  bool ParsePragmaCount(llvm::StringRef *, size_t n_lines);
+
 public:
-    RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) {}
+  RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) {}
+
+  ~RSModuleDescriptor() = default;
 
-    ~RSModuleDescriptor() = default;
+  bool ParseRSInfo();
 
-    bool
-    ParseRSInfo();
+  void Dump(Stream &strm) const;
 
-    void
-    Dump(Stream &strm) const;
+  void WarnIfVersionMismatch(Stream *s) const;
 
-    const lldb::ModuleSP m_module;
-    std::vector<RSKernelDescriptor> m_kernels;
-    std::vector<RSGlobalDescriptor> m_globals;
-    std::map<std::string, std::string> m_pragmas;
-    std::string m_resname;
+  const lldb::ModuleSP m_module;
+  std::vector<RSKernelDescriptor> m_kernels;
+  std::vector<RSGlobalDescriptor> m_globals;
+  std::vector<RSReductionDescriptor> m_reductions;
+  std::map<std::string, std::string> m_pragmas;
+  std::string m_resname;
 };
 
+struct RSScriptGroupDescriptor {
+  struct Kernel {
+    ConstString m_name;
+    lldb::addr_t m_addr;
+  };
+  ConstString m_name;
+  std::vector<Kernel> m_kernels;
+};
+
+typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList;
+
+class RSScriptGroupBreakpointResolver : public BreakpointResolver {
+public:
+  RSScriptGroupBreakpointResolver(Breakpoint *bp, const ConstString &name,
+                                  const RSScriptGroupList &groups,
+                                  bool stop_on_all)
+      : BreakpointResolver(bp, BreakpointResolver::NameResolver),
+        m_group_name(name), m_script_groups(groups),
+        m_stop_on_all(stop_on_all) {}
+
+  void GetDescription(Stream *strm) override {
+    if (strm)
+      strm->Printf("RenderScript ScriptGroup breakpoint for '%s'",
+                   m_group_name.AsCString());
+  }
+
+  void Dump(Stream *s) const override {}
+
+  Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
+                                          SymbolContext &context, Address *addr,
+                                          bool containing) override;
+
+  Searcher::Depth GetDepth() override { return Searcher::eDepthModule; }
+
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(Breakpoint &breakpoint) override {
+    lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver(
+        &breakpoint, m_group_name, m_script_groups, m_stop_on_all));
+    return ret_sp;
+  }
+
+protected:
+  const RSScriptGroupDescriptorSP
+  FindScriptGroup(const ConstString &name) const {
+    for (auto sg : m_script_groups) {
+      if (ConstString::Compare(sg->m_name, name) == 0)
+        return sg;
+    }
+    return RSScriptGroupDescriptorSP();
+  }
+
+  ConstString m_group_name;
+  const RSScriptGroupList &m_script_groups;
+  bool m_stop_on_all;
+};
 } // namespace lldb_renderscript
 
-class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime
-{
+class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime {
 public:
-    enum ModuleKind
-    {
-        eModuleKindIgnored,
-        eModuleKindLibRS,
-        eModuleKindDriver,
-        eModuleKindImpl,
-        eModuleKindKernelObj
-    };
+  enum ModuleKind {
+    eModuleKindIgnored,
+    eModuleKindLibRS,
+    eModuleKindDriver,
+    eModuleKindImpl,
+    eModuleKindKernelObj
+  };
+
+  ~RenderScriptRuntime() override;
+
+  //------------------------------------------------------------------
+  // Static Functions
+  //------------------------------------------------------------------
+  static void Initialize();
+
+  static void Terminate();
 
-    ~RenderScriptRuntime() override;
+  static lldb_private::LanguageRuntime *
+  CreateInstance(Process *process, lldb::LanguageType language);
 
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
+  static lldb::CommandObjectSP
+  GetCommandObject(CommandInterpreter &interpreter);
 
-    static void
-    Terminate();
+  static lldb_private::ConstString GetPluginNameStatic();
 
-    static lldb_private::LanguageRuntime *
-    CreateInstance(Process *process, lldb::LanguageType language);
+  static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp);
 
-    static lldb::CommandObjectSP
-    GetCommandObject(CommandInterpreter &interpreter);
+  static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp);
 
-    static lldb_private::ConstString
-    GetPluginNameStatic();
+  static void ModulesDidLoad(const lldb::ProcessSP &process_sp,
+                             const ModuleList &module_list);
 
-    static bool
-    IsRenderScriptModule(const lldb::ModuleSP &module_sp);
+  bool IsVTableName(const char *name) override;
 
-    static ModuleKind
-    GetModuleKind(const lldb::ModuleSP &module_sp);
+  bool GetDynamicTypeAndAddress(ValueObject &in_value,
+                                lldb::DynamicValueType use_dynamic,
+                                TypeAndOrName &class_type_or_name,
+                                Address &address,
+                                Value::ValueType &value_type) override;
 
-    static void
-    ModulesDidLoad(const lldb::ProcessSP &process_sp, const ModuleList &module_list);
+  TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
+                                 ValueObject &static_value) override;
 
-    bool
-    IsVTableName(const char *name) override;
+  bool CouldHaveDynamicValue(ValueObject &in_value) override;
 
-    bool
-    GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic,
-                             TypeAndOrName &class_type_or_name, Address &address,
-                             Value::ValueType &value_type) override;
+  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bp,
+                                                     bool catch_bp,
+                                                     bool throw_bp) override;
 
-    TypeAndOrName
-    FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value) override;
+  bool LoadModule(const lldb::ModuleSP &module_sp);
 
-    bool
-    CouldHaveDynamicValue(ValueObject &in_value) override;
+  void DumpModules(Stream &strm) const;
 
-    lldb::BreakpointResolverSP
-    CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
+  void DumpContexts(Stream &strm) const;
 
-    bool
-    LoadModule(const lldb::ModuleSP &module_sp);
+  void DumpKernels(Stream &strm) const;
 
-    void
-    DumpModules(Stream &strm) const;
+  bool DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id);
 
-    void
-    DumpContexts(Stream &strm) const;
+  void ListAllocations(Stream &strm, StackFrame *frame_ptr,
+                       const uint32_t index);
 
-    void
-    DumpKernels(Stream &strm) const;
+  bool RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr);
 
-    bool
-    DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id);
+  bool PlaceBreakpointOnKernel(
+      lldb::TargetSP target, Stream &messages, const char *name,
+      const lldb_renderscript::RSCoordinate *coords = nullptr);
 
-    void
-    ListAllocations(Stream &strm, StackFrame *frame_ptr, const uint32_t index);
+  bool PlaceBreakpointOnReduction(
+      lldb::TargetSP target, Stream &messages, const char *reduce_name,
+      const lldb_renderscript::RSCoordinate *coords = nullptr,
+      int kernel_types = ~(0));
 
-    bool
-    RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr);
+  bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm,
+                                    const ConstString &name, bool stop_on_all);
 
-    void
-    PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array<int, 3> coords, Error &error,
-                            lldb::TargetSP target);
+  void SetBreakAllKernels(bool do_break, lldb::TargetSP target);
 
-    void
-    SetBreakAllKernels(bool do_break, lldb::TargetSP target);
+  void Status(Stream &strm) const;
 
-    void
-    Status(Stream &strm) const;
+  void ModulesDidLoad(const ModuleList &module_list) override;
 
-    void
-    ModulesDidLoad(const ModuleList &module_list) override;
+  bool LoadAllocation(Stream &strm, const uint32_t alloc_id,
+                      const char *filename, StackFrame *frame_ptr);
 
-    bool
-    LoadAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr);
+  bool SaveAllocation(Stream &strm, const uint32_t alloc_id,
+                      const char *filename, StackFrame *frame_ptr);
 
-    bool
-    SaveAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr);
+  void Update();
 
-    void
-    Update();
+  void Initiate();
 
-    void
-    Initiate();
+  const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const {
+    return m_scriptGroups;
+  };
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
+  bool IsKnownKernel(const ConstString &name) {
+    for (const auto &module : m_rsmodules)
+      for (const auto &kernel : module->m_kernels)
+        if (kernel.m_name == name)
+          return true;
+    return false;
+  }
 
-    uint32_t
-    GetPluginVersion() override;
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
 
-    static bool
-    GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord, Thread *thread_ptr);
+  uint32_t GetPluginVersion() override;
+
+  static bool GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord,
+                                  Thread *thread_ptr);
+
+  bool ResolveKernelName(lldb::addr_t kernel_address, ConstString &name);
 
 protected:
-    struct ScriptDetails;
-    struct AllocationDetails;
-    struct Element;
-
-    void
-    InitSearchFilter(lldb::TargetSP target)
-    {
-        if (!m_filtersp)
-            m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target));
-    }
-    
-    void
-    FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
+  struct ScriptDetails;
+  struct AllocationDetails;
+  struct Element;
+
+  lldb_renderscript::RSScriptGroupList m_scriptGroups;
+
+  void InitSearchFilter(lldb::TargetSP target) {
+    if (!m_filtersp)
+      m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target));
+  }
+
+  void FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
+
+  void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind);
 
-    void
-    LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind);
+  bool RefreshAllocation(AllocationDetails *alloc, StackFrame *frame_ptr);
 
-    bool
-    RefreshAllocation(AllocationDetails *allocation, StackFrame *frame_ptr);
+  bool EvalRSExpression(const char *expression, StackFrame *frame_ptr,
+                        uint64_t *result);
 
-    bool
-    EvalRSExpression(const char *expression, StackFrame *frame_ptr, uint64_t *result);
+  lldb::BreakpointSP CreateScriptGroupBreakpoint(const ConstString &name,
+                                                 bool multi);
 
-    lldb::BreakpointSP
-    CreateKernelBreakpoint(const ConstString &name);
+  lldb::BreakpointSP CreateKernelBreakpoint(const ConstString &name);
 
-    void
-    BreakOnModuleKernels(const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
+  lldb::BreakpointSP CreateReductionBreakpoint(const ConstString &name,
+                                               int kernel_types);
 
-    struct RuntimeHook;
-    typedef void (RenderScriptRuntime::*CaptureStateFn)(RuntimeHook *hook_info,
-                                                        ExecutionContext &context); // Please do this!
+  void BreakOnModuleKernels(
+      const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
 
-    struct HookDefn
-    {
-        const char *name;
-        const char *symbol_name_m32; // mangled name for the 32 bit architectures
-        const char *symbol_name_m64; // mangled name for the 64 bit archs
-        uint32_t version;
-        ModuleKind kind;
-        CaptureStateFn grabber;
-    };
+  struct RuntimeHook;
+  typedef void (RenderScriptRuntime::*CaptureStateFn)(
+      RuntimeHook *hook_info,
+      ExecutionContext &context); // Please do this!
 
-    struct RuntimeHook
-    {
-        lldb::addr_t address;
-        const HookDefn *defn;
-        lldb::BreakpointSP bp_sp;
-    };
+  struct HookDefn {
+    const char *name;
+    const char *symbol_name_m32; // mangled name for the 32 bit architectures
+    const char *symbol_name_m64; // mangled name for the 64 bit archs
+    uint32_t version;
+    ModuleKind kind;
+    CaptureStateFn grabber;
+  };
 
-    typedef std::shared_ptr<RuntimeHook> RuntimeHookSP;
+  struct RuntimeHook {
+    lldb::addr_t address;
+    const HookDefn *defn;
+    lldb::BreakpointSP bp_sp;
+  };
 
-    lldb::ModuleSP m_libRS;
-    lldb::ModuleSP m_libRSDriver;
-    lldb::ModuleSP m_libRSCpuRef;
-    std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules;
+  typedef std::shared_ptr<RuntimeHook> RuntimeHookSP;
 
-    std::vector<std::unique_ptr<ScriptDetails>> m_scripts;
-    std::vector<std::unique_ptr<AllocationDetails>> m_allocations;
+  lldb::ModuleSP m_libRS;
+  lldb::ModuleSP m_libRSDriver;
+  lldb::ModuleSP m_libRSCpuRef;
+  std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules;
 
-    std::map<lldb::addr_t, lldb_renderscript::RSModuleDescriptorSP> m_scriptMappings;
-    std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks;
-    std::map<lldb::user_id_t, std::shared_ptr<uint32_t>> m_conditional_breaks;
+  std::vector<std::unique_ptr<ScriptDetails>> m_scripts;
+  std::vector<std::unique_ptr<AllocationDetails>> m_allocations;
 
-    lldb::SearchFilterSP m_filtersp; // Needed to create breakpoints through Target API
+  std::map<lldb::addr_t, lldb_renderscript::RSModuleDescriptorSP>
+      m_scriptMappings;
+  std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks;
+  std::map<lldb::user_id_t, std::unique_ptr<lldb_renderscript::RSCoordinate>>
+      m_conditional_breaks;
 
-    bool m_initiated;
-    bool m_debuggerPresentFlagged;
-    bool m_breakAllKernels;
-    static const HookDefn s_runtimeHookDefns[];
-    static const size_t s_runtimeHookCount;
+  lldb::SearchFilterSP
+      m_filtersp; // Needed to create breakpoints through Target API
+
+  bool m_initiated;
+  bool m_debuggerPresentFlagged;
+  bool m_breakAllKernels;
+  static const HookDefn s_runtimeHookDefns[];
+  static const size_t s_runtimeHookCount;
+  LLVMUserExpression::IRPasses *m_ir_passes;
 
 private:
-    RenderScriptRuntime(Process *process); // Call CreateInstance instead.
-    
-    static bool
-    HookCallback(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+  RenderScriptRuntime(Process *process); // Call CreateInstance instead.
+
+  static bool HookCallback(void *baton, StoppointCallbackContext *ctx,
+                           lldb::user_id_t break_id,
+                           lldb::user_id_t break_loc_id);
+
+  static bool KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx,
+                                  lldb::user_id_t break_id,
+                                  lldb::user_id_t break_loc_id);
+
+  void HookCallback(RuntimeHook *hook_info, ExecutionContext &context);
+
+  // Callback function when 'debugHintScriptGroup2' executes on the target.
+  void CaptureDebugHintScriptGroup2(RuntimeHook *hook_info,
+                                    ExecutionContext &context);
+
+  void CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context);
 
-    static bool
-    KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id,
-                        lldb::user_id_t break_loc_id);
+  void CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context);
 
-    void
-    HookCallback(RuntimeHook *hook_info, ExecutionContext &context);
+  void CaptureAllocationDestroy(RuntimeHook *hook_info,
+                                ExecutionContext &context);
 
-    void
-    CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context);
+  void CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context);
 
-    void
-    CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context);
+  void CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info,
+                                       ExecutionContext &context);
 
-    void
-    CaptureAllocationDestroy(RuntimeHook *hook_info, ExecutionContext &context);
+  AllocationDetails *FindAllocByID(Stream &strm, const uint32_t alloc_id);
 
-    void
-    CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context);
+  std::shared_ptr<uint8_t> GetAllocationData(AllocationDetails *alloc,
+                                             StackFrame *frame_ptr);
 
-    void
-    CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info, ExecutionContext &context);
+  void SetElementSize(Element &elem);
 
-    AllocationDetails *
-    FindAllocByID(Stream &strm, const uint32_t alloc_id);
+  static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP,
+                                    const char *var_name, uint64_t &val);
 
-    std::shared_ptr<uint8_t>
-    GetAllocationData(AllocationDetails *allocation, StackFrame *frame_ptr);
+  void FindStructTypeName(Element &elem, StackFrame *frame_ptr);
 
-    void
-    SetElementSize(Element &elem);
+  size_t PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer,
+                                size_t offset, const Element &elem);
 
-    static bool
-    GetFrameVarAsUnsigned(const lldb::StackFrameSP, const char *var_name, uint64_t &val);
+  size_t CalculateElementHeaderSize(const Element &elem);
 
-    void
-    FindStructTypeName(Element &elem, StackFrame *frame_ptr);
+  void SetConditional(lldb::BreakpointSP bp, lldb_private::Stream &messages,
+                      const lldb_renderscript::RSCoordinate &coord);
+  //
+  // Helper functions for jitting the runtime
+  //
 
-    size_t
-    PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer, size_t offset, const Element &elem);
+  bool JITDataPointer(AllocationDetails *alloc, StackFrame *frame_ptr,
+                      uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);
 
-    size_t
-    CalculateElementHeaderSize(const Element &elem);
+  bool JITTypePointer(AllocationDetails *alloc, StackFrame *frame_ptr);
 
-    //
-    // Helper functions for jitting the runtime
-    //
+  bool JITTypePacked(AllocationDetails *alloc, StackFrame *frame_ptr);
 
-    bool
-    JITDataPointer(AllocationDetails *allocation, StackFrame *frame_ptr, 
-                   uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);
+  bool JITElementPacked(Element &elem, const lldb::addr_t context,
+                        StackFrame *frame_ptr);
 
-    bool
-    JITTypePointer(AllocationDetails *allocation, StackFrame *frame_ptr);
+  bool JITAllocationSize(AllocationDetails *alloc, StackFrame *frame_ptr);
 
-    bool
-    JITTypePacked(AllocationDetails *allocation, StackFrame *frame_ptr);
+  bool JITSubelements(Element &elem, const lldb::addr_t context,
+                      StackFrame *frame_ptr);
 
-    bool
-    JITElementPacked(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr);
+  bool JITAllocationStride(AllocationDetails *alloc, StackFrame *frame_ptr);
 
-    bool
-    JITAllocationSize(AllocationDetails *allocation, StackFrame *frame_ptr);
+  // Search for a script detail object using a target address.
+  // If a script does not currently exist this function will return nullptr.
+  // If 'create' is true and there is no previous script with this address,
+  // then a new Script detail object will be created for this address and
+  // returned.
+  ScriptDetails *LookUpScript(lldb::addr_t address, bool create);
 
-    bool
-    JITSubelements(Element &elem, const lldb::addr_t context, StackFrame *frame_ptr);
+  // Search for a previously saved allocation detail object using a target
+  // address.
+  // If an allocation does not exist for this address then nullptr will be
+  // returned.
+  AllocationDetails *LookUpAllocation(lldb::addr_t address);
 
-    bool
-    JITAllocationStride(AllocationDetails *allocation, StackFrame *frame_ptr);
+  // Creates a new allocation with the specified address assigning a new ID and
+  // removes
+  // any previous stored allocation which has the same address.
+  AllocationDetails *CreateAllocation(lldb::addr_t address);
 
-    // Search for a script detail object using a target address.
-    // If a script does not currently exist this function will return nullptr.
-    // If 'create' is true and there is no previous script with this address,
-    // then a new Script detail object will be created for this address and returned.
-    ScriptDetails *
-    LookUpScript(lldb::addr_t address, bool create);
+  bool GetOverrideExprOptions(clang::TargetOptions &prototype) override;
 
-    // Search for a previously saved allocation detail object using a target address.
-    // If an allocation does not exist for this address then nullptr will be returned.
-    // If 'create' is true and there is no previous allocation then a new allocation
-    // detail object will be created for this address and returned.
-    AllocationDetails *
-    LookUpAllocation(lldb::addr_t address, bool create);
+  bool GetIRPasses(LLVMUserExpression::IRPasses &passes) override;
 };
 
 } // namespace lldb_private
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp
new file mode 100644
index 0000000..a8202dd
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.cpp
@@ -0,0 +1,162 @@
+//===-- RenderScriptScriptGroup.cpp -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Host/StringConvert.h"
+#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/Options.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
+#include "RenderScriptRuntime.h"
+#include "RenderScriptScriptGroup.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_renderscript;
+
+class CommandObjectRenderScriptScriptGroupBreakpointSet
+    : public CommandObjectParsed {
+public:
+  CommandObjectRenderScriptScriptGroupBreakpointSet(
+      CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "renderscript scriptgroup breakpoint set",
+            "Place a breakpoint on all kernels forming a script group.",
+            "renderscript scriptgroup breakpoint set <group_name>",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptScriptGroupBreakpointSet() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    Stream &stream = result.GetOutputStream();
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+    assert(runtime);
+    auto &target = m_exe_ctx.GetTargetSP();
+    bool stop_on_all = false;
+    const llvm::StringRef long_stop_all("--stop-on-all"), short_stop_all("-a");
+    std::vector<ConstString> sites;
+    sites.reserve(command.GetArgumentCount());
+    for (size_t i = 0; i < command.GetArgumentCount(); ++i) {
+      const auto arg = command.GetArgumentAtIndex(i);
+      if (long_stop_all == arg || short_stop_all == arg)
+        stop_on_all = true;
+      else
+        sites.push_back(ConstString(arg));
+    }
+    for (const auto &name : sites) {
+      runtime->PlaceBreakpointOnScriptGroup(target, stream, name, stop_on_all);
+    }
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
+};
+
+class CommandObjectRenderScriptScriptGroupBreakpoint
+    : public CommandObjectMultiword {
+public:
+  CommandObjectRenderScriptScriptGroupBreakpoint(
+      CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "renderscript scriptgroup breakpoint",
+            "Renderscript scriptgroup breakpoint interaction.",
+            "renderscript scriptgroup breakpoint set [--stop-on-all/-a]"
+            "<scriptgroup name> ...",
+            eCommandRequiresProcess | eCommandProcessMustBeLaunched) {
+    LoadSubCommand(
+        "set",
+        CommandObjectSP(new CommandObjectRenderScriptScriptGroupBreakpointSet(
+            interpreter)));
+  }
+
+  ~CommandObjectRenderScriptScriptGroupBreakpoint() override = default;
+};
+
+class CommandObjectRenderScriptScriptGroupList : public CommandObjectParsed {
+public:
+  CommandObjectRenderScriptScriptGroupList(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "renderscript scriptgroup list",
+                            "List all currently discovered script groups.",
+                            "renderscript scriptgroup list",
+                            eCommandRequiresProcess |
+                                eCommandProcessMustBeLaunched) {}
+
+  ~CommandObjectRenderScriptScriptGroupList() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    Stream &stream = result.GetOutputStream();
+    RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
+        m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
+            eLanguageTypeExtRenderScript));
+    assert(runtime);
+    const RSScriptGroupList &groups = runtime->GetScriptGroups();
+    // print script group count
+    stream.Printf("%" PRIu64 " script %s", uint64_t(groups.size()),
+                  (groups.size() == 1) ? "group" : "groups");
+    stream.EOL();
+    // print script group details
+    stream.IndentMore();
+    for (const RSScriptGroupDescriptorSP &g : groups) {
+      if (g) {
+        stream.Indent();
+        // script group name
+        stream.Printf("%s", g->m_name.AsCString());
+        stream.EOL();
+        // print out the kernels
+        stream.IndentMore();
+        for (const auto &k : g->m_kernels) {
+          stream.Indent();
+          stream.Printf(". %s", k.m_name.AsCString());
+          stream.EOL();
+        }
+        stream.IndentLess();
+      }
+    }
+    stream.IndentLess();
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
+};
+
+class CommandObjectRenderScriptScriptGroup : public CommandObjectMultiword {
+public:
+  CommandObjectRenderScriptScriptGroup(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(interpreter, "renderscript scriptgroup",
+                               "Command set for interacting with scriptgroups.",
+                               nullptr, eCommandRequiresProcess |
+                                            eCommandProcessMustBeLaunched) {
+    LoadSubCommand(
+        "breakpoint",
+        CommandObjectSP(
+            new CommandObjectRenderScriptScriptGroupBreakpoint(interpreter)));
+    LoadSubCommand(
+        "list", CommandObjectSP(
+                    new CommandObjectRenderScriptScriptGroupList(interpreter)));
+  }
+
+  ~CommandObjectRenderScriptScriptGroup() override = default;
+};
+
+lldb::CommandObjectSP NewCommandObjectRenderScriptScriptGroup(
+    lldb_private::CommandInterpreter &interpreter) {
+  return CommandObjectSP(new CommandObjectRenderScriptScriptGroup(interpreter));
+}
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.h b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.h
new file mode 100644
index 0000000..5c5608c
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptScriptGroup.h
@@ -0,0 +1,18 @@
+//===-- RenderScriptScriptGroup.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_RenderScriptScriptGroup_h_
+#define liblldb_RenderScriptScriptGroup_h_
+
+#include "lldb/Interpreter/CommandInterpreter.h"
+
+lldb::CommandObjectSP NewCommandObjectRenderScriptScriptGroup(
+    lldb_private::CommandInterpreter &interpreter);
+
+#endif // liblldb_RenderScriptScriptGroup_h_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
new file mode 100644
index 0000000..aaca045
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
@@ -0,0 +1,297 @@
+//===-- RenderScriptx86ABIFixups.cpp ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+// C++ Includes
+#include <set>
+
+// Other libraries and framework includes
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/CallSite.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IRReader/IRReader.h"
+#include "llvm/Pass.h"
+
+// Project includes
+#include "lldb/Core/Log.h"
+#include "lldb/Target/Process.h"
+
+using namespace lldb_private;
+namespace {
+
+bool isRSAPICall(llvm::Module &module, llvm::CallInst *call_inst) {
+  // TODO get the list of renderscript modules from lldb and check if
+  // this llvm::Module calls into any of them.
+  (void)module;
+  const auto func_name = call_inst->getCalledFunction()->getName();
+  if (func_name.startswith("llvm") || func_name.startswith("lldb"))
+    return false;
+
+  if (call_inst->getCalledFunction()->isIntrinsic())
+    return false;
+
+  return true;
+}
+
+bool isRSLargeReturnCall(llvm::Module &module, llvm::CallInst *call_inst) {
+  // i686 and x86_64 returns for large vectors in the RenderScript API are not
+  // handled as normal
+  // register pairs, but as a hidden sret type. This is not reflected in the
+  // debug info or mangled
+  // symbol name, and the android ABI for x86 and x86_64, (as well as the
+  // emulators) specifies there is
+  // no AVX, so bcc generates an sret function because we cannot natively return
+  // 256 bit vectors.
+  // This function simply checks whether a function has a > 128bit return type.
+  // It is perhaps an
+  // unreliable heuristic, and relies on bcc not generating AVX code, so if the
+  // android ABI one day
+  // provides for AVX, this function may go out of fashion.
+  (void)module;
+  if (!call_inst || !call_inst->getCalledFunction())
+    return false;
+
+  return call_inst->getCalledFunction()
+             ->getReturnType()
+             ->getPrimitiveSizeInBits() > 128;
+}
+
+bool isRSAllocationPtrTy(const llvm::Type *type) {
+  if (!type->isPointerTy())
+    return false;
+  auto ptr_type = type->getPointerElementType();
+
+  return ptr_type->isStructTy() &&
+         ptr_type->getStructName().startswith("struct.rs_allocation");
+}
+
+bool isRSAllocationTyCallSite(llvm::Module &module, llvm::CallInst *call_inst) {
+  (void)module;
+  if (!call_inst->hasByValArgument())
+    return false;
+  for (const auto &param : call_inst->operand_values())
+    if (isRSAllocationPtrTy(param->getType()))
+      return true;
+  return false;
+}
+
+llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) {
+  // on x86 StructReturn functions return a pointer to the return value, rather
+  // than the return
+  // value itself [ref](http://www.agner.org/optimize/calling_conventions.pdf
+  // section 6).
+  // We create a return type by getting the pointer type of the old return type,
+  // and inserting a new
+  // initial argument of pointer type of the original return type.
+  Log *log(
+      GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_EXPRESSIONS));
+
+  assert(call_inst && "no CallInst");
+  llvm::Function *orig = call_inst->getCalledFunction();
+  assert(orig && "CallInst has no called function");
+  llvm::FunctionType *orig_type = orig->getFunctionType();
+  auto name = orig->getName();
+  if (log)
+    log->Printf("%s - cloning to StructRet function for '%s'", __FUNCTION__,
+                name.str().c_str());
+
+  unsigned num_params = orig_type->getNumParams();
+  std::vector<llvm::Type *> new_params{num_params + 1, nullptr};
+  std::vector<llvm::Type *> params{orig_type->param_begin(),
+                                   orig_type->param_end()};
+
+  // This may not work if the function is somehow declared void as llvm is
+  // strongly typed
+  // and represents void* with i8*
+  assert(!orig_type->getReturnType()->isVoidTy() &&
+         "Cannot add StructRet attribute to void function");
+  llvm::PointerType *return_type_ptr_type =
+      llvm::PointerType::getUnqual(orig->getReturnType());
+  assert(return_type_ptr_type &&
+         "failed to get function return type PointerType");
+  if (!return_type_ptr_type)
+    return nullptr;
+
+  if (log)
+    log->Printf("%s - return type pointer type for StructRet clone @ '0x%p':\n",
+                __FUNCTION__, (void *)return_type_ptr_type);
+  // put the the sret pointer argument in place at the beginning of the argument
+  // list.
+  params.emplace(params.begin(), return_type_ptr_type);
+  assert(params.size() == num_params + 1);
+  return llvm::FunctionType::get(return_type_ptr_type, params,
+                                 orig->isVarArg());
+}
+
+bool findRSCallSites(llvm::Module &module,
+                     std::set<llvm::CallInst *> &rs_callsites,
+                     bool (*predicate)(llvm::Module &, llvm::CallInst *)) {
+  bool found = false;
+
+  for (auto &func : module.getFunctionList())
+    for (auto &block : func.getBasicBlockList())
+      for (auto &inst : block) {
+        llvm::CallInst *call_inst =
+            llvm::dyn_cast_or_null<llvm::CallInst>(&inst);
+        if (!call_inst || !call_inst->getCalledFunction())
+          // This is not the call-site you are looking for...
+          continue;
+        if (isRSAPICall(module, call_inst) && predicate(module, call_inst)) {
+          rs_callsites.insert(call_inst);
+          found = true;
+        }
+      }
+  return found;
+}
+
+bool fixupX86StructRetCalls(llvm::Module &module) {
+  bool changed = false;
+  // changing a basic block while iterating over it seems to have some undefined
+  // behaviour
+  // going on so we find all RS callsites first, then fix them up after
+  // consuming
+  // the iterator.
+  std::set<llvm::CallInst *> rs_callsites;
+  if (!findRSCallSites(module, rs_callsites, isRSLargeReturnCall))
+    return false;
+
+  for (auto call_inst : rs_callsites) {
+    llvm::FunctionType *new_func_type = cloneToStructRetFnTy(call_inst);
+    assert(new_func_type &&
+           "failed to clone functionType for Renderscript ABI fixup");
+
+    llvm::CallSite call_site(call_inst);
+    llvm::Function *func = call_inst->getCalledFunction();
+    assert(func && "cannot resolve function in RenderScriptRuntime");
+    // Copy the original call arguments
+    std::vector<llvm::Value *> new_call_args(call_site.arg_begin(),
+                                             call_site.arg_end());
+
+    // Allocate enough space to store the return value of the original function
+    // we pass a pointer to this allocation as the StructRet param, and then
+    // copy its
+    // value into the lldb return value
+    llvm::AllocaInst *return_value_alloc = new llvm::AllocaInst(
+        func->getReturnType(), "var_vector_return_alloc", call_inst);
+    // use the new allocation as the new first argument
+    new_call_args.emplace(new_call_args.begin(),
+                          llvm::cast<llvm::Value>(return_value_alloc));
+    llvm::PointerType *new_func_ptr_type =
+        llvm::PointerType::get(new_func_type, 0);
+    // Create the type cast from the old function type to the new one
+    llvm::Constant *new_func_cast = llvm::ConstantExpr::getCast(
+        llvm::Instruction::BitCast, func, new_func_ptr_type);
+    // create an allocation for a new function pointer
+    llvm::AllocaInst *new_func_ptr =
+        new llvm::AllocaInst(new_func_ptr_type, "new_func_ptr", call_inst);
+    // store the new_func_cast to the newly allocated space
+    (new llvm::StoreInst(new_func_cast, new_func_ptr, call_inst))
+        ->setName("new_func_ptr_load_cast");
+    // load the new function address ready for a jump
+    llvm::LoadInst *new_func_addr_load =
+        new llvm::LoadInst(new_func_ptr, "load_func_pointer", call_inst);
+    // and create a callinstruction from it
+    llvm::CallInst *new_call_inst = llvm::CallInst::Create(
+        new_func_addr_load, new_call_args, "new_func_call", call_inst);
+    new_call_inst->setCallingConv(call_inst->getCallingConv());
+    new_call_inst->setTailCall(call_inst->isTailCall());
+    llvm::LoadInst *lldb_save_result_address =
+        new llvm::LoadInst(return_value_alloc, "save_return_val", call_inst);
+
+    // Now remove the old broken call
+    call_inst->replaceAllUsesWith(lldb_save_result_address);
+    call_inst->eraseFromParent();
+    changed = true;
+  }
+  return changed;
+}
+
+bool fixupRSAllocationStructByValCalls(llvm::Module &module) {
+  // On x86_64, calls to functions in the RS runtime that take an
+  // `rs_allocation` type argument
+  // are actually handled as by-ref params by bcc, but appear to be passed by
+  // value by lldb (the callsite all use
+  // `struct byval`).
+  // On x86_64 Linux, struct arguments are transferred in registers if the
+  // struct size is no bigger than
+  // 128bits [ref](http://www.agner.org/optimize/calling_conventions.pdf)
+  // section 7.1 "Passing and returning objects"
+  // otherwise passed on the stack.
+  // an object of type `rs_allocation` is actually 256bits, so should be passed
+  // on the stack. However, code generated
+  // by bcc actually treats formal params of type `rs_allocation` as
+  // `rs_allocation *` so we need to convert the
+  // calling convention to pass by reference, and remove any hint of byval from
+  // formal parameters.
+  bool changed = false;
+  std::set<llvm::CallInst *> rs_callsites;
+  if (!findRSCallSites(module, rs_callsites, isRSAllocationTyCallSite))
+    return false;
+
+  std::set<llvm::Function *> rs_functions;
+
+  // for all call instructions
+  for (auto call_inst : rs_callsites) {
+    // add the called function to a set so that we can strip its byval
+    // attributes in another pass
+    rs_functions.insert(call_inst->getCalledFunction());
+
+    // get the function attributes
+    llvm::AttributeSet call_attribs = call_inst->getAttributes();
+
+    // iterate over the argument attributes
+    for (size_t i = 1; i <= call_attribs.getNumSlots(); ++i) {
+      // if this argument is passed by val
+      if (call_attribs.hasAttribute(i, llvm::Attribute::ByVal)) {
+        // strip away the byval attribute
+        call_inst->removeAttribute(i, llvm::Attribute::ByVal);
+        changed = true;
+      }
+    }
+  }
+
+  llvm::AttributeSet attr_byval =
+      llvm::AttributeSet::get(module.getContext(), 1u, llvm::Attribute::ByVal);
+
+  // for all called function decls
+  for (auto func : rs_functions) {
+    // inspect all of the arguments in the call
+    llvm::SymbolTableList<llvm::Argument> &arg_list = func->getArgumentList();
+    for (auto &arg : arg_list) {
+      if (arg.hasByValAttr()) {
+        arg.removeAttr(attr_byval);
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+} // end anonymous namespace
+
+namespace lldb_private {
+namespace lldb_renderscript {
+
+bool fixupX86FunctionCalls(llvm::Module &module) {
+  return fixupX86StructRetCalls(module);
+}
+
+bool fixupX86_64FunctionCalls(llvm::Module &module) {
+  bool changed = false;
+  changed |= fixupX86StructRetCalls(module);
+  changed |= fixupRSAllocationStructByValCalls(module);
+  return changed;
+}
+
+} // end namespace lldb_renderscript
+} // end namespace lldb_private
diff --git a/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h
new file mode 100644
index 0000000..b2caea4
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.h
@@ -0,0 +1,23 @@
+//===-- RenderScriptx86ABIFixups.h ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_RENDERSCRIPT_X86_H
+#define LLDB_RENDERSCRIPT_X86_H
+
+#include "llvm/IR/Module.h"
+
+namespace lldb_private {
+namespace lldb_renderscript {
+
+bool fixupX86FunctionCalls(llvm::Module &module);
+
+bool fixupX86_64FunctionCalls(llvm::Module &module);
+}
+}
+#endif