Implement interactive command interruption

[lemo]

Summary

The core of this change is the new CommandInterpreter::m_command_state, which models the state transitions for interactive commands, including an "interrupted" state transition.

In general, command interruption requires cooperation from the code executing the command, which needs to poll for interruption requests through CommandInterpreter::WasInterrupted().

CommandInterpreter::PrintCommandOutput() implements an optionally interruptible printing of the command output, which for large outputs was likely the longest blocking part

(ex. target modules dump symtab on a complex binary could take 10+ minutes)

Differential Revision: https://reviews.llvm.org/D37923

[amccarth]

I haven't looked at the whole patch yet, but it seems the SIGINT fix is well isolated. That should probably be in a separate patch.

[lemo]

Split the SIGINT handles fixes into a stanalone patch

[amccarth]

source/Commands/CommandObjectTarget.cpp

2058

Many LLVM developers prefer to omit the braces when the body of the control-flow statement is a single statement.

source/Interpreter/CommandInterpreter.cpp

2713

Should we be that trusting of a caller? In a non-debug build, if a caller doesn't end the (non-empty) string with '\n', this'll just run past the end of the buffer. Did I miss something that guarantees the caller won't make a mistake? Would it be too expensive to play it safe?

2720

This assert should precede the line before it.

tools/driver/Driver.cpp

1182 ↗

(On Diff #115463)

I'm not sure why these two ifs aren't one, as in:

if (g_driver && !g_interrupt_sent.test_and_set())

1189 ↗

(On Diff #115463)

Can you add a comment explaining why this uses _exit rather than exit? It's not obvious to me.

tools/lldb-mi/MIDriverMain.cpp

71 ↗

(On Diff #115463)

I think this concurrency fix for SIGINT would be better in a separate patch. I understand how it's related to the rest of this patch, but LLVM folks tend to prefer small, incremental patches.

[lemo]

source/Commands/CommandObjectTarget.cpp

2058

So do the hackers: https://blog.codecentric.de/en/2014/02/curly-braces :) I too prefer to omit braces in small test snippets, but in production code it's not worth the risk of making a silly mistake.

source/Interpreter/CommandInterpreter.cpp

2720

Pedantically, it should be both before and after (and for ultimate paranoid mode, asserting that Write returns <= than the passed in value)

But the asserts looks for the really nasty case where "size -= chunk_size" overflows.

tools/driver/Driver.cpp

1189 ↗

(On Diff #115463)

Explained in the SIGINT patch: exit() is not signal-safe (http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html)

Calling it from a signal handler can result in all kind of nasty issues, in particular exit() does call a lot of stuff, both runtime and user code (ex. atexit functions)

tools/lldb-mi/MIDriverMain.cpp

71 ↗

(On Diff #115463)

Agreed, I already split this change into separate patches (I wasn't sure if people prefer to review two small changes vs a single one with more context)

[clayborg]

source/Commands/CommandObjectTarget.cpp

2056–2058

Remove braces

2086–2088

Remove braces

2153–2155

Remove braces

2176–2178

Remove braces

2250–2252

Remove braces

2273–2275

Remove braces

2342–2344

Remove braces

source/Interpreter/CommandInterpreter.cpp

2682

lldb_assert

2687

lldb_assert

2708–2710

Since we are using "llvm::StringRef" here, why not use its split functionality? Something like:

bool done = false;
while (!done) {
  auto pair = str.split('\n');
  auto len = pair.first.size();
  done = pair.second.empty();
  // Include newline if we are not done
  if (!done)
    ++len; 
  stream.Write(pair.first.data(), 
}

This approach also avoids the issue amccarth mentioned below about not ending with a newline. It is also quite a bit simpler to follow.

2728

llvm::StringRef can contain NULLs right? Maybe use

stream.Write(data, size);

[lemo]

source/Interpreter/CommandInterpreter.cpp

2708–2710

I'll give it a try, thanks for the suggestion.

2713

There's no assumption that the string ends with \n, see the loop condition: chunk_size < size. The assert is just to validate that we don't have embedded NULs.

2728

The original code (line 2714) was using PutCString(), so this path is just preserving the original functionality (which also suggests that the output is not expected to have embedded nuls)

[lemo]

Incorporating CR feedback.

[lemo]

source/Interpreter/CommandInterpreter.cpp

2708–2710

I forgot to reply to this: I tried using str.split() as suggested, with a small tweak to avoid reading past the end of the first slice (++len to include the '\n'):

while (!str.empty() && !WasInterrupted()) {
  auto pair = str.split('\n');
  stream.Write(pair.first.data(), pair.first.size());
  if (str.size() != pair.first.size())
    stream.PutChar('\n');
  str = pair.second;
}
if (!str.empty()) {
  stream.Printf("\n... Interrupted.\n");
}

While this version is shorter there I see a number of small problems with it:

1. It requires a close look at the StringRef::split() interface (ex. done = pair.second.empty() is actually not the correct check since it will eat the final \n)
2. While conceptually straightforward, the StringRef::split() interface is not ideal in this case - see #1
3. This version assumes that stream.Write() actually writes everything (ie. not handling the return size)
4. In order to avoid reading past the end of the first slice we need to do a separate PutChar() for each \n

So in the end I prefer the original version, which although a bit more verbose, tracks the invariants clearly, is potentially faster and handles strings regardless if they are terminated with \n or not.

[lemo]

source/Interpreter/CommandInterpreter.cpp

2708–2710

Thoughts?

[zturner]

source/Interpreter/CommandInterpreter.cpp

2708–2710

I haven't followed the rest of this too closely, so forgive me if this is a dumb question, but it looks like by the time we reach this function, the command is already complete. Why would you want to interrupt it if it's already done? Couldn't you just print the entire output in one call to stream.Write() at this point?

[clayborg]

I think Zach might be correct. If we already gathered the data, why not just output it all? Lets answer this first before returning to which implementation to use when parsing it up into lines and dumping it. Seems a shame to throw any data away.

[jingham]

In the original discussion of this feature (it was on the mailing list), it sounded like the specific case that motivated Leonard in adding this feature was when there's a command that's in the process of generating tons of output, and you want to interrupt the tons of output. Not the work, just the output. So the fact that is discards output was part of the design.

[jingham]

And in general, interruption should be as responsive as you can make it. When I tell lldb to "Stop right now" it really should do as close as possible to "stop right now". Not, :-"excuse me I have 10 more pages of output to dump". It's not uncommon to dump some info, see what you want and not need to see the rest. Interrupt in that case is expressing that "don't show me any more" so we should honor that.

[clayborg]

ok. Then back to the "can we use StringRef"? We might be able to check if the second.data() is NULL? It might be NULL if the string doesn't end with a newline. It it does, it might be empty but contain a pointer to the '\0' byte?

[lemo]

Ping? Are there any more open questions or unresolved comments or is this good to be checked in?

Thanks!

[clayborg]

We should have a test. The test would need to use pexpect or something similar. If anyone has any pointer on how to make a test for this, please chime in. I was thinking just a pexpect based test.

[zturner]

Give me a few more hours, if there's a way to make this work with line_iterator I'd really prefer that since I think it improves readability. Can you confirm that if you were able to write:

auto begin = line_iterator(str, /* skip_empty_lines =*/ false);
auto end = line_iterator();
while (begin != end && !WasInterrupted()) {
  stream.Write(*begin);
  if (++begin != end)
    stream.Write("\n");
}

That this would be equivalent?

[zturner]

In D37923#875322, @clayborg wrote:

We should have a test. The test would need to use pexpect or something similar. If anyone has any pointer on how to make a test for this, please chime in. I was thinking just a pexpect based test.

This kind of thing is perfect for a unit test, but I'm not sure how easy that would be with the current design. You'd basically do something like:

struct MockStream {
  explicit MockStream(CommandInterpreter &Interpreter, int InterruptAfter) 
    : CommandInterpreter(Interpreter), InterruptAfter(InterruptAfter) {}

  CommandInterpreter &Interpreter;
  const int InterruptAfter;
  int Lines = 0;
  std::string Buffer;

  void Write(StringRef S) {
    ++Lines;
    if (Lines >= InterruptAfter) {
      Interpreter.Interrupt();
      return;
    }
    Buffer += S;
  }
};

TEST_F(CommandInterruption) {
  CommandInterpreter Interpreter;
  MockStream Stream(Interpreter, 3);
  Interpreter.PrintCommandOutput(Stream, "a\nb\nc\nd\ne\nf\n");
  EXPECT_EQ(Stream.Lines == 3);
  EXPECT_EQ(Stream.Buffer == "a\nb\nc\n");
}

[lemo]

1. Added SB APIs (SBCommandInterpreter::WasInterrupted()). This allows python commands to query for interrupt requests.

2. I talked offline with Zach and decided that the line_iterator would require more tinkering to get it to work and it's not worth blocking the change for it.

3. I looked into adding a test for the SB APIs, but it would not really test much of the real path - which targets the _interactive_ interruption. Also, while I appreciate the ideal of testing everything I'm afraid that the net value of a test here might be negative (testing for async interruption would introduce some level of non determinism in the test suite and would require extra logic that's only used for testing). If anyone has any specific guidance on how to create a good test please let me know!

[zturner]

seems fine to me, I agree with the point about non-determinism, due to the nature of signals and the fact this is only intended to provide a best-effort interruption.

[jingham]

I don't quite understand the comment about signals adding indeterminacy. No signal delivery is required to test this part. The lldb driver has a sigint handler that calls SBDebugger::DispatchInputInterrupt. But since you aren't testing whether SIGINT actually calls DispatchInputInterrupt, you can just call it directly. I was suggesting executing a command (with SBCommandInterpreter::ExecuteCommand) for a Python command that cycles calling WasInterrupted. Then you would make another thread in Python and have that thread wait a bit then call DispatchInputInterrupt, If "wait a bit" bothers you then you could have the python based command you are interrupting signal the interrupting thread before going into its loop. I don't see how this would result in indeterminacy, And it would be testing exactly what you want to test: does calling DispatchInputInterrupt cause a command in flight to be interrupted.

But this change is fine. Check it in and I'll add a test when I get a chance.

[amccarth]

LGTM.

But just a thought: Is it worth doing all the work to scan for line endings for the interruption points? What if, instead, it just printed the next _n_ characters on each iteration until the entire buffer has been printed. Sure, sometimes an interruption will split a line, and sometimes it won't. I'm not sure that's important for interactive usage. It would mean less fiddly code, faster output (because you don't have to scan every character), and a zillion short lines will print as fast as a smaller number of longer lines that represents the same volume of text.

[lemo]

Updating the original changes to handle reentrant calls to CommandInterpreter::IOHandlerInputComplete().

• This fixes bug #34758
• Also enhanced the existing test case for "command source" to cover this regression
• I considered changing SBCommandReturnObject::PutOutput() to handle output interruptions too, but CommandReturnObjects are decoupled from CommandInterpreter instances, so there's no easy way to query for interruption in the current scheme.

[jingham]

That looks fine.

[amccarth]

LGTM

include/lldb/API/SBCommandInterpreter.h

public:
   int HandleCompletion(const char *current_line, const char *cursor,
                        const char *last_char, int match_start_point,
                        int max_return_elements, lldb::SBStringList &matches);
 
   int HandleCompletion(const char *current_line, uint32_t cursor_pos,
                        int match_start_point, int max_return_elements,
                        lldb::SBStringList &matches);
 
+  bool WasInterrupted() const;
+
   // Catch commands before they execute by registering a callback that will
   // get called when the command gets executed. This allows GUI or command
   // line interfaces to intercept a command and stop it from happening
   bool SetCommandOverrideCallback(const char *command_name,
                                   lldb::CommandOverrideCallback callback,
                                   void *baton);
 
   SBCommandInterpreter(

include/lldb/Core/IOHandler.h

 /// object that inherits from this delegate class when a token is
 /// received.
 //------------------------------------------------------------------
 class IOHandlerDelegate {
 public:
   enum class Completion { None, LLDBCommand, Expression };
 
   IOHandlerDelegate(Completion completion = Completion::None)
-      : m_completion(completion), m_io_handler_done(false) {}
+      : m_completion(completion) {}
 
   virtual ~IOHandlerDelegate() = default;
 
   virtual void IOHandlerActivated(IOHandler &io_handler) {}
 
   virtual void IOHandlerDeactivated(IOHandler &io_handler) {}
 
   virtual int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
public:
   //
   // Return true if the interrupt was handled, false if the IOHandler
   // should continue to try handle the interrupt itself.
   //------------------------------------------------------------------
   virtual bool IOHandlerInterrupt(IOHandler &io_handler) { return false; }
 
 protected:
   Completion m_completion; // Support for common builtin completions
-  bool m_io_handler_done;
 };
 
 //----------------------------------------------------------------------
 // IOHandlerDelegateMultiline
 //
 // A IOHandlerDelegate that handles terminating multi-line input when
 // the last line is equal to "end_line" which is specified in the
 // constructor.

include/lldb/Interpreter/CommandInterpreter.h

CommandObject *BuildAliasResult(llvm::StringRef alias_name,
                                   CommandReturnObject &result);
 
   bool HandleCommand(const char *command_line, LazyBool add_to_history,
                      CommandReturnObject &result,
                      ExecutionContext *override_context = nullptr,
                      bool repeat_on_empty_command = true,
                      bool no_context_switching = false);
 
+  bool WasInterrupted() const;
+
   //------------------------------------------------------------------
   /// Execute a list of commands in sequence.
   ///
   /// @param[in] commands
   ///    The list of commands to execute.
   /// @param[in,out] context
   ///    The execution context in which to run the commands. Can be nullptr in
   ///    which case the default
private:
   // and translated command.
   CommandObject *ResolveCommandImpl(std::string &command_line,
                                     CommandReturnObject &result);
 
   void FindCommandsForApropos(llvm::StringRef word, StringList &commands_found,
                               StringList &commands_help,
                               CommandObject::CommandMap &command_map);
 
+  // An interruptible wrapper around the stream output
+  void PrintCommandOutput(Stream &stream, llvm::StringRef str,
+                          bool interruptible);
+
+  // A very simple state machine which models the command handling transitions
+  enum class CommandHandlingState {
+    eIdle,
+    eInProgress,
+    eInterrupted,
+  };
+
+  std::atomic<CommandHandlingState> m_command_state {CommandHandlingState::eIdle};
+
+  void StartHandlingCommand();
+  void FinishHandlingCommand();
+  bool InterruptCommand();
+
   Debugger &m_debugger; // The debugger session that this interpreter is
                         // associated with
   ExecutionContextRef m_exe_ctx_ref; // The current execution context to use
                                      // when handling commands
   bool m_synchronous_execution;
   bool m_skip_lldbinit_files;
   bool m_skip_app_init_files;
   CommandObject::CommandMap m_command_dict; // Stores basic built-in commands

scripts/interface/SBCommandInterpreter.i

 ") SBCommandInterpreter;
 class SBCommandInterpreter
 {
 public:
     enum
     {
         eBroadcastBitThreadShouldExit       = (1 << 0),
         eBroadcastBitResetPrompt            = (1 << 1),
-        eBroadcastBitQuitCommandReceived    = (1 << 2),           // User entered quit 
+        eBroadcastBitQuitCommandReceived    = (1 << 2),           // User entered quit
         eBroadcastBitAsynchronousOutputData = (1 << 3),
         eBroadcastBitAsynchronousErrorData  = (1 << 4)
     };
 
     SBCommandInterpreter (const lldb::SBCommandInterpreter &rhs);
-    
     ~SBCommandInterpreter ();
 
-    static const char * 
+    static const char *
     GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
-    
     static const char *
     GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type);
 
     static bool
     EventIsCommandInterpreterEvent (const lldb::SBEvent &event);
 
     bool
     IsValid() const;
public:
     bool
     HasAliases ();
 
     bool
     HasAliasOptions ();
 
     lldb::SBProcess
     GetProcess ();
-    
     lldb::SBDebugger
     GetDebugger ();
 
     void
     SourceInitFileInHomeDirectory (lldb::SBCommandReturnObject &result);
 
     void
     SourceInitFileInCurrentWorkingDirectory (lldb::SBCommandReturnObject &result);
HandleCommandsFromFile (lldb::SBFileSpec &file,
                             lldb::SBCommandReturnObject result);
 
     int
     HandleCompletion (const char *current_line,
                       uint32_t cursor_pos,
                       int match_start_point,
                       int max_return_elements,
                       lldb::SBStringList &matches);
-    
     bool
     IsActive ();
 
+    bool
+    WasInterrupted () const;
 };
 
 } // namespace lldb

source/API/SBCommandInterpreter.cpp

bool SBCommandInterpreter::AliasExists(const char *cmd) {
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::IsActive() {
   return (IsValid() ? m_opaque_ptr->IsActive() : false);
 }
 
+bool SBCommandInterpreter::WasInterrupted() const {
+  return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
+}
+
 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
   return (IsValid()
               ? m_opaque_ptr->GetDebugger()
                     .GetTopIOHandlerControlSequence(ch)
                     .GetCString()
               : nullptr);
 }
 

source/Commands/CommandObjectTarget.cpp

if (target == nullptr) {
           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);
if (target == nullptr) {
           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);
         }
if (target == nullptr) {
       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
if (target == nullptr) {
         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 (DumpModuleSymbolVendor(
                     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 (DumpModuleSymbolVendor(result.GetOutputStream(), module))
                   num_dumped++;
               }
             }
           } else
             result.AppendWarningWithFormat(
                 "Unable to find an image that matches '%s'.\n", arg_cstr);
if (command.GetArgumentCount() == 0) {
         FileSpec file_spec(arg_cstr, false);
 
         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) {
           uint32_t num_dumped = 0;
           for (uint32_t i = 0; i < num_modules; ++i) {
+            if (m_interpreter.WasInterrupted())
+              break;
             if (DumpCompileUnitLineTable(
                     m_interpreter, result.GetOutputStream(),
                     target_modules.GetModulePointerAtIndexUnlocked(i),
                     file_spec, m_exe_ctx.GetProcessPtr() &&
                                    m_exe_ctx.GetProcessRef().IsAlive()))
               num_dumped++;
           }
           if (num_dumped == 0)
             result.AppendWarningWithFormat(

source/Core/Debugger.cpp

 #if 0
 static void
 TestPromptFormats (StackFrame *frame)
 {
     if (frame == nullptr)
         return;
 
     StreamString s;
-    const char *prompt_format =         
+    const char *prompt_format =
     "{addr = '${addr}'\n}"
     "{addr-file-or-load = '${addr-file-or-load}'\n}"
     "{current-pc-arrow = '${current-pc-arrow}'\n}"
     "{process.id = '${process.id}'\n}"
     "{process.name = '${process.name}'\n}"
     "{process.file.basename = '${process.file.basename}'\n}"
     "{process.file.fullpath = '${process.file.fullpath}'\n}"
     "{thread.id = '${thread.id}'\n}"

source/Interpreter/CommandInterpreter.cpp

void CommandInterpreter::LoadCommandDictionary() {
   if (tbreak_regex_cmd_ap.get()) {
     bool success = true;
     for (size_t i = 0; i < num_regexes; i++) {
       // If you add a resultant command string longer than 1024 characters be
       // sure to increase the size of this buffer.
       char buffer[1024];
       int num_printed =
           snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o");
-      assert(num_printed < 1024);
+      lldbassert(num_printed < 1024);
       UNUSED_IF_ASSERT_DISABLED(num_printed);
       success =
           tbreak_regex_cmd_ap->AddRegexCommand(break_regexes[i][0], buffer);
       if (!success)
         break;
     }
     success =
         tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
CommandObjectSP CommandInterpreter::GetCommandSP(llvm::StringRef cmd_str,
 
   return command_sp;
 }
 
 bool CommandInterpreter::AddCommand(llvm::StringRef name,
                                     const lldb::CommandObjectSP &cmd_sp,
                                     bool can_replace) {
   if (cmd_sp.get())
-    assert((this == &cmd_sp->GetCommandInterpreter()) &&
+    lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&
            "tried to add a CommandObject from a different interpreter");
 
   if (name.empty())
     return false;
 
   std::string name_sstr(name);
   auto name_iter = m_command_dict.find(name_sstr);
   if (name_iter != m_command_dict.end()) {
     if (!can_replace || !name_iter->second->IsRemovable())
       return false;
     name_iter->second = cmd_sp;
   } else {
     m_command_dict[name_sstr] = cmd_sp;
   }
   return true;
 }
 
 bool CommandInterpreter::AddUserCommand(llvm::StringRef name,
                                         const lldb::CommandObjectSP &cmd_sp,
                                         bool can_replace) {
   if (cmd_sp.get())
-    assert((this == &cmd_sp->GetCommandInterpreter()) &&
+    lldbassert((this == &cmd_sp->GetCommandInterpreter()) &&
            "tried to add a CommandObject from a different interpreter");
 
   if (!name.empty()) {
     // do not allow replacement of internal commands
     if (CommandExists(name)) {
       if (can_replace == false)
         return false;
       if (m_command_dict[name]->IsRemovable() == false)
bool CommandInterpreter::UserCommandExists(llvm::StringRef cmd) const {
   return m_user_dict.find(cmd) != m_user_dict.end();
 }
 
 CommandAlias *
 CommandInterpreter::AddAlias(llvm::StringRef alias_name,
                              lldb::CommandObjectSP &command_obj_sp,
                              llvm::StringRef args_string) {
   if (command_obj_sp.get())
-    assert((this == &command_obj_sp->GetCommandInterpreter()) &&
+    lldbassert((this == &command_obj_sp->GetCommandInterpreter()) &&
            "tried to add a CommandObject from a different interpreter");
 
   std::unique_ptr<CommandAlias> command_alias_up(
       new CommandAlias(*this, command_obj_sp, args_string, alias_name));
 
   if (command_alias_up && command_alias_up->IsValid()) {
     m_alias_dict[alias_name] = CommandObjectSP(command_alias_up.get());
     return command_alias_up.release();
if (cursor > current_line && cursor[-1] == ' ') {
     }
   }
 
   int num_command_matches;
 
   matches.Clear();
 
   // Only max_return_elements == -1 is supported at present:
-  assert(max_return_elements == -1);
+  lldbassert(max_return_elements == -1);
   bool word_complete;
   num_command_matches = HandleCompletionMatches(
       parsed_line, cursor_index, cursor_char_position, match_start_point,
       max_return_elements, word_complete, matches);
 
   if (num_command_matches <= 0)
     return num_command_matches;
 
if (process_sp) {
         m_debugger.GetErrorFile()->Write(stdio_buffer, bytes_written);
         total_bytes += len;
       }
     }
   }
   return total_bytes;
 }
 
+void CommandInterpreter::StartHandlingCommand() {
+  auto prev_state = m_command_state.exchange(CommandHandlingState::eInProgress);
+  lldbassert(prev_state == CommandHandlingState::eIdle);
+}
+
+void CommandInterpreter::FinishHandlingCommand() {
+  auto prev_state = m_command_state.exchange(CommandHandlingState::eIdle);
+  lldbassert(prev_state != CommandHandlingState::eIdle);
+}
+
+bool CommandInterpreter::InterruptCommand() {
+  auto in_progress = CommandHandlingState::eInProgress;
+  return m_command_state.compare_exchange_strong(
+      in_progress, CommandHandlingState::eInterrupted);
+}
+
+bool CommandInterpreter::WasInterrupted() const {
+  return m_command_state == CommandHandlingState::eInterrupted;
+}
+
+void CommandInterpreter::PrintCommandOutput(Stream &stream, llvm::StringRef str,
+                                            bool interruptible) {
+  if (str.empty())
+    return;
+
+  if (interruptible) {
+    // Split the output into lines and poll for interrupt requests
+    const char *data = str.data();
+    size_t size = str.size();
+    while (size > 0 && !WasInterrupted()) {
+      size_t chunk_size = 0;
+      for (; chunk_size < size; ++chunk_size) {
+        lldbassert(data[chunk_size] != '\0');
+        if (data[chunk_size] == '\n') {
+          ++chunk_size;
+          break;
+        }
+      }
+      chunk_size = stream.Write(data, chunk_size);
+      lldbassert(size >= chunk_size);
+      data += chunk_size;
+      size -= chunk_size;
+    }
+    if (size > 0) {
+      stream.Printf("\n... Interrupted.\n");
+    }
+  } else {
+    stream.PutCString(str);
+  }
+}
+
 void CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
                                                 std::string &line) {
   const bool is_interactive = io_handler.GetIsInteractive();
   if (is_interactive == false) {
     // When we are not interactive, don't execute blank lines. This will happen
     // sourcing a commands file. We don't want blank lines to repeat the
     // previous
     // command and cause any errors to occur (like redefining an alias, get an
     // error
     // and stop parsing the commands file).
     if (line.empty())
       return;
 
     // When using a non-interactive file handle (like when sourcing commands
     // from a file)
     // we need to echo the command out so we don't just see the command output
     // and no
     // command...
     if (io_handler.GetFlags().Test(eHandleCommandFlagEchoCommand))
       io_handler.GetOutputStreamFile()->Printf("%s%s\n", io_handler.GetPrompt(),
                                                line.c_str());
   }
 
+  StartHandlingCommand();
+
   lldb_private::CommandReturnObject result;
   HandleCommand(line.c_str(), eLazyBoolCalculate, result);
 
   // Now emit the command output text from the command we just executed
   if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) {
     // Display any STDOUT/STDERR _prior_ to emitting the command result text
     GetProcessOutput();
 
     if (!result.GetImmediateOutputStream()) {
       llvm::StringRef output = result.GetOutputData();
-      if (!output.empty())
-        io_handler.GetOutputStreamFile()->PutCString(output);
+      PrintCommandOutput(*io_handler.GetOutputStreamFile(), output,
+                         is_interactive);
     }
 
     // Now emit the command error text from the command we just executed
     if (!result.GetImmediateErrorStream()) {
       llvm::StringRef error = result.GetErrorData();
-      if (!error.empty())
-        io_handler.GetErrorStreamFile()->PutCString(error);
+      PrintCommandOutput(*io_handler.GetErrorStreamFile(), error,
+                         is_interactive);
     }
   }
 
+  FinishHandlingCommand();
+
   switch (result.GetStatus()) {
   case eReturnStatusInvalid:
   case eReturnStatusSuccessFinishNoResult:
   case eReturnStatusSuccessFinishResult:
   case eReturnStatusStarted:
     break;
 
   case eReturnStatusSuccessContinuingNoResult:
if (!m_quit_requested && result.GetDidChangeProcessState() &&
     }
   }
 }
 
 bool CommandInterpreter::IOHandlerInterrupt(IOHandler &io_handler) {
   ExecutionContext exe_ctx(GetExecutionContext());
   Process *process = exe_ctx.GetProcessPtr();
 
+  if (InterruptCommand())
+    return true;
+
   if (process) {
     StateType state = process->GetState();
     if (StateIsRunningState(state)) {
       process->Halt();
       return true; // Don't do any updating when we are running
     }
   }
 
if (cmd_obj == nullptr) {
                          next_word.c_str());
 
         for (uint32_t i = 0; i < num_matches; ++i) {
           error_msg.Printf("\t%s\n", matches.GetStringAtIndex(i));
         }
         result.AppendRawError(error_msg.GetString());
       } else {
         // We didn't have only one match, otherwise we wouldn't get here.
-        assert(num_matches == 0);
+        lldbassert(num_matches == 0);
         result.AppendErrorWithFormat("'%s' is not a valid command.\n",
                                      next_word.c_str());
       }
       result.SetStatus(eReturnStatusFailed);
       return nullptr;
     }
 
     if (cmd_obj->IsMultiwordObject()) {