[lldb] Construct the dummy target when the first Dummy object is constructed

[teemperor]

Summary

We should always have a dummy target, so we might as well construct it directly when we create a Debugger object.

The idea is that if this patch doesn't cause any problems that we can get rid of all the logic
that handles situations where we don't have a dummy target (as all that code is currently
untested as there seems to be no way to have no dummy target in LLDB).

[labath]

This looks good to me (I wanted to do something like that myself at one point), but maybe let @jingham have a say too. (Overall, I would say that shouldn't be any reason why constructing a dummy target should ever fail, nor a reason for its creation to consume a large chunk of any kind of resource, so we can save ourselves a lot of second-guessing by just ensuring that the dummy target really always is there.)

lldb/include/lldb/Core/Debugger.h

403 ↗

(On Diff #216578)

this would be m_dummy_target_sp, according to the lldb style.

[teemperor]

• Fix variable name.
• Move GetDummyTarget to header as it's only a one-liner.

[jingham]

You can go a long time without actually using the Dummy target, which is why I made it lazily.

Thinking of lldb as the command line program, we tend to think "I'll only ever make one debugger" so making one extra per-debugger thing doesn't seem very important. But since the Debugger holds the Console, most UI's make one Debugger per debugging session, and may have many of them. So if making the one-per-debugger thing is not trivial, you do need to think a little harder about the cost.

OTOH, as Pavel says, a target with no executables that never connects to any platforms, or gets any expressions run in it, should be really cheap. So I'm fine with this change.

lldb/trunk/include/lldb/Core/Debugger.h

public:
   bool IsHandlingEvents() const { return m_event_handler_thread.IsJoinable(); }
 
   Status RunREPL(lldb::LanguageType language, const char *repl_options);
 
   // This is for use in the command interpreter, when you either want the
   // selected target, or if no target is present you want to prime the dummy
   // target with entities that will be copied over to new targets.
   Target *GetSelectedOrDummyTarget(bool prefer_dummy = false);
-  Target *GetDummyTarget();
+  Target *GetDummyTarget() { return m_dummy_target_sp.get(); }
 
   lldb::BroadcasterManagerSP GetBroadcasterManager() {
     return m_broadcaster_manager_sp;
   }
 
 protected:
   friend class CommandInterpreter;
   friend class REPL;
protected:
   static LoadPluginCallbackType g_load_plugin_callback;
   typedef std::vector<llvm::sys::DynamicLibrary> LoadedPluginsList;
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;
   HostThread m_io_handler_thread;
   Broadcaster m_sync_broadcaster;
   lldb::ListenerSP m_forward_listener_sp;
   llvm::once_flag m_clear_once;
+  lldb::TargetSP m_dummy_target_sp;
 
   // Events for m_sync_broadcaster
   enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 
 private:
   // Use Debugger::CreateInstance() to get a shared pointer to a new debugger

lldb/trunk/source/Core/Debugger.cpp

if (log_callback)
     m_log_callback_stream_sp =
         std::make_shared<StreamCallback>(log_callback, baton);
   m_command_interpreter_up->Initialize();
   // Always add our default platform to the platform list
   PlatformSP default_platform_sp(Platform::GetHostPlatform());
   assert(default_platform_sp);
   m_platform_list.Append(default_platform_sp, true);
 
+  m_dummy_target_sp = m_target_list.GetDummyTarget(*this);
+  assert(m_dummy_target_sp.get() && "Couldn't construct dummy target?");
+
   m_collection_sp->Initialize(g_debugger_properties);
   m_collection_sp->AppendProperty(
       ConstString("target"),
       ConstString("Settings specify to debugging targets."), true,
       Target::GetGlobalProperties()->GetValueProperties());
   m_collection_sp->AppendProperty(
       ConstString("platform"), ConstString("Platform settings."), true,
       Platform::GetGlobalPlatformProperties()->GetValueProperties());

 void Debugger::JoinIOHandlerThread() {
   if (HasIOHandlerThread()) {
     thread_result_t result;
     m_io_handler_thread.Join(&result);
     m_io_handler_thread = LLDB_INVALID_HOST_THREAD;
   }
 }
 
-Target *Debugger::GetDummyTarget() {
-  return m_target_list.GetDummyTarget(*this).get();
-}
-
 Target *Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) {
   Target *target = nullptr;
   if (!prefer_dummy) {
     target = m_target_list.GetSelectedTarget().get();
     if (target)
       return target;
   }