[lldb] Unify target checking in CommandObject

[teemperor]

Summary

We currently have several CommandObjects that manually reimplement the checking for a selected target
or a target in the execution context (which is the selected target when they are invoked). This patch removes
all these checks and replaces them by setting the eCommandRequiresTarget flag that Pavel suggested. With
this flag we are doing the same check but without having to duplicate this code in all these CommandObjects.

I also added a GetSelectedTarget() variant of the GetSelectedOrDummyTarget() function to the
CommandObject that checks that the flag is set and then returns a reference to the target. I didn't rewrite
all the target variables from Target * to Target & in this patch as last time this change caused a lot of merge
conflicts in Swift and I would prefer having that in a separate NFC commit.

[amccarth]

I support anything that reduces the code path differences between user-entered commands and their SBAPI counterparts. Thanks for doing this!

[jingham]

The whole command flags was a late addition, but we were using it for new commands and "when you touch it" kind of changes. That seems to have stalled the conversion, so thanks for completing this!

As a minor style thing, prior to this change CommandObjectThreadStepUntil required a thread, but didn't require a process explicitly, because you can't have a thread without a process. You also can't have a thread without a target since you can't have a process without a target. But your change means that if I specify that I require a thread I now ALSO have to require a target explicitly or I will get an assert calling GetSelectedTarget. That seems a little awkward to me (especially since you still don't have to require a process...) It would be better if eCommandRequiresThread implied eCommandRequiresProcess & eCommandRequiresTarget. That would keep these definitions less noisy.

[labath]

Awesome.

In D66863#1649436, @jingham wrote:

As a minor style thing, prior to this change CommandObjectThreadStepUntil required a thread, but didn't require a process explicitly, because you can't have a thread without a process. You also can't have a thread without a target since you can't have a process without a target. But your change means that if I specify that I require a thread I now ALSO have to require a target explicitly or I will get an assert calling GetSelectedTarget. That seems a little awkward to me (especially since you still don't have to require a process...) It would be better if eCommandRequiresThread implied eCommandRequiresProcess & eCommandRequiresTarget. That would keep these definitions less noisy.

This sounds like a good idea to me.

lldb/source/Commands/CommandObjectTarget.cpp

2615–2617 ↗

(On Diff #217580)

Another quirk of clang-format is that it will not re-merge strings that it has split previously. If you manually join these three strings into one, and then re-run clang-format, you'll probably end up with something slightly nicer...

[teemperor]

• Removed target requirement where we already have another flag that's implying that we need a target.
• Properly formatted some strings.
• Extended check in GetSelectedTarget to also check for flags that imply eCommandRequiresTarget.

[clayborg]

Just a few string reflows and fix a typo

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

593 ↗

(On Diff #218084)

replace multiple spaces with just one

lldb/source/Commands/CommandObjectTarget.cpp

2615–2617 ↗

(On Diff #218084)

Fix string

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

552–554 ↗

(On Diff #218084)

reflow the string

lldb/source/Interpreter/CommandObject.cpp

929 ↗

(On Diff #218084)

s/AnySe/AnySet/

[teemperor]

• Fix typo in code and comment.
• Reflow some changed strings.

lldb/trunk/include/lldb/Interpreter/CommandObject.h

protected:
   virtual const char *GetInvalidRegContextDescription() {
     return "invalid frame, no registers";
   }
 
   // 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 &GetSelectedTarget();
   Target &GetDummyTarget();
 
   // If a command needs to use the "current" thread, use this call. Command
   // objects will have an ExecutionContext to use, and that may or may not have
   // a thread in it.  If it does, you should use that by default, if not, then
   // use the ExecutionContext's target's selected thread, etc... This call
   // insulates you from the details of this calculation.
   Thread *GetDefaultThread();

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

private:
   CommandOptions m_options;
 };
 
 // CommandObjectBreakpointCommandList
 
 class CommandObjectBreakpointCommandList : public CommandObjectParsed {
 public:
   CommandObjectBreakpointCommandList(CommandInterpreter &interpreter)
-      : CommandObjectParsed(interpreter, "list", "List the script or set of "
-                                                 "commands to be executed when "
-                                                 "the breakpoint is hit.",
-                            nullptr) {
+      : CommandObjectParsed(interpreter, "list",
+                            "List the script or set of commands to be "
+                            "executed when the breakpoint is hit.",
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandArgumentData bp_id_arg;
 
     // Define the first (and only) variant of this arg.
     bp_id_arg.arg_type = eArgTypeBreakpointID;
     bp_id_arg.arg_repetition = eArgRepeatPlain;
 
     // There is only one variant this argument could be; put it into the
     // argument entry.
     arg.push_back(bp_id_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectBreakpointCommandList() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-
-    if (target == nullptr) {
-      result.AppendError("There is not a current executable; there are no "
-                         "breakpoints for which to list commands");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     const BreakpointList &breakpoints = target->GetBreakpointList();
     size_t num_breakpoints = breakpoints.GetSize();
 
     if (num_breakpoints == 0) {
       result.AppendError("No breakpoints exist for which to list commands");
       result.SetStatus(eReturnStatusFailed);
       return false;

lldb/trunk/source/Commands/CommandObjectDisassemble.cpp

 
 CommandObjectDisassemble::CommandObjectDisassemble(
     CommandInterpreter &interpreter)
     : CommandObjectParsed(
           interpreter, "disassemble",
           "Disassemble specified instructions in the current target.  "
           "Defaults to the current function for the current thread and "
           "stack frame.",
-          "disassemble [<cmd-options>]"),
+          "disassemble [<cmd-options>]", eCommandRequiresTarget),
       m_options() {}
 
 CommandObjectDisassemble::~CommandObjectDisassemble() = default;
 
 bool CommandObjectDisassemble::DoExecute(Args &command,
                                          CommandReturnObject &result) {
-  Target *target = GetDebugger().GetSelectedTarget().get();
-  if (target == nullptr) {
-    result.AppendError("invalid target, create a debug target using the "
-                       "'target create' command");
-    result.SetStatus(eReturnStatusFailed);
-    return false;
-  }
+  Target *target = &GetSelectedTarget();
+
   if (!m_options.arch.IsValid())
     m_options.arch = target->GetArchitecture();
 
   if (!m_options.arch.IsValid()) {
     result.AppendError(
         "use the --arch option or set the target architecture to disassemble");
     result.SetStatus(eReturnStatusFailed);
     return false;

lldb/trunk/source/Commands/CommandObjectProcess.cpp

public:
     std::string pass;
   };
 
   CommandObjectProcessHandle(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process handle",
                             "Manage LLDB handling of OS signals for the "
                             "current target process.  Defaults to showing "
                             "current policy.",
-                            nullptr),
+                            nullptr, eCommandRequiresTarget),
         m_options() {
     SetHelpLong("\nIf no signals are specified, update them all.  If no update "
                 "option is specified, list the current values.");
     CommandArgumentEntry arg;
     CommandArgumentData signal_arg;
 
     signal_arg.arg_type = eArgTypeUnixSignal;
     signal_arg.arg_repetition = eArgRepeatStar;
if (num_valid_signals > 0) {
                     signals_sp);
         signo = signals_sp->GetNextSignalNumber(signo);
       }
     }
   }
 
 protected:
   bool DoExecute(Args &signal_args, CommandReturnObject &result) override {
-    TargetSP target_sp = GetDebugger().GetSelectedTarget();
-
-    if (!target_sp) {
-      result.AppendError("No current target;"
-                         " cannot handle signals until you have a valid target "
-                         "and process.\n");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target_sp = &GetSelectedTarget();
 
     ProcessSP process_sp = target_sp->GetProcessSP();
 
     if (!process_sp) {
       result.AppendError("No current process; cannot handle signals until you "
                          "have a valid process.\n");
       result.SetStatus(eReturnStatusFailed);
       return false;

lldb/trunk/source/Commands/CommandObjectTarget.cpp

 #pragma mark CommandObjectTargetModulesSearchPathsAdd
 
 class CommandObjectTargetModulesSearchPathsAdd : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesSearchPathsAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target modules search-paths add",
                             "Add new image search paths substitution pairs to "
                             "the current target.",
-                            nullptr) {
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandArgumentData old_prefix_arg;
     CommandArgumentData new_prefix_arg;
 
     // Define the first variant of this arg pair.
     old_prefix_arg.arg_type = eArgTypeOldPathPrefix;
     old_prefix_arg.arg_repetition = eArgRepeatPairPlus;
 
CommandObjectTargetModulesSearchPathsAdd(CommandInterpreter &interpreter)
 
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectTargetModulesSearchPathsAdd() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target) {
-      const size_t argc = command.GetArgumentCount();
-      if (argc & 1) {
-        result.AppendError("add requires an even number of arguments\n");
-        result.SetStatus(eReturnStatusFailed);
-      } else {
-        for (size_t i = 0; i < argc; i += 2) {
-          const char *from = command.GetArgumentAtIndex(i);
-          const char *to = command.GetArgumentAtIndex(i + 1);
+    Target *target = &GetSelectedTarget();
 
-          if (from[0] && to[0]) {
-            Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-            if (log) {
-              LLDB_LOGF(log,
-                        "target modules search path adding ImageSearchPath "
-                        "pair: '%s' -> '%s'",
-                        from, to);
-            }
-            bool last_pair = ((argc - i) == 2);
-            target->GetImageSearchPathList().Append(
-                ConstString(from), ConstString(to),
-                last_pair); // Notify if this is the last pair
-            result.SetStatus(eReturnStatusSuccessFinishNoResult);
-          } else {
-            if (from[0])
-              result.AppendError("<path-prefix> can't be empty\n");
-            else
-              result.AppendError("<new-path-prefix> can't be empty\n");
-            result.SetStatus(eReturnStatusFailed);
-          }
-        }
-      }
-    } else {
-      result.AppendError("invalid target\n");
-      result.SetStatus(eReturnStatusFailed);
-    }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesSearchPathsClear
 
 class CommandObjectTargetModulesSearchPathsClear : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesSearchPathsClear(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target modules search-paths clear",
                             "Clear all current image search path substitution "
                             "pairs from the current target.",
-                            "target modules search-paths clear") {}
+                            "target modules search-paths clear",
+                            eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesSearchPathsClear() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target) {
-      bool notify = true;
-      target->GetImageSearchPathList().Clear(notify);
-      result.SetStatus(eReturnStatusSuccessFinishNoResult);
-    } else {
-      result.AppendError("invalid target\n");
-      result.SetStatus(eReturnStatusFailed);
-    }
+    Target *target = &GetSelectedTarget();
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesSearchPathsInsert
 
 class CommandObjectTargetModulesSearchPathsInsert : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesSearchPathsInsert(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target modules search-paths insert",
                             "Insert a new image search path substitution pair "
                             "into the current target at the specified index.",
-                            nullptr) {
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg1;
     CommandArgumentEntry arg2;
     CommandArgumentData index_arg;
     CommandArgumentData old_prefix_arg;
     CommandArgumentData new_prefix_arg;
 
     // Define the first and only variant of this arg.
     index_arg.arg_type = eArgTypeIndex;
CommandObjectTargetModulesSearchPathsInsert(CommandInterpreter &interpreter)
     m_arguments.push_back(arg1);
     m_arguments.push_back(arg2);
   }
 
   ~CommandObjectTargetModulesSearchPathsInsert() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target) {
-      size_t argc = command.GetArgumentCount();
-      // check for at least 3 arguments and an odd number of parameters
-      if (argc >= 3 && argc & 1) {
-        bool success = false;
+    Target *target = &GetSelectedTarget();
 
-        uint32_t insert_idx = StringConvert::ToUInt32(
-            command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success);
 
-        if (!success) {
-          result.AppendErrorWithFormat(
-              "<index> parameter is not an integer: '%s'.\n",
-              command.GetArgumentAtIndex(0));
-          result.SetStatus(eReturnStatusFailed);
-          return result.Succeeded();
-        }
 
-        // shift off the index
-        command.Shift();
-        argc = command.GetArgumentCount();
 
-        for (uint32_t i = 0; i < argc; i += 2, ++insert_idx) {
-          const char *from = command.GetArgumentAtIndex(i);
-          const char *to = command.GetArgumentAtIndex(i + 1);
 
-          if (from[0] && to[0]) {
-            bool last_pair = ((argc - i) == 2);
-            target->GetImageSearchPathList().Insert(
-                ConstString(from), ConstString(to), insert_idx, last_pair);
-            result.SetStatus(eReturnStatusSuccessFinishNoResult);
-          } else {
-            if (from[0])
-              result.AppendError("<path-prefix> can't be empty\n");
-            else
-              result.AppendError("<new-path-prefix> can't be empty\n");
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-          }
-        }
-      } else {
-        result.AppendError("insert requires at least three arguments\n");
-        result.SetStatus(eReturnStatusFailed);
-        return result.Succeeded();
-      }
-
-    } else {
-      result.AppendError("invalid target\n");
-      result.SetStatus(eReturnStatusFailed);
-    }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesSearchPathsList
 
 class CommandObjectTargetModulesSearchPathsList : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesSearchPathsList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target modules search-paths list",
                             "List all current image search path substitution "
                             "pairs in the current target.",
-                            "target modules search-paths list") {}
+                            "target modules search-paths list",
+                            eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesSearchPathsList() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target) {
-      if (command.GetArgumentCount() != 0) {
-        result.AppendError("list takes no arguments\n");
-        result.SetStatus(eReturnStatusFailed);
-        return result.Succeeded();
-      }
+    Target *target = &GetSelectedTarget();
 
-      target->GetImageSearchPathList().Dump(&result.GetOutputStream());
-      result.SetStatus(eReturnStatusSuccessFinishResult);
-    } else {
-      result.AppendError("invalid target\n");
-      result.SetStatus(eReturnStatusFailed);
-    }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesSearchPathsQuery
 
 class CommandObjectTargetModulesSearchPathsQuery : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesSearchPathsQuery(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "target modules search-paths query",
             "Transform a path using the first applicable image search path.",
-            nullptr) {
+            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandArgumentData path_arg;
 
     // Define the first (and only) variant of this arg.
     path_arg.arg_type = eArgTypeDirectoryName;
     path_arg.arg_repetition = eArgRepeatPlain;
 
     // There is only one variant this argument could be; put it into the
     // argument entry.
     arg.push_back(path_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectTargetModulesSearchPathsQuery() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target) {
-      if (command.GetArgumentCount() != 1) {
-        result.AppendError("query requires one argument\n");
-        result.SetStatus(eReturnStatusFailed);
-        return result.Succeeded();
-      }
+    Target *target = &GetSelectedTarget();
 
-      ConstString orig(command.GetArgumentAtIndex(0));
-      ConstString transformed;
-      if (target->GetImageSearchPathList().RemapPath(orig, transformed))
-        result.GetOutputStream().Printf("%s\n", transformed.GetCString());
-      else
-        result.GetOutputStream().Printf("%s\n", orig.GetCString());
 
-      result.SetStatus(eReturnStatusSuccessFinishResult);
-    } else {
-      result.AppendError("invalid target\n");
-      result.SetStatus(eReturnStatusFailed);
-    }
     return result.Succeeded();
   }
 };
 
 // Static Helper functions
 static void DumpModuleArchitecture(Stream &strm, Module *module,
                                    bool full_triple, uint32_t width) {
   if (module) {

 // paths
 
 class CommandObjectTargetModulesModuleAutoComplete
     : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesModuleAutoComplete(CommandInterpreter &interpreter,
                                                const char *name,
                                                const char *help,
-                                               const char *syntax)
-      : CommandObjectParsed(interpreter, name, help, syntax) {
+                                               const char *syntax,
+                                               uint32_t flags = 0)
+      : CommandObjectParsed(interpreter, name, help, syntax, flags) {
     CommandArgumentEntry arg;
     CommandArgumentData file_arg;
 
     // Define the first (and only) variant of this arg.
     file_arg.arg_type = eArgTypeFilename;
     file_arg.arg_repetition = eArgRepeatStar;
 
     // There is only one variant this argument could be; put it into the

 
 class CommandObjectTargetModulesDumpObjfile
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesDumpObjfile(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
             interpreter, "target modules dump objfile",
             "Dump the object file headers from one or more target modules.",
-            nullptr) {}
+            nullptr, eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesDumpObjfile() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
     result.GetOutputStream().SetAddressByteSize(addr_byte_size);
     result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
     size_t num_dumped = 0;
     if (command.GetArgumentCount() == 0) {
       // Dump all headers for all modules images

 #include "CommandOptions.inc"
 
 class CommandObjectTargetModulesDumpSymtab
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
             interpreter, "target modules dump symtab",
-            "Dump the symbol table from one or more target modules.", nullptr),
+            "Dump the symbol table from one or more target modules.", nullptr,
+            eCommandRequiresTarget),
         m_options() {}
 
   ~CommandObjectTargetModulesDumpSymtab() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_modules_dump_symtab_options);
     }
 
     SortOrder m_sort_order;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    } else {
-      uint32_t num_dumped = 0;
+    Target *target = &GetSelectedTarget();
 
-      uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
-      result.GetOutputStream().SetAddressByteSize(addr_byte_size);
-      result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
-      if (command.GetArgumentCount() == 0) {
-        // Dump all sections for all modules images
-        std::lock_guard<std::recursive_mutex> guard(
-            target->GetImages().GetMutex());
-        const size_t num_modules = target->GetImages().GetSize();
-        if (num_modules > 0) {
-          result.GetOutputStream().Printf("Dumping symbol table for %" PRIu64
-                                          " modules.\n",
-                                          (uint64_t)num_modules);
-          for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
-            if (num_dumped > 0) {
-              result.GetOutputStream().EOL();
-              result.GetOutputStream().EOL();
-            }
-            if (m_interpreter.WasInterrupted())
-              break;
-            num_dumped++;
-            DumpModuleSymtab(
-                m_interpreter, result.GetOutputStream(),
-                target->GetImages().GetModulePointerAtIndexUnlocked(image_idx),
-                m_options.m_sort_order);
-          }
-        } else {
-          result.AppendError("the target has no associated executable images");
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-      } else {
-        // Dump specified images (by basename or fullpath)
-        const char *arg_cstr;
-        for (int arg_idx = 0;
-             (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
-             ++arg_idx) {
-          ModuleList module_list;
-          const size_t num_matches =
-              FindModulesByName(target, arg_cstr, module_list, true);
-          if (num_matches > 0) {
-            for (size_t i = 0; i < num_matches; ++i) {
-              Module *module = module_list.GetModulePointerAtIndex(i);
-              if (module) {
-                if (num_dumped > 0) {
-                  result.GetOutputStream().EOL();
-                  result.GetOutputStream().EOL();
-                }
-                if (m_interpreter.WasInterrupted())
-                  break;
-                num_dumped++;
-                DumpModuleSymtab(m_interpreter, result.GetOutputStream(),
-                                 module, m_options.m_sort_order);
-              }
-            }
-          } else
-            result.AppendWarningWithFormat(
-                "Unable to find an image that matches '%s'.\n", arg_cstr);
-        }
-      }
+              DumpModuleSymtab(m_interpreter, result.GetOutputStream(), module,
+                               m_options.m_sort_order);
 
-      if (num_dumped > 0)
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-      else {
-        result.AppendError("no matching executable images found");
-        result.SetStatus(eReturnStatusFailed);
-      }
-    }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 #pragma mark CommandObjectTargetModulesDumpSections
 
 // Image section dumping command
 
 class CommandObjectTargetModulesDumpSections
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesDumpSections(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
             interpreter, "target modules dump sections",
             "Dump the sections from one or more target modules.",
             //"target modules dump sections [<file1> ...]")
-            nullptr) {}
+            nullptr, eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesDumpSections() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    } else {
-      uint32_t num_dumped = 0;
+    Target *target = &GetSelectedTarget();
 
-      uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
-      result.GetOutputStream().SetAddressByteSize(addr_byte_size);
-      result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
-      if (command.GetArgumentCount() == 0) {
-        // Dump all sections for all modules images
-        const size_t num_modules = target->GetImages().GetSize();
-        if (num_modules > 0) {
-          result.GetOutputStream().Printf("Dumping sections for %" PRIu64
-                                          " modules.\n",
-                                          (uint64_t)num_modules);
-          for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
-            if (m_interpreter.WasInterrupted())
-              break;
-            num_dumped++;
-            DumpModuleSections(
-                m_interpreter, result.GetOutputStream(),
-                target->GetImages().GetModulePointerAtIndex(image_idx));
-          }
-        } else {
-          result.AppendError("the target has no associated executable images");
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-      } else {
-        // Dump specified images (by basename or fullpath)
-        const char *arg_cstr;
-        for (int arg_idx = 0;
-             (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
-             ++arg_idx) {
-          ModuleList module_list;
-          const size_t num_matches =
-              FindModulesByName(target, arg_cstr, module_list, true);
-          if (num_matches > 0) {
-            for (size_t i = 0; i < num_matches; ++i) {
-              if (m_interpreter.WasInterrupted())
-                break;
-              Module *module = module_list.GetModulePointerAtIndex(i);
-              if (module) {
-                num_dumped++;
-                DumpModuleSections(m_interpreter, result.GetOutputStream(),
-                                   module);
-              }
-            }
-          } else {
-            // Check the global list
-            std::lock_guard<std::recursive_mutex> guard(
-                Module::GetAllocationModuleCollectionMutex());
 
-            result.AppendWarningWithFormat(
-                "Unable to find an image that matches '%s'.\n", arg_cstr);
-          }
-        }
-      }
 
-      if (num_dumped > 0)
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-      else {
-        result.AppendError("no matching executable images found");
-        result.SetStatus(eReturnStatusFailed);
-      }
-    }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpSections
 
 // Clang AST dumping command
 
 class CommandObjectTargetModulesDumpClangAST
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesDumpClangAST(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
             interpreter, "target modules dump ast",
             "Dump the clang ast for a given module's symbol file.",
             //"target modules dump ast [<file1> ...]")
-            nullptr) {}
+            nullptr, eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesDumpClangAST() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     const size_t num_modules = target->GetImages().GetSize();
     if (num_modules == 0) {
       result.AppendError("the target has no associated executable images");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 

 class CommandObjectTargetModulesDumpSymfile
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesDumpSymfile(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
             interpreter, "target modules dump symfile",
             "Dump the debug symbol file for one or more target modules.",
             //"target modules dump symfile [<file1> ...]")
-            nullptr) {}
+            nullptr, eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesDumpSymfile() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    } else {
-      uint32_t num_dumped = 0;
+    Target *target = &GetSelectedTarget();
 
-      uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
-      result.GetOutputStream().SetAddressByteSize(addr_byte_size);
-      result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
-      if (command.GetArgumentCount() == 0) {
-        // Dump all sections for all modules images
-        const ModuleList &target_modules = target->GetImages();
-        std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
-        const size_t num_modules = target_modules.GetSize();
-        if (num_modules > 0) {
-          result.GetOutputStream().Printf("Dumping debug symbols for %" PRIu64
-                                          " modules.\n",
-                                          (uint64_t)num_modules);
-          for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) {
-            if (m_interpreter.WasInterrupted())
-              break;
-            if (DumpModuleSymbolFile(
-                    result.GetOutputStream(),
-                    target_modules.GetModulePointerAtIndexUnlocked(image_idx)))
-              num_dumped++;
-          }
-        } else {
-          result.AppendError("the target has no associated executable images");
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-      } else {
-        // Dump specified images (by basename or fullpath)
-        const char *arg_cstr;
-        for (int arg_idx = 0;
-             (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
-             ++arg_idx) {
-          ModuleList module_list;
-          const size_t num_matches =
-              FindModulesByName(target, arg_cstr, module_list, true);
-          if (num_matches > 0) {
-            for (size_t i = 0; i < num_matches; ++i) {
-              if (m_interpreter.WasInterrupted())
-                break;
-              Module *module = module_list.GetModulePointerAtIndex(i);
-              if (module) {
-                if (DumpModuleSymbolFile(result.GetOutputStream(), module))
-                  num_dumped++;
-              }
-            }
-          } else
-            result.AppendWarningWithFormat(
-                "Unable to find an image that matches '%s'.\n", arg_cstr);
-        }
-      }
 
-      if (num_dumped > 0)
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-      else {
-        result.AppendError("no matching executable images found");
-        result.SetStatus(eReturnStatusFailed);
-      }
-    }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpLineTable
 #define LLDB_OPTIONS_target_modules_dump
 #include "CommandOptions.inc"
 
public:
   ~CommandObjectTargetModulesDump() override = default;
 };
 
 class CommandObjectTargetModulesAdd : public CommandObjectParsed {
 public:
   CommandObjectTargetModulesAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target modules add",
                             "Add a new module to the current target's modules.",
-                            "target modules add [<module>]"),
-        m_option_group(),
-        m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's', 0,
-                      eArgTypeFilename, "Fullpath to a stand alone debug "
+                            "target modules add [<module>]",
+                            eCommandRequiresTarget),
+        m_option_group(), m_symbol_file(LLDB_OPT_SET_1, false, "symfile", 's',
+                                        0, eArgTypeFilename,
+                                        "Fullpath to a stand alone debug "
                                         "symbols file for when debug symbols "
                                         "are not in the executable.") {
     m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL,
                           LLDB_OPT_SET_1);
     m_option_group.Append(&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
public:
   }
 
 protected:
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupFile m_symbol_file;
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    } else {
-      bool flush = false;
+    Target *target = &GetSelectedTarget();
 
-      const size_t argc = args.GetArgumentCount();
-      if (argc == 0) {
-        if (m_uuid_option_group.GetOptionValue().OptionWasSet()) {
-          // We are given a UUID only, go locate the file
-          ModuleSpec module_spec;
-          module_spec.GetUUID() =
-              m_uuid_option_group.GetOptionValue().GetCurrentValue();
-          if (m_symbol_file.GetOptionValue().OptionWasSet())
-            module_spec.GetSymbolFileSpec() =
-                m_symbol_file.GetOptionValue().GetCurrentValue();
-          if (Symbols::DownloadObjectAndSymbolFile(module_spec)) {
-            ModuleSP module_sp(target->GetOrCreateModule(module_spec,
-                                                 true /* notify */));
-            if (module_sp) {
-              result.SetStatus(eReturnStatusSuccessFinishResult);
-              return true;
-            } else {
-              StreamString strm;
-              module_spec.GetUUID().Dump(&strm);
-              if (module_spec.GetFileSpec()) {
-                if (module_spec.GetSymbolFileSpec()) {
-                  result.AppendErrorWithFormat(
-                      "Unable to create the executable or symbol file with "
-                      "UUID %s with path %s and symbol file %s",
-                      strm.GetData(),
-                      module_spec.GetFileSpec().GetPath().c_str(),
-                      module_spec.GetSymbolFileSpec().GetPath().c_str());
-                } else {
-                  result.AppendErrorWithFormat(
-                      "Unable to create the executable or symbol file with "
-                      "UUID %s with path %s",
-                      strm.GetData(),
-                      module_spec.GetFileSpec().GetPath().c_str());
-                }
-              } else {
-                result.AppendErrorWithFormat("Unable to create the executable "
-                                             "or symbol file with UUID %s",
-                                             strm.GetData());
-              }
-              result.SetStatus(eReturnStatusFailed);
-              return false;
-            }
-          } else {
-            StreamString strm;
-            module_spec.GetUUID().Dump(&strm);
-            result.AppendErrorWithFormat(
-                "Unable to locate the executable or symbol file with UUID %s",
-                strm.GetData());
-            result.SetStatus(eReturnStatusFailed);
-            return false;
-          }
-        } else {
-          result.AppendError(
-              "one or more executable image paths must be specified");
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-      } else {
-        for (auto &entry : args.entries()) {
-          if (entry.ref.empty())
-            continue;
+          ModuleSP module_sp(
+              target->GetOrCreateModule(module_spec, true /* notify */));
+                    strm.GetData(), module_spec.GetFileSpec().GetPath().c_str(),
 
-          FileSpec file_spec(entry.ref);
-          if (FileSystem::Instance().Exists(file_spec)) {
-            ModuleSpec module_spec(file_spec);
-            if (m_uuid_option_group.GetOptionValue().OptionWasSet())
-              module_spec.GetUUID() =
-                  m_uuid_option_group.GetOptionValue().GetCurrentValue();
-            if (m_symbol_file.GetOptionValue().OptionWasSet())
-              module_spec.GetSymbolFileSpec() =
-                  m_symbol_file.GetOptionValue().GetCurrentValue();
-            if (!module_spec.GetArchitecture().IsValid())
-              module_spec.GetArchitecture() = target->GetArchitecture();
-            Status error;
-            ModuleSP module_sp(target->GetOrCreateModule(module_spec, 
-                                            true /* notify */, &error));
-            if (!module_sp) {
-              const char *error_cstr = error.AsCString();
-              if (error_cstr)
-                result.AppendError(error_cstr);
-              else
-                result.AppendErrorWithFormat("unsupported module: %s",
-                                             entry.c_str());
-              result.SetStatus(eReturnStatusFailed);
-              return false;
-            } else {
-              flush = true;
-            }
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-          } else {
-            std::string resolved_path = file_spec.GetPath();
-            result.SetStatus(eReturnStatusFailed);
-            if (resolved_path != entry.ref) {
-              result.AppendErrorWithFormat(
-                  "invalid module path '%s' with resolved path '%s'\n",
-                  entry.ref.str().c_str(), resolved_path.c_str());
-              break;
-            }
-            result.AppendErrorWithFormat("invalid module path '%s'\n",
-                                         entry.c_str());
-            break;
-          }
-        }
-      }
+          ModuleSP module_sp(target->GetOrCreateModule(
+              module_spec, true /* notify */, &error));
 
-      if (flush) {
-        ProcessSP process = target->GetProcessSP();
-        if (process)
-          process->Flush();
-      }
-    }
 
     return result.Succeeded();
   }
 };
 
 class CommandObjectTargetModulesLoad
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesLoad(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
-            interpreter, "target modules load", "Set the load addresses for "
-                                                "one or more sections in a "
-                                                "target module.",
+            interpreter, "target modules load",
+            "Set the load addresses for one or more sections in a target "
+            "module.",
             "target modules load [--file <module> --uuid <uuid>] <sect-name> "
-            "<address> [<sect-name> <address> ....]"),
+            "<address> [<sect-name> <address> ....]",
+            eCommandRequiresTarget),
         m_option_group(),
         m_file_option(LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName,
                       "Fullpath or basename for module to load.", ""),
         m_load_option(LLDB_OPT_SET_1, false, "load", 'l',
                       "Write file contents to the memory.", false, true),
         m_pc_option(LLDB_OPT_SET_1, false, "set-pc-to-entry", 'p',
                     "Set PC to the entry point."
                     " Only applicable with '--load' option.",
public:
   }
 
   ~CommandObjectTargetModulesLoad() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    Target *target = &GetSelectedTarget();
     const bool load = m_load_option.GetOptionValue().GetCurrentValue();
     const bool set_pc = m_pc_option.GetOptionValue().GetCurrentValue();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    } else {
-      const size_t argc = args.GetArgumentCount();
-      ModuleSpec module_spec;
-      bool search_using_module_spec = false;
+
 
-      // Allow "load" option to work without --file or --uuid option.
-      if (load) {
-        if (!m_file_option.GetOptionValue().OptionWasSet() &&
-            !m_uuid_option_group.GetOptionValue().OptionWasSet()) {
-          ModuleList &module_list = target->GetImages();
-          if (module_list.GetSize() == 1) {
-            search_using_module_spec = true;
-            module_spec.GetFileSpec() =
-                module_list.GetModuleAtIndex(0)->GetFileSpec();
-          }
-        }
-      }
 
-      if (m_file_option.GetOptionValue().OptionWasSet()) {
-        search_using_module_spec = true;
-        const char *arg_cstr = m_file_option.GetOptionValue().GetCurrentValue();
-        const bool use_global_module_list = true;
-        ModuleList module_list;
-        const size_t num_matches = FindModulesByName(
-            target, arg_cstr, module_list, use_global_module_list);
-        if (num_matches == 1) {
-          module_spec.GetFileSpec() =
-              module_list.GetModuleAtIndex(0)->GetFileSpec();
-        } else if (num_matches > 1) {
-          search_using_module_spec = false;
-          result.AppendErrorWithFormat(
-              "more than 1 module matched by name '%s'\n", arg_cstr);
-          result.SetStatus(eReturnStatusFailed);
-        } else {
-          search_using_module_spec = false;
-          result.AppendErrorWithFormat("no object file for module '%s'\n",
-                                       arg_cstr);
-          result.SetStatus(eReturnStatusFailed);
-        }
-      }
 
-      if (m_uuid_option_group.GetOptionValue().OptionWasSet()) {
-        search_using_module_spec = true;
-        module_spec.GetUUID() =
-            m_uuid_option_group.GetOptionValue().GetCurrentValue();
-      }
 
-      if (search_using_module_spec) {
-        ModuleList matching_modules;
-        const size_t num_matches =
-            target->GetImages().FindModules(module_spec, matching_modules);
 
-        char path[PATH_MAX];
-        if (num_matches == 1) {
-          Module *module = matching_modules.GetModulePointerAtIndex(0);
-          if (module) {
-            ObjectFile *objfile = module->GetObjectFile();
-            if (objfile) {
-              SectionList *section_list = module->GetSectionList();
-              if (section_list) {
-                bool changed = false;
-                if (argc == 0) {
-                  if (m_slide_option.GetOptionValue().OptionWasSet()) {
-                    const addr_t slide =
-                        m_slide_option.GetOptionValue().GetCurrentValue();
-                    const bool slide_is_offset = true;
-                    module->SetLoadAddress(*target, slide, slide_is_offset,
-                                           changed);
-                  } else {
-                    result.AppendError("one or more section name + load "
-                                       "address pair must be specified");
-                    result.SetStatus(eReturnStatusFailed);
-                    return false;
-                  }
-                } else {
-                  if (m_slide_option.GetOptionValue().OptionWasSet()) {
-                    result.AppendError("The \"--slide <offset>\" option can't "
-                                       "be used in conjunction with setting "
-                                       "section load addresses.\n");
-                    result.SetStatus(eReturnStatusFailed);
-                    return false;
-                  }
 
-                  for (size_t i = 0; i < argc; i += 2) {
-                    const char *sect_name = args.GetArgumentAtIndex(i);
-                    const char *load_addr_cstr = args.GetArgumentAtIndex(i + 1);
-                    if (sect_name && load_addr_cstr) {
-                      ConstString const_sect_name(sect_name);
-                      bool success = false;
-                      addr_t load_addr = StringConvert::ToUInt64(
-                          load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
-                      if (success) {
-                        SectionSP section_sp(
-                            section_list->FindSectionByName(const_sect_name));
-                        if (section_sp) {
-                          if (section_sp->IsThreadSpecific()) {
-                            result.AppendErrorWithFormat(
-                                "thread specific sections are not yet "
-                                "supported (section '%s')\n",
-                                sect_name);
-                            result.SetStatus(eReturnStatusFailed);
-                            break;
-                          } else {
-                            if (target->GetSectionLoadList()
-                                    .SetSectionLoadAddress(section_sp,
-                                                           load_addr))
-                              changed = true;
-                            result.AppendMessageWithFormat(
-                                "section '%s' loaded at 0x%" PRIx64 "\n",
-                                sect_name, load_addr);
-                          }
-                        } else {
-                          result.AppendErrorWithFormat("no section found that "
-                                                       "matches the section "
-                                                       "name '%s'\n",
-                                                       sect_name);
-                          result.SetStatus(eReturnStatusFailed);
-                          break;
-                        }
-                      } else {
-                        result.AppendErrorWithFormat(
-                            "invalid load address string '%s'\n",
-                            load_addr_cstr);
-                        result.SetStatus(eReturnStatusFailed);
-                        break;
-                      }
-                    } else {
-                      if (sect_name)
-                        result.AppendError("section names must be followed by "
-                                           "a load address.\n");
-                      else
-                        result.AppendError("one or more section name + load "
-                                           "address pair must be specified.\n");
-                      result.SetStatus(eReturnStatusFailed);
-                      break;
-                    }
-                  }
-                }
+                                  .SetSectionLoadAddress(section_sp, load_addr))
+                          "invalid load address string '%s'\n", load_addr_cstr);
 
-                if (changed) {
-                  target->ModulesDidLoad(matching_modules);
-                  Process *process = m_exe_ctx.GetProcessPtr();
-                  if (process)
-                    process->Flush();
-                }
-                if (load) {
-                  ProcessSP process = target->CalculateProcess();
-                  Address file_entry = objfile->GetEntryPointAddress();
-                  if (!process) {
-                    result.AppendError("No process");
-                    return false;
-                  }
-                  if (set_pc && !file_entry.IsValid()) {
-                    result.AppendError("No entry address in object file");
-                    return false;
-                  }
-                  std::vector<ObjectFile::LoadableData> loadables(
-                      objfile->GetLoadableData(*target));
-                  if (loadables.size() == 0) {
-                    result.AppendError("No loadable sections");
-                    return false;
-                  }
-                  Status error = process->WriteObjectFile(std::move(loadables));
-                  if (error.Fail()) {
-                    result.AppendError(error.AsCString());
-                    return false;
-                  }
-                  if (set_pc) {
-                    ThreadList &thread_list = process->GetThreadList();
-                    RegisterContextSP reg_context(
-                        thread_list.GetSelectedThread()->GetRegisterContext());
-                    addr_t file_entry_addr = file_entry.GetLoadAddress(target);
-                    if (!reg_context->SetPC(file_entry_addr)) {
-                      result.AppendErrorWithFormat("failed to set PC value to "
-                                                   "0x%" PRIx64 "\n",
-                                                   file_entry_addr);
-                      result.SetStatus(eReturnStatusFailed);
-                    }
-                  }
-                }
-              } else {
-                module->GetFileSpec().GetPath(path, sizeof(path));
-                result.AppendErrorWithFormat(
-                    "no sections in object file '%s'\n", path);
-                result.SetStatus(eReturnStatusFailed);
-              }
-            } else {
-              module->GetFileSpec().GetPath(path, sizeof(path));
-              result.AppendErrorWithFormat("no object file for module '%s'\n",
-                                           path);
-              result.SetStatus(eReturnStatusFailed);
-            }
-          } else {
-            FileSpec *module_spec_file = module_spec.GetFileSpecPtr();
-            if (module_spec_file) {
-              module_spec_file->GetPath(path, sizeof(path));
-              result.AppendErrorWithFormat("invalid module '%s'.\n", path);
-            } else
-              result.AppendError("no module spec");
-            result.SetStatus(eReturnStatusFailed);
-          }
-        } else {
-          std::string uuid_str;
+              result.AppendErrorWithFormat("no sections in object file '%s'\n",
+                                           path);
 
-          if (module_spec.GetFileSpec())
-            module_spec.GetFileSpec().GetPath(path, sizeof(path));
-          else
-            path[0] = '\0';
 
-          if (module_spec.GetUUIDPtr())
-            uuid_str = module_spec.GetUUID().GetAsString();
-          if (num_matches > 1) {
-            result.AppendErrorWithFormat(
-                "multiple modules match%s%s%s%s:\n", path[0] ? " file=" : "",
-                path, !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str());
-            for (size_t i = 0; i < num_matches; ++i) {
-              if (matching_modules.GetModulePointerAtIndex(i)
-                      ->GetFileSpec()
-                      .GetPath(path, sizeof(path)))
-                result.AppendMessageWithFormat("%s\n", path);
-            }
-          } else {
-            result.AppendErrorWithFormat(
-                "no modules were found  that match%s%s%s%s.\n",
-                path[0] ? " file=" : "", path,
-                !uuid_str.empty() ? " uuid=" : "", uuid_str.c_str());
-          }
-          result.SetStatus(eReturnStatusFailed);
-        }
-      } else {
-        result.AppendError("either the \"--file <module>\" or the \"--uuid "
-                           "<uuid>\" option must be specified.\n");
-        result.SetStatus(eReturnStatusFailed);
-        return false;
-      }
-    }
+              path[0] ? " file=" : "", path, !uuid_str.empty() ? " uuid=" : "",
+              uuid_str.c_str());
     return result.Succeeded();
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupString m_file_option;
   OptionGroupBoolean m_load_option;
   OptionGroupBoolean m_pc_option;
bool LookupInModule(CommandInterpreter &interpreter, Module *module,
     }
 
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    } else {
-      bool syntax_error = false;
-      uint32_t i;
-      uint32_t num_successful_lookups = 0;
-      uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
-      result.GetOutputStream().SetAddressByteSize(addr_byte_size);
-      result.GetErrorStream().SetAddressByteSize(addr_byte_size);
-      // Dump all sections for all modules images
+    Target *target = &GetSelectedTarget();
 
-      if (command.GetArgumentCount() == 0) {
-        ModuleSP current_module;
 
-        // Where it is possible to look in the current symbol context first,
-        // try that.  If this search was successful and --all was not passed,
-        // don't print anything else.
-        if (LookupHere(m_interpreter, result, syntax_error)) {
-          result.GetOutputStream().EOL();
-          num_successful_lookups++;
-          if (!m_options.m_print_all) {
-            result.SetStatus(eReturnStatusSuccessFinishResult);
-            return result.Succeeded();
-          }
-        }
 
-        // Dump all sections for all other modules
 
-        const ModuleList &target_modules = target->GetImages();
-        std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
-        const size_t num_modules = target_modules.GetSize();
-        if (num_modules > 0) {
-          for (i = 0; i < num_modules && !syntax_error; ++i) {
-            Module *module_pointer =
-                target_modules.GetModulePointerAtIndexUnlocked(i);
 
-            if (module_pointer != current_module.get() &&
-                LookupInModule(
-                    m_interpreter,
-                    target_modules.GetModulePointerAtIndexUnlocked(i), result,
-                    syntax_error)) {
-              result.GetOutputStream().EOL();
-              num_successful_lookups++;
-            }
-          }
-        } else {
-          result.AppendError("the target has no associated executable images");
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-      } else {
-        // Dump specified images (by basename or fullpath)
-        const char *arg_cstr;
-        for (i = 0; (arg_cstr = command.GetArgumentAtIndex(i)) != nullptr &&
-                    !syntax_error;
-             ++i) {
-          ModuleList module_list;
-          const size_t num_matches =
-              FindModulesByName(target, arg_cstr, module_list, false);
-          if (num_matches > 0) {
-            for (size_t j = 0; j < num_matches; ++j) {
-              Module *module = module_list.GetModulePointerAtIndex(j);
-              if (module) {
-                if (LookupInModule(m_interpreter, module, result,
-                                   syntax_error)) {
-                  result.GetOutputStream().EOL();
-                  num_successful_lookups++;
-                }
-              }
-            }
-          } else
-            result.AppendWarningWithFormat(
-                "Unable to find an image that matches '%s'.\n", arg_cstr);
-        }
-      }
+              LookupInModule(m_interpreter,
+                             target_modules.GetModulePointerAtIndexUnlocked(i),
+                             result, syntax_error)) {
+              if (LookupInModule(m_interpreter, module, result, syntax_error)) {
 
-      if (num_successful_lookups > 0)
-        result.SetStatus(eReturnStatusSuccessFinishResult);
-      else
-        result.SetStatus(eReturnStatusFailed);
-    }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 #pragma mark CommandObjectMultiwordImageSearchPaths
 

lldb/trunk/source/Commands/CommandObjectThread.cpp

CommandObjectThreadContinue(CommandInterpreter &interpreter)
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectThreadContinue() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     bool synchronous_execution = m_interpreter.GetSynchronous();
 
-    if (!GetDebugger().GetSelectedTarget()) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
-
     Process *process = m_exe_ctx.GetProcessPtr();
     if (process == nullptr) {
       result.AppendError("no process exists. Cannot continue");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     StateType state = process->GetState();
public:
   ~CommandObjectThreadUntil() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     bool synchronous_execution = m_interpreter.GetSynchronous();
 
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("invalid target, create a debug target using the "
-                         "'target create' command");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     Process *process = m_exe_ctx.GetProcessPtr();
     if (process == nullptr) {
       result.AppendError("need a valid process to step");
       result.SetStatus(eReturnStatusFailed);
     } else {
       Thread *thread = nullptr;
       std::vector<uint32_t> line_numbers;

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

static void AddWatchpointDescription(Stream *s, Watchpoint *wp,
   s->IndentMore();
   wp->GetDescription(s, level);
   s->IndentLess();
   s->EOL();
 }
 
 static bool CheckTargetForWatchpointOperations(Target *target,
                                                CommandReturnObject &result) {
-  if (target == nullptr) {
-    result.AppendError("Invalid target.  No existing target or watchpoints.");
-    result.SetStatus(eReturnStatusFailed);
-    return false;
-  }
   bool process_is_valid =
       target->GetProcessSP() && target->GetProcessSP()->IsAlive();
   if (!process_is_valid) {
     result.AppendError("Thre's no process or it is not alive.");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
   // Target passes our checks, return true.

 
 #pragma mark List
 
 class CommandObjectWatchpointList : public CommandObjectParsed {
 public:
   CommandObjectWatchpointList(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "watchpoint list",
-            "List all watchpoints at configurable levels of detail.", nullptr),
+            "List all watchpoints at configurable levels of detail.", nullptr,
+            eCommandRequiresTarget),
         m_options() {
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
public:
 
     // Instance variables to hold the values for command options.
 
     lldb::DescriptionLevel m_level;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-    if (target == nullptr) {
-      result.AppendError("Invalid target. No current target or watchpoints.");
-      result.SetStatus(eReturnStatusSuccessFinishNoResult);
-      return true;
-    }
+    Target *target = &GetSelectedTarget();
 
     if (target->GetProcessSP() && target->GetProcessSP()->IsAlive()) {
       uint32_t num_supported_hardware_watchpoints;
       Status error = target->GetProcessSP()->GetWatchpointSupportInfo(
           num_supported_hardware_watchpoints);
       if (error.Success())
         result.AppendMessageWithFormat(
             "Number of supported hardware watchpoints: %u\n",

 #pragma mark Enable
 
 class CommandObjectWatchpointEnable : public CommandObjectParsed {
 public:
   CommandObjectWatchpointEnable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "enable",
                             "Enable the specified disabled watchpoint(s). If "
                             "no watchpoints are specified, enable all of them.",
-                            nullptr) {
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointEnable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
 

 
 class CommandObjectWatchpointDisable : public CommandObjectParsed {
 public:
   CommandObjectWatchpointDisable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "watchpoint disable",
                             "Disable the specified watchpoint(s) without "
                             "removing it/them.  If no watchpoints are "
                             "specified, disable them all.",
-                            nullptr) {
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointDisable() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
     size_t num_watchpoints = watchpoints.GetSize();

 #pragma mark Delete
 
 class CommandObjectWatchpointDelete : public CommandObjectParsed {
 public:
   CommandObjectWatchpointDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "watchpoint delete",
                             "Delete the specified watchpoint(s).  If no "
                             "watchpoints are specified, delete them all.",
-                            nullptr) {
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointDelete() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
 

 #include "CommandOptions.inc"
 
 class CommandObjectWatchpointIgnore : public CommandObjectParsed {
 public:
   CommandObjectWatchpointIgnore(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "watchpoint ignore",
                             "Set ignore count on the specified watchpoint(s).  "
                             "If no watchpoints are specified, set them all.",
-                            nullptr),
+                            nullptr, eCommandRequiresTarget),
         m_options() {
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
public:
 
     // Instance variables to hold the values for command options.
 
     uint32_t m_ignore_count;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
 
public:
   CommandObjectWatchpointModify(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "watchpoint modify",
             "Modify the options on a watchpoint or set of watchpoints in the "
             "executable.  "
             "If no watchpoint is specified, act on the last created "
             "watchpoint.  "
             "Passing an empty argument clears the modification.",
-            nullptr),
+            nullptr, eCommandRequiresTarget),
         m_options() {
     CommandArgumentEntry arg;
     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
public:
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
     bool m_condition_passed;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
+    Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
 

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.cpp

 
 class CommandObjectWatchpointCommandAdd : public CommandObjectParsed,
                                           public IOHandlerDelegateMultiline {
 public:
   CommandObjectWatchpointCommandAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "add",
                             "Add a set of LLDB commands to a watchpoint, to be "
                             "executed whenever the watchpoint is hit.",
-                            nullptr),
+                            nullptr, eCommandRequiresTarget),
         IOHandlerDelegateMultiline("DONE",
                                    IOHandlerDelegate::Completion::LLDBCommand),
         m_options() {
     SetHelpLong(
         R"(
 General information about entering watchpoint commands
 ------------------------------------------------------
 
public:
     bool m_use_one_liner;
     std::string m_one_liner;
     bool m_stop_on_error;
     std::string m_function_name;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-
-    if (target == nullptr) {
-      result.AppendError("There is not a current executable; there are no "
-                         "watchpoints to which to add commands");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
     size_t num_watchpoints = watchpoints.GetSize();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to have commands added");
       result.SetStatus(eReturnStatusFailed);
       return false;

 
 // CommandObjectWatchpointCommandDelete
 
 class CommandObjectWatchpointCommandDelete : public CommandObjectParsed {
 public:
   CommandObjectWatchpointCommandDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "delete",
                             "Delete the set of commands from a watchpoint.",
-                            nullptr) {
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandArgumentData wp_id_arg;
 
     // Define the first (and only) variant of this arg.
     wp_id_arg.arg_type = eArgTypeWatchpointID;
     wp_id_arg.arg_repetition = eArgRepeatPlain;
 
     // There is only one variant this argument could be; put it into the
     // argument entry.
     arg.push_back(wp_id_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointCommandDelete() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-
-    if (target == nullptr) {
-      result.AppendError("There is not a current executable; there are no "
-                         "watchpoints from which to delete commands");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
     size_t num_watchpoints = watchpoints.GetSize();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist to have commands deleted");
       result.SetStatus(eReturnStatusFailed);
       return false;
protected:
   }
 };
 
 // CommandObjectWatchpointCommandList
 
 class CommandObjectWatchpointCommandList : public CommandObjectParsed {
 public:
   CommandObjectWatchpointCommandList(CommandInterpreter &interpreter)
-      : CommandObjectParsed(interpreter, "list", "List the script or set of "
-                                                 "commands to be executed when "
-                                                 "the watchpoint is hit.",
-                            nullptr) {
+      : CommandObjectParsed(interpreter, "list",
+                            "List the script or set of commands to be executed "
+                            "when the watchpoint is hit.",
+                            nullptr, eCommandRequiresTarget) {
     CommandArgumentEntry arg;
     CommandArgumentData wp_id_arg;
 
     // Define the first (and only) variant of this arg.
     wp_id_arg.arg_type = eArgTypeWatchpointID;
     wp_id_arg.arg_repetition = eArgRepeatPlain;
 
     // There is only one variant this argument could be; put it into the
     // argument entry.
     arg.push_back(wp_id_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointCommandList() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    Target *target = GetDebugger().GetSelectedTarget().get();
-
-    if (target == nullptr) {
-      result.AppendError("There is not a current executable; there are no "
-                         "watchpoints for which to list commands");
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
+    Target *target = &GetSelectedTarget();
 
     const WatchpointList &watchpoints = target->GetWatchpointList();
     size_t num_watchpoints = watchpoints.GetSize();
 
     if (num_watchpoints == 0) {
       result.AppendError("No watchpoints exist for which to list commands");
       result.SetStatus(eReturnStatusFailed);
       return false;

lldb/trunk/source/Interpreter/CommandObject.cpp

 Target &CommandObject::GetDummyTarget() {
   return *m_interpreter.GetDebugger().GetDummyTarget();
 }
 
 Target &CommandObject::GetSelectedOrDummyTarget(bool prefer_dummy) {
   return *m_interpreter.GetDebugger().GetSelectedOrDummyTarget(prefer_dummy);
 }
 
+Target &CommandObject::GetSelectedTarget() {
+  assert(m_flags.AnySet(eCommandRequiresTarget | eCommandProcessMustBePaused |
+                        eCommandProcessMustBeLaunched | eCommandRequiresFrame |
+                        eCommandRequiresThread | eCommandRequiresProcess |
+                        eCommandRequiresRegContext) &&
+         "GetSelectedTarget called from object that may have no target");
+  return *m_interpreter.GetDebugger().GetSelectedTarget();
+}
+
 Thread *CommandObject::GetDefaultThread() {
   Thread *thread_to_use = m_exe_ctx.GetThreadPtr();
   if (thread_to_use)
     return thread_to_use;
 
   Process *process = m_exe_ctx.GetProcessPtr();
   if (!process) {
     Target *target = m_exe_ctx.GetTargetPtr();