Make CommandInterpreter's execution context the same as debugger's one.

[tatyana-krasnukha]

Summary

Currently, the interpreter's context is not updated until a command is executed. This has resulted in the behavior of SB-interface functions and some commands depend on previous user actions. The interpreter's context can stay uninitialized, point to a currently selected target, or point to one of the previously selected targets.

This patch removes any usages of CommandInterpreter::UpdateExecutionContext. CommandInterpreter::HandleCommand* functions still may temporarily override context, but now they always restore it before exiting.

Added test reproduces one of the issues. Without this fix, the last assertion fails because the interpreter's execution context is empty until running "target list", so, the value of the global property was updated instead of the process's local instance.

[tatyana-krasnukha]

Removed refactoring to make the changes clearer.

[JDevlieghere]

lldb/packages/Python/lldbsuite/test/python_api/debugger/main.cpp

1 ↗

(On Diff #308325)

Test source files shouldn't have the header.

lldb/source/API/SBDebugger.cpp

1315 ↗

(On Diff #308325)

Does this append or override the error message? If it overrides you might as well us LLDB_LOG directly which supports formatv.

[jingham]

I don't see any reason for, and lots of reasons against having more than one source of truth for a Debugger's "Currently Selected ExecutionContext". In particular, I can't see any good uses of the Debugger and the CommandInterpreter being able to have different "currently selected targets/threads/frames". For instance, I think people would generally be surprised if calling SBDebugger.SetSelectedTarget didn't also change the default target that subsequent command interpreter commands use.

This patch solves the problem that the CommandInterpreter's version of this truth is out of sync with the Debugger's notion by ignoring the CommandInterpreter's version. That seems to me the wrong way to solve the problem.

Rather, we should make sure that everyone is looking to the same source. I'm not sure it makes sense for the CommandInterpreter to be the one holding the "Currently Selected Execution Context". Maybe that should be kept in the Debugger, and the Command Interpreter could then call Debugger::GetSelectedExecutionContext?

[tatyana-krasnukha]

Addressed comments

[jingham]

This all looks fine except I'm not sure you can have a single override context. The lldb command line is only a bit recursive, but you can have sequences like:

(lldb) command source file_that_contains_a_step

Step hits a breakpoint which has commands

One of those commands is a Python command that calls SBCommandInterpreter::HandleCommandsFromFile - passing in some other SBExecutionContext

IIUC, running the breakpoint command will push one override before running the command. Then HandleCommandsFromFile will push another, and you'll won't get back to the first one.

And one of the weaknesses of lldb right now is that commands can't nest as well as they should. For instance, you really should be able to hit a breakpoint, and have the breakpoint command able to do a couple of next's of whatever, even though the weakness of the lldb command interpreter precludes that at present.

So both for somewhat esoteric reasons like that above, and to future proof this change, I think you have to use a stack for the overrides/restore, not a single element.

[tatyana-krasnukha]

Thanks for pointing to the nested command problem! Replaced pointer to the execution context with the stack of contexts.

[jingham]

LGTM - thanks for doing this!

[labath]

Sorry for not keeping track of this patch -- I'm not very active these days.

Nevertheless, I did notice that this patch introduced some kind of nondeterminism/raciness/flakyness to the "finish" command. Specifically, it causes the command (as used in TestGuiBasicDebug.py) to fail occasionally (~20% of the time). Since this patch landed (in build 3660, there has been a constant stream of builds (build 3667, build 3674, build 3678, ...) where this test is failing. The test has been stable up to that point.

The breakage can be also by running the test commands without the gui mode:

$ bin/lldb lldb-test-build.noindex/commands/gui/basicdebug/TestGuiBasicDebug.test_gui/a.out -o 'br set -f main.c -p "// Break here"' -o r
(lldb) target create "lldb-test-build.noindex/commands/gui/basicdebug/TestGuiBasicDebug.test_gui/a.out"
Current executable set to '/home/pavelo/ll/build/opt/lldb-test-build.noindex/commands/gui/basicdebug/TestGuiBasicDebug.test_gui/a.out' (x86_64).
(lldb) br set -f main.c -p "// Break here"
Breakpoint 1: where = a.out`main + 22 at main.c:4:3, address = 0x0000000000401116
(lldb) r
Process 32346 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000000401116 a.out`main(argc=1, argv=0x00007fffffffdb58) at main.c:4:3
   1   	extern int func();
   2   	
   3   	int main(int argc, char **argv) {
-> 4   	  func(); // Break here
   5   	  func(); // Second
   6   	  return 0;
   7   	}

Process 32346 launched: '/home/pavelo/ll/build/opt/lldb-test-build.noindex/commands/gui/basicdebug/TestGuiBasicDebug.test_gui/a.out' (x86_64)
(lldb) s
Process 32346 stopped
* thread #1, name = 'a.out', stop reason = step in
    frame #0: 0x0000000000401134 a.out`func at func.c:2:3
   1   	int func() {
-> 2   	  return 1; // In function
   3   	}
(lldb) fin
Process 32346 exited with status = 0 (0x00000000) 

I've reverted this patch to get the build green. I think it should be fairly easy to reproduce this problem (the command line approach fails 100% consistently for me), but if you're having trouble reproducing it, let me know, and I can send some logs or something. (The logs seem to indicate that the "step out" thread plan does not dequeue itself after steping out, but I guess the root cause is somewhere else.)

[tatyana-krasnukha]

Fixed CommandInterpreter::GetProcessOutput to avoid deadlock in Windows process plugin. This should also fix the problem @labath described above.

Pavel, could you please check whether it works for you?

[labath]

With this version of the patch, I am unable to reproduce the issue using the approach I described in the previous comment. However, it still reproduces when issuing the equivalent commands via the "gui" (either "by hand" or by running TestGuiBasicDebug.py).

[tatyana-krasnukha]

In D92164#2463734, @labath wrote:

With this version of the patch, I am unable to reproduce the issue using the approach I described in the previous comment. However, it still reproduces when issuing the equivalent commands via the "gui" (either "by hand" or by running TestGuiBasicDebug.py).

Could you send logs, please? I cannot reproduce the issue on available platforms.

[labath]

I've included two logs, showing failing and successful runs (the successful run was captured without this patch). Interesting things happen around line 1057, where the "step out" plan decides we should not stop after stepping out. I'm not sure what's the relation to this patch, but I suppose it could have something to do with it not (always) fetching the correct frame (from which it should step out) from the execution context.

fail.log144 KBDownload

ok.log139 KBDownload

[tatyana-krasnukha]

It turns out that the Debugger recalculated the selected stack frame without taking the Process's run lock. I replaced the whole context evaluation with creating ExecutionContextRef which does these things right.

@labath, I would appreciate it if you check that the latest version works for you too (I ran TestGuiBasicDebug.py 100 times on Linux and it succeeded all the time).

[tatyana-krasnukha]

Removed test since the same case was added by D95761.

[werat]

In D92164#2534626, @tatyana-krasnukha wrote:

Removed test since the same case was added by D95761.

I think your test case is even better, the one in D95761 doesn't try to run commands.

[tatyana-krasnukha]

In D92164#2536036, @werat wrote:

I think your test case is even better, the one in D95761 doesn't try to run commands.

Ok, then I'll replace it if you don't mind.

[teemperor]

I reverted D95761 (see Jim's comment), so you can just re-add your old test. Thanks!

lldb/include/lldb/Interpreter/CommandInterpreter.h

 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
+
 #include <mutex>
+#include <stack>
 
 namespace lldb_private {
 class CommandInterpreter;
 
 class CommandInterpreterRunResult {
 public:
   CommandInterpreterRunResult()
       : m_num_errors(0), m_result(lldb::eCommandInterpreterResultSuccess) {}
enum CommandTypes {
     eCommandTypesUserDef = 0x0002, // scripted commands
     eCommandTypesAliases = 0x0004, // aliases such as "po"
     eCommandTypesHidden = 0x0008,  // commands prefixed with an underscore
     eCommandTypesAllThem = 0xFFFF  // all commands
   };
 
   CommandInterpreter(Debugger &debugger, bool synchronous_execution);
 
-  ~CommandInterpreter() override;
+  ~CommandInterpreter() override = default;
 
   // These two functions fill out the Broadcaster interface:
 
   static ConstString &GetStaticBroadcasterClass();
 
   ConstString &GetBroadcasterClass() const override {
     return GetStaticBroadcasterClass();
   }
public:
   const CommandAlias *GetAlias(llvm::StringRef alias_name) const;
 
   CommandObject *BuildAliasResult(llvm::StringRef alias_name,
                                   std::string &raw_input_string,
                                   std::string &alias_result,
                                   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);
+                     const ExecutionContext &override_context,
+                     CommandReturnObject &result);
+
+  bool HandleCommand(const char *command_line, LazyBool add_to_history,
+                     CommandReturnObject &result);
 
   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
-  ///    context will be used.
+  ///    The execution context in which to run the commands.
   /// \param[in] options
   ///    This object holds the options used to control when to stop, whether to
   ///    execute commands,
   ///    etc.
   /// \param[out] result
   ///    This is marked as succeeding with no output if all commands execute
   ///    safely,
   ///    and failed with some explanation if we aborted executing the commands
   ///    at some point.
-  void HandleCommands(const StringList &commands, ExecutionContext *context,
-                      CommandInterpreterRunOptions &options,
+  void HandleCommands(const StringList &commands,
+                      const ExecutionContext &context,
+                      const CommandInterpreterRunOptions &options,
+                      CommandReturnObject &result);
+
+  void HandleCommands(const StringList &commands,
+                      const CommandInterpreterRunOptions &options,
                       CommandReturnObject &result);
 
   /// Execute a list of commands from a file.
   ///
   /// \param[in] file
   ///    The file from which to read in commands.
   /// \param[in,out] context
-  ///    The execution context in which to run the commands. Can be nullptr in
-  ///    which case the default
-  ///    context will be used.
+  ///    The execution context in which to run the commands.
   /// \param[in] options
   ///    This object holds the options used to control when to stop, whether to
   ///    execute commands,
   ///    etc.
   /// \param[out] result
   ///    This is marked as succeeding with no output if all commands execute
   ///    safely,
   ///    and failed with some explanation if we aborted executing the commands
   ///    at some point.
-  void HandleCommandsFromFile(FileSpec &file, ExecutionContext *context,
-                              CommandInterpreterRunOptions &options,
+  void HandleCommandsFromFile(FileSpec &file, const ExecutionContext &context,
+                              const CommandInterpreterRunOptions &options,
+                              CommandReturnObject &result);
+
+  void HandleCommandsFromFile(FileSpec &file,
+                              const CommandInterpreterRunOptions &options,
                               CommandReturnObject &result);
 
   CommandObject *GetCommandObjectForCommand(llvm::StringRef &command_line);
 
   /// Returns the auto-suggestion string that should be added to the given
   /// command line.
   llvm::Optional<std::string> GetAutoSuggestionForCommand(llvm::StringRef line);
 
public:
   // to type some text and have it printed in a reasonable way on screen. If
   // so, use OutputFormattedHelpText
   void OutputHelpText(Stream &stream, llvm::StringRef command_word,
                       llvm::StringRef separator, llvm::StringRef help_text,
                       uint32_t max_word_len);
 
   Debugger &GetDebugger() { return m_debugger; }
 
-  ExecutionContext GetExecutionContext() {
-    const bool thread_and_frame_only_if_stopped = true;
-    return m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped);
-  }
-
-  void UpdateExecutionContext(ExecutionContext *override_context);
+  ExecutionContext GetExecutionContext() const;
 
   lldb::PlatformSP GetPlatform(bool prefer_target_platform);
 
   const char *ProcessEmbeddedScriptCommands(const char *arg);
 
   void UpdatePrompt(llvm::StringRef prompt);
 
   bool Confirm(llvm::StringRef message, bool default_answer);
protected:
 
   lldb::CommandObjectSP GetCommandSP(llvm::StringRef cmd,
                                      bool include_aliases = true,
                                      bool exact = true,
                                      StringList *matches = nullptr,
                                      StringList *descriptions = nullptr) const;
 
 private:
+  void OverrideExecutionContext(const ExecutionContext &override_context);
+
+  void RestoreExecutionContext();
+
   Status PreprocessCommand(std::string &command);
 
   void SourceInitFile(FileSpec file, CommandReturnObject &result);
 
   // Completely resolves aliases and abbreviations, returning a pointer to the
   // final command object and updating command_line to the fully substituted
   // and translated command.
   CommandObject *ResolveCommandImpl(std::string &command_line,
private:
   int m_iohandler_nesting_level = 0;
 
   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
+  // Execution contexts that were temporarily set by some of HandleCommand*
+  // overloads.
+  std::stack<ExecutionContext> m_overriden_exe_contexts;
   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
                                             // (they cannot be deleted, removed
                                             // or overwritten).
   CommandObject::CommandMap
       m_alias_dict; // Stores user aliases/abbreviations for commands

lldb/source/API/SBCommandInterpreter.cpp

 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
     const char *command_line, SBExecutionContext &override_context,
     SBCommandReturnObject &result, bool add_to_history) {
   LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
                      (const char *, lldb::SBExecutionContext &,
                       lldb::SBCommandReturnObject &, bool),
                      command_line, override_context, result, add_to_history);
 
-
-  ExecutionContext ctx, *ctx_ptr;
-  if (override_context.get()) {
-    ctx = override_context.get()->Lock(true);
-    ctx_ptr = &ctx;
-  } else
-    ctx_ptr = nullptr;
-
   result.Clear();
   if (command_line && IsValid()) {
     result.ref().SetInteractive(false);
-    m_opaque_ptr->HandleCommand(command_line,
-                                add_to_history ? eLazyBoolYes : eLazyBoolNo,
-                                result.ref(), ctx_ptr);
+    auto do_add_to_history = add_to_history ? eLazyBoolYes : eLazyBoolNo;
+    if (override_context.get())
+      m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
+                                  override_context.get()->Lock(true),
+                                  result.ref());
+    else
+      m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
+                                  result.ref());
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
 
-
   return result.GetStatus();
 }
 
 void SBCommandInterpreter::HandleCommandsFromFile(
     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
     lldb::SBCommandInterpreterRunOptions &options,
     lldb::SBCommandReturnObject result) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
void SBCommandInterpreter::HandleCommandsFromFile(
   if (!file.IsValid()) {
     SBStream s;
     file.GetDescription(s);
     result->AppendErrorWithFormat("File is not valid: %s.", s.GetData());
     result->SetStatus(eReturnStatusFailed);
   }
 
   FileSpec tmp_spec = file.ref();
-  ExecutionContext ctx, *ctx_ptr;
-  if (override_context.get()) {
-    ctx = override_context.get()->Lock(true);
-    ctx_ptr = &ctx;
-  } else
-    ctx_ptr = nullptr;
-
-  m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(),
+  if (override_context.get())
+    m_opaque_ptr->HandleCommandsFromFile(tmp_spec,
+                                         override_context.get()->Lock(true),
+                                         options.ref(),
                                          result.ref());
+
+  else
+    m_opaque_ptr->HandleCommandsFromFile(tmp_spec, options.ref(), result.ref());
 }
 
 int SBCommandInterpreter::HandleCompletion(
     const char *current_line, const char *cursor, const char *last_char,
     int match_start_point, int max_return_elements, SBStringList &matches) {
   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
                      (const char *, const char *, const char *, int, int,
                       lldb::SBStringList &),

lldb/source/Breakpoint/BreakpointOptions.cpp

if (target) {
       CommandInterpreterRunOptions options;
       options.SetStopOnContinue(true);
       options.SetStopOnError(data->stop_on_error);
       options.SetEchoCommands(true);
       options.SetPrintResults(true);
       options.SetPrintErrors(true);
       options.SetAddToHistory(false);
 
-      debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
+      debugger.GetCommandInterpreter().HandleCommands(commands, exe_ctx,
                                                       options, result);
       result.GetImmediateOutputStream()->Flush();
       result.GetImmediateErrorStream()->Flush();
     }
   }
   return ret_value;
 }
 

lldb/source/Commands/CommandObjectCommands.cpp

if (command.GetArgumentCount() != 1) {
           "'%s' takes exactly one executable filename argument.\n",
           GetCommandName().str().c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     FileSpec cmd_file(command[0].ref());
     FileSystem::Instance().Resolve(cmd_file);
-    ExecutionContext *exe_ctx = nullptr; // Just use the default context.
 
+    CommandInterpreterRunOptions options;
     // If any options were set, then use them
     if (m_options.m_stop_on_error.OptionWasSet() ||
         m_options.m_silent_run.OptionWasSet() ||
         m_options.m_stop_on_continue.OptionWasSet()) {
-      // Use user set settings
-      CommandInterpreterRunOptions options;
-
       if (m_options.m_stop_on_continue.OptionWasSet())
         options.SetStopOnContinue(
             m_options.m_stop_on_continue.GetCurrentValue());
 
       if (m_options.m_stop_on_error.OptionWasSet())
         options.SetStopOnError(m_options.m_stop_on_error.GetCurrentValue());
 
       // Individual silent setting is override for global command echo settings.
       if (m_options.m_silent_run.GetCurrentValue()) {
         options.SetSilent(true);
       } else {
         options.SetPrintResults(true);
         options.SetPrintErrors(true);
         options.SetEchoCommands(m_interpreter.GetEchoCommands());
         options.SetEchoCommentCommands(m_interpreter.GetEchoCommentCommands());
       }
-
-      m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
-    } else {
-      // No options were set, inherit any settings from nested "command source"
-      // commands, or set to sane default settings...
-      CommandInterpreterRunOptions options;
-      m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
     }
+
+    m_interpreter.HandleCommandsFromFile(cmd_file, options, result);
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 #pragma mark CommandObjectCommandsAlias
 // CommandObjectCommandsAlias

lldb/source/Commands/CommandObjectExpression.cpp

 void CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
   EvaluateExpressionOptions options;
   options.SetCoerceToId(m_varobj_options.use_objc);
   options.SetLanguage(m_command_options.language);
   options.SetExecutionPolicy(lldb_private::eExecutionPolicyNever);
   options.SetAutoApplyFixIts(false);
   options.SetGenerateDebugInfo(false);
 
-  // We need a valid execution context with a frame pointer for this
-  // completion, so if we don't have one we should try to make a valid
-  // execution context.
-  if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
-    m_interpreter.UpdateExecutionContext(nullptr);
-
-  // This didn't work, so let's get out before we start doing things that
-  // expect a valid frame pointer.
-  if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
+  ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
+
+  // Get out before we start doing things that expect a valid frame pointer.
+  if (exe_ctx.GetFramePtr() == nullptr)
     return;
 
-  ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
   Target *exe_target = exe_ctx.GetTargetPtr();
   Target &target = exe_target ? *exe_target : GetDummyTarget();
 
   unsigned cursor_pos = request.GetRawCursorPos();
   // Get the full user input including the suffix. The suffix is necessary
   // as OptionsWithRaw will use it to detect if the cursor is cursor is in the
   // argument part of in the raw input part of the arguments. If we cut of
   // of the suffix then "expr -arg[cursor] --" would interpret the "-arg" as

lldb/source/Commands/CommandObjectProcess.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     if (command.GetArgumentCount()) {
       result.AppendErrorWithFormat("Invalid arguments for '%s'.\nUsage: %s\n",
                                    m_cmd_name.c_str(), m_cmd_syntax.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    m_interpreter.UpdateExecutionContext(nullptr);
     StreamString stream;
     const auto error = target->Attach(m_options.attach_info, &stream);
     if (error.Success()) {
       ProcessSP process_sp(target->GetProcessSP());
       if (process_sp) {
         result.AppendMessage(stream.GetString());
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
         result.SetDidChangeProcessState(true);

lldb/source/Commands/CommandObjectRegexCommand.cpp

if (pos->regex.Execute(command, &matches)) {
         }
       }
       // Interpret the new command and return this as the result!
       if (m_interpreter.GetExpandRegexAliases())
         result.GetOutputStream().Printf("%s\n", new_command.c_str());
       // Pass in true for "no context switching".  The command that called us
       // should have set up the context appropriately, we shouldn't have to
       // redo that.
-      return m_interpreter.HandleCommand(
-          new_command.c_str(), eLazyBoolCalculate, result, nullptr, true, true);
+      return m_interpreter.HandleCommand(new_command.c_str(),
+                                         eLazyBoolCalculate, result);
     }
   }
   result.SetStatus(eReturnStatusFailed);
   if (!GetSyntax().empty())
     result.AppendError(GetSyntax());
   else
     result.GetOutputStream() << "Command contents '" << command
                              << "' failed to match any "

lldb/source/Commands/CommandObjectSettings.cpp

public:
     // Instance variables to hold the values for command options.
     std::string m_filename;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     FileSpec file(m_options.m_filename);
     FileSystem::Instance().Resolve(file);
-    ExecutionContext clean_ctx;
     CommandInterpreterRunOptions options;
     options.SetAddToHistory(false);
     options.SetEchoCommands(false);
     options.SetPrintResults(true);
     options.SetPrintErrors(true);
     options.SetStopOnError(false);
-    m_interpreter.HandleCommandsFromFile(file, &clean_ctx, options, result);
+    m_interpreter.HandleCommandsFromFile(file, options, result);
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectSettingsList -- List settable variables

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

if (commands.GetSize() > 0) {
         CommandInterpreterRunOptions options;
         options.SetStopOnContinue(true);
         options.SetStopOnError(data->stop_on_error);
         options.SetEchoCommands(false);
         options.SetPrintResults(true);
         options.SetPrintErrors(true);
         options.SetAddToHistory(false);
 
-        debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
+        debugger.GetCommandInterpreter().HandleCommands(commands, exe_ctx,
                                                         options, result);
         result.GetImmediateOutputStream()->Flush();
         result.GetImmediateErrorStream()->Flush();
       }
     }
     return ret_value;
   }
 

lldb/source/Core/Debugger.cpp

void Debugger::SaveInputTerminalState() {
   int fd = GetInputFile().GetDescriptor();
   if (fd != File::kInvalidDescriptor)
     m_terminal_state.Save(fd, true);
 }
 
 void Debugger::RestoreInputTerminalState() { m_terminal_state.Restore(); }
 
 ExecutionContext Debugger::GetSelectedExecutionContext() {
-  ExecutionContext exe_ctx;
-  TargetSP target_sp(GetSelectedTarget());
-  exe_ctx.SetTargetSP(target_sp);
-
-  if (target_sp) {
-    ProcessSP process_sp(target_sp->GetProcessSP());
-    exe_ctx.SetProcessSP(process_sp);
-    if (process_sp && !process_sp->IsRunning()) {
-      ThreadSP thread_sp(process_sp->GetThreadList().GetSelectedThread());
-      if (thread_sp) {
-        exe_ctx.SetThreadSP(thread_sp);
-        exe_ctx.SetFrameSP(thread_sp->GetSelectedFrame());
-        if (exe_ctx.GetFramePtr() == nullptr)
-          exe_ctx.SetFrameSP(thread_sp->GetStackFrameAtIndex(0));
-      }
-    }
-  }
-  return exe_ctx;
+  bool adopt_selected = true;
+  ExecutionContextRef exe_ctx_ref(GetSelectedTarget().get(), adopt_selected);
+  return ExecutionContext(exe_ctx_ref);
 }
 
 void Debugger::DispatchInputInterrupt() {
   std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
   IOHandlerSP reader_sp(m_io_handler_stack.Top());
   if (reader_sp)
     reader_sp->Interrupt();
 }

lldb/source/Core/IOHandlerCursesGUI.cpp

#endif
 
             if (event_sp) {
               Broadcaster *broadcaster = event_sp->GetBroadcaster();
               if (broadcaster) {
                 // uint32_t event_type = event_sp->GetType();
                 ConstString broadcaster_class(
                     broadcaster->GetBroadcasterClass());
                 if (broadcaster_class == broadcaster_class_process) {
-                  debugger.GetCommandInterpreter().UpdateExecutionContext(
-                      nullptr);
                   m_update_screen = true;
                   continue; // Don't get any key, just update our view
                 }
               }
             }
           }
         }
       } else {
         HandleCharResult key_result = m_window_sp->HandleChar(ch);
         switch (key_result) {
         case eKeyHandled:
-          debugger.GetCommandInterpreter().UpdateExecutionContext(nullptr);
           m_update_screen = true;
           break;
         case eKeyNotHandled:
           if (ch == 12) { // Ctrl+L, force full redraw
             redrawwin(m_window_sp->get());
             m_update_screen = true;
           }
           break;

lldb/source/Interpreter/CommandInterpreter.cpp

 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnixSignals.h"
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace lldb;
 using namespace lldb_private;
if (error.Success()) {
       }
     }
   }
   return error;
 }
 
 bool CommandInterpreter::HandleCommand(const char *command_line,
                                        LazyBool lazy_add_to_history,
-                                       CommandReturnObject &result,
-                                       ExecutionContext *override_context,
-                                       bool repeat_on_empty_command,
-                                       bool no_context_switching)
+                                       const ExecutionContext &override_context,
+                                       CommandReturnObject &result) {
 
-{
+  OverrideExecutionContext(override_context);
+  bool status = HandleCommand(command_line, lazy_add_to_history, result);
+  RestoreExecutionContext();
+  return status;
+}
+
+bool CommandInterpreter::HandleCommand(const char *command_line,
+                                       LazyBool lazy_add_to_history,
+                                       CommandReturnObject &result) {
 
   std::string command_string(command_line);
   std::string original_command_string(command_line);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS));
   llvm::PrettyStackTraceFormat stack_trace("HandleCommand(command = \"%s\")",
                                    command_line);
 
   LLDB_LOGF(log, "Processing command: %s", command_line);
   LLDB_SCOPED_TIMERF("Processing command: %s.", command_line);
 
-  if (!no_context_switching)
-    UpdateExecutionContext(override_context);
-
   if (WasInterrupted()) {
     result.AppendError("interrupted");
     result.SetStatus(eReturnStatusFailed);
     return false;
   }
 
   bool add_to_history;
   if (lazy_add_to_history == eLazyBoolCalculate)
else if (command_string[non_space] == CommandHistory::g_repeat_char) {
                                      command_string.c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
   }
 
   if (empty_command) {
-    if (repeat_on_empty_command) {
-      if (m_command_history.IsEmpty()) {
-        result.AppendError("empty command");
-        result.SetStatus(eReturnStatusFailed);
-        return false;
-      } else {
-        command_line = m_repeat_command.c_str();
-        command_string = command_line;
-        original_command_string = command_line;
-        if (m_repeat_command.empty()) {
-          result.AppendError("No auto repeat.");
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-      }
-      add_to_history = false;
-    } else {
-      result.SetStatus(eReturnStatusSuccessFinishNoResult);
-      return true;
-    }
+    }
+
+
   } else if (comment_command) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return true;
   }
 
   Status error(PreprocessCommand(command_string));
 
   if (error.Fail()) {
if (command_object) {
       request.ShiftArguments();
       command_object->HandleCompletion(request);
     }
   }
 }
 
 void CommandInterpreter::HandleCompletion(CompletionRequest &request) {
 
-  UpdateExecutionContext(nullptr);
-
   // Don't complete comments, and if the line we are completing is just the
   // history repeat character, substitute the appropriate history line.
   llvm::StringRef first_arg = request.GetParsedLine().GetArgumentAtIndex(0);
 
   if (!first_arg.empty()) {
     if (first_arg.front() == m_comment_char)
       return;
     if (first_arg.front() == CommandHistory::g_repeat_char) {
CommandInterpreter::GetAutoSuggestionForCommand(llvm::StringRef line) {
   for (int i = s - 1; i >= 0; --i) {
     llvm::StringRef entry = m_command_history.GetStringAtIndex(i);
     if (entry.consume_front(line))
       return entry.str();
   }
   return llvm::None;
 }
 
-CommandInterpreter::~CommandInterpreter() {}
-
 void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
   EventSP prompt_change_event_sp(
       new Event(eBroadcastBitResetPrompt, new EventDataBytes(new_prompt)));
   ;
   BroadcastEvent(prompt_change_event_sp);
   if (m_command_io_handler_sp)
     m_command_io_handler_sp->SetPrompt(new_prompt);
 }
if (!FileSystem::Instance().Exists(file)) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return;
   }
 
   // Use HandleCommand to 'source' the given file; this will do the actual
   // broadcasting of the commands back to any appropriate listener (see
   // CommandObjectSource::Execute for more details).
   const bool saved_batch = SetBatchCommandMode(true);
-  ExecutionContext *ctx = nullptr;
   CommandInterpreterRunOptions options;
   options.SetSilent(true);
   options.SetPrintErrors(true);
   options.SetStopOnError(false);
   options.SetStopOnContinue(true);
-  HandleCommandsFromFile(file, ctx, options, result);
+  HandleCommandsFromFile(file, options, result);
   SetBatchCommandMode(saved_batch);
 }
 
 void CommandInterpreter::SourceInitFileCwd(CommandReturnObject &result) {
   if (m_skip_lldbinit_files) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return;
   }
PlatformSP CommandInterpreter::GetPlatform(bool prefer_target_platform) {
   }
 
   if (!platform_sp)
     platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform();
   return platform_sp;
 }
 
 bool CommandInterpreter::DidProcessStopAbnormally() const {
-  TargetSP target_sp = m_debugger.GetTargetList().GetSelectedTarget();
+  auto exe_ctx = GetExecutionContext();
+  TargetSP target_sp = exe_ctx.GetTargetSP();
   if (!target_sp)
     return false;
 
   ProcessSP process_sp(target_sp->GetProcessSP());
   if (!process_sp)
     return false;
 
   if (eStateStopped != process_sp->GetState())
if (reason == eStopReasonSignal) {
         // The signal very likely implies a crash.
         return true;
     }
   }
 
   return false;
 }
 
+void
+CommandInterpreter::HandleCommands(const StringList &commands,
+                                   const ExecutionContext &override_context,
+                                   const CommandInterpreterRunOptions &options,
+                                   CommandReturnObject &result) {
+
+  OverrideExecutionContext(override_context);
+  HandleCommands(commands, options, result);
+  RestoreExecutionContext();
+}
+
 void CommandInterpreter::HandleCommands(const StringList &commands,
-                                        ExecutionContext *override_context,
-                                        CommandInterpreterRunOptions &options,
+                                        const CommandInterpreterRunOptions &options,
                                         CommandReturnObject &result) {
   size_t num_lines = commands.GetSize();
 
   // If we are going to continue past a "continue" then we need to run the
   // commands synchronously. Make sure you reset this value anywhere you return
   // from the function.
 
   bool old_async_execution = m_debugger.GetAsyncExecution();
 
-  // If we've been given an execution context, set it at the start, but don't
-  // keep resetting it or we will cause series of commands that change the
-  // context, then do an operation that relies on that context to fail.
-
-  if (override_context != nullptr)
-    UpdateExecutionContext(override_context);
-
   if (!options.GetStopOnContinue()) {
     m_debugger.SetAsyncExecution(false);
   }
 
   for (size_t idx = 0; idx < num_lines && !WasInterrupted(); idx++) {
     const char *cmd = commands.GetStringAtIndex(idx);
     if (cmd[0] == '\0')
       continue;
 
     if (options.GetEchoCommands()) {
       // TODO: Add Stream support.
       result.AppendMessageWithFormat("%s %s\n",
                                      m_debugger.GetPrompt().str().c_str(), cmd);
     }
 
     CommandReturnObject tmp_result(m_debugger.GetUseColor());
     tmp_result.SetInteractive(result.GetInteractive());
 
-    // If override_context is not NULL, pass no_context_switching = true for
-    // HandleCommand() since we updated our context already.
-
     // We might call into a regex or alias command, in which case the
     // add_to_history will get lost.  This m_command_source_depth dingus is the
     // way we turn off adding to the history in that case, so set it up here.
     if (!options.GetAddToHistory())
       m_command_source_depth++;
-    bool success =
-        HandleCommand(cmd, options.m_add_to_history, tmp_result,
-                      nullptr, /* override_context */
-                      true,    /* repeat_on_empty_command */
-                      override_context != nullptr /* no_context_switching */);
+    bool success = HandleCommand(cmd, options.m_add_to_history, tmp_result);
     if (!options.GetAddToHistory())
       m_command_source_depth--;
 
     if (options.GetPrintResults()) {
       if (tmp_result.Succeeded())
         result.AppendMessage(tmp_result.GetOutputData());
     }
 
enum {
   eHandleCommandFlagEchoCommand = (1u << 2),
   eHandleCommandFlagEchoCommentCommand = (1u << 3),
   eHandleCommandFlagPrintResult = (1u << 4),
   eHandleCommandFlagPrintErrors = (1u << 5),
   eHandleCommandFlagStopOnCrash = (1u << 6)
 };
 
 void CommandInterpreter::HandleCommandsFromFile(
-    FileSpec &cmd_file, ExecutionContext *context,
-    CommandInterpreterRunOptions &options, CommandReturnObject &result) {
+    FileSpec &cmd_file, const ExecutionContext &context,
+    const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
+  OverrideExecutionContext(context);
+  HandleCommandsFromFile(cmd_file, options, result);
+  RestoreExecutionContext();
+}
+
+void CommandInterpreter::HandleCommandsFromFile(FileSpec &cmd_file,
+    const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
   if (!FileSystem::Instance().Exists(cmd_file)) {
     result.AppendErrorWithFormat(
         "Error reading commands from file %s - file not found.\n",
         cmd_file.GetFilename().AsCString("<Unknown>"));
     result.SetStatus(eReturnStatusFailed);
     return;
   }
 
if (search_user_commands)
     FindCommandsForApropos(search_word, commands_found, commands_help,
                            m_user_dict);
 
   if (search_alias_commands)
     FindCommandsForApropos(search_word, commands_found, commands_help,
                            m_alias_dict);
 }
 
-void CommandInterpreter::UpdateExecutionContext(
-    ExecutionContext *override_context) {
-  if (override_context != nullptr) {
-    m_exe_ctx_ref = *override_context;
-  } else {
-    const bool adopt_selected = true;
-    m_exe_ctx_ref.SetTargetPtr(m_debugger.GetSelectedTarget().get(),
-                               adopt_selected);
-  }
+ExecutionContext CommandInterpreter::GetExecutionContext() const {
+  return !m_overriden_exe_contexts.empty()
+             ? m_overriden_exe_contexts.top()
+             : m_debugger.GetSelectedExecutionContext();
+
+void CommandInterpreter::OverrideExecutionContext(
+    const ExecutionContext &override_context) {
+  m_overriden_exe_contexts.push(override_context);
 }
 
-void CommandInterpreter::GetProcessOutput() {
-  TargetSP target_sp(m_debugger.GetTargetList().GetSelectedTarget());
-  if (!target_sp)
-    return;
+void CommandInterpreter::RestoreExecutionContext() {
+  if (!m_overriden_exe_contexts.empty())
+    m_overriden_exe_contexts.pop();
+}
 
-  if (ProcessSP process_sp = target_sp->GetProcessSP())
+void CommandInterpreter::GetProcessOutput() {
+  if (ProcessSP process_sp = GetExecutionContext().GetProcessSP())
     m_debugger.FlushProcessOutput(*process_sp, /*flush_stdout*/ true,
                                   /*flush_stderr*/ true);
 }
 
 void CommandInterpreter::StartHandlingCommand() {
   auto idle_state = CommandHandlingState::eIdle;
   if (m_command_state.compare_exchange_strong(
           idle_state, CommandHandlingState::eInProgress))
if (!is_interactive) {
     // command output and no command...
     if (EchoCommandNonInteractive(line, io_handler.GetFlags()))
       io_handler.GetOutputStreamFileSP()->Printf(
           "%s%s\n", io_handler.GetPrompt(), line.c_str());
   }
 
   StartHandlingCommand();
 
+  OverrideExecutionContext(m_debugger.GetSelectedExecutionContext());
+  llvm::make_scope_exit([this]() { RestoreExecutionContext(); });
+
   lldb_private::CommandReturnObject result(m_debugger.GetUseColor());
   HandleCommand(line.c_str(), eLazyBoolCalculate, result);
 
   // Now emit the command output text from the command we just executed
   if ((result.Succeeded() &&
        io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) ||
       io_handler.GetFlags().Test(eHandleCommandFlagPrintErrors)) {
     // Display any STDOUT/STDERR _prior_ to emitting the command result text

lldb/source/Target/Target.cpp

Target::StopHookCommandLine::HandleStop(ExecutionContext &exc_ctx,
   options.SetEchoCommands(false);
   options.SetPrintResults(true);
   options.SetPrintErrors(true);
   options.SetAddToHistory(false);
 
   // Force Async:
   bool old_async = debugger.GetAsyncExecution();
   debugger.SetAsyncExecution(true);
-  debugger.GetCommandInterpreter().HandleCommands(GetCommands(), &exc_ctx,
+  debugger.GetCommandInterpreter().HandleCommands(GetCommands(), exc_ctx,
                                                   options, result);
   debugger.SetAsyncExecution(old_async);
   lldb::ReturnStatus status = result.GetStatus();
   if (status == eReturnStatusSuccessContinuingNoResult ||
       status == eReturnStatusSuccessContinuingResult)
     return StopHookResult::AlreadyContinued;
   return StopHookResult::KeepStopped;
 }