Add language command with ability to load plugin command objects.

[domipheus]

Summary

Follows on from http://reviews.llvm.org/D9002.

Added language command with load, as to initially load language runtime commands and allow the ability to use existing CommandObject infrastructure. Previous discussion resulted in not having a load, but HandleCommand(char*) which simply dispatched to a LanguageRuntime. However that meant losing help functionality. Having an explicit load allows using existing CommandObjects and better overall user experience.

Added the language list output to 'help language' as to reflect current behaviour.

[clayborg]

Why do we need a "language load" command? Shouldn't we just be able to do:

(lldb) language c++ ...
(lldb) language objc ...
(lldb) language renderscript ...

Each one would try to get the LanguageRuntime from the current process and fail if they aren't available.

include/lldb/Target/LanguageRuntime.h

139 ↗

(On Diff #24729)

return lldb::CommandObjectSP() here.

[domipheus]

Maybe I'm missing something here. There isn't a CommandObjectProxy style object that can resolve on the fly. If there was no load command we'd need to re-execute the command if we wanted built in help.

We can use the Handle method suggested before, but without the ability to help language <languagenane> I have a feeling we'd be changing this later on anyway, for use sake.

[clayborg]

The idea is that we have a language command whose second argument is the language name. We can probably make it so that we can get a CommandObjectSP from the LanguageRuntime static plugin callbacks (like we do with the CreateInstance static functions) so that we have the "language" CommandObject multi-word command populate its subcommands during CommandObjectLanguage::Initialize() (a static init function that would be run after all plug-ins have loaded.

[domipheus]

Thanks for the explanation - I'll have a go at implementing it in that style and update the patch tomorrow.

[clayborg]

Great, I look forward to seeing this new patch.

[domipheus]

I re-read the comment and there are sill areas of confusion. Can you define 'after all plug-ins have loaded' for this? The root cause of this problem is there is no defined load point for LanguageRuntimes, before they are requested for grabbing values. That was what I was trying to solve with the explicit load command.

[clayborg]

So my idea is to modify the static plug-in manager code that currently looks like:

bool
PluginManager::RegisterPlugin
(
    const ConstString &name,
    const char *description,
    LanguageRuntimeCreateInstance create_callback
)

to look like:

bool
PluginManager::RegisterPlugin
(
    const ConstString &name,
    const char *description,
    LanguageType language,
    LanguageRuntimeCreateInstance create_callback
    LanguageRuntimeCreateCommandObject command_callback
)

Then the LanguageRuntimeInstance structure in PluginManager.cpp would need to add fields to store "LanguageType language" and "LanguageRuntimeCreateCommandObject command_callback".

This decouples the need for an actual LanguageRuntime instance since it requires a valid process in order to exist. Then each command_callback can be NULL if the language doesn't vend a command object. Then after all of the ::Initialize() calls in SystemInitializerCommon::Initialize() and SystemInitializerFull::Initialize(), we can call the LanguageRuntime::Initialize() function so it can register any command objects with the "language" multi-word command object.

Each CommandObject in DoExecite() will need to try and grab the current language runtime from the process, if it needs the current language runtime in a process to do its job, and error out if it doesn't get it. Each language command object might be able to just look through the target images and report some information without needed an actual "LanguageRuntime*" instance. Like "c++" might be able to find where the RTTI info for a type "MyType" is by looking for mangled names in the symbol table.

Does that make more sense?

[domipheus]

Sorry for the delay in reply - and thanks for the further explanation. How does this look? I've tested it by modifying the renderscript language runtime to use this new method and it works well.

The xcode project will need updating to add the new command source.

[clayborg]

Very nice.

lldb/trunk/include/lldb/Core/PluginManager.h

public:
     GetOperatingSystemCreateCallbackForPluginName (const ConstString &name);
 
     //------------------------------------------------------------------
     // LanguageRuntime
     //------------------------------------------------------------------
     static bool
     RegisterPlugin (const ConstString &name,
                     const char *description,
-                    LanguageRuntimeCreateInstance create_callback);
+                    LanguageRuntimeCreateInstance create_callback,
+                    LanguageRuntimeGetCommandObject command_callback = nullptr);
 
     static bool
     UnregisterPlugin (LanguageRuntimeCreateInstance create_callback);
 
     static LanguageRuntimeCreateInstance
     GetLanguageRuntimeCreateCallbackAtIndex (uint32_t idx);
 
+    static LanguageRuntimeGetCommandObject
+    GetLanguageRuntimeGetCommandObjectAtIndex (uint32_t idx);
+
     static LanguageRuntimeCreateInstance
     GetLanguageRuntimeCreateCallbackForPluginName (const ConstString &name);
 
 
     //------------------------------------------------------------------
     // SystemRuntime
     //------------------------------------------------------------------
     static bool

lldb/trunk/include/lldb/Target/LanguageRuntime.h

class LanguageRuntime :
     public PluginInterface
 {
 public:
     virtual
     ~LanguageRuntime();
     
     static LanguageRuntime* 
     FindPlugin (Process *process, lldb::LanguageType language);
-    
+    static void
+    InitializeCommands (CommandObject* parent);
+    
     virtual lldb::LanguageType
     GetLanguageType () const = 0;
     
     virtual bool
     GetObjectDescription (Stream &str, ValueObject &object) = 0;
     
     virtual bool
     GetObjectDescription (Stream &str, Value &value, ExecutionContextScope *exe_scope) = 0;

lldb/trunk/include/lldb/lldb-private-interfaces.h

namespace lldb_private
     typedef size_t (*ObjectFileGetModuleSpecifications) (const FileSpec &file, lldb::DataBufferSP& data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, ModuleSpecList &module_specs);
     typedef ObjectFile* (*ObjectFileCreateInstance) (const lldb::ModuleSP &module_sp, lldb::DataBufferSP& data_sp, lldb::offset_t data_offset, const FileSpec* file, lldb::offset_t file_offset, lldb::offset_t length);
     typedef ObjectFile* (*ObjectFileCreateMemoryInstance) (const lldb::ModuleSP &module_sp, lldb::DataBufferSP& data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t offset);
     typedef bool (*ObjectFileSaveCore) (const lldb::ProcessSP &process_sp, const FileSpec &outfile, Error &error);
     typedef LogChannel* (*LogChannelCreateInstance) ();
     typedef EmulateInstruction * (*EmulateInstructionCreateInstance) (const ArchSpec &arch, InstructionType inst_type);
     typedef OperatingSystem* (*OperatingSystemCreateInstance) (Process *process, bool force);
     typedef LanguageRuntime *(*LanguageRuntimeCreateInstance) (Process *process, lldb::LanguageType language);
+    typedef lldb::CommandObjectSP (*LanguageRuntimeGetCommandObject) (CommandInterpreter& interpreter);
     typedef SystemRuntime *(*SystemRuntimeCreateInstance) (Process *process);
     typedef lldb::PlatformSP (*PlatformCreateInstance) (bool force, const ArchSpec *arch);
     typedef lldb::ProcessSP (*ProcessCreateInstance) (Target &target, Listener &listener, const FileSpec *crash_file_path);
     typedef SymbolFile* (*SymbolFileCreateInstance) (ObjectFile* obj_file);
     typedef SymbolVendor* (*SymbolVendorCreateInstance) (const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm);   // Module can be NULL for default system symbol vendor
     typedef bool (*BreakpointHitCallback) (void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
     typedef bool (*WatchpointHitCallback) (void *baton, StoppointCallbackContext *context, lldb::user_id_t watch_id);
     typedef void (*OptionValueChangedCallback) (void *baton, OptionValue *option_value);

lldb/trunk/source/Commands/CMakeLists.txt

add_lldb_library(lldbCommands
   CommandObjectSource.cpp
   CommandObjectSyntax.cpp
   CommandObjectTarget.cpp
   CommandObjectThread.cpp
   CommandObjectType.cpp
   CommandObjectVersion.cpp
   CommandObjectWatchpoint.cpp
   CommandObjectWatchpointCommand.cpp
+  CommandObjectLanguage.cpp
   )

lldb/trunk/source/Commands/CommandObjectLanguage.h

+//===-- CommandObjectLanguage.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_CommandObjectLanguage_h_
+#define liblldb_CommandObjectLanguage_h_
+
+// C Includes
+// C++ Includes
+
+
+// Other libraries and framework includes
+// Project includes
+
+#include "lldb/lldb-types.h"
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+
+namespace lldb_private {
+    class CommandObjectLanguage : public CommandObjectMultiword
+    {
+    public:
+        CommandObjectLanguage (CommandInterpreter &interpreter);
+        
+        virtual
+        ~CommandObjectLanguage ();
+        
+        virtual void
+        GenerateHelpText (Stream &output_stream);
+        
+    protected:
+        bool
+        DoExecute (Args& command, CommandReturnObject &result);
+    };
+} // namespace lldb_private
+
+#endif  // liblldb_CommandObjectLanguage_h_

lldb/trunk/source/Commands/CommandObjectLanguage.cpp

+//===-- CommandObjectLanguage.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/lldb-python.h"
+
+#include "CommandObjectLanguage.h"
+
+#include "lldb/Host/Host.h"
+
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+
+#include "lldb/Target/LanguageRuntime.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+CommandObjectLanguage::CommandObjectLanguage (CommandInterpreter &interpreter) :
+CommandObjectMultiword (interpreter,
+                        "language",
+                        "A set of commands for managing language-specific functionality.'.",
+                        "language <language-name> <subcommand> [<subcommand-options>]"
+                        )
+{
+    //Let the LanguageRuntime populates this command with subcommands
+    LanguageRuntime::InitializeCommands(this);
+}
+
+void
+CommandObjectLanguage::GenerateHelpText (Stream &output_stream) {
+    CommandObjectMultiword::GenerateHelpText(output_stream);
+
+    output_stream << "\nlanguage name can be one of the following:\n";
+
+    LanguageRuntime::PrintAllLanguages(output_stream, "  ", "\n");
+}
+
+CommandObjectLanguage::~CommandObjectLanguage ()
+{
+}

lldb/trunk/source/Core/PluginManager.cpp

LanguageRuntimeInstance() :
         description(),
         create_callback(NULL)
     {
     }
 
     ConstString name;
     std::string description;
     LanguageRuntimeCreateInstance create_callback;
+    LanguageRuntimeGetCommandObject command_callback;
 };
 
 typedef std::vector<LanguageRuntimeInstance> LanguageRuntimeInstances;
 
 static Mutex &
 GetLanguageRuntimeMutex ()
 {
     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
     return g_instances_mutex;
 }
 
 static LanguageRuntimeInstances &
 GetLanguageRuntimeInstances ()
 {
     static LanguageRuntimeInstances g_instances;
     return g_instances;
 }
 
 bool
 PluginManager::RegisterPlugin
 (
     const ConstString &name,
     const char *description,
-    LanguageRuntimeCreateInstance create_callback
+    LanguageRuntimeCreateInstance create_callback,
+    LanguageRuntimeGetCommandObject command_callback
 )
 {
     if (create_callback)
     {
         LanguageRuntimeInstance instance;
         assert ((bool)name);
         instance.name = name;
         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
+        instance.command_callback = command_callback;
         Mutex::Locker locker (GetLanguageRuntimeMutex ());
         GetLanguageRuntimeInstances ().push_back (instance);
     }
     return false;
 }
 
 bool
 PluginManager::UnregisterPlugin (LanguageRuntimeCreateInstance create_callback)

 {
     Mutex::Locker locker (GetLanguageRuntimeMutex ());
     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;
     return NULL;
 }
 
+LanguageRuntimeGetCommandObject
+PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex (uint32_t idx)
+{
+    Mutex::Locker locker (GetLanguageRuntimeMutex ());
+    LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
+    if (idx < instances.size())
+        return instances[idx].command_callback;
+    return NULL;
+}
+
 LanguageRuntimeCreateInstance
 PluginManager::GetLanguageRuntimeCreateCallbackForPluginName (const ConstString &name)
 {
     if (name)
     {
         Mutex::Locker locker (GetLanguageRuntimeMutex ());
         LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
         

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

 #include "../Commands/CommandObjectSource.h"
 #include "../Commands/CommandObjectCommands.h"
 #include "../Commands/CommandObjectSyntax.h"
 #include "../Commands/CommandObjectTarget.h"
 #include "../Commands/CommandObjectThread.h"
 #include "../Commands/CommandObjectType.h"
 #include "../Commands/CommandObjectVersion.h"
 #include "../Commands/CommandObjectWatchpoint.h"
+#include "../Commands/CommandObjectLanguage.h"
 
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Timer.h"
CommandInterpreter::LoadCommandDictionary ()
     m_command_dict["script"]    = CommandObjectSP (new CommandObjectScript (*this, script_language));
     m_command_dict["settings"]  = CommandObjectSP (new CommandObjectMultiwordSettings (*this));
     m_command_dict["source"]    = CommandObjectSP (new CommandObjectMultiwordSource (*this));
     m_command_dict["target"]    = CommandObjectSP (new CommandObjectMultiwordTarget (*this));
     m_command_dict["thread"]    = CommandObjectSP (new CommandObjectMultiwordThread (*this));
     m_command_dict["type"]      = CommandObjectSP (new CommandObjectType (*this));
     m_command_dict["version"]   = CommandObjectSP (new CommandObjectVersion (*this));
     m_command_dict["watchpoint"]= CommandObjectSP (new CommandObjectMultiwordWatchpoint (*this));
+    m_command_dict["language"]  = CommandObjectSP (new CommandObjectLanguage(*this));
 
     const char *break_regexes[][2] = {{"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "breakpoint set --file '%1' --line %2"},
                                       {"^/([^/]+)/$", "breakpoint set --source-pattern-regexp '%1'"},
                                       {"^([[:digit:]]+)[[:space:]]*$", "breakpoint set --line %1"},
                                       {"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1"},
                                       {"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$", "breakpoint set --name '%1'"},
                                       {"^(-.*)$", "breakpoint set %1"},
                                       {"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%2' --shlib '%1'"},

lldb/trunk/source/Target/LanguageRuntime.cpp

 //===-- LanguageRuntime.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/Target/LanguageRuntime.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/SearchFilter.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 class ExceptionSearchFilter : public SearchFilter
 {
 public:
switch (language)
         case eLanguageTypeC_plus_plus_11:
         case eLanguageTypeC_plus_plus_14:
             return true;
         default:
             return false;
     }
 }
 
+void
+LanguageRuntime::InitializeCommands (CommandObject* parent)
+{
+    if (!parent)
+        return;
+
+    if (!parent->IsMultiwordObject())
+        return;
+
+    LanguageRuntimeCreateInstance create_callback;
+
+    for (uint32_t idx = 0;
+         (create_callback = PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != nullptr;
+         ++idx)
+    {
+        if (LanguageRuntimeGetCommandObject command_callback = 
+                PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(idx))
+        {
+            CommandObjectSP command = command_callback(parent->GetCommandInterpreter());
+            if (command)
+            {
+                parent->LoadSubCommand(command->GetCommandName(), command);
+            }
+        }
+    }
+}
+
 lldb::SearchFilterSP
 LanguageRuntime::CreateExceptionSearchFilter ()
 {
     return m_process->GetTarget().GetSearchFilterForModule(NULL);
 }