1 //===-- RenderScriptRuntime.h -----------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef liblldb_RenderScriptRuntime_h_
10 #define liblldb_RenderScriptRuntime_h_
11 
12 #include <array>
13 #include <map>
14 #include <memory>
15 #include <string>
16 #include <vector>
17 
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "lldb/Core/Module.h"
21 #include "lldb/Expression/LLVMUserExpression.h"
22 #include "lldb/Target/LanguageRuntime.h"
23 #include "lldb/lldb-private.h"
24 
25 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
26 
27 namespace lldb_private {
28 namespace lldb_renderscript {
29 
30 typedef uint32_t RSSlot;
31 class RSModuleDescriptor;
32 struct RSGlobalDescriptor;
33 struct RSKernelDescriptor;
34 struct RSReductionDescriptor;
35 struct RSScriptGroupDescriptor;
36 
37 typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP;
38 typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP;
39 typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP;
40 typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP;
41 
42 struct RSCoordinate {
43   uint32_t x, y, z;
44 
45   RSCoordinate() : x(), y(), z(){};
46 
47   bool operator==(const lldb_renderscript::RSCoordinate &rhs) {
48     return x == rhs.x && y == rhs.y && z == rhs.z;
49   }
50 };
51 
52 // Breakpoint Resolvers decide where a breakpoint is placed, so having our own
53 // allows us to limit the search scope to RS kernel modules. As well as check
54 // for .expand kernels as a fallback.
55 class RSBreakpointResolver : public BreakpointResolver {
56 public:
57   RSBreakpointResolver(Breakpoint *bp, ConstString name)
58       : BreakpointResolver(bp, BreakpointResolver::NameResolver),
59         m_kernel_name(name) {}
60 
61   void GetDescription(Stream *strm) override {
62     if (strm)
63       strm->Printf("RenderScript kernel breakpoint for '%s'",
64                    m_kernel_name.AsCString());
65   }
66 
67   void Dump(Stream *s) const override {}
68 
69   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
70                                           SymbolContext &context,
71                                           Address *addr) override;
72 
73   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
74 
75   lldb::BreakpointResolverSP
76   CopyForBreakpoint(Breakpoint &breakpoint) override {
77     lldb::BreakpointResolverSP ret_sp(
78         new RSBreakpointResolver(&breakpoint, m_kernel_name));
79     return ret_sp;
80   }
81 
82 protected:
83   ConstString m_kernel_name;
84 };
85 
86 class RSReduceBreakpointResolver : public BreakpointResolver {
87 public:
88   enum ReduceKernelTypeFlags {
89     eKernelTypeAll = ~(0),
90     eKernelTypeNone = 0,
91     eKernelTypeAccum = (1 << 0),
92     eKernelTypeInit = (1 << 1),
93     eKernelTypeComb = (1 << 2),
94     eKernelTypeOutC = (1 << 3),
95     eKernelTypeHalter = (1 << 4)
96   };
97 
98   RSReduceBreakpointResolver(
99       Breakpoint *breakpoint, ConstString reduce_name,
100       std::vector<lldb_renderscript::RSModuleDescriptorSP> *rs_modules,
101       int kernel_types = eKernelTypeAll)
102       : BreakpointResolver(breakpoint, BreakpointResolver::NameResolver),
103         m_reduce_name(reduce_name), m_rsmodules(rs_modules),
104         m_kernel_types(kernel_types) {
105     // The reduce breakpoint resolver handles adding breakpoints for named
106     // reductions.
107     // Breakpoints will be resolved for all constituent kernels in the named
108     // reduction
109   }
110 
111   void GetDescription(Stream *strm) override {
112     if (strm)
113       strm->Printf("RenderScript reduce breakpoint for '%s'",
114                    m_reduce_name.AsCString());
115   }
116 
117   void Dump(Stream *s) const override {}
118 
119   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
120                                           SymbolContext &context,
121                                           Address *addr) override;
122 
123   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
124 
125   lldb::BreakpointResolverSP
126   CopyForBreakpoint(Breakpoint &breakpoint) override {
127     lldb::BreakpointResolverSP ret_sp(new RSReduceBreakpointResolver(
128         &breakpoint, m_reduce_name, m_rsmodules, m_kernel_types));
129     return ret_sp;
130   }
131 
132 private:
133   ConstString m_reduce_name; // The name of the reduction
134   std::vector<lldb_renderscript::RSModuleDescriptorSP> *m_rsmodules;
135   int m_kernel_types;
136 };
137 
138 struct RSKernelDescriptor {
139 public:
140   RSKernelDescriptor(const RSModuleDescriptor *module, llvm::StringRef name,
141                      uint32_t slot)
142       : m_module(module), m_name(name), m_slot(slot) {}
143 
144   void Dump(Stream &strm) const;
145 
146   const RSModuleDescriptor *m_module;
147   ConstString m_name;
148   RSSlot m_slot;
149 };
150 
151 struct RSGlobalDescriptor {
152 public:
153   RSGlobalDescriptor(const RSModuleDescriptor *module, llvm::StringRef name)
154       : m_module(module), m_name(name) {}
155 
156   void Dump(Stream &strm) const;
157 
158   const RSModuleDescriptor *m_module;
159   ConstString m_name;
160 };
161 
162 struct RSReductionDescriptor {
163   RSReductionDescriptor(const RSModuleDescriptor *module, uint32_t sig,
164                         uint32_t accum_data_size, llvm::StringRef name,
165                         llvm::StringRef init_name, llvm::StringRef accum_name,
166                         llvm::StringRef comb_name, llvm::StringRef outc_name,
167                         llvm::StringRef halter_name = ".")
168       : m_module(module), m_reduce_name(name), m_init_name(init_name),
169         m_accum_name(accum_name), m_comb_name(comb_name),
170         m_outc_name(outc_name), m_halter_name(halter_name) {
171     // TODO Check whether the combiner is an autogenerated name, and track
172     // this
173   }
174 
175   void Dump(Stream &strm) const;
176 
177   const RSModuleDescriptor *m_module;
178   ConstString m_reduce_name; // This is the name given to the general reduction
179                              // as a group as passed to pragma
180   // reduce(m_reduce_name). There is no kernel function with this name
181   ConstString m_init_name;  // The name of the initializer name. "." if no
182                             // initializer given
183   ConstString m_accum_name; // The accumulator function name. "." if not given
184   ConstString m_comb_name; // The name of the combiner function. If this was not
185                            // given, a name is generated by the
186                            // compiler. TODO
187   ConstString m_outc_name; // The name of the outconverter
188 
189   ConstString m_halter_name; // The name of the halter function. XXX This is not
190                              // yet specified by the RenderScript
191   // compiler or runtime, and its semantics and existence is still under
192   // discussion by the
193   // RenderScript Contributors
194   RSSlot m_accum_sig; // metatdata signature for this reduction (bitwise mask of
195                       // type information (see
196                       // libbcc/include/bcinfo/MetadataExtractor.h
197   uint32_t m_accum_data_size; // Data size of the accumulator function input
198   bool m_comb_name_generated; // Was the combiner name generated by the compiler
199 };
200 
201 class RSModuleDescriptor {
202   std::string m_slang_version;
203   std::string m_bcc_version;
204 
205   bool ParseVersionInfo(llvm::StringRef *, size_t n_lines);
206 
207   bool ParseExportForeachCount(llvm::StringRef *, size_t n_lines);
208 
209   bool ParseExportVarCount(llvm::StringRef *, size_t n_lines);
210 
211   bool ParseExportReduceCount(llvm::StringRef *, size_t n_lines);
212 
213   bool ParseBuildChecksum(llvm::StringRef *, size_t n_lines);
214 
215   bool ParsePragmaCount(llvm::StringRef *, size_t n_lines);
216 
217 public:
218   RSModuleDescriptor(const lldb::ModuleSP &module) : m_module(module) {}
219 
220   ~RSModuleDescriptor() = default;
221 
222   bool ParseRSInfo();
223 
224   void Dump(Stream &strm) const;
225 
226   void WarnIfVersionMismatch(Stream *s) const;
227 
228   const lldb::ModuleSP m_module;
229   std::vector<RSKernelDescriptor> m_kernels;
230   std::vector<RSGlobalDescriptor> m_globals;
231   std::vector<RSReductionDescriptor> m_reductions;
232   std::map<std::string, std::string> m_pragmas;
233   std::string m_resname;
234 };
235 
236 struct RSScriptGroupDescriptor {
237   struct Kernel {
238     ConstString m_name;
239     lldb::addr_t m_addr;
240   };
241   ConstString m_name;
242   std::vector<Kernel> m_kernels;
243 };
244 
245 typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList;
246 
247 class RSScriptGroupBreakpointResolver : public BreakpointResolver {
248 public:
249   RSScriptGroupBreakpointResolver(Breakpoint *bp, ConstString name,
250                                   const RSScriptGroupList &groups,
251                                   bool stop_on_all)
252       : BreakpointResolver(bp, BreakpointResolver::NameResolver),
253         m_group_name(name), m_script_groups(groups),
254         m_stop_on_all(stop_on_all) {}
255 
256   void GetDescription(Stream *strm) override {
257     if (strm)
258       strm->Printf("RenderScript ScriptGroup breakpoint for '%s'",
259                    m_group_name.AsCString());
260   }
261 
262   void Dump(Stream *s) const override {}
263 
264   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
265                                           SymbolContext &context,
266                                           Address *addr) override;
267 
268   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
269 
270   lldb::BreakpointResolverSP
271   CopyForBreakpoint(Breakpoint &breakpoint) override {
272     lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver(
273         &breakpoint, m_group_name, m_script_groups, m_stop_on_all));
274     return ret_sp;
275   }
276 
277 protected:
278   const RSScriptGroupDescriptorSP
279   FindScriptGroup(ConstString name) const {
280     for (auto sg : m_script_groups) {
281       if (ConstString::Compare(sg->m_name, name) == 0)
282         return sg;
283     }
284     return RSScriptGroupDescriptorSP();
285   }
286 
287   ConstString m_group_name;
288   const RSScriptGroupList &m_script_groups;
289   bool m_stop_on_all;
290 };
291 } // namespace lldb_renderscript
292 
293 class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime {
294 public:
295   enum ModuleKind {
296     eModuleKindIgnored,
297     eModuleKindLibRS,
298     eModuleKindDriver,
299     eModuleKindImpl,
300     eModuleKindKernelObj
301   };
302 
303   ~RenderScriptRuntime() override;
304 
305   // Static Functions
306   static void Initialize();
307 
308   static void Terminate();
309 
310   static lldb_private::LanguageRuntime *
311   CreateInstance(Process *process, lldb::LanguageType language);
312 
313   static lldb::CommandObjectSP
314   GetCommandObject(CommandInterpreter &interpreter);
315 
316   static lldb_private::ConstString GetPluginNameStatic();
317 
318   static char ID;
319 
320   bool isA(const void *ClassID) const override {
321     return ClassID == &ID || CPPLanguageRuntime::isA(ClassID);
322   }
323 
324   static bool classof(const LanguageRuntime *runtime) {
325     return runtime->isA(&ID);
326   }
327 
328   static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp);
329 
330   static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp);
331 
332   static void ModulesDidLoad(const lldb::ProcessSP &process_sp,
333                              const ModuleList &module_list);
334 
335   bool GetDynamicTypeAndAddress(ValueObject &in_value,
336                                 lldb::DynamicValueType use_dynamic,
337                                 TypeAndOrName &class_type_or_name,
338                                 Address &address,
339                                 Value::ValueType &value_type) override;
340 
341   TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
342                                  ValueObject &static_value) override;
343 
344   bool CouldHaveDynamicValue(ValueObject &in_value) override;
345 
346   lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bp,
347                                                      bool catch_bp,
348                                                      bool throw_bp) override;
349 
350   bool LoadModule(const lldb::ModuleSP &module_sp);
351 
352   void DumpModules(Stream &strm) const;
353 
354   void DumpContexts(Stream &strm) const;
355 
356   void DumpKernels(Stream &strm) const;
357 
358   bool DumpAllocation(Stream &strm, StackFrame *frame_ptr, const uint32_t id);
359 
360   void ListAllocations(Stream &strm, StackFrame *frame_ptr,
361                        const uint32_t index);
362 
363   bool RecomputeAllAllocations(Stream &strm, StackFrame *frame_ptr);
364 
365   bool PlaceBreakpointOnKernel(
366       lldb::TargetSP target, Stream &messages, const char *name,
367       const lldb_renderscript::RSCoordinate *coords = nullptr);
368 
369   bool PlaceBreakpointOnReduction(
370       lldb::TargetSP target, Stream &messages, const char *reduce_name,
371       const lldb_renderscript::RSCoordinate *coords = nullptr,
372       int kernel_types = ~(0));
373 
374   bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm,
375                                     ConstString name, bool stop_on_all);
376 
377   void SetBreakAllKernels(bool do_break, lldb::TargetSP target);
378 
379   void DumpStatus(Stream &strm) const;
380 
381   void ModulesDidLoad(const ModuleList &module_list) override;
382 
383   bool LoadAllocation(Stream &strm, const uint32_t alloc_id,
384                       const char *filename, StackFrame *frame_ptr);
385 
386   bool SaveAllocation(Stream &strm, const uint32_t alloc_id,
387                       const char *filename, StackFrame *frame_ptr);
388 
389   void Update();
390 
391   void Initiate();
392 
393   const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const {
394     return m_scriptGroups;
395   };
396 
397   bool IsKnownKernel(ConstString name) {
398     for (const auto &module : m_rsmodules)
399       for (const auto &kernel : module->m_kernels)
400         if (kernel.m_name == name)
401           return true;
402     return false;
403   }
404 
405   // PluginInterface protocol
406   lldb_private::ConstString GetPluginName() override;
407 
408   uint32_t GetPluginVersion() override;
409 
410   static bool GetKernelCoordinate(lldb_renderscript::RSCoordinate &coord,
411                                   Thread *thread_ptr);
412 
413   bool ResolveKernelName(lldb::addr_t kernel_address, ConstString &name);
414 
415 protected:
416   struct ScriptDetails;
417   struct AllocationDetails;
418   struct Element;
419 
420   lldb_renderscript::RSScriptGroupList m_scriptGroups;
421 
422   void InitSearchFilter(lldb::TargetSP target) {
423     if (!m_filtersp)
424       m_filtersp.reset(new SearchFilterForUnconstrainedSearches(target));
425   }
426 
427   void FixupScriptDetails(lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
428 
429   void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind);
430 
431   bool RefreshAllocation(AllocationDetails *alloc, StackFrame *frame_ptr);
432 
433   bool EvalRSExpression(const char *expression, StackFrame *frame_ptr,
434                         uint64_t *result);
435 
436   lldb::BreakpointSP CreateScriptGroupBreakpoint(ConstString name,
437                                                  bool multi);
438 
439   lldb::BreakpointSP CreateKernelBreakpoint(ConstString name);
440 
441   lldb::BreakpointSP CreateReductionBreakpoint(ConstString name,
442                                                int kernel_types);
443 
444   void BreakOnModuleKernels(
445       const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
446 
447   struct RuntimeHook;
448   typedef void (RenderScriptRuntime::*CaptureStateFn)(
449       RuntimeHook *hook_info,
450       ExecutionContext &context); // Please do this!
451 
452   struct HookDefn {
453     const char *name;
454     const char *symbol_name_m32; // mangled name for the 32 bit architectures
455     const char *symbol_name_m64; // mangled name for the 64 bit archs
456     uint32_t version;
457     ModuleKind kind;
458     CaptureStateFn grabber;
459   };
460 
461   struct RuntimeHook {
462     lldb::addr_t address;
463     const HookDefn *defn;
464     lldb::BreakpointSP bp_sp;
465   };
466 
467   typedef std::shared_ptr<RuntimeHook> RuntimeHookSP;
468 
469   lldb::ModuleSP m_libRS;
470   lldb::ModuleSP m_libRSDriver;
471   lldb::ModuleSP m_libRSCpuRef;
472   std::vector<lldb_renderscript::RSModuleDescriptorSP> m_rsmodules;
473 
474   std::vector<std::unique_ptr<ScriptDetails>> m_scripts;
475   std::vector<std::unique_ptr<AllocationDetails>> m_allocations;
476 
477   std::map<lldb::addr_t, lldb_renderscript::RSModuleDescriptorSP>
478       m_scriptMappings;
479   std::map<lldb::addr_t, RuntimeHookSP> m_runtimeHooks;
480   std::map<lldb::user_id_t, std::unique_ptr<lldb_renderscript::RSCoordinate>>
481       m_conditional_breaks;
482 
483   lldb::SearchFilterSP
484       m_filtersp; // Needed to create breakpoints through Target API
485 
486   bool m_initiated;
487   bool m_debuggerPresentFlagged;
488   bool m_breakAllKernels;
489   static const HookDefn s_runtimeHookDefns[];
490   static const size_t s_runtimeHookCount;
491   LLVMUserExpression::IRPasses *m_ir_passes;
492 
493 private:
494   RenderScriptRuntime(Process *process); // Call CreateInstance instead.
495 
496   static bool HookCallback(void *baton, StoppointCallbackContext *ctx,
497                            lldb::user_id_t break_id,
498                            lldb::user_id_t break_loc_id);
499 
500   static bool KernelBreakpointHit(void *baton, StoppointCallbackContext *ctx,
501                                   lldb::user_id_t break_id,
502                                   lldb::user_id_t break_loc_id);
503 
504   void HookCallback(RuntimeHook *hook_info, ExecutionContext &context);
505 
506   // Callback function when 'debugHintScriptGroup2' executes on the target.
507   void CaptureDebugHintScriptGroup2(RuntimeHook *hook_info,
508                                     ExecutionContext &context);
509 
510   void CaptureScriptInit(RuntimeHook *hook_info, ExecutionContext &context);
511 
512   void CaptureAllocationInit(RuntimeHook *hook_info, ExecutionContext &context);
513 
514   void CaptureAllocationDestroy(RuntimeHook *hook_info,
515                                 ExecutionContext &context);
516 
517   void CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context);
518 
519   void CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info,
520                                        ExecutionContext &context);
521 
522   AllocationDetails *FindAllocByID(Stream &strm, const uint32_t alloc_id);
523 
524   std::shared_ptr<uint8_t> GetAllocationData(AllocationDetails *alloc,
525                                              StackFrame *frame_ptr);
526 
527   void SetElementSize(Element &elem);
528 
529   static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP,
530                                     const char *var_name, uint64_t &val);
531 
532   void FindStructTypeName(Element &elem, StackFrame *frame_ptr);
533 
534   size_t PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer,
535                                 size_t offset, const Element &elem);
536 
537   size_t CalculateElementHeaderSize(const Element &elem);
538 
539   void SetConditional(lldb::BreakpointSP bp, lldb_private::Stream &messages,
540                       const lldb_renderscript::RSCoordinate &coord);
541   //
542   // Helper functions for jitting the runtime
543   //
544 
545   bool JITDataPointer(AllocationDetails *alloc, StackFrame *frame_ptr,
546                       uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);
547 
548   bool JITTypePointer(AllocationDetails *alloc, StackFrame *frame_ptr);
549 
550   bool JITTypePacked(AllocationDetails *alloc, StackFrame *frame_ptr);
551 
552   bool JITElementPacked(Element &elem, const lldb::addr_t context,
553                         StackFrame *frame_ptr);
554 
555   bool JITAllocationSize(AllocationDetails *alloc, StackFrame *frame_ptr);
556 
557   bool JITSubelements(Element &elem, const lldb::addr_t context,
558                       StackFrame *frame_ptr);
559 
560   bool JITAllocationStride(AllocationDetails *alloc, StackFrame *frame_ptr);
561 
562   // Search for a script detail object using a target address.
563   // If a script does not currently exist this function will return nullptr.
564   // If 'create' is true and there is no previous script with this address,
565   // then a new Script detail object will be created for this address and
566   // returned.
567   ScriptDetails *LookUpScript(lldb::addr_t address, bool create);
568 
569   // Search for a previously saved allocation detail object using a target
570   // address.
571   // If an allocation does not exist for this address then nullptr will be
572   // returned.
573   AllocationDetails *LookUpAllocation(lldb::addr_t address);
574 
575   // Creates a new allocation with the specified address assigning a new ID and
576   // removes
577   // any previous stored allocation which has the same address.
578   AllocationDetails *CreateAllocation(lldb::addr_t address);
579 
580   bool GetOverrideExprOptions(clang::TargetOptions &prototype) override;
581 
582   bool GetIRPasses(LLVMUserExpression::IRPasses &passes) override;
583 };
584 
585 } // namespace lldb_private
586 
587 #endif // liblldb_RenderScriptRuntime_h_
588