[lldb] Lower GetRealStopInfo into ThreadPlanCallFunction (NFC)

[kastiglione]

Summary

GetRealStopInfo has only one call site, and in that call site a reference to the
concrete thread plan is available (ThreadPlanCallUserExpression), from which
GetRealStopInfo can be called.

[jingham]

It does seem odd to peek behind the back of a thread plan to figure out how to proceed, so making this special to the UserExpression thread plans, which are special in a bunch of ways, isn't a bad idea.

lldb/include/lldb/Target/ThreadPlan.h

void SetThreadPlanTracer(lldb::ThreadPlanTracerSP new_tracer_sp) {
     m_tracer_sp = new_tracer_sp;
   }
 
   void DoTraceLog() {
     if (m_tracer_sp && m_tracer_sp->TracingEnabled())
       m_tracer_sp->Log();
   }
 
-  // Some thread plans hide away the actual stop info which caused any
-  // particular stop.  For instance the ThreadPlanCallFunction restores the
-  // original stop reason so that stopping and calling a few functions won't
-  // lose the history of the run. This call can be implemented to get you back
-  // to the real stop info.
-  virtual lldb::StopInfoSP GetRealStopInfo() { 
-    return GetThread().GetStopInfo();
-  }
-
   // If the completion of the thread plan stepped out of a function, the return
   // value of the function might have been captured by the thread plan
   // (currently only ThreadPlanStepOut does this.) If so, the ReturnValueObject
   // can be retrieved from here.
 
   virtual lldb::ValueObjectSP GetReturnValueObject() {
     return lldb::ValueObjectSP();
   }

lldb/include/lldb/Target/ThreadPlanCallFunction.h

 //===-- ThreadPlanCallFunction.h --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_THREADPLANCALLFUNCTION_H
 #define LLDB_TARGET_THREADPLANCALLFUNCTION_H
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace lldb_private {
 
 class ThreadPlanCallFunction : public ThreadPlan {
public:
   // If the thread plan stops mid-course, this will be the stop reason that
   // interrupted us. Once DoTakedown is called, this will be the real stop
   // reason at the end of the function call. If it hasn't been set for one or
   // the other of these reasons, we'll return the PrivateStopReason. This is
   // needed because we want the CallFunction thread plans not to show up as the
   // stop reason. But if something bad goes wrong, it is nice to be able to
   // tell the user what really happened.
 
-  lldb::StopInfoSP GetRealStopInfo() override {
+  virtual lldb::StopInfoSP GetRealStopInfo() {
     if (m_real_stop_info_sp)
       return m_real_stop_info_sp;
     else
       return GetPrivateStopInfo();
   }
 
   lldb::addr_t GetStopAddress() { return m_stop_address; }
 

lldb/source/Expression/LLVMUserExpression.cpp

 //===-- LLVMUserExpression.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "lldb/Expression/LLVMUserExpression.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Expression/Materializer.h"
if (m_can_interpret) {
 
     LLDB_LOGF(log, "-- [UserExpression::Execute] Execution of expression "
                    "completed --");
 
     if (execution_result == lldb::eExpressionInterrupted ||
         execution_result == lldb::eExpressionHitBreakpoint) {
       const char *error_desc = nullptr;
 
-      if (call_plan_sp) {
-        lldb::StopInfoSP real_stop_info_sp = call_plan_sp->GetRealStopInfo();
-        if (real_stop_info_sp)
+      if (user_expression_plan) {
+        if (auto real_stop_info_sp = user_expression_plan->GetRealStopInfo())
           error_desc = real_stop_info_sp->GetDescription();
       }
       if (error_desc)
         diagnostic_manager.Printf(eDiagnosticSeverityError,
                                   "Execution was interrupted, reason: %s.",
                                   error_desc);
       else
         diagnostic_manager.PutString(eDiagnosticSeverityError,