Vendor import of lldb trunk r290819:vendor/lldb/lldb-trunk-r290819

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

1 files changed, 434 insertions, 271 deletions

diff --git a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
index 2a0839a1a78b..a1211a2814b7 100644
--- a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
+++ b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
@@ -19,397 +19,560 @@
 #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;
+};
+
+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
-{
+class RSModuleDescriptor {
+  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;
+  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;
+};
 
-    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;
+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();
+
+  static lldb_private::LanguageRuntime *
+  CreateInstance(Process *process, lldb::LanguageType language);
 
-    ~RenderScriptRuntime() override;
+  static lldb::CommandObjectSP
+  GetCommandObject(CommandInterpreter &interpreter);
 
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
+  static lldb_private::ConstString GetPluginNameStatic();
 
-    static void
-    Terminate();
+  static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp);
 
-    static lldb_private::LanguageRuntime *
-    CreateInstance(Process *process, lldb::LanguageType language);
+  static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp);
 
-    static lldb::CommandObjectSP
-    GetCommandObject(CommandInterpreter &interpreter);
+  static void ModulesDidLoad(const lldb::ProcessSP &process_sp,
+                             const ModuleList &module_list);
 
-    static lldb_private::ConstString
-    GetPluginNameStatic();
+  bool IsVTableName(const char *name) override;
 
-    static bool
-    IsRenderScriptModule(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 ModuleKind
-    GetModuleKind(const lldb::ModuleSP &module_sp);
+  TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
+                                 ValueObject &static_value) override;
 
-    static void
-    ModulesDidLoad(const lldb::ProcessSP &process_sp, const ModuleList &module_list);
+  bool CouldHaveDynamicValue(ValueObject &in_value) override;
 
-    bool
-    IsVTableName(const char *name) override;
+  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bp,
+                                                     bool catch_bp,
+                                                     bool throw_bp) override;
 
-    bool
-    GetDynamicTypeAndAddress(ValueObject &in_value, lldb::DynamicValueType use_dynamic,
-                             TypeAndOrName &class_type_or_name, Address &address,
-                             Value::ValueType &value_type) override;
+  bool LoadModule(const lldb::ModuleSP &module_sp);
 
-    TypeAndOrName
-    FixUpDynamicType(const TypeAndOrName &type_and_or_name, ValueObject &static_value) override;
+  void DumpModules(Stream &strm) const;
 
-    bool
-    CouldHaveDynamicValue(ValueObject &in_value) override;
+  void DumpContexts(Stream &strm) const;
 
-    lldb::BreakpointResolverSP
-    CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
+  void DumpKernels(Stream &strm) const;
 
-    bool
-    LoadModule(const lldb::ModuleSP &module_sp);
+  bool DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id);
 
-    void
-    DumpModules(Stream &strm) const;
+  void ListAllocations(Stream &strm, StackFrame *frame_ptr,
+                       const uint32_t index);
 
-    void
-    DumpContexts(Stream &strm) const;
+  bool RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr);
 
-    void
-    DumpKernels(Stream &strm) const;
+  bool PlaceBreakpointOnKernel(
+      lldb::TargetSP target, Stream &messages, const char *name,
+      const lldb_renderscript::RSCoordinate *coords = nullptr);
 
-    bool
-    DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id);
+  bool PlaceBreakpointOnReduction(
+      lldb::TargetSP target, Stream &messages, const char *reduce_name,
+      const lldb_renderscript::RSCoordinate *coords = nullptr,
+      int kernel_types = ~(0));
 
-    void
-    ListAllocations(Stream &strm, StackFrame *frame_ptr, const uint32_t index);
+  bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm,
+                                    const ConstString &name, bool stop_on_all);
 
-    bool
-    RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr);
+  void SetBreakAllKernels(bool do_break, lldb::TargetSP target);
 
-    void
-    PlaceBreakpointOnKernel(Stream &strm, const char *name, const std::array<int, 3> coords, Error &error,
-                            lldb::TargetSP target);
+  void Status(Stream &strm) const;
 
-    void
-    SetBreakAllKernels(bool do_break, lldb::TargetSP target);
+  void ModulesDidLoad(const ModuleList &module_list) override;
 
-    void
-    Status(Stream &strm) const;
+  bool LoadAllocation(Stream &strm, const uint32_t alloc_id,
+                      const char *filename, StackFrame *frame_ptr);
 
-    void
-    ModulesDidLoad(const ModuleList &module_list) override;
+  bool SaveAllocation(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);
+  void Update();
 
-    bool
-    SaveAllocation(Stream &strm, const uint32_t alloc_id, const char *filename, StackFrame *frame_ptr);
+  void Initiate();
 
-    void
-    Update();
+  const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const {
+    return m_scriptGroups;
+  };
 
-    void
-    Initiate();
+  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;
+  }
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
 
-    uint32_t
-    GetPluginVersion() override;
+  uint32_t GetPluginVersion() override;
 
-    static bool
-    GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord, Thread *thread_ptr);
+  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