Merge commit '2fbeabf59fc3' from apple/stable/20210107 into swift/main

Author: git apple-llvm automerger

lldb/include/lldb/Interpreter/CommandInterpreter.h

@@ -24,9 +24,7 @@
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
-
 #include <mutex>
-#include <stack>
 
 namespace lldb_private {
 class CommandInterpreter;
@@ -247,7 +245,7 @@ class CommandInterpreter : public Broadcaster,
 
   CommandInterpreter(Debugger &debugger, bool synchronous_execution);
 
-  ~CommandInterpreter() override = default;
+  ~CommandInterpreter() override;
 
   // These two functions fill out the Broadcaster interface:
 
@@ -302,11 +300,10 @@ class CommandInterpreter : public Broadcaster,
                                   CommandReturnObject &result);
 
   bool HandleCommand(const char *command_line, LazyBool add_to_history,
-                     const ExecutionContext &override_context,
-                     CommandReturnObject &result);
-
-  bool HandleCommand(const char *command_line, LazyBool add_to_history,
-                     CommandReturnObject &result);
+                     CommandReturnObject &result,
+                     ExecutionContext *override_context = nullptr,
+                     bool repeat_on_empty_command = true,
+                     bool no_context_switching = false);
 
   bool WasInterrupted() const;
 
@@ -315,7 +312,9 @@ class CommandInterpreter : public Broadcaster,
   /// \param[in] commands
   ///    The list of commands to execute.
   /// \param[in,out] context
-  ///    The execution context in which to run the commands.
+  ///    The execution context in which to run the commands. Can be nullptr in
+  ///    which case the default
+  ///    context will be used.
   /// \param[in] options
   ///    This object holds the options used to control when to stop, whether to
   ///    execute commands,
@@ -325,21 +324,18 @@ class CommandInterpreter : public Broadcaster,
   ///    safely,
   ///    and failed with some explanation if we aborted executing the commands
   ///    at some point.
-  void HandleCommands(const StringList &commands,
-                      const ExecutionContext &context,
-                      const CommandInterpreterRunOptions &options,
-                      CommandReturnObject &result);
-
-  void HandleCommands(const StringList &commands,
-                      const CommandInterpreterRunOptions &options,
+  void HandleCommands(const StringList &commands, ExecutionContext *context,
+                      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.
+  ///    The execution context in which to run the commands. Can be nullptr in
+  ///    which case the default
+  ///    context will be used.
   /// \param[in] options
   ///    This object holds the options used to control when to stop, whether to
   ///    execute commands,
@@ -349,12 +345,8 @@ class CommandInterpreter : public Broadcaster,
   ///    safely,
   ///    and failed with some explanation if we aborted executing the commands
   ///    at some point.
-  void HandleCommandsFromFile(FileSpec &file, const ExecutionContext &context,
-                              const CommandInterpreterRunOptions &options,
-                              CommandReturnObject &result);
-
-  void HandleCommandsFromFile(FileSpec &file,
-                              const CommandInterpreterRunOptions &options,
+  void HandleCommandsFromFile(FileSpec &file, ExecutionContext *context,
+                              CommandInterpreterRunOptions &options,
                               CommandReturnObject &result);
 
   CommandObject *GetCommandObjectForCommand(llvm::StringRef &command_line);
@@ -399,7 +391,12 @@ class CommandInterpreter : public Broadcaster,
 
   Debugger &GetDebugger() { return m_debugger; }
 
-  ExecutionContext GetExecutionContext() const;
+  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);
 
   lldb::PlatformSP GetPlatform(bool prefer_target_platform);
 
@@ -586,10 +583,6 @@ class CommandInterpreter : public Broadcaster,
                                      StringList *descriptions = nullptr) const;
 
 private:
-  void OverrideExecutionContext(const ExecutionContext &override_context);
-
-  void RestoreExecutionContext();
-
   Status PreprocessCommand(std::string &command);
 
   void SourceInitFile(FileSpec file, CommandReturnObject &result);
@@ -628,9 +621,8 @@ class CommandInterpreter : public Broadcaster,
 
   Debugger &m_debugger; // The debugger session that this interpreter is
                         // associated with
-  // Execution contexts that were temporarily set by some of HandleCommand*
-  // overloads.
-  std::stack<ExecutionContext> m_overriden_exe_contexts;
+  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;

lldb/source/API/SBCommandInterpreter.cpp

@@ -171,23 +171,27 @@ lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
                       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);
-    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());
+    m_opaque_ptr->HandleCommand(command_line,
+                                add_to_history ? eLazyBoolYes : eLazyBoolNo,
+                                result.ref(), ctx_ptr);
   } else {
     result->AppendError(
         "SBCommandInterpreter or the command line is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
 
+
   return result.GetStatus();
 }
 
@@ -215,14 +219,15 @@ void SBCommandInterpreter::HandleCommandsFromFile(
   }
 
   FileSpec tmp_spec = file.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());
+  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(),
+                                       result.ref());
 }
 
 int SBCommandInterpreter::HandleCompletion(

lldb/source/Breakpoint/BreakpointOptions.cpp

@@ -647,7 +647,7 @@ bool BreakpointOptions::BreakpointOptionsCallbackFunction(
       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();

lldb/source/Commands/CommandObjectCommands.cpp

@@ -134,12 +134,15 @@ class CommandObjectCommandsSource : public CommandObjectParsed {
 
     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());
@@ -156,9 +159,14 @@ class CommandObjectCommandsSource : public CommandObjectParsed {
         options.SetEchoCommands(m_interpreter.GetEchoCommands());
         options.SetEchoCommentCommands(m_interpreter.GetEchoCommentCommands());
       }
-    }
 
-    m_interpreter.HandleCommandsFromFile(cmd_file, options, result);
+      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);
+    }
     return result.Succeeded();
   }
 

lldb/source/Commands/CommandObjectExpression.cpp

@@ -298,12 +298,18 @@ void CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
   options.SetAutoApplyFixIts(false);
   options.SetGenerateDebugInfo(false);
 
-  ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
-
-  // Get out before we start doing things that expect a valid frame pointer.
-  if (exe_ctx.GetFramePtr() == nullptr)
+  // 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)
     return;
 
+  ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
   Target *exe_target = exe_ctx.GetTargetPtr();
   Target &target = exe_target ? *exe_target : GetDummyTarget();
 

lldb/source/Commands/CommandObjectProcess.cpp

@@ -380,6 +380,7 @@ class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach {
       return false;
     }
 
+    m_interpreter.UpdateExecutionContext(nullptr);
     StreamString stream;
     const auto error = target->Attach(m_options.attach_info, &stream);
     if (error.Success()) {

lldb/source/Commands/CommandObjectRegexCommand.cpp

@@ -53,8 +53,8 @@ bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command,
       // 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);
+      return m_interpreter.HandleCommand(
+          new_command.c_str(), eLazyBoolCalculate, result, nullptr, true, true);
     }
   }
   result.SetStatus(eReturnStatusFailed);

lldb/source/Commands/CommandObjectSettings.cpp

@@ -469,13 +469,14 @@ class CommandObjectSettingsRead : public CommandObjectParsed {
   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, options, result);
+    m_interpreter.HandleCommandsFromFile(file, &clean_ctx, options, result);
     return result.Succeeded();
   }
 

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

@@ -301,7 +301,7 @@ are no syntax errors may indicate that a function was declared but never called.
         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();

lldb/source/Core/IOHandlerCursesGUI.cpp

@@ -1390,6 +1390,8 @@ class Application {
                 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
                 }
@@ -1401,6 +1403,7 @@ class Application {
         HandleCharResult key_result = m_window_sp->HandleChar(ch);
         switch (key_result) {
         case eKeyHandled:
+          debugger.GetCommandInterpreter().UpdateExecutionContext(nullptr);
           m_update_screen = true;
           break;
         case eKeyNotHandled: