[lldb/python] Fix (some) dangling pointers in our glue code

[labath]

Summary

This starts to fix the other half of the lifetime problems in this code

• dangling references. SB objects created on the stack will go away

when the function returns, which is a problem if the python code they
were meant for stashes a reference to them somewhere. Most of the time
this goes by unnoticed, as the code rarely has a reason to store these,
but in case it does, we shouldn't respond by crashing.

This patch fixes the management for a couple of SB objects (Debugger,
Frame, Thread). The SB objects are now created on the heap, and
their ownership is immediately passed on to SWIG, which will ensure they
are destroyed when the last python reference goes away. I will handle
the other objects in separate patches.

I include one test which demonstrates the lifetime issue for SBDebugger.
Strictly speaking, one should create a test case for each of these
objects and each of the contexts they are being used. That would require
figuring out how to persist (and later access) each of these objects.
Some of those may involve a lot of hoop-jumping (we can run python code
from within a frame-format string). I don't think that is
necessary/worth it since the new wrapper functions make it very hard to
get this wrong.

[mib]

Thanks for fixing this! LGTM beside a small nit.

lldb/test/API/commands/command/script/TestCommandScript.py

172

persistence.py doesn't seem to have a use_debugger function

[labath]

Thanks. In case anyone's wondering, the reason for that stray command is because I originally wanted to test this via use_debugger command. However, that turned out to not work because the SBDebugger object for the use_debuggers own argument was created at the exact same spot on the stack as the argument to the save_debugger command. Do, the test passed even when it shouldn't have. I have now removed the leftover command.

lldb/bindings/python/python-swigsafecast.swig

 namespace lldb_private {
 namespace python {
 
 PyObject *SBTypeToSWIGWrapper(lldb::SBEvent &event_sb) {
   return SWIG_NewPointerObj(&event_sb, SWIGTYPE_p_lldb__SBEvent, 0);
 }
 
-PyObject *SBTypeToSWIGWrapper(lldb::SBThread &thread_sb) {
-  return SWIG_NewPointerObj(&thread_sb, SWIGTYPE_p_lldb__SBThread, 0);
-}
-
-PyObject *SBTypeToSWIGWrapper(lldb::SBFrame &frame_sb) {
-  return SWIG_NewPointerObj(&frame_sb, SWIGTYPE_p_lldb__SBFrame, 0);
-}
-
-PyObject *SBTypeToSWIGWrapper(lldb::SBDebugger &debugger_sb) {
-  return SWIG_NewPointerObj(&debugger_sb, SWIGTYPE_p_lldb__SBDebugger, 0);
-}
-
 PyObject *SBTypeToSWIGWrapper(lldb::SBWatchpoint &watchpoint_sb) {
   return SWIG_NewPointerObj(&watchpoint_sb, SWIGTYPE_p_lldb__SBWatchpoint, 0);
 }
 
 PyObject *
 SBTypeToSWIGWrapper(lldb::SBBreakpointLocation &breakpoint_location_sb) {
   return SWIG_NewPointerObj(&breakpoint_location_sb,
                             SWIGTYPE_p_lldb__SBBreakpointLocation, 0);

 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb) {
   return ToSWIGHelper(data_sb.release(), SWIGTYPE_p_lldb__SBStructuredData);
 }
 
 PythonObject ToSWIGWrapper(const StructuredDataImpl &data_impl) {
   return ToSWIGWrapper(std::make_unique<lldb::SBStructuredData>(data_impl));
 }
 
+PythonObject ToSWIGWrapper(lldb::ThreadSP thread_sp) {
+  return ToSWIGHelper(new lldb::SBThread(std::move(thread_sp)),
+                      SWIGTYPE_p_lldb__SBThread);
+}
+
+PythonObject ToSWIGWrapper(lldb::StackFrameSP frame_sp) {
+  return ToSWIGHelper(new lldb::SBFrame(std::move(frame_sp)),
+                      SWIGTYPE_p_lldb__SBFrame);
+}
+
+PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp) {
+  return ToSWIGHelper(new lldb::SBDebugger(std::move(debugger_sp)),
+                      SWIGTYPE_p_lldb__SBDebugger);
+}
+
 } // namespace python
 } // namespace lldb_private

lldb/bindings/python/python-wrapper.swig

 
 llvm::Expected<bool> lldb_private::LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &frame_sp,
     const lldb::BreakpointLocationSP &bp_loc_sp,
     const lldb_private::StructuredDataImpl &args_impl) {
   using namespace llvm;
 
-  lldb::SBFrame sb_frame(frame_sp);
   lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
 
   PyErr_Cleaner py_err_cleaner(true);
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   unsigned max_positional_args;
   if (auto arg_info = pfunc.GetArgInfo())
     max_positional_args = arg_info.get().max_positional_args;
   else
     return arg_info.takeError();
 
-  PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
+  PythonObject frame_arg = ToSWIGWrapper(frame_sp);
   PythonObject bp_loc_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_bp_loc));
 
   auto result = [&]() -> Expected<PythonObject> {
     // If the called function doesn't take extra_args, drop them here:
     if (max_positional_args < 4)
       return pfunc.Call(frame_arg, bp_loc_arg, dict);
     return pfunc.Call(frame_arg, bp_loc_arg, ToSWIGWrapper(args_impl), dict);
   }();

 
 // This function is called by
 // lldb_private::ScriptInterpreterPython::WatchpointCallbackFunction(...) and is
 // used when a script command is attached to a watchpoint for execution.
 
 bool lldb_private::LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &frame_sp, const lldb::WatchpointSP &wp_sp) {
-  lldb::SBFrame sb_frame(frame_sp);
   lldb::SBWatchpoint sb_wp(wp_sp);
 
   bool stop_at_watchpoint = true;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return stop_at_watchpoint;
 
-  PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
+  PythonObject frame_arg = ToSWIGWrapper(frame_sp);
   PythonObject wp_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_wp));
   PythonObject result = pfunc(frame_arg, wp_arg, dict);
 
   if (result.get() == Py_False)
     stop_at_watchpoint = false;
 
   return stop_at_watchpoint;
 }
void *lldb_private::LLDBSwigPythonCreateSyntheticProvider(
   if (result.IsAllocated())
     return result.release();
 
   Py_RETURN_NONE;
 }
 
 void *lldb_private::LLDBSwigPythonCreateCommandObject(
     const char *python_class_name, const char *session_dictionary_name,
-    const lldb::DebuggerSP debugger_sp) {
+    lldb::DebuggerSP debugger_sp) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
       !session_dictionary_name)
     Py_RETURN_NONE;
 
   PyErr_Cleaner py_err_cleaner(true);
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_class_name, dict);
 
   if (!pfunc.IsAllocated())
     return nullptr;
 
-  lldb::SBDebugger debugger_sb(debugger_sp);
-  PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
-  PythonObject result = pfunc(debugger_arg, dict);
+  PythonObject result = pfunc(ToSWIGWrapper(std::move(debugger_sp)), dict);
 
   if (result.IsAllocated())
     return result.release();
 
   Py_RETURN_NONE;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedProcess(
void *lldb_private::LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *
   if (valid_cast == -1)
     return NULL;
 
   return sb_ptr;
 }
 
 bool lldb_private::LLDBSwigPythonCallCommand(
     const char *python_function_name, const char *session_dictionary_name,
-    lldb::DebuggerSP &debugger, const char *args,
+    lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
   lldb::SBCommandReturnObject cmd_retobj_sb(cmd_retobj);
-  lldb::SBDebugger debugger_sb(debugger);
   lldb::SBExecutionContext exe_ctx_sb(exe_ctx_ref_sp);
 
   PyErr_Cleaner py_err_cleaner(true);
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
     return false;
 
   auto argc = pfunc.GetArgInfo();
   if (!argc) {
     llvm::consumeError(argc.takeError());
     return false;
   }
-  PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
+  PythonObject debugger_arg = ToSWIGWrapper(std::move(debugger));
   PythonObject exe_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(exe_ctx_sb));
   PythonObject cmd_retobj_arg(PyRefType::Owned,
                               SBTypeToSWIGWrapper(cmd_retobj_sb));
 
   if (argc.get().max_positional_args < 5u)
     pfunc(debugger_arg, PythonString(args), cmd_retobj_arg, dict);
   else
     pfunc(debugger_arg, PythonString(args), exe_ctx_arg, cmd_retobj_arg, dict);
 
   return true;
 }
 
 bool lldb_private::LLDBSwigPythonCallCommandObject(
-    PyObject * implementor, lldb::DebuggerSP & debugger, const char *args,
+    PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
   lldb::SBCommandReturnObject cmd_retobj_sb(cmd_retobj);
-  lldb::SBDebugger debugger_sb(debugger);
   lldb::SBExecutionContext exe_ctx_sb(exe_ctx_ref_sp);
 
   PyErr_Cleaner py_err_cleaner(true);
 
   PythonObject self(PyRefType::Borrowed, implementor);
   auto pfunc = self.ResolveName<PythonCallable>("__call__");
 
   if (!pfunc.IsAllocated())
     return false;
 
-  PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
   PythonObject exe_ctx_arg(PyRefType::Owned, SBTypeToSWIGWrapper(exe_ctx_sb));
   PythonObject cmd_retobj_arg(PyRefType::Owned,
                               SBTypeToSWIGWrapper(cmd_retobj_sb));
 
-  pfunc(debugger_arg, PythonString(args), exe_ctx_arg, cmd_retobj_arg);
+  pfunc(ToSWIGWrapper(std::move(debugger)), PythonString(args), exe_ctx_arg,
+        cmd_retobj_arg);
 
   return true;
 }
 
 void *lldb_private::LLDBSWIGPythonCreateOSPlugin(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::ProcessSP &process_sp) {
   if (python_class_name == NULL || python_class_name[0] == '\0' ||
void *lldb_private::LLDBSWIGPython_CreateFrameRecognizer(
 
   Py_RETURN_NONE;
 }
 
 PyObject *lldb_private::LLDBSwigPython_GetRecognizedArguments(
     PyObject * implementor, const lldb::StackFrameSP &frame_sp) {
   static char callee_name[] = "get_recognized_arguments";
 
-  lldb::SBFrame frame_sb(frame_sp);
-  PyObject *arg = SBTypeToSWIGWrapper(frame_sb);
+  PythonObject arg = ToSWIGWrapper(frame_sp);
 
   PythonString str(callee_name);
   PyObject *result =
       PyObject_CallMethodObjArgs(implementor, str.get(), arg, NULL);
   return result;
 }
 
 void *lldb_private::LLDBSWIGPython_GetDynamicSetting(
bool lldb_private::LLDBSWIGPythonRunScriptKeywordProcess(
 
   auto result = pfunc(ToSWIGWrapper(process), dict);
 
   output = result.Str().GetString().str();
 
   return true;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordThread(
+llvm::Optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordThread(
     const char *python_function_name, const char *session_dictionary_name,
-    lldb::ThreadSP &thread, std::string &output)
-
-{
+    lldb::ThreadSP thread) {
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
-    return false;
+    return llvm::None;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
-    return false;
+    return llvm::None;
 
-  lldb::SBThread thread_sb(thread);
-  PythonObject thread_arg(PyRefType::Owned, SBTypeToSWIGWrapper(thread_sb));
-  auto result = pfunc(thread_arg, dict);
+  auto result = pfunc(ToSWIGWrapper(std::move(thread)), dict);
 
-  output = result.Str().GetString().str();
-
-  return true;
+  return result.Str().GetString().str();
 }
 
 bool lldb_private::LLDBSWIGPythonRunScriptKeywordTarget(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::TargetSP &target, std::string &output) {
 
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
bool lldb_private::LLDBSWIGPythonRunScriptKeywordTarget(
 
   auto result = pfunc(ToSWIGWrapper(target), dict);
 
   output = result.Str().GetString().str();
 
   return true;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordFrame(
+llvm::Optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordFrame(
     const char *python_function_name, const char *session_dictionary_name,
-    lldb::StackFrameSP &frame, std::string &output)
-
-{
+    lldb::StackFrameSP frame) {
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
-    return false;
+    return llvm::None;
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   if (!pfunc.IsAllocated())
-    return false;
+    return llvm::None;
 
-  lldb::SBFrame frame_sb(frame);
-  PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(frame_sb));
-  auto result = pfunc(frame_arg, dict);
+  auto result = pfunc(ToSWIGWrapper(std::move(frame)), dict);
 
-  output = result.Str().GetString().str();
-
-  return true;
+  return result.Str().GetString().str();
 }
 
 bool lldb_private::LLDBSWIGPythonRunScriptKeywordValue(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &value, std::string &output) {
 
   if (python_function_name == NULL || python_function_name[0] == '\0' ||
       !session_dictionary_name)
bool lldb_private::LLDBSWIGPythonRunScriptKeywordValue(
 
   output = result.Str().GetString().str();
 
   return true;
 }
 
 bool lldb_private::LLDBSwigPythonCallModuleInit(
     const char *python_module_name, const char *session_dictionary_name,
-    lldb::DebuggerSP &debugger) {
+    lldb::DebuggerSP debugger) {
   std::string python_function_name_string = python_module_name;
   python_function_name_string += ".__lldb_init_module";
   const char *python_function_name = python_function_name_string.c_str();
 
   PyErr_Cleaner py_err_cleaner(true);
 
   auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
       session_dictionary_name);
   auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
       python_function_name, dict);
 
   // This method is optional and need not exist.  So if we don't find it,
   // it's actually a success, not a failure.
   if (!pfunc.IsAllocated())
     return true;
 
-  lldb::SBDebugger debugger_sb(debugger);
-  PythonObject debugger_arg(PyRefType::Owned, SBTypeToSWIGWrapper(debugger_sb));
-  pfunc(debugger_arg, dict);
+  pfunc(ToSWIGWrapper(std::move(debugger)), dict);
 
   return true;
 }
 
 lldb::ValueObjectSP lldb_private::LLDBSWIGPython_GetValueObjectSPFromSBValue(
     void *data) {
   lldb::ValueObjectSP valobj_sp;
   if (data) {

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

 
 void *
 LLDBSwigPythonCreateSyntheticProvider(const char *python_class_name,
                                       const char *session_dictionary_name,
                                       const lldb::ValueObjectSP &valobj_sp);
 
 void *LLDBSwigPythonCreateCommandObject(const char *python_class_name,
                                         const char *session_dictionary_name,
-                                        const lldb::DebuggerSP debugger_sp);
+                                        lldb::DebuggerSP debugger_sp);
 
 void *LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
     const StructuredDataImpl &args_data, std::string &error_string,
     const lldb::ThreadPlanSP &thread_plan_sp);
 
 bool LLDBSWIGPythonCallThreadPlan(void *implementor, const char *method_name,
                                   lldb_private::Event *event_sp,

 
 bool LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
     PyObject *implementor);
 
 PyObject *LLDBSwigPython_GetValueSynthProviderInstance(PyObject *implementor);
 
 bool LLDBSwigPythonCallCommand(const char *python_function_name,
                                const char *session_dictionary_name,
-                               lldb::DebuggerSP &debugger, const char *args,
+                               lldb::DebuggerSP debugger, const char *args,
                                lldb_private::CommandReturnObject &cmd_retobj,
                                lldb::ExecutionContextRefSP exe_ctx_ref_sp);
 
 bool LLDBSwigPythonCallCommandObject(
-    PyObject *implementor, lldb::DebuggerSP &debugger, const char *args,
+    PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp);
 
 bool LLDBSwigPythonCallModuleInit(const char *python_module_name,
                                   const char *session_dictionary_name,
-                                  lldb::DebuggerSP &debugger);
+                                  lldb::DebuggerSP debugger);
 
 void *LLDBSWIGPythonCreateOSPlugin(const char *python_class_name,
                                    const char *session_dictionary_name,
                                    const lldb::ProcessSP &process_sp);
 
 void *LLDBSWIGPython_CreateFrameRecognizer(const char *python_class_name,
                                            const char *session_dictionary_name);
 
 PyObject *
 LLDBSwigPython_GetRecognizedArguments(PyObject *implementor,
                                       const lldb::StackFrameSP &frame_sp);
 
 bool LLDBSWIGPythonRunScriptKeywordProcess(const char *python_function_name,
                                            const char *session_dictionary_name,
                                            const lldb::ProcessSP &process,
                                            std::string &output);
 
-bool LLDBSWIGPythonRunScriptKeywordThread(const char *python_function_name,
-                                          const char *session_dictionary_name,
-                                          lldb::ThreadSP &thread,
-                                          std::string &output);
+llvm::Optional<std::string>
+LLDBSWIGPythonRunScriptKeywordThread(const char *python_function_name,
+                                     lldb::ThreadSP thread);
 
 bool LLDBSWIGPythonRunScriptKeywordTarget(const char *python_function_name,
                                           const char *session_dictionary_name,
                                           const lldb::TargetSP &target,
                                           std::string &output);
 
-bool LLDBSWIGPythonRunScriptKeywordFrame(const char *python_function_name,
-                                         const char *session_dictionary_name,
-                                         lldb::StackFrameSP &frame,
-                                         std::string &output);
+llvm::Optional<std::string>
+LLDBSWIGPythonRunScriptKeywordFrame(const char *python_function_name,
+                                    lldb::StackFrameSP frame);
 
 bool LLDBSWIGPythonRunScriptKeywordValue(const char *python_function_name,
                                          const char *session_dictionary_name,
                                          const lldb::ValueObjectSP &value,
                                          std::string &output);
 
 void *LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
                                        const lldb::TargetSP &target_sp);
 
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SWIGPYTHONBRIDGE_H

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, Thread *thread, std::string &output,
     Status &error) {
-  bool ret_val;
   if (!thread) {
     error.SetErrorString("no thread");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
-  {
-    ThreadSP thread_sp(thread->shared_from_this());
-    Locker py_lock(this,
-                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSWIGPythonRunScriptKeywordThread(
-        impl_function, m_dictionary_name.c_str(), thread_sp, output);
-    if (!ret_val)
-      error.SetErrorString("python script evaluation failed");
+  if (llvm::Optional<std::string> result = LLDBSWIGPythonRunScriptKeywordThread(
+          impl_function, m_dictionary_name.c_str(),
+          thread->shared_from_this())) {
+    output = std::move(*result);
+    return true;
   }
-  return ret_val;
+  error.SetErrorString("python script evaluation failed");
+  return false;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, Target *target, std::string &output,
     Status &error) {
   bool ret_val;
   if (!target) {
     error.SetErrorString("no thread");
if (!ret_val)
       error.SetErrorString("python script evaluation failed");
   }
   return ret_val;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, StackFrame *frame, std::string &output,
     Status &error) {
-  bool ret_val;
   if (!frame) {
     error.SetErrorString("no frame");
     return false;
   }
   if (!impl_function || !impl_function[0]) {
     error.SetErrorString("no function to execute");
     return false;
   }
 
-  {
-    StackFrameSP frame_sp(frame->shared_from_this());
-    Locker py_lock(this,
-                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-    ret_val = LLDBSWIGPythonRunScriptKeywordFrame(
-        impl_function, m_dictionary_name.c_str(), frame_sp, output);
-    if (!ret_val)
-      error.SetErrorString("python script evaluation failed");
+  if (llvm::Optional<std::string> result = LLDBSWIGPythonRunScriptKeywordFrame(
+          impl_function, m_dictionary_name.c_str(),
+          frame->shared_from_this())) {
+    output = std::move(*result);
+    return true;
   }
-  return ret_val;
+  error.SetErrorString("python script evaluation failed");
+  return false;
 }
 
 bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
     const char *impl_function, ValueObject *value, std::string &output,
     Status &error) {
   bool ret_val;
   if (!value) {
     error.SetErrorString("no value");
llvm::Expected<std::unique_ptr<ScriptInterpreterIORedirect>>
           exc_options.GetEnableIO(), m_debugger, /*result=*/nullptr);
 
   if (!io_redirect_or_error) {
     error = io_redirect_or_error.takeError();
     return false;
   }
 
   ScriptInterpreterIORedirect &io_redirect = **io_redirect_or_error;
-  lldb::DebuggerSP debugger_sp = m_debugger.shared_from_this();
 
   // Before executing Python code, lock the GIL.
   Locker py_lock(this,
                  Locker::AcquireLock |
                      (options.GetInitSession() ? Locker::InitSession : 0) |
                      Locker::NoSTDIN,
                  Locker::FreeAcquiredLock |
                      (options.GetInitSession() ? Locker::TearDownSession : 0),
bool ScriptInterpreterPythonImpl::LoadScriptingModule(
 
   error = ExecuteMultipleLines(command_stream.GetData(), exc_options);
   if (error.Fail())
     return false;
 
   // if we are here, everything worked
   // call __lldb_init_module(debugger,dict)
   if (!LLDBSwigPythonCallModuleInit(module_name.c_str(),
-                                    m_dictionary_name.c_str(), debugger_sp)) {
+                                    m_dictionary_name.c_str(),
+                                    m_debugger.shared_from_this())) {
     error.SetErrorString("calling __lldb_init_module failed");
     return false;
   }
 
   if (module_sp) {
     // everything went just great, now set the module object
     command_stream.Clear();
     command_stream.Printf("%s", module_name.c_str());

lldb/test/API/commands/command/script/TestCommandScript.py

# check that the execution context is passed in to commands that ask for it
                     substrs=['cannot add command'])
 
         # http://llvm.org/bugs/show_bug.cgi?id=11569
         # LLDBSwigPythonCallCommand crashes when a command script returns an
         # object
         self.runCmd('command script add -f bug11569 bug11569')
         # This should not crash.
         self.runCmd('bug11569', check=False)
+
+    def test_persistence(self):
+        self.runCmd("command script import persistence.py")
+        self.runCmd("command script add -f persistence.save_debugger save_debugger")
+        self.expect("save_debugger", substrs=[str(self.dbg)])
+        self.expect("script str(persistence.debugger_copy)", substrs=[str(self.dbg)])

lldb/test/API/commands/command/script/persistence.py

+import lldb
+
+debugger_copy = None
+
+def save_debugger(debugger, command, context, result, internal_dict):
+    global debugger_copy
+    debugger_copy = debugger
+    result.AppendMessage(str(debugger))
+    result.SetStatus(lldb.eReturnStatusSuccessFinishResult)

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 void *lldb_private::LLDBSwigPythonCreateSyntheticProvider(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &valobj_sp) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSwigPythonCreateCommandObject(
     const char *python_class_name, const char *session_dictionary_name,
-    const lldb::DebuggerSP debugger_sp) {
+    lldb::DebuggerSP debugger_sp) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
     const StructuredDataImpl &args_data, std::string &error_string,
     const lldb::ThreadPlanSP &thread_plan_sp) {
   return nullptr;

 
 PyObject *lldb_private::LLDBSwigPython_GetValueSynthProviderInstance(
     PyObject *implementor) {
   return nullptr;
 }
 
 bool lldb_private::LLDBSwigPythonCallCommand(
     const char *python_function_name, const char *session_dictionary_name,
-    lldb::DebuggerSP &debugger, const char *args,
+    lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
   return false;
 }
 
 bool lldb_private::LLDBSwigPythonCallCommandObject(
-    PyObject *implementor, lldb::DebuggerSP &debugger, const char *args,
+    PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
     lldb_private::CommandReturnObject &cmd_retobj,
     lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
   return false;
 }
 
 bool lldb_private::LLDBSwigPythonCallModuleInit(
     const char *python_module_name, const char *session_dictionary_name,
-    lldb::DebuggerSP &debugger) {
+    lldb::DebuggerSP debugger) {
   return false;
 }
 
 void *
 lldb_private::LLDBSWIGPythonCreateOSPlugin(const char *python_class_name,
                                            const char *session_dictionary_name,
                                            const lldb::ProcessSP &process_sp) {
   return nullptr;

 }
 
 bool lldb_private::LLDBSWIGPythonRunScriptKeywordProcess(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ProcessSP &process, std::string &output) {
   return false;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordThread(
+llvm::Optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordThread(
     const char *python_function_name, const char *session_dictionary_name,
-    lldb::ThreadSP &thread, std::string &output) {
-  return false;
+    lldb::ThreadSP thread) {
+  return llvm::None;
 }
 
 bool lldb_private::LLDBSWIGPythonRunScriptKeywordTarget(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::TargetSP &target, std::string &output) {
   return false;
 }
 
-bool lldb_private::LLDBSWIGPythonRunScriptKeywordFrame(
+llvm::Optional<std::string> lldb_private::LLDBSWIGPythonRunScriptKeywordFrame(
     const char *python_function_name, const char *session_dictionary_name,
-    lldb::StackFrameSP &frame, std::string &output) {
-  return false;
+    lldb::StackFrameSP frame) {
+  return llvm::None;
 }
 
 bool lldb_private::LLDBSWIGPythonRunScriptKeywordValue(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::ValueObjectSP &value, std::string &output) {
   return false;
 }