Prevent dead locking when calling PrintAsync

[teemperor]

Summary

While working on the expr completion, I've encountered the issue that sometimes lldb
deadlocks when doing input/output. The underlying cause for this is that we seem to expect
that we can always call Debugger::PrintAsync from any point of lldb and that this call will
always return at some point.

However this is not always the case. For example, when calling the completion handler, we
obviously hold locks that make the console IO thread safe. The expression parsing
code then tries to parse the user expression to provide possible completions. It's possible
that while parsing our expression, we hit a case where some code decides to print
information to the debugger output (for example to inform the user that some functionality
has failed unexpectedly). This call now deadlocks the lldb prompt as PrintAsync waits on
Editline to release the mutex, while our Editline handler waits on PrintAsync to print its error
message.

To prevent this issue in the future, this patch introduces the notion of delayed output scopes,
that essentially act as safe zones in which all calls to PrintAsync for a given debugger
are safe independently of the locking inside the IOHandlers or related issues. While printing in
this scope, we queue messages and then actually print them once we leave the scope.

[teemperor]

Not sure who should review this, but maybe Fred or Jim know :)

[teemperor]

• Small code style adjustment.

[jingham]

The IOHandlers are Greg's construct. He's likely the best person to review this.

[teemperor]

Adding Pavel because he wrote the PrintAsync code.

Also @labath: Can you tell me what variables/functionality the m_output_mutex in Editline.cpp is supposed to shield? I don't see any documentation for that.

The m_output_mutex name suggests its related to console output, but we actually take the lock also when reading *input*. Especially in EditLine::GetLine we take a guard on the lock but then somehow unlock the guarded mutex from inside Editline::GetCharacter that we call afterwards (which completely breaks this patch):

// This mutex is locked by our caller (GetLine). Unlock it while we read a
// character (blocking operation), so we do not hold the mutex
// indefinitely. This gives a chance for someone to interrupt us. After
// Read returns, immediately lock the mutex again and check if we were
// interrupted.
m_output_mutex.unlock();
int read_count = m_input_connection.Read(&ch, 1, llvm::None, status, NULL);
m_output_mutex.lock();
if (m_editor_status == EditorStatus::Interrupted) {
  while (read_count > 0 && status == lldb::eConnectionStatusSuccess)
    read_count = m_input_connection.Read(&ch, 1, llvm::None, status, NULL);
  lldbassert(status == lldb::eConnectionStatusInterrupted);
  return 0;
}

[clayborg]

source/Core/Debugger.cpp

1011–1027

Can this code become:

// We check if any user requested to delay output to a later time
// (which is designated by m_delayed_output_counter being not 0).
{
  std::lock_guard<std::mutex> guard(m_delayed_output_mutex);
  if (m_delayed_output_counter != 0) {
    // We want to delay messages, so push them to the buffer.
    m_delayed_output.emplace_back(std::string(s, len), is_stdout);
      return;
  }
}
lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile();
m_input_reader_stack.PrintAsync(stream.get(), s, len);

source/Core/IOHandler.cpp

358

So anytime we have a "(lldb)" prompt we won't be able to output something?

[labath]

In D48463#1140861, @teemperor wrote:

Adding Pavel because he wrote the PrintAsync code.

Also @labath: Can you tell me what variables/functionality the m_output_mutex in Editline.cpp is supposed to shield? I don't see any documentation for that.

The m_output_mutex name suggests its related to console output, but we actually take the lock also when reading *input*. Especially in EditLine::GetLine we take a guard on the lock but then somehow unlock the guarded mutex from inside Editline::GetCharacter that we call afterwards (which completely breaks this patch):

If I remember correctly (it was a long time ago), the idea was behind this was to make sure that nobody prints anything to stdout while libedit is playing around with it. That's why it's called "output" mutex. The thing that this (admittedly strange) locking strategy achieves is that the the only time the PrintAsync function can write to stdout is while we are blocked waiting for input, as that's the place we can be sure we aren't writing to stdout -- before, or after that, we could be in libedit code and it could mess with stdout to write it's prompt or whatever. IIRC, PrintAsync should eventually end up taking the same mutex, and then depending on the current state of libedit machinery, do the "right thing" wrt. erasing the prompt et al.

Hmm.. Now that I have spelled this out, it sounds like this same pattern could be used to achieve your goal too -- while you're inside the completion handler, you also shouldn't be doing any funny things with stdout. Maybe the solution would be do just drop the output mutex while the running the completion code. Could you try if something like that would work?

// This mutex is locked by our caller (GetLine). Unlock it while we read a
// character (blocking operation), so we do not hold the mutex
// indefinitely. This gives a chance for someone to interrupt us. After
// Read returns, immediately lock the mutex again and check if we were
// interrupted.

This comment refers to the second purpose of the surrounding code, which is to make sure that any interrupt request is handled exactly once.

[teemperor]

• We now also handle the case where a guarded mutex is manually unlocked from a nested call.
• Refactoring based on review comments.

[teemperor]

• Fixed that we only pass a nullptr as a debugger to the real editline object (which now fixes the deadlock in the code completion patch).

[teemperor]

@labath Thanks for the explanation! Well in theory we could poke more holes in our guard from some nested function, but this only fixes the deadlock symptom. PrintAsync would still be blocking whenever the mutex is hold by someone.

source/Core/Debugger.cpp

1011–1027

It can and did. Removed the same pattern from the TryFlushingDelayedMessages method.

source/Core/IOHandler.cpp

358

Yes, that was the unintended effect of this patch (which was caught by the test suite actually). I didn't see until after I submitted that we actually manually unlock the guarded mutex from a called function. This now has been fixed by doing something like the unlock/lock code with the DisableMessageDelayScope in EditLine::GetCharacter.

[labath]

In D48463#1145434, @teemperor wrote:

Well in theory we could poke more holes in our guard from some nested function, but this only fixes the deadlock symptom. PrintAsync would still be blocking whenever the mutex is hold by someone.

Yes, but for me the real question is do really need to be calling PrintAsync while holding the output mutex. The output mutex is only used within the editline support code, and I think it's fair to require that this code be wary of when it is printing stuff to stdout. Making sure the mutex is dropped (and the rest of the output machinery is in a sane state) when calling "foreign" code is a part of its job.

"Poking holes" in the mutex, as you have so aptly phrased it, is not nice, but neither is your solution (you're doing the exact same thing with the DisableMessageDelayScope object), and I'd rather have one sub-optimal solution than two.

Instead of coming up with another solution which does something-similar-but-not-quite, I think we should invest more time improving the existing solution. For example the DisableMessageDelayScope approach would be useful for the scoped disabling of the output mutex. This will make it easy to unlock the mutex in any editline callback where we deem it safe to print text (and any place where it isn't safe to print text shouldn't be calling random code anyway). We're never going to be able to have a nice scoped locking strategy for this because the thing we want to lock is not scoped, but this should improve the situation somewhat. It will also make the thing fully contained inside the Editline class, instead of spreading it out over Core and Host modules. That also means the solution will be unit-testable, at least to some extent (right now, you don't have any tests for this code)

source/Host/common/Editline.cpp

14

This is wrong layering. Editline should not know anything about the debugger. If we really want to proceed with this, then this needs to be abstracted and re-layered. However, I don't think that is really necessary. More on that below.

[teemperor]

Abandon in favor of D50912

include/lldb/Core/Debugger.h

 //===-- Debugger.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Debugger_h_
 #define liblldb_Debugger_h_
 
 // C Includes
 #include <stdint.h>
 
 // C++ Includes
+#include <cassert>
 #include <memory>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/IOHandler.h"
public:
   // Synchronously run an input reader until it is done
   void RunIOHandler(const lldb::IOHandlerSP &reader_sp);
 
   bool IsTopIOHandler(const lldb::IOHandlerSP &reader_sp);
 
   bool CheckTopIOHandlerTypes(IOHandler::Type top_type,
                               IOHandler::Type second_top_type);
 
+  //------------------------------------------------------------------
+  /// Guard class that delays the output printing from the given debugger
+  /// until the end of the scope. Useful if you aquire any IOHandler locks
+  /// in the current scope and also call code that might print via an IOHandler
+  /// (which could lead to deadlocks).
+  ///
+  /// This guard can be used in nested scopes. Multiple guards on the
+  /// same debugger behave the same as if only the top-most guard
+  /// requested to delay the messages.
+  ///
+  /// If a nullptr is passed as a debugger object, this guard will perform no
+  /// actions.
+  ///
+  /// @see EnableDelayedPrinting()
+  /// @see TryFlushingDelayedMessages()
+  /// @see DisableMessageDelayScope
+  //------------------------------------------------------------------
+  struct MessageDelayScope {
+    Debugger *m_debugger;
+    explicit MessageDelayScope(Debugger *d) : m_debugger(d) {
+      if (m_debugger)
+        m_debugger->EnableDelayedPrinting();
+    }
+    ~MessageDelayScope() {
+      if (m_debugger)
+        m_debugger->TryFlushingDelayedMessages();
+    }
+    DISALLOW_COPY_AND_ASSIGN(MessageDelayScope);
+  };
+
+  //------------------------------------------------------------------
+  /// Guard class that reverts the effect of one existing MessageDelayScope
+  /// during its lifetime. This guard can only be instantiated on a debugger
+  /// with at least one active MessageDelayScope. If a nullptr is passed as a
+  /// debugger, this guard will perform no actions.
+  ///
+  /// @note This class is intended to make existing code compatible with
+  /// MessageDelayScope and shouldn't be used in new code if possible.
+  ///
+  /// @see MessageDelayScope
+  //------------------------------------------------------------------
+  struct DisableMessageDelayScope {
+    Debugger *m_debugger;
+    // TODO: This constructor should not take a debugger object, but rather an
+    // existing MessageDelayScope to prevent using it in a spot where no active
+    // MessageDelayScope exists. However, we currently don't have access to the
+    // current MessageDelayScope object in all places where we need this.
+    explicit DisableMessageDelayScope(Debugger *d) : m_debugger(d) {
+      if (m_debugger)
+        m_debugger->TryFlushingDelayedMessages();
+    }
+    ~DisableMessageDelayScope() {
+      if (m_debugger)
+        m_debugger->EnableDelayedPrinting();
+    }
+    DISALLOW_COPY_AND_ASSIGN(DisableMessageDelayScope);
+  };
+
   void PrintAsync(const char *s, size_t len, bool is_stdout);
 
   ConstString GetTopIOHandlerControlSequence(char ch);
 
   const char *GetIOHandlerCommandPrefix();
 
   const char *GetIOHandlerHelpPrologue();
 
enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 
 private:
   // Use Debugger::CreateInstance() to get a shared pointer to a new debugger
   // object
   Debugger(lldb::LogOutputCallback m_log_callback, void *baton);
 
+  //------------------------------------------------------------------
+  /// A message sent via PrintAsync that we store to delay the actual
+  /// call until later.
+  //------------------------------------------------------------------
+  struct DelayedMessage {
+    DelayedMessage(std::string data, bool for_stdout)
+        : m_data(data), m_for_stdout(for_stdout) {}
+    std::string m_data;
+    bool m_for_stdout;
+  };
+
+  //------------------------------------------------------------------
+  /// Starts delaying any calls to PrintAsync until a matching call
+  /// to FlushDelayedMessages occurs. This function should only be
+  /// called before a matching call to FlushDelayedMessages.
+  ///
+  /// This method is intentionally private. Use MessageDelayScope to
+  /// call this method (and the matching FlushDelayedMessage()) method
+  /// below.
+  //------------------------------------------------------------------
+  void EnableDelayedPrinting() {
+    std::lock_guard<std::mutex> guard(m_delayed_output_mutex);
+    ++m_delayed_output_counter;
+  }
+
+  //------------------------------------------------------------------
+  /// Tries to flush any delayed messages to PrintAsync. This might
+  /// not be possible if it was requested by multiple users to
+  /// delay messages and not all have given consent at this point for
+  /// forwarding the messages.
+  //------------------------------------------------------------------
+  void TryFlushingDelayedMessages();
+
+  /// This mutex protects *only* m_async_buffer and m_should_buffer_async.
+  std::mutex m_delayed_output_mutex;
+  /// The list of delayed messages in the order in which they arrived.
+  /// @note Protected by m_delayed_output_mutex.
+  std::vector<DelayedMessage> m_delayed_output;
+  /// This counter keeps track of how many users have requested that we delay
+  /// the forwarding of calls to PrintAsync to the IOHandlers. If the counter
+  /// is 0, then it's safe to directly forward all calls to PrintAsync to the
+  /// IOHandlers. If the counter is *not* 0, then all calls to PrintAsync
+  /// should be cached until the counter is 0 again.
+  /// @see EnableDelayedPrinting()
+  /// @see TryFlushingDelayedMessages().
+  /// @note Protected by m_delayed_output_mutex.
+  unsigned m_delayed_output_counter = 0;
+
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Debugger_h_

include/lldb/Host/Editline.h

 #include <string>
 #include <vector>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
+class Debugger;
 namespace line_editor {
 
 // type alias's to help manage 8 bit and wide character versions of libedit
 #if LLDB_EDITLINE_USE_WCHAR
 using EditLineStringType = std::wstring;
 using EditLineStringStreamType = std::wstringstream;
 using EditLineCharType = wchar_t;
 #else

 using namespace line_editor;
 
 /// Instances of Editline provide an abstraction over libedit's EditLine
 /// facility.  Both
 /// single- and multi-line editing are supported.
 class Editline {
 public:
   Editline(const char *editor_name, FILE *input_file, FILE *output_file,
-           FILE *error_file, bool color_prompts);
+           FILE *error_file, bool color_prompts,
+           lldb_private::Debugger *debugger);
 
   ~Editline();
 
   /// Uses the user data storage of EditLine to retrieve an associated instance
   /// of Editline.
   static Editline *InstanceFor(::EditLine *editline);
 
   /// Sets a string to be used as a prompt, or combined with a line number to
#endif
   IsInputCompleteCallbackType m_is_input_complete_callback = nullptr;
   void *m_is_input_complete_callback_baton = nullptr;
   FixIndentationCallbackType m_fix_indentation_callback = nullptr;
   void *m_fix_indentation_callback_baton = nullptr;
   const char *m_fix_indentation_callback_chars = nullptr;
   CompleteCallbackType m_completion_callback = nullptr;
   void *m_completion_callback_baton = nullptr;
 
+  /// The debugger that is using this Editline instance for input/output. May
+  /// be a nullptr if there is no debugger using this instance.
+  lldb_private::Debugger *m_debugger = nullptr;
   std::mutex m_output_mutex;
 };
 }
 
 #endif // #if defined(__cplusplus)
 #endif // liblldb_Editline_h_

source/Core/Debugger.cpp

Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
   term_width->SetMaximumValue(1024);
 
   // Turn off use-color if this is a dumb terminal.
   const char *term = getenv("TERM");
   if (term && !strcmp(term, "dumb"))
     SetUseColor(false);
 }
 
+void Debugger::TryFlushingDelayedMessages() {
+  // We copy the buffer here. We do *not* want to call PrintAsync (or
+  // anything else) while we own this lock.
+  std::vector<DelayedMessage> buffer_to_send;
+  {
+    std::lock_guard<std::mutex> guard(m_delayed_output_mutex);
+    buffer_to_send = std::move(m_delayed_output);
+    m_delayed_output.clear();
+    // It's an error if we call this method before EnableDelayedPrinting.
+    assert(m_delayed_output_counter > 0);
+    --m_delayed_output_counter;
+    // 0 means that all users we have have consented that we can now forward
+    // our delayed messages to the IOHandlers. Other values mean we that can't
+    // forward the delayed messages yet.
+    if (m_delayed_output_counter != 0)
+      return;
+  }
+  // Forward all cached messages to the IOHandlers.
+  for (const auto &msg : buffer_to_send) {
+    PrintAsync(msg.m_data.data(), msg.m_data.size(), msg.m_for_stdout);
+  }
+}
+
 Debugger::~Debugger() { Clear(); }
 
 void Debugger::Clear() {
   //----------------------------------------------------------------------
   // Make sure we call this function only once. With the C++ global destructor
   // chain having a list of debuggers and with code that can be running on
   // other threads, we need to ensure this doesn't happen multiple times.
   //

 }
 
 bool Debugger::CheckTopIOHandlerTypes(IOHandler::Type top_type,
                                       IOHandler::Type second_top_type) {
   return m_input_reader_stack.CheckTopIOHandlerTypes(top_type, second_top_type);
 }
 
 void Debugger::PrintAsync(const char *s, size_t len, bool is_stdout) {
+  // We check if any user requested to delay output to a later time
+  // (which is designated by m_delayed_output_counter being not 0).
+  {
+    std::lock_guard<std::mutex> guard(m_delayed_output_mutex);
+    if (m_delayed_output_counter != 0) {
+      // We want to delay messages, so push them to the buffer.
+      m_delayed_output.emplace_back(std::string(s, len), is_stdout);
+      return;
+    }
+  }
   lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile();
   m_input_reader_stack.PrintAsync(stream.get(), s, len);
 }
 
 ConstString Debugger::GetTopIOHandlerControlSequence(char ch) {
   return m_input_reader_stack.GetTopIOHandlerControlSequence(ch);
 }
 
 const char *Debugger::GetIOHandlerCommandPrefix() {
   return m_input_reader_stack.GetTopIOHandlerCommandPrefix();
 }
 
 const char *Debugger::GetIOHandlerHelpPrologue() {
   return m_input_reader_stack.GetTopIOHandlerHelpPrologue();
 }

source/Core/IOHandler.cpp

 #ifndef LLDB_DISABLE_LIBEDIT
   bool use_editline = false;
 
   use_editline = m_input_sp->GetFile().GetIsRealTerminal();
 
   if (use_editline) {
     m_editline_ap.reset(new Editline(editline_name, GetInputFILE(),
                                      GetOutputFILE(), GetErrorFILE(),
-                                     m_color_prompts));
+                                     m_color_prompts, &m_debugger));
     m_editline_ap->SetIsInputCompleteCallback(IsInputCompleteCallback, this);
     m_editline_ap->SetAutoCompleteCallback(AutoCompleteCallback, this);
     // See if the delegate supports fixing indentation
     const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
     if (indent_chars) {
       // The delegate does support indentation, hook it up so when any
       // indentation character is typed, the delegate gets a chance to fix it
       m_editline_ap->SetFixIndentationCallback(FixIndentationCallback, this,

 bool IOHandlerEditline::GetLine(std::string &line, bool &interrupted) {
 #ifndef LLDB_DISABLE_LIBEDIT
   if (m_editline_ap) {
     return m_editline_ap->GetLine(line, interrupted);
   } else {
 #endif
     line.clear();
 
     FILE *in = GetInputFILE();
     if (in) {
       if (GetIsInteractive()) {
         const char *prompt = nullptr;
 
         if (m_multi_line && m_curr_line_idx > 0)
           prompt = GetContinuationPrompt();
 
         if (prompt == nullptr)

source/Host/common/Editline.cpp

 //===-- Editline.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <iomanip>
 #include <iostream>
 #include <limits.h>
 
+#include "lldb/Core/Debugger.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Editline.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
while (true) {
     lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess;
     char ch = 0;
 
     // This mutex is locked by our caller (GetLine). Unlock it while we read a
     // character (blocking operation), so we do not hold the mutex
     // indefinitely. This gives a chance for someone to interrupt us. After
     // Read returns, immediately lock the mutex again and check if we were
     // interrupted.
+    int read_count;
     m_output_mutex.unlock();
-    int read_count = m_input_connection.Read(&ch, 1, llvm::None, status, NULL);
+    {
+      // We also disable the message delaying while we have the mutex unlocked.
+      lldb_private::Debugger::DisableMessageDelayScope guard(m_debugger);
+      read_count = m_input_connection.Read(&ch, 1, llvm::None, status, NULL);
+    }
     m_output_mutex.lock();
+
     if (m_editor_status == EditorStatus::Interrupted) {
       while (read_count > 0 && status == lldb::eConnectionStatusSuccess)
         read_count = m_input_connection.Read(&ch, 1, llvm::None, status, NULL);
       lldbassert(status == lldb::eConnectionStatusInterrupted);
       return 0;
     }
 
     if (read_count) {

 
 Editline *Editline::InstanceFor(EditLine *editline) {
   Editline *editor;
   el_get(editline, EL_CLIENTDATA, &editor);
   return editor;
 }
 
 Editline::Editline(const char *editline_name, FILE *input_file,
-                   FILE *output_file, FILE *error_file, bool color_prompts)
+                   FILE *output_file, FILE *error_file, bool color_prompts,
+                   Debugger *debugger)
     : m_editor_status(EditorStatus::Complete), m_color_prompts(color_prompts),
       m_input_file(input_file), m_output_file(output_file),
-      m_error_file(error_file), m_input_connection(fileno(input_file), false) {
+      m_error_file(error_file), m_input_connection(fileno(input_file), false),
+      m_debugger(debugger) {
   // Get a shared history instance
   m_editor_name = (editline_name == nullptr) ? "lldb-tmp" : editline_name;
   m_history_sp = EditlineHistory::GetHistory(m_editor_name);
 
 #ifdef USE_SETUPTERM_WORKAROUND
   if (m_output_file) {
     const int term_fd = fileno(m_output_file);
     if (term_fd != -1) {
bool Editline::SetFixIndentationCallback(FixIndentationCallbackType callback,
   return false;
 }
 
 bool Editline::GetLine(std::string &line, bool &interrupted) {
   ConfigureEditor(false);
   m_input_lines = std::vector<EditLineStringType>();
   m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
 
+  // While we own the output mutex, we delay all messages that are printed via
+  // PrintAsync until we release the mutex again. This prevents dead locks that
+  // are caused when someone calls PrintAsync (which also needs to aquire
+  // the output mutex). Note that Editline::GetCharacter unlocks the guarded
+  // mutex from a nested call and also temporarily disables the message delay.
+  Debugger::MessageDelayScope msg_guard(m_debugger);
   std::lock_guard<std::mutex> guard(m_output_mutex);
 
   lldbassert(m_editor_status != EditorStatus::Editing);
   if (m_editor_status == EditorStatus::Interrupted) {
     m_editor_status = EditorStatus::Complete;
     interrupted = true;
     return true;
   }
bool Editline::GetLines(int first_line_number, StringList &lines,
   ConfigureEditor(true);
 
   // Print the initial input lines, then move the cursor back up to the start
   // of input
   SetBaseLineNumber(first_line_number);
   m_input_lines = std::vector<EditLineStringType>();
   m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
 
+  // We delay all message printing until we release the output mutex. See
+  // Editline::GetLine for a more detailed explanation.
+  Debugger::MessageDelayScope msg_guard(m_debugger);
   std::lock_guard<std::mutex> guard(m_output_mutex);
   // Begin the line editing loop
   DisplayInput();
   SetCurrentLine(0);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::BlockStart);
   m_editor_status = EditorStatus::Editing;
   m_in_history = false;
 

unittests/Editline/EditlineTest.cpp

EditlineAdapter::EditlineAdapter()
   _pty_slave_fd = _pty.GetSlaveFileDescriptor();
 
   _el_slave_file.reset(new FilePointer(fdopen(_pty_slave_fd, "rw")));
   EXPECT_FALSE(nullptr == *_el_slave_file);
   if (*_el_slave_file == nullptr)
     return;
 
   // Create an Editline instance.
-  _editline_sp.reset(new lldb_private::Editline("gtest editor", *_el_slave_file,
-                                                *_el_slave_file,
-                                                *_el_slave_file, false));
+  _editline_sp.reset(new lldb_private::Editline(
+      "gtest editor", *_el_slave_file, *_el_slave_file, *_el_slave_file, false,
+      nullptr));
   _editline_sp->SetPrompt("> ");
 
   // Hookup our input complete callback.
   _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
 }
 
 void EditlineAdapter::CloseInput() {
   if (_el_slave_file != nullptr)