[lldb] Clarify StructuredDataImpl ownership

[labath]

Summary

StructuredDataImpl ownership semantics is unclear at best. Various
structures were holding a non-owning pointer to it, with a comment that
the object is owned somewhere else. From what I was able to gather that
"somewhere else" was the SBStructuredData object, but I am not sure that
all created object eventually made its way there. (It wouldn't matter
even if they did, as we are leaking most of our SBStructuredData
objects.)

Since StructuredDataImpl is just a collection of two (shared) pointers,
there's really no point in elaborate lifetime management, so this patch
replaces all StructuredDataImpl pointers with actual objects or
unique_ptrs to it. This makes it much easier to resolve SBStructuredData
leaks in a follow-up patch.

[labath]

lldb/source/API/SBThreadPlan.cpp

72–74

I haven't been able to figure out how/if this works. As far as I can tell, this object will get destroyed immediately after construction due to lack of any shared_ptrs pointing to it.

[mib]

LGTM with some minor nits.

lldb/bindings/lua/lua-wrapper.swig

14

May be we should keep consistency with the python-wrapper.swig definition ?

lldb/source/API/SBThreadPlan.cpp

72–74

I agree in this case, m_opaque should be either a UP or SP but not a week_ptr.

[labath]

lldb/bindings/lua/lua-wrapper.swig

14

Good point. This actually uncovered that I was now leaking this StructuredDataImpl object.

lldb/bindings/lua/lua-wrapper.swig

 %header %{
 
 template <typename T>
 void
 PushSBClass(lua_State* L, T* obj);
 
 // This function is called from Lua::CallBreakpointCallback
 llvm::Expected<bool>
 lldb_private::LLDBSwigLuaBreakpointCallbackFunction
 (
    lua_State *L,
    lldb::StackFrameSP stop_frame_sp,
    lldb::BreakpointLocationSP bp_loc_sp,
-   StructuredDataImpl *extra_args_impl
+   const StructuredDataImpl &extra_args_impl
 )
 {
    lldb::SBFrame sb_frame(stop_frame_sp);
    lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
    int nargs = 2;
 
-   llvm::Optional<lldb::SBStructuredData> extra_args;
-   if (extra_args_impl)
-      extra_args = lldb::SBStructuredData(extra_args_impl);
+   lldb::SBStructuredData extra_args(extra_args_impl);
 
    // Push the Lua wrappers
    PushSBClass(L, &sb_frame);
    PushSBClass(L, &sb_bp_loc);
 
-   if (extra_args.hasValue()) {
-      PushSBClass(L, extra_args.getPointer());
+   if (extra_args.IsValid()) {
+      PushSBClass(L, &extra_args);
       nargs++;
    }
 
    // Call into the Lua callback passing 'sb_frame' and 'sb_bp_loc'.
    // Expects a boolean return.
    if (lua_pcall(L, nargs, 1, 0) != LUA_OK) {
       llvm::Error E = llvm::make_error<llvm::StringError>(
             llvm::formatv("{0}\n", lua_tostring(L, -1)),

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,
-    lldb_private::StructuredDataImpl *args_impl
+    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);

 }
 
 void*
 lldb_private::LLDBSwigPythonCreateScriptedProcess
 (
     const char *python_class_name,
     const char *session_dictionary_name,
     const lldb::TargetSP& target_sp,
-    lldb_private::StructuredDataImpl *args_impl,
+    const lldb_private::StructuredDataImpl &args_impl,
     std::string &error_string
 )
 {
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
if (!arg_info) {
                 error_string.append(E.message());
             });
         Py_RETURN_NONE;
     }
 
     PythonObject result = {};
     if (arg_info.get().max_positional_args == 2) {
         // FIXME: SBStructuredData leaked here
-        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(*new lldb::SBStructuredData(args_impl)));
+        PythonObject args_arg(
+            PyRefType::Owned,
+            SBTypeToSWIGWrapper(*new lldb::SBStructuredData(args_impl)));
         result = pfunc(target_arg, args_arg);
     } else {
         error_string.assign("wrong number of arguments in __init__, should be 2 (not including self)");
         Py_RETURN_NONE;
     }
 
     if (result.IsAllocated())
         return result.release();
     Py_RETURN_NONE;
 }
 
 void*
 lldb_private::LLDBSwigPythonCreateScriptedThread
 (
     const char *python_class_name,
     const char *session_dictionary_name,
     const lldb::ProcessSP& process_sp,
-    lldb_private::StructuredDataImpl *args_impl,
+    const StructuredDataImpl &args_impl,
     std::string &error_string
 )
 {
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
if (!arg_info) {
                 error_string.append(E.message());
             });
         Py_RETURN_NONE;
     }
 
     PythonObject result = {};
     if (arg_info.get().max_positional_args == 2) {
         // FIXME: SBStructuredData leaked here
-        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(*new lldb::SBStructuredData(args_impl)));
+        PythonObject args_arg(
+            PyRefType::Owned,
+            SBTypeToSWIGWrapper(*new lldb::SBStructuredData(args_impl)));
         result = pfunc(ToSWIGWrapper(process_sp), args_arg);
     } else {
         error_string.assign("wrong number of arguments in __init__, should be 2 (not including self)");
         Py_RETURN_NONE;
     }
 
     if (result.IsAllocated())
         return result.release();
     Py_RETURN_NONE;
 }
 
 void*
 lldb_private::LLDBSwigPythonCreateScriptedThreadPlan
 (
     const char *python_class_name,
     const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_impl,
+    const lldb_private::StructuredDataImpl &args_impl,
     std::string &error_string,
     const lldb::ThreadPlanSP& thread_plan_sp
 )
 {
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
 
if (!arg_info) {
             },
             [&](const llvm::ErrorInfoBase &E) {
                 error_string.append(E.message());
             });
         Py_RETURN_NONE;
     }
 
     PythonObject result = {};
+    // FIXME: SBStructuredData leaked here
+    auto *args_sb = new lldb::SBStructuredData(args_impl);
     if (arg_info.get().max_positional_args == 2) {
-        if (args_impl != nullptr) {
+        if (args_sb->IsValid()) {
            error_string.assign("args passed, but __init__ does not take an args dictionary");
            Py_RETURN_NONE;
         }
         result = pfunc(tp_arg, dict);
     } else if (arg_info.get().max_positional_args >= 3) {
-        // FIXME: SBStructuredData leaked here
-        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(*new lldb::SBStructuredData(args_impl)));
+        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(*args_sb));
         result = pfunc(tp_arg, args_arg, dict);
     } else {
         error_string.assign("wrong number of arguments in __init__, should be 2 or 3 (not including self)");
         Py_RETURN_NONE;
     }
 
     // FIXME: At this point we should check that the class we found supports all the methods
     // that we need.
)
     // Somebody returned the wrong thing...
     got_error = true;
     printf ("Wrong return value type for call to %s.\n", method_name);
     return false;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedBreakpointResolver(
     const char *python_class_name, const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_impl,
+    const StructuredDataImpl &args_impl,
     const lldb::BreakpointSP &breakpoint_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);

 }
 
 void *
 lldb_private::LLDBSwigPythonCreateScriptedStopHook
 (
     lldb::TargetSP target_sp,
     const char *python_class_name,
     const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_impl,
+    const StructuredDataImpl &args_impl,
     Status &error
 )
 {
     if (python_class_name == NULL || python_class_name[0] == '\0') {
         error.SetErrorString("Empty class name.");
         Py_RETURN_NONE;
     }
     if (!session_dictionary_name) {

lldb/include/lldb/API/SBStructuredData.h

 class SBStructuredData {
 public:
   SBStructuredData();
 
   SBStructuredData(const lldb::SBStructuredData &rhs);
 
   SBStructuredData(const lldb::EventSP &event_sp);
 
-  SBStructuredData(lldb_private::StructuredDataImpl *impl);
+  SBStructuredData(const lldb_private::StructuredDataImpl &impl);
 
   ~SBStructuredData();
 
   lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;

lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h

 //===-- BreakpointResolverScripted.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_BREAKPOINT_BREAKPOINTRESOLVERSCRIPTED_H
 #define LLDB_BREAKPOINT_BREAKPOINTRESOLVERSCRIPTED_H
 
-#include "lldb/lldb-forward.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Core/ModuleSpec.h"
-
+#include "lldb/Core/StructuredDataImpl.h"
+#include "lldb/lldb-forward.h"
 
 namespace lldb_private {
 
 /// \class BreakpointResolverScripted BreakpointResolverScripted.h
 /// "lldb/Breakpoint/BreakpointResolverScripted.h" This class sets breakpoints
 /// on a given Address.  This breakpoint only takes once, and then it won't
 /// attempt to reset itself.
 
 class BreakpointResolverScripted : public BreakpointResolver {
 public:
   BreakpointResolverScripted(const lldb::BreakpointSP &bkpt,
                              const llvm::StringRef class_name,
                              lldb::SearchDepth depth,
-                             StructuredDataImpl *args_data);
+                             const StructuredDataImpl &args_data);
 
   ~BreakpointResolverScripted() override = default;
 
   static BreakpointResolver *
   CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 

 protected:
   void NotifyBreakpointSet() override;
 private:
   void CreateImplementationIfNeeded(lldb::BreakpointSP bkpt);
   ScriptInterpreter *GetScriptInterpreter();
   
   std::string m_class_name;
   lldb::SearchDepth m_depth;
-  StructuredDataImpl *m_args_ptr; // We own this, but the implementation
-                                  // has to manage the UP (since that is
-                                  // how it gets stored in the
-                                  // SBStructuredData).
+  StructuredDataImpl m_args;
   StructuredData::GenericSP m_implementation_sp;
 
   BreakpointResolverScripted(const BreakpointResolverScripted &) = delete;
   const BreakpointResolverScripted &
   operator=(const BreakpointResolverScripted &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVERSCRIPTED_H

lldb/include/lldb/Core/StructuredDataImpl.h

 namespace lldb_private {
 
 class StructuredDataImpl {
 public:
   StructuredDataImpl() : m_plugin_wp(), m_data_sp() {}
 
   StructuredDataImpl(const StructuredDataImpl &rhs) = default;
 
+  StructuredDataImpl(StructuredData::ObjectSP obj)
+      : m_data_sp(std::move(obj)) {}
+
   StructuredDataImpl(const lldb::EventSP &event_sp)
       : m_plugin_wp(
             EventDataStructuredData::GetPluginFromEvent(event_sp.get())),
         m_data_sp(EventDataStructuredData::GetObjectFromEvent(event_sp.get())) {
   }
 
   ~StructuredDataImpl() = default;
 

lldb/include/lldb/Interpreter/ScriptInterpreter.h

public:
   virtual StructuredData::DictionarySP
   OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp,
                         lldb::tid_t tid, lldb::addr_t context) {
     return StructuredData::DictionarySP();
   }
 
   virtual StructuredData::ObjectSP
   CreateScriptedThreadPlan(const char *class_name,
-                           StructuredDataImpl *args_data,
+                           const StructuredDataImpl &args_data,
                            std::string &error_str,
                            lldb::ThreadPlanSP thread_plan_sp) {
     return StructuredData::ObjectSP();
   }
 
   virtual bool
   ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
                                  Event *event, bool &script_error) {
public:
   ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp,
                                 bool &script_error) {
     script_error = true;
     return lldb::eStateStepping;
   }
 
   virtual StructuredData::GenericSP
   CreateScriptedBreakpointResolver(const char *class_name,
-                                   StructuredDataImpl *args_data,
+                                   const StructuredDataImpl &args_data,
                                    lldb::BreakpointSP &bkpt_sp) {
     return StructuredData::GenericSP();
   }
 
   virtual bool
   ScriptedBreakpointResolverSearchCallback(StructuredData::GenericSP implementor_sp,
                                            SymbolContext *sym_ctx)
   {
     return false;
   }
 
   virtual lldb::SearchDepth
   ScriptedBreakpointResolverSearchDepth(StructuredData::GenericSP implementor_sp)
   {
     return lldb::eSearchDepthModule;
   }
 
   virtual StructuredData::GenericSP
   CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name,
-                         StructuredDataImpl *args_data, Status &error) {
+                         const StructuredDataImpl &args_data, Status &error) {
     error.SetErrorString("Creating scripted stop-hooks with the current "
                          "script interpreter is not supported.");
     return StructuredData::GenericSP();
   }
 
   // This dispatches to the handle_stop method of the stop-hook class.  It
   // returns a "should_stop" bool.
   virtual bool

lldb/include/lldb/Target/Target.h

 #include <vector>
 
 #include "lldb/Breakpoint/BreakpointList.h"
 #include "lldb/Breakpoint/BreakpointName.h"
 #include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Core/Architecture.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Target/SectionLoadHistory.h"
 #include "lldb/Target/Statistics.h"
public:
 
     void GetSubclassDescription(Stream *s,
                                 lldb::DescriptionLevel level) const override;
 
   private:
     std::string m_class_name;
     /// This holds the dictionary of keys & values that can be used to
     /// parametrize any given callback's behavior.
-    StructuredDataImpl *m_extra_args; // We own this structured data,
-                                      // but the SD itself manages the UP.
+    StructuredDataImpl m_extra_args;
     /// This holds the python callback object.
     StructuredData::GenericSP m_implementation_sp;
 
     /// Use CreateStopHook to make a new empty stop hook. The GetCommandPointer
     /// and fill it with commands, and SetSpecifier to set the specifier shared
     /// pointer (can be null, that will match anything.)
     StopHookScripted(lldb::TargetSP target_sp, lldb::user_id_t uid)
         : StopHook(target_sp, uid) {}

lldb/include/lldb/Target/ThreadPlanPython.h

 //===-- ThreadPlanPython.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_THREADPLANPYTHON_H
 #define LLDB_TARGET_THREADPLANPYTHON_H
 
 #include <string>
 
-#include "lldb/lldb-forward.h"
-
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanTracer.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UserID.h"
+#include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //  ThreadPlanPython:
 //
 
 class ThreadPlanPython : public ThreadPlan {
 public:
-  ThreadPlanPython(Thread &thread, const char *class_name, 
-                   StructuredDataImpl *args_data);
-  ~ThreadPlanPython() override;
+  ThreadPlanPython(Thread &thread, const char *class_name,
+                   const StructuredDataImpl &args_data);
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
   bool ValidatePlan(Stream *error) override;
 
   bool ShouldStop(Event *event_ptr) override;
 
   bool MischiefManaged() override;
protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   lldb::StateType GetPlanRunState() override;
   
   ScriptInterpreter *GetScriptInterpreter();
 
 private:
   std::string m_class_name;
-  StructuredDataImpl *m_args_data; // We own this, but the implementation
-                                   // has to manage the UP (since that is
-                                   // how it gets stored in the
-                                   // SBStructuredData).
+  StructuredDataImpl m_args_data;
   std::string m_error_str;
   StructuredData::ObjectSP m_implementation_sp;
   bool m_did_push;
   bool m_stop_others;
 
   ThreadPlanPython(const ThreadPlanPython &) = delete;
   const ThreadPlanPython &operator=(const ThreadPlanPython &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANPYTHON_H

lldb/source/API/SBStructuredData.cpp

LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
                           rhs);
 }
 
 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
     : m_impl_up(new StructuredDataImpl(event_sp)) {
   LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
 }
 
-SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl)
-    : m_impl_up(impl ? impl : new StructuredDataImpl()) {
+SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
+    : m_impl_up(new StructuredDataImpl(impl)) {
   LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
-                          (lldb_private::StructuredDataImpl *), impl);
+                          (const lldb_private::StructuredDataImpl &), impl);
 }
 
 SBStructuredData::~SBStructuredData() = default;
 
 SBStructuredData &SBStructuredData::
 operator=(const lldb::SBStructuredData &rhs) {
   LLDB_RECORD_METHOD(
       lldb::SBStructuredData &,

 namespace lldb_private {
 namespace repro {
 
 template <> void RegisterMethods<SBStructuredData>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &));
   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
-                            (lldb_private::StructuredDataImpl *));
+                            (const lldb_private::StructuredDataImpl &));
   LLDB_REGISTER_METHOD(
       lldb::SBStructuredData &,
       SBStructuredData, operator=,(const lldb::SBStructuredData &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
                        (lldb::SBStream &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
                        (const char *));
   LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());

lldb/source/API/SBThreadPlan.cpp

 }
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
   LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
                           sb_thread, class_name);
 
   Thread *thread = sb_thread.get();
   if (thread)
-    m_opaque_wp =
-        std::make_shared<ThreadPlanPython>(*thread, class_name, nullptr);
+    m_opaque_wp = std::make_shared<ThreadPlanPython>(*thread, class_name,
+                                                     StructuredDataImpl());
 }
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
                            lldb::SBStructuredData &args_data) {
   LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
                                          SBStructuredData &),
                           sb_thread, class_name, args_data);
 
   Thread *thread = sb_thread.get();
   if (thread)
     m_opaque_wp = std::make_shared<ThreadPlanPython>(*thread, class_name,
-                                                     args_data.m_impl_up.get());
+                                                     *args_data.m_impl_up);
 }
 
 // Assignment operator
 
 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
                      SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
 

lldb/source/Breakpoint/BreakpointResolverScripted.cpp

 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverScripted:
 BreakpointResolverScripted::BreakpointResolverScripted(
     const BreakpointSP &bkpt, const llvm::StringRef class_name,
-    lldb::SearchDepth depth, StructuredDataImpl *args_data)
+    lldb::SearchDepth depth, const StructuredDataImpl &args_data)
     : BreakpointResolver(bkpt, BreakpointResolver::PythonResolver),
-      m_class_name(std::string(class_name)), m_depth(depth),
-      m_args_ptr(args_data) {
+      m_class_name(std::string(class_name)), m_depth(depth), m_args(args_data) {
   CreateImplementationIfNeeded(bkpt);
 }
 
 void BreakpointResolverScripted::CreateImplementationIfNeeded(
     BreakpointSP breakpoint_sp) {
   if (m_implementation_sp)
     return;
 
   if (m_class_name.empty())
     return;
 
   if (!breakpoint_sp)
     return;
 
   TargetSP target_sp = breakpoint_sp->GetTargetSP();
   ScriptInterpreter *script_interp = target_sp->GetDebugger()
                                               .GetScriptInterpreter();
   if (!script_interp)
     return;
 
   m_implementation_sp = script_interp->CreateScriptedBreakpointResolver(
-      m_class_name.c_str(), m_args_ptr, breakpoint_sp);
+      m_class_name.c_str(), m_args, breakpoint_sp);
 }
 
 void BreakpointResolverScripted::NotifyBreakpointSet() {
   CreateImplementationIfNeeded(GetBreakpoint());
 }
 
 BreakpointResolver *
 BreakpointResolverScripted::CreateFromStructuredData(
     const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   llvm::StringRef class_name;
   bool success;
   
   success = options_dict.GetValueForKeyAsString(
       GetKey(OptionNames::PythonClassName), class_name);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find class name entry.");
     return nullptr;
   }
   // The Python function will actually provide the search depth, this is a
   // placeholder.
   lldb::SearchDepth depth = lldb::eSearchDepthTarget;
-  
-  StructuredDataImpl *args_data_impl = new StructuredDataImpl();
+  StructuredDataImpl args_data_impl;
   StructuredData::Dictionary *args_dict = nullptr;
-  success = options_dict.GetValueForKeyAsDictionary(
-    GetKey(OptionNames::ScriptArgs), args_dict);
-  if (success) {
-      args_data_impl->SetObjectSP(args_dict->shared_from_this());
-  }
+  if (options_dict.GetValueForKeyAsDictionary(GetKey(OptionNames::ScriptArgs),
+                                              args_dict))
+    args_data_impl.SetObjectSP(args_dict->shared_from_this());
   return new BreakpointResolverScripted(bkpt, class_name, depth, 
                                         args_data_impl);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverScripted::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());
 
   options_dict_sp->AddStringItem(GetKey(OptionNames::PythonClassName),
                                    m_class_name);
-  if (m_args_ptr->IsValid())
-      options_dict_sp->AddItem(GetKey(OptionNames::ScriptArgs),
-          m_args_ptr->GetObjectSP());
+  if (m_args.IsValid())
+                             m_args.GetObjectSP());
 
   return WrapOptionsDict(options_dict_sp);
 }
 
 ScriptInterpreter *BreakpointResolverScripted::GetScriptInterpreter() {
   return GetBreakpoint()->GetTarget().GetDebugger().GetScriptInterpreter();
 }
 
void BreakpointResolverScripted::GetDescription(Stream *s) {
   else
     s->Printf("python class = %s", m_class_name.c_str());
 }
 
 void BreakpointResolverScripted::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
 BreakpointResolverScripted::CopyForBreakpoint(BreakpointSP &breakpoint) {
-  // FIXME: Have to make a copy of the arguments from the m_args_ptr and then
-  // pass that to the new resolver.
-  lldb::BreakpointResolverSP ret_sp(
-      new BreakpointResolverScripted(breakpoint, m_class_name, m_depth, 
-                                     nullptr));
-  return ret_sp;
+  return std::make_shared<BreakpointResolverScripted>(breakpoint, m_class_name,
+                                                      m_depth, m_args);
 }

lldb/source/Plugins/ScriptInterpreter/Lua/Lua.cpp

 
 llvm::Expected<bool>
 Lua::CallBreakpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp,
                             lldb::BreakpointLocationSP bp_loc_sp,
                             StructuredData::ObjectSP extra_args_sp) {
 
   lua_pushlightuserdata(m_lua_state, baton);
   lua_gettable(m_lua_state, LUA_REGISTRYINDEX);
-  auto *extra_args_impl = [&]() -> StructuredDataImpl * {
-    if (extra_args_sp == nullptr)
-      return nullptr;
-    auto *extra_args_impl = new StructuredDataImpl();
-    extra_args_impl->SetObjectSP(extra_args_sp);
-    return extra_args_impl;
-  }();
+  StructuredDataImpl extra_args_impl(std::move(extra_args_sp));
   return LLDBSwigLuaBreakpointCallbackFunction(m_lua_state, stop_frame_sp,
                                                bp_loc_sp, extra_args_impl);
 }
 
 llvm::Error Lua::RegisterWatchpointCallback(void *baton, const char *body) {
   lua_pushlightuserdata(m_lua_state, baton);
   const char *fmt_str = "return function(frame, wp, ...) {0} end";
   std::string func_str = llvm::formatv(fmt_str, body).str();

lldb/source/Plugins/ScriptInterpreter/Lua/SWIGLuaBridge.h

 #include "lldb/lldb-forward.h"
 #include "lua.hpp"
 #include "llvm/Support/Error.h"
 
 namespace lldb_private {
 
 llvm::Expected<bool> LLDBSwigLuaBreakpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp,
-    lldb::BreakpointLocationSP bp_loc_sp, StructuredDataImpl *extra_args_impl);
+    lldb::BreakpointLocationSP bp_loc_sp,
+    const StructuredDataImpl &extra_args_impl);
 
 llvm::Expected<bool> LLDBSwigLuaWatchpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp);
 
 } // namespace lldb_private
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_LUA_SWIGLUABRIDGE_H

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

 
 // These prototypes are the Pythonic implementations of the required callbacks.
 // Although these are scripting-language specific, their definition depends on
 // the public API.
 
 void *LLDBSwigPythonCreateScriptedProcess(const char *python_class_name,
                                           const char *session_dictionary_name,
                                           const lldb::TargetSP &target_sp,
-                                          StructuredDataImpl *args_impl,
+                                          const StructuredDataImpl &args_impl,
                                           std::string &error_string);
 
 void *LLDBSwigPythonCreateScriptedThread(const char *python_class_name,
                                          const char *session_dictionary_name,
                                          const lldb::ProcessSP &process_sp,
-                                         StructuredDataImpl *args_impl,
+                                         const StructuredDataImpl &args_impl,
                                          std::string &error_string);
 
 llvm::Expected<bool> LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame,
     const lldb::BreakpointLocationSP &sb_bp_loc,
-    lldb_private::StructuredDataImpl *args_impl);
+    const lldb_private::StructuredDataImpl &args_impl);
 
 bool LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp);
 
 bool LLDBSwigPythonCallTypeScript(const char *python_function_name,
                                   const void *session_dictionary,
                                   const lldb::ValueObjectSP &valobj_sp,
                                   void **pyfunct_wrapper,
                                   const lldb::TypeSummaryOptionsSP &options_sp,
                                   std::string &retval);
 
 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);
 
 void *LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_data, std::string &error_string,
+    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 &got_error);
 
 void *LLDBSwigPythonCreateScriptedBreakpointResolver(
     const char *python_class_name, const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args, const lldb::BreakpointSP &bkpt_sp);
+    const StructuredDataImpl &args, const lldb::BreakpointSP &bkpt_sp);
 
 unsigned int
 LLDBSwigPythonCallBreakpointResolver(void *implementor, const char *method_name,
                                      lldb_private::SymbolContext *sym_ctx);
 
-void *LLDBSwigPythonCreateScriptedStopHook(
-    lldb::TargetSP target_sp, const char *python_class_name,
-    const char *session_dictionary_name, lldb_private::StructuredDataImpl *args,
+void *LLDBSwigPythonCreateScriptedStopHook(lldb::TargetSP target_sp,
+                                           const char *python_class_name,
+                                           const char *session_dictionary_name,
+                                           const StructuredDataImpl &args,
                                            lldb_private::Status &error);
 
 bool LLDBSwigPythonStopHookCallHandleStop(void *implementor,
                                           lldb::ExecutionContextRefSP exc_ctx,
                                           lldb::StreamSP stream);
 
 size_t LLDBSwigPython_CalculateNumChildren(PyObject *implementor, uint32_t max);
 
 PyObject *LLDBSwigPython_GetChildAtIndex(PyObject *implementor, uint32_t idx);

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

 class ScriptInterpreterPython : public ScriptInterpreter,
                                 public IOHandlerDelegateMultiline {
 public:
   class CommandDataPython : public BreakpointOptions::CommandData {
   public:
     CommandDataPython() : BreakpointOptions::CommandData() {
       interpreter = lldb::eScriptLanguagePython;
     }
-    CommandDataPython(StructuredData::ObjectSP extra_args_sp) :
-        BreakpointOptions::CommandData(),
-        m_extra_args_up(new StructuredDataImpl()) {
-        interpreter = lldb::eScriptLanguagePython;
-        m_extra_args_up->SetObjectSP(extra_args_sp);
+    CommandDataPython(StructuredData::ObjectSP extra_args_sp)
+        : BreakpointOptions::CommandData(),
+          m_extra_args(std::move(extra_args_sp)) {
     }
-    lldb::StructuredDataImplUP m_extra_args_up;
+    StructuredDataImpl m_extra_args;
   };
 
   ScriptInterpreterPython(Debugger &debugger)
       : ScriptInterpreter(debugger, lldb::eScriptLanguagePython),
         IOHandlerDelegateMultiline("DONE") {}
 
   StructuredData::DictionarySP GetInterpreterInfo() override;
   static void Initialize();

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

StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_CreateThread(
   if (py_return.get()) {
     PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
     return result_dict.CreateStructuredDictionary();
   }
   return StructuredData::DictionarySP();
 }
 
 StructuredData::ObjectSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
-    const char *class_name, StructuredDataImpl *args_data,
+    const char *class_name, const StructuredDataImpl &args_data,
     std::string &error_str, lldb::ThreadPlanSP thread_plan_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();
 
   if (!thread_plan_sp.get())
     return {};
 
   Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
lldb::StateType ScriptInterpreterPythonImpl::ScriptedThreadPlanGetRunState(
   }
   if (should_step)
     return lldb::eStateStepping;
   return lldb::eStateRunning;
 }
 
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::CreateScriptedBreakpointResolver(
-    const char *class_name, StructuredDataImpl *args_data,
+    const char *class_name, const StructuredDataImpl &args_data,
     lldb::BreakpointSP &bkpt_sp) {
 
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!bkpt_sp.get())
     return StructuredData::GenericSP();
 
if (depth_as_int == lldb::eSearchDepthInvalid)
     return lldb::eSearchDepthModule;
 
   if (depth_as_int <= lldb::kLastSearchDepthKind)
     return (lldb::SearchDepth)depth_as_int;
   return lldb::eSearchDepthModule;
 }
 
 StructuredData::GenericSP ScriptInterpreterPythonImpl::CreateScriptedStopHook(
-    TargetSP target_sp, const char *class_name, StructuredDataImpl *args_data,
-    Status &error) {
+    TargetSP target_sp, const char *class_name,
+    const StructuredDataImpl &args_data, Status &error) {
 
   if (!target_sp) {
     error.SetErrorString("No target for scripted stop-hook.");
     return StructuredData::GenericSP();
   }
 
   if (class_name == nullptr || class_name[0] == '\0') {
     error.SetErrorString("No class name for scripted stop-hook.");
if (breakpoint_sp) {
         {
           Locker py_lock(python_interpreter, Locker::AcquireLock |
                                                  Locker::InitSession |
                                                  Locker::NoSTDIN);
           Expected<bool> maybe_ret_val =
               LLDBSwigPythonBreakpointCallbackFunction(
                   python_function_name,
                   python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
-                  bp_loc_sp, bp_option_data->m_extra_args_up.get());
+                  bp_loc_sp, bp_option_data->m_extra_args);
 
           if (!maybe_ret_val) {
 
             llvm::handleAllErrors(
                 maybe_ret_val.takeError(),
                 [&](PythonException &E) {
                   debugger.GetErrorStream() << E.ReadBacktrace();
                 },

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

public:
   CreateSyntheticScriptedProvider(const char *class_name,
                                   lldb::ValueObjectSP valobj) override;
 
   StructuredData::GenericSP
   CreateScriptCommandObject(const char *class_name) override;
 
   StructuredData::ObjectSP
   CreateScriptedThreadPlan(const char *class_name,
-                           StructuredDataImpl *args_data,
+                           const StructuredDataImpl &args_data,
                            std::string &error_str,
                            lldb::ThreadPlanSP thread_plan) override;
 
   bool ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
                                       Event *event,
                                       bool &script_error) override;
 
   bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp,
                                     Event *event, bool &script_error) override;
 
   bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp,
                                  bool &script_error) override;
 
   lldb::StateType
   ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp,
                                 bool &script_error) override;
 
   StructuredData::GenericSP
   CreateScriptedBreakpointResolver(const char *class_name,
-                                   StructuredDataImpl *args_data,
+                                   const StructuredDataImpl &args_data,
                                    lldb::BreakpointSP &bkpt_sp) override;
   bool ScriptedBreakpointResolverSearchCallback(
       StructuredData::GenericSP implementor_sp,
       SymbolContext *sym_ctx) override;
 
   lldb::SearchDepth ScriptedBreakpointResolverSearchDepth(
       StructuredData::GenericSP implementor_sp) override;
 
   StructuredData::GenericSP
   CreateScriptedStopHook(lldb::TargetSP target_sp, const char *class_name,
-                         StructuredDataImpl *args_data, Status &error) override;
+                         const StructuredDataImpl &args_data,
+                         Status &error) override;
 
   bool ScriptedStopHookHandleStop(StructuredData::GenericSP implementor_sp,
                                   ExecutionContext &exc_ctx,
                                   lldb::StreamSP stream_sp) override;
 
   StructuredData::GenericSP
   CreateFrameRecognizer(const char *class_name) override;
 

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

 
 StructuredData::GenericSP ScriptedProcessPythonInterface::CreatePluginObject(
     llvm::StringRef class_name, ExecutionContext &exe_ctx,
     StructuredData::DictionarySP args_sp) {
   if (class_name.empty())
     return {};
 
   TargetSP target_sp = exe_ctx.GetTargetSP();
-  StructuredDataImpl *args_impl = nullptr;
-  if (args_sp) {
-    args_impl = new StructuredDataImpl();
-    args_impl->SetObjectSP(args_sp);
-  }
+  StructuredDataImpl args_impl(args_sp);
   std::string error_string;
 
   Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
                  Locker::FreeLock);
 
   void *ret_val = LLDBSwigPythonCreateScriptedProcess(
       class_name.str().c_str(), m_interpreter.GetDictionaryName(), target_sp,
       args_impl, error_string);

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

 StructuredData::GenericSP ScriptedThreadPythonInterface::CreatePluginObject(
     const llvm::StringRef class_name, ExecutionContext &exe_ctx,
     StructuredData::DictionarySP args_sp) {
 
   if (class_name.empty())
     return {};
 
   ProcessSP process_sp = exe_ctx.GetProcessSP();
-  StructuredDataImpl *args_impl = nullptr;
-  if (args_sp) {
-    args_impl = new StructuredDataImpl();
-    args_impl->SetObjectSP(args_sp);
-  }
+  StructuredDataImpl args_impl(args_sp);
   std::string error_string;
 
   Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
                  Locker::FreeLock);
 
   void *ret_val = LLDBSwigPythonCreateScriptedThread(
       class_name.str().c_str(), m_interpreter.GetDictionaryName(), process_sp,
       args_impl, error_string);

lldb/source/Target/Target.cpp

filter_sp =
         GetSearchFilterForModuleAndCUList(nullptr, containingSourceFiles);
   } else if (has_modules) {
     filter_sp = GetSearchFilterForModuleList(containingModules);
   } else {
     filter_sp = std::make_shared<SearchFilterForUnconstrainedSearches>(
         shared_from_this());
   }
 
-  StructuredDataImpl *extra_args_impl = new StructuredDataImpl();
-  if (extra_args_sp)
-    extra_args_impl->SetObjectSP(extra_args_sp);
-
   BreakpointResolverSP resolver_sp(new BreakpointResolverScripted(
-      nullptr, class_name, depth, extra_args_impl));
+      nullptr, class_name, depth, StructuredDataImpl(extra_args_sp)));
   return CreateBreakpoint(filter_sp, resolver_sp, internal, false, true);
 }
 
 BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp,
                                       BreakpointResolverSP &resolver_sp,
                                       bool internal, bool request_hardware,
                                       bool resolve_indirect_symbols) {
   BreakpointSP bp_sp;
Status Target::StopHookScripted::SetScriptCallback(
   ScriptInterpreter *script_interp =
       GetTarget()->GetDebugger().GetScriptInterpreter();
   if (!script_interp) {
     error.SetErrorString("No script interpreter installed.");
     return error;
   }
 
   m_class_name = class_name;
-
-  m_extra_args = new StructuredDataImpl();
-
-  if (extra_args_sp)
-    m_extra_args->SetObjectSP(extra_args_sp);
+  m_extra_args.SetObjectSP(extra_args_sp);
 
   m_implementation_sp = script_interp->CreateScriptedStopHook(
       GetTarget(), m_class_name.c_str(), m_extra_args, error);
 
   return error;
 }
 
 Target::StopHook::StopHookResult
if (level == eDescriptionLevelBrief) {
     return;
   }
   s->Indent("Class:");
   s->Printf("%s\n", m_class_name.c_str());
 
   // Now print the extra args:
   // FIXME: We should use StructuredData.GetDescription on the m_extra_args
   // but that seems to rely on some printing plugin that doesn't exist.
-  if (!m_extra_args->IsValid())
+  if (!m_extra_args.IsValid())
     return;
-  StructuredData::ObjectSP object_sp = m_extra_args->GetObjectSP();
+  StructuredData::ObjectSP object_sp = m_extra_args.GetObjectSP();
   if (!object_sp || !object_sp->IsValid())
     return;
 
   StructuredData::Dictionary *as_dict = object_sp->GetAsDictionary();
   if (!as_dict || !as_dict->IsValid())
     return;
 
   uint32_t num_keys = as_dict->GetSize();

lldb/source/Target/Thread.cpp

ThreadPlanSP Thread::QueueThreadPlanForStepUntil(
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 lldb::ThreadPlanSP Thread::QueueThreadPlanForStepScripted(
     bool abort_other_plans, const char *class_name, 
     StructuredData::ObjectSP extra_args_sp,  bool stop_other_threads,
     Status &status) {
-    
-  StructuredDataImpl *extra_args_impl = nullptr; 
-  if (extra_args_sp) {
-    extra_args_impl = new StructuredDataImpl();
-    extra_args_impl->SetObjectSP(extra_args_sp);
-  }
-
-  ThreadPlanSP thread_plan_sp(new ThreadPlanPython(*this, class_name, 
-                                                   extra_args_impl));
+  ThreadPlanSP thread_plan_sp(new ThreadPlanPython(
+      *this, class_name, StructuredDataImpl(extra_args_sp)));
   thread_plan_sp->SetStopOthers(stop_other_threads);
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 uint32_t Thread::GetIndexID() const { return m_index_id; }
 
 TargetSP Thread::CalculateTarget() {

lldb/source/Target/ThreadPlanPython.cpp

 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlanPython
 
 ThreadPlanPython::ThreadPlanPython(Thread &thread, const char *class_name,
-                                   StructuredDataImpl *args_data)
+                                   const StructuredDataImpl &args_data)
     : ThreadPlan(ThreadPlan::eKindPython, "Python based Thread Plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_class_name(class_name), m_args_data(args_data), m_did_push(false),
       m_stop_others(false) {
   SetIsControllingPlan(true);
   SetOkayToDiscard(true);
   SetPrivate(false);
 }
 
-ThreadPlanPython::~ThreadPlanPython() {
-  // FIXME, do I need to decrement the ref count on this implementation object
-  // to make it go away?
-}
-
 bool ThreadPlanPython::ValidatePlan(Stream *error) {
   if (!m_did_push)
     return true;
 
   if (!m_implementation_sp) {
     if (error)
       error->Printf("Error constructing Python ThreadPlan: %s",
           m_error_str.empty() ? "<unknown error>"

lldb/unittests/ScriptInterpreter/Lua/LuaTests.cpp

 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 extern "C" int luaopen_lldb(lua_State *L) { return 0; }
 
 llvm::Expected<bool> lldb_private::LLDBSwigLuaBreakpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp,
-    lldb::BreakpointLocationSP bp_loc_sp, StructuredDataImpl *extra_args_impl) {
+    lldb::BreakpointLocationSP bp_loc_sp,
+    const StructuredDataImpl &extra_args_impl) {
   return false;
 }
 
 llvm::Expected<bool> lldb_private::LLDBSwigLuaWatchpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp) {
   return false;
 }
 

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 #else
 extern "C" void init_lldb(void) {}
 #endif
 
 llvm::Expected<bool> lldb_private::LLDBSwigPythonBreakpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame,
     const lldb::BreakpointLocationSP &sb_bp_loc,
-    StructuredDataImpl *args_impl) {
+    const StructuredDataImpl &args_impl) {
   return false;
 }
 
 bool lldb_private::LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp) {
   return false;
 }

 void *lldb_private::LLDBSwigPythonCreateCommandObject(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::DebuggerSP debugger_sp) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
-    StructuredDataImpl *args_data, std::string &error_string,
+    const StructuredDataImpl &args_data, std::string &error_string,
     const lldb::ThreadPlanSP &thread_plan_sp) {
   return nullptr;
 }
 
 bool lldb_private::LLDBSWIGPythonCallThreadPlan(void *implementor,
                                                 const char *method_name,
                                                 Event *event_sp,
                                                 bool &got_error) {
   return false;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedBreakpointResolver(
     const char *python_class_name, const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args, const lldb::BreakpointSP &bkpt_sp) {
+    const StructuredDataImpl &args, const lldb::BreakpointSP &bkpt_sp) {
   return nullptr;
 }
 
 unsigned int lldb_private::LLDBSwigPythonCallBreakpointResolver(
     void *implementor, const char *method_name,
     lldb_private::SymbolContext *sym_ctx) {
   return 0;
 }

 lldb_private::LLDBSWIGPythonCreateOSPlugin(const char *python_class_name,
                                            const char *session_dictionary_name,
                                            const lldb::ProcessSP &process_sp) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedProcess(
     const char *python_class_name, const char *session_dictionary_name,
-    const lldb::TargetSP &target_sp, StructuredDataImpl *args_impl,
+    const lldb::TargetSP &target_sp, const StructuredDataImpl &args_impl,
     std::string &error_string) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedThread(
     const char *python_class_name, const char *session_dictionary_name,
-    const lldb::ProcessSP &process_sp, StructuredDataImpl *args_impl,
+    const lldb::ProcessSP &process_sp, const StructuredDataImpl &args_impl,
     std::string &error_string) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSWIGPython_CreateFrameRecognizer(
     const char *python_class_name, const char *session_dictionary_name) {
   return nullptr;
 }

 
 void *lldb_private::LLDBSWIGPython_GetDynamicSetting(
     void *module, const char *setting, const lldb::TargetSP &target_sp) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSwigPythonCreateScriptedStopHook(
     lldb::TargetSP target_sp, const char *python_class_name,
-    const char *session_dictionary_name,
-    lldb_private::StructuredDataImpl *args_impl, Status &error) {
+    const char *session_dictionary_name, const StructuredDataImpl &args_impl,
+    Status &error) {
   return nullptr;
 }
 
 bool lldb_private::LLDBSwigPythonStopHookCallHandleStop(
     void *implementor, lldb::ExecutionContextRefSP exc_ctx_sp,
     lldb::StreamSP stream) {
   return false;
 }