More additions to RenderScriptRuntime

[domipheus]

Summary

Additions to RenderScriptRuntime in prep for detection of RenderScript modules and moving of the command interpreter manipulation to after construction.

[clayborg]

Looks good.

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

public:
     const lldb::ModuleSP m_module;
     std::vector<RSKernelDescriptor> m_kernels;
     std::vector<RSGlobalDescriptor> m_globals;
 };
 
 class RenderScriptRuntime : public lldb_private::CPPLanguageRuntime
 {
   public:
+
+    enum ModuleKind
+    {
+        eModuleKindIgnored,
+        eModuleKindLibRS,
+        eModuleKindDriver,
+        eModuleKindImpl,
+        eModuleKindKernelObj
+    };
+
     ~RenderScriptRuntime() {}
 
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void Initialize();
 
     static void Terminate();
 
     static lldb_private::LanguageRuntime *CreateInstance(Process *process, lldb::LanguageType language);
 
     static lldb_private::ConstString GetPluginNameStatic();
 
+    static bool IsRenderScriptModule(const lldb::ModuleSP &module_sp);
+
+    static ModuleKind GetModuleKind(const lldb::ModuleSP &module_sp);
+
+    static void ModulesDidLoad(const lldb::ProcessSP& process_sp, const ModuleList &module_list );
+
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
     virtual lldb_private::ConstString GetPluginName();
 
     virtual uint32_t GetPluginVersion();
 
     virtual bool IsVTableName(const char *name);
public:
     bool ProbeModules(const ModuleList module_list);
 
     void DumpModules(Stream &strm) const;
 
     virtual size_t GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) {
         return static_cast<size_t>(0);
     }
 
+    virtual void ModulesDidLoad(const ModuleList &module_list );
+
+    void Update();
+
+    void Initiate();
+
   protected:
     std::vector<RSModuleDescriptor> m_rsmodules;
-
+    bool m_initiated;
   private:
     RenderScriptRuntime(Process *process); // Call CreateInstance instead.
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_RenderScriptRuntime_h_

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 
 lldb_private::ConstString
 RenderScriptRuntime::GetPluginNameStatic()
 {
     static ConstString g_name("renderscript");
     return g_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;
+        }
+    }
+    return eModuleKindIgnored;
+}
+
+bool
+RenderScriptRuntime::IsRenderScriptModule(const lldb::ModuleSP &module_sp)
+{
+    return GetModuleKind(module_sp) != eModuleKindIgnored;
+}
+
+
+void 
+RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list )
+{
+    Mutex::Locker locker (module_list.GetMutex ());
+
+    size_t num_modules = module_list.GetSize();
+    for (size_t i = 0; i < num_modules; i++)
+    {
+        auto mod = module_list.GetModuleAtIndex (i);
+        if (IsRenderScriptModule (mod))
+        {
+            LoadModule(mod);
+        }
+    }
+}
+
+
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 lldb_private::ConstString
 RenderScriptRuntime::GetPluginName()
 {
     return GetPluginNameStatic();
 }

 {
     if (module_sp)
     {
         for (const auto &rs_module : m_rsmodules)
         {
             if (rs_module.m_module == module_sp)
                 return false;
         }
+        bool module_loaded = false;
+        switch (GetModuleKind(module_sp))
+        {
+            case eModuleKindKernelObj:
+            {
                 RSModuleDescriptor module_desc(module_sp);
                 if (module_desc.ParseRSInfo())
                 {
                     m_rsmodules.push_back(module_desc);
-            return true;
+                    module_loaded = true;
+                }
+                break;
             }
+            case eModuleKindDriver:
+            case eModuleKindImpl:
+            case eModuleKindLibRS:
+            default:
+                break;
+        }
+        if (module_loaded)
+            Update();  
+        return module_loaded;
     }
     return false;
 }
 
+void
+RenderScriptRuntime::Update()
+{
+    if (m_rsmodules.size() > 0)
+    {
+        if (!m_initiated)
+        {
+            Initiate();
+        }
+    }
+}
+
+
 // The maximum line length of an .rs.info packet
 #define MAXLINE 500
 
 // 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()
 {
CommandObjectRenderScriptRuntime(CommandInterpreter &interpreter)
         : CommandObjectMultiword(interpreter, "renderscript", "A set of commands for operating on renderscript.",
                                  "renderscript <subcommand> [<subcommand-options>]")
     {
         LoadSubCommand("module", CommandObjectSP(new CommandObjectRenderScriptRuntimeModule(interpreter)));
     }
 
     ~CommandObjectRenderScriptRuntime() {}
 };
-RenderScriptRuntime::RenderScriptRuntime(Process *process)
-    : lldb_private::CPPLanguageRuntime(process)
+
+void
+RenderScriptRuntime::Initiate()
 {
+    assert(!m_initiated);
+    Process* process = GetProcess();
     if (process)
     {
         CommandInterpreter &interpreter = process->GetTarget().GetDebugger().GetCommandInterpreter();
-        interpreter.AddCommand("renderscript", CommandObjectSP(new CommandObjectRenderScriptRuntime(interpreter)),
-                               true);
+        m_initiated = interpreter.AddCommand("renderscript", CommandObjectSP(
+                                           new CommandObjectRenderScriptRuntime(interpreter)), true);
     }
 }
+
+RenderScriptRuntime::RenderScriptRuntime(Process *process)
+    : lldb_private::CPPLanguageRuntime(process), m_initiated(false)
+{
+
+}