make 'step out' step out of the selected frame

[labath]

This should definitely have a test case.

[llunak]

Added a test.

lldb/include/lldb/Target/Thread.h

virtual Status StepOver(
       bool source_step,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   /// Default implementation for stepping out.
   ///
   /// This function is designed to be used by commands where the
   /// process is publicly stopped.
   ///
+  /// \param[in] frame_idx
+  ///     The frame index to step out of.
+  ///
   /// \return
   ///     An error that describes anything that went wrong
-  virtual Status StepOut();
+  virtual Status StepOut(uint32_t frame_idx = 0);
 
   /// Retrieves the per-thread data area.
   /// Most OSs maintain a per-thread pointer (e.g. the FS register on
   /// x64), which we return the value of here.
   ///
   /// \return
   ///     LLDB_INVALID_ADDRESS if not supported, otherwise the thread
   ///     pointer value.
public:
   ///
   /// \param[in] report_stop_vote
   ///    See standard meanings for the stop & run votes in ThreadPlan.h.
   ///
   /// \param[in] report_run_vote
   ///    See standard meanings for the stop & run votes in ThreadPlan.h.
   ///
   /// \param[in] frame_idx
-  ///     The fame index.
+  ///     The frame index.
   ///
   /// \param[out] status
   ///     A status with an error if queuing failed.
   ///
   /// \param[in] continue_to_next_branch
   ///    Normally this will enqueue a plan that will put a breakpoint on the
   ///    return address and continue
   ///    to there.  If continue_to_next_branch is true, this is an operation not

lldb/source/Core/IOHandlerCursesGUI.cpp

case eMenuID_ThreadStepIn: {
       return MenuActionResult::Handled;
 
     case eMenuID_ThreadStepOut: {
       ExecutionContext exe_ctx =
           m_debugger.GetCommandInterpreter().GetExecutionContext();
       if (exe_ctx.HasThreadScope()) {
         Process *process = exe_ctx.GetProcessPtr();
         if (process && process->IsAlive() &&
-            StateIsStoppedState(process->GetState(), true))
-          exe_ctx.GetThreadRef().StepOut();
+            StateIsStoppedState(process->GetState(), true)) {
+          Thread *thread = exe_ctx.GetThreadPtr();
+          uint32_t frame_idx = thread->GetSelectedFrameIndex();
+          exe_ctx.GetThreadRef().StepOut(frame_idx);
+        }
       }
     }
       return MenuActionResult::Handled;
 
     case eMenuID_ThreadStepOver: {
       ExecutionContext exe_ctx =
           m_debugger.GetCommandInterpreter().GetExecutionContext();
       if (exe_ctx.HasThreadScope()) {
HandleCharResult WindowDelegateHandleChar(Window &window, int c) override {
 
     case 'f':
       // 'f' == step out (finish)
       {
         ExecutionContext exe_ctx =
             m_debugger.GetCommandInterpreter().GetExecutionContext();
         if (exe_ctx.HasThreadScope() &&
             StateIsStoppedState(exe_ctx.GetProcessRef().GetState(), true)) {
-          exe_ctx.GetThreadRef().StepOut();
+          Thread *thread = exe_ctx.GetThreadPtr();
+          uint32_t frame_idx = thread->GetSelectedFrameIndex();
+          exe_ctx.GetThreadRef().StepOut(frame_idx);
         }
       }
       return eKeyHandled;
 
     case 'n': // 'n' == step over
     case 'N': // 'N' == step over instruction
     {
       ExecutionContext exe_ctx =

lldb/source/Target/Thread.cpp

if (StateIsStoppedState(process->GetState(), true)) {
     process->GetThreadList().SetSelectedThreadByID(GetID());
     error = process->Resume();
   } else {
     error.SetErrorString("process not stopped");
   }
   return error;
 }
 
-Status Thread::StepOut() {
+Status Thread::StepOut(uint32_t frame_idx) {
   Status error;
   Process *process = GetProcess().get();
   if (StateIsStoppedState(process->GetState(), true)) {
     const bool first_instruction = false;
     const bool stop_other_threads = false;
     const bool abort_other_plans = false;
 
     ThreadPlanSP new_plan_sp(QueueThreadPlanForStepOut(
         abort_other_plans, nullptr, first_instruction, stop_other_threads,
-        eVoteYes, eVoteNoOpinion, 0, error));
+        eVoteYes, eVoteNoOpinion, frame_idx, error));
 
     new_plan_sp->SetIsControllingPlan(true);
     new_plan_sp->SetOkayToDiscard(false);
 
     // Why do we need to set the current thread by ID here???
     process->GetThreadList().SetSelectedThreadByID(GetID());
     error = process->Resume();
   } else {

lldb/test/API/commands/gui/basicdebug/TestGuiBasicDebug.py

def test_gui(self):
 
         # Start the GUI.
         self.child.sendline("gui")
 
         # Simulate a simple debugging session.
         self.child.send("s") # step
         self.child.expect("return 1; // In function[^\r\n]+<<< Thread 1: step in")
         self.child.send("u") # up
-        self.child.expect_exact("func(); // Break here")
+        self.child.expect_exact("func();    // Break here")
         self.child.send("d") # down
         self.child.expect_exact("return 1; // In function")
         self.child.send("f") # finish
         self.child.expect("<<< Thread 1: step out")
         self.child.send("s") # move onto the second one
         self.child.expect("<<< Thread 1: step in")
         self.child.send("n") # step over
-        self.child.expect("<<< Thread 1: step over")
+        self.child.expect("// Dummy command 1[^\r\n]+<<< Thread 1: step over")
+        self.child.send("n")
+
+        # Test that 'up' + 'step out' steps out of the selected function.
+        self.child.send("s") # move into func_up()
+        self.child.expect("// In func_up")
+        self.child.send("s") # move into func_down()
+        self.child.expect("// In func_down")
+        self.child.send("u") # up
+        self.child.expect("// In func_up")
+        self.child.send("f") # finish
+        self.child.expect("// Dummy command 2[^\r\n]+<<< Thread 1: step out")
+        self.child.send("n")
 
         # Press escape to quit the gui
         self.child.send(escape_key)
 
         self.expect_prompt()
         self.quit()

lldb/test/API/commands/gui/basicdebug/func.c

 int func() {
   return 1; // In function
 }
+
+void func_down() {
+  int dummy = 1; // In func_down
+  (void)dummy;
+}
+
+void func_up() {
+  func_down(); // In func_up
+}

lldb/test/API/commands/gui/basicdebug/main.c

 extern int func();
+extern void func_up();
 
 int main(int argc, char **argv) {
-  func(); // Break here
-  func(); // Second
+  int dummy;
+  func();    // Break here
+  func();    // Second
+  dummy = 1; // Dummy command 1
+
+  func_up(); // First func1 call
+  dummy = 2; // Dummy command 2
+
   return 0;
 }