[lldb] Convert script native types to StructuredData counterpart

[mib]

Summary

This patch adds the ability to pass native types from the script
interpreter to methods that use a {SB,}StructuredData argument.

To do so, this patch changes the ScriptedObject struture that holds
the pointer to the script object as well as the originating script
interpreter language. It also exposes that to the SB API via a new class
called SBScriptObject.

This structure allows the debugger to parse the script object and
convert it to a StructuredData object. If the type is not compatible
with the StructuredData types, we will store its pointer in a
StructuredData::Generic object.

This patch also adds some SWIG typemaps that checks the input argument to
ensure it's either an SBStructuredData object, in which case it just
passes it throught, or a python object that is NOT another SB type, to
provide some guardrails for the user.

rdar://111467140

Signed-off-by: Med Ismail Bennani <[e-mail]>

[bulbazord]

Very interesting, I think this will be pretty useful for the ergonomics of the SBAPI from python!

lldb/bindings/python/python-typemaps.swig

74–75

Two things about this part:

1. llvm::toString(Error) returns a std::string, so taking a StringRef to this thing is not safe. It's pointing to a temporary, the moment you get to line 75 err_msg will be pointing to unmanaged memory.
2. PyErr_SetString takes a const char * as its second parameter. In general, it is not safe to pass a StringRef's data field in these scenarios because you can't always guarantee that it points to a null-terminated string. If the StringRef is constructed from a std::string it's usually okay, but it's difficult to reason about these kinds of things when you come across them.

81–82

Same as above here.

91–92

Same here

98–99

Same here

104–105

This may be as simple as:

std::string error_msg = "Input type is invalid: " + type_name.get();
PyErr_SetString(PyExc_TypeError, error_msg.c_str());

Right?

108

Do we actually have to do any conversions here? Like to turn it into an SBStructuredData from a python list or dictionary?

lldb/include/lldb/API/SBStructuredData.h

38–40

Why do we offer both this and SBDebugger::CreateStructuredDataFromScriptObject? They do the exact same thing, when would you want to use one over the other?

lldb/source/API/SBDebugger.cpp

1709–1710 ↗

(On Diff #539891)

Can you document what true is supposed to represent here?

lldb/source/API/SBStructuredData.cpp

74–76

I already asked why this is necessary, but if it does stick around you'll want to add LLDB_INSTRUMENT_VA here too yeah?

[mib]

lldb/bindings/python/python-typemaps.swig

108

No, if the input is a lldb.SBStructuredData python object, SWIG takes care of doing the conversion to the C++ type (line 87), but here we just made sure that the input is not an SB type and leave the type conversion to be done in lldb by the Script Interpreter code.

lldb/include/lldb/API/SBStructuredData.h

38–40

This actually calls the SBDebugger method, but I tried to put myself in the user's shoes and I think I'd go look at the SBStructuredData help if I wanted to create a one from a script object. This one is for better discoverability and the other one (SBDebugger) is for better ergonomics (since we don't have to pass a debugger).

lldb/source/API/SBStructuredData.cpp

74–76

This is a static method and I don't think we call LLDB_INSTRUMENT_VA in that case. Might be wrong though @JDevlieghere ?

[JDevlieghere]

lldb/source/API/SBStructuredData.cpp

74–76

We do, see SBDebugger::Create for example. we just don't pass this.

[mib]

Address @bulbazord comments.

[bulbazord]

I'm good with this approach. One thing to note is that this change is explicitly ABI breaking. Specifically this change removes lldb::ScriptedObject so SBProcess::GetScriptedImplementation's return value changes. lldb::ScriptedObject was originally added in February 2023 (see: c1928033047409f977b26ffc938d59188f1ced97) so this has not made it into an LLDB release so far. Even though this does break ABI, from a release perspective this should be okay to do since it's technically additive when compared to the previous release.

I'll defer to @JDevlieghere for approval.

lldb/bindings/python/python-typemaps.swig

144–152

[mib]

In D155161#4516564, @bulbazord wrote:

I'm good with this approach. One thing to note is that this change is explicitly ABI breaking. Specifically this change removes lldb::ScriptedObject so SBProcess::GetScriptedImplementation's return value changes. lldb::ScriptedObject was originally added in February 2023 (see: c1928033047409f977b26ffc938d59188f1ced97) so this has not made it into an LLDB release so far. Even though this does break ABI, from a release perspective this should be okay to do since it's technically additive when compared to the previous release.

That is true, this change is ABI breaking, but as you mentioned it, this hasn't been distributed to other client and should only be used by us. Also, I've changed the typemap so that this change is transparent to people who were using this API from python (you might have notices that I didn't have to change the test for GetScriptedImplementation).

[JDevlieghere]

I'm okay with the ABI break given that this (1) hasn't made it into a release yet, (2) it is under active development by Ismail himself and (3) has existing adopters beyond the ones motivating the original and current change.

However, now that it's more than a typedef, we should rename ScriptObject to SBScriptObject, move it to its own file and hide its implementation with PIMPL. There is no precedent for having small structs in lldb-types and I don't see why we would want lock ourselves into the current implementation. If anything this patch itself serves as an example that we want the ability to change this class without breaking the ABI (again).

[mib]

Address @JDevlieghere & @bulbazord comments:

• Add SBScriptObject with PIMPL

[JDevlieghere]

lldb/include/lldb/API/SBScriptObject.h

48

Does this need to be a shared pointer as opposed to a unique pointer? If so please add a comment why.

lldb/include/lldb/Utility/ScriptObject.h

9 ↗

(On Diff #543101)

Not sure if this really belongs in Utility. What about putting it under Plugins/ScriptInterpreter/ or Interpreter/ next to ScriptInterpreter.h. The header guard seems to suggest that it was there at some point?

lldb/source/API/SBScriptObject.cpp

47

Missing newline.

[mib]

Address @JDevlieghere last comments.

• Use unique_ptr instead of shared_ptr for PIMPL
• Add missing new line after instrumentation macros
• Move ScriptObject from Utility to Interpreter

[JDevlieghere]

Thanks for bearing with me. LGTM.

lldb/bindings/headers.swig

 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBProcessInfo.h"
 #include "lldb/API/SBQueue.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBReproducer.h"
+#include "lldb/API/SBScriptObject.h"
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBSymbol.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/API/SBSymbolContextList.h"

lldb/bindings/interface/SBScriptObjectExtensions.i

+%extend lldb::SBScriptObject {
+#ifdef SWIGPYTHON
+    %pythoncode %{
+        ptr = property(GetPointer, None, doc='''A read only property that returns the underlying script object.''')
+        lang = property(GetLanguage, None, doc='''A read only property that returns the script language associated with with this script object.''')
+    %}
+#endif
+}

lldb/bindings/interfaces.swig

 %include "lldb/API/SBModule.h"
 %include "lldb/API/SBModuleSpec.h"
 %include "lldb/API/SBPlatform.h"
 %include "lldb/API/SBProcess.h"
 %include "lldb/API/SBProcessInfo.h"
 %include "lldb/API/SBQueue.h"
 %include "lldb/API/SBQueueItem.h"
 %include "lldb/API/SBReproducer.h"
+%include "lldb/API/SBScriptObject.h"
 %include "lldb/API/SBSection.h"
 %include "lldb/API/SBSourceManager.h"
 %include "lldb/API/SBStream.h"
 %include "lldb/API/SBStringList.h"
 %include "lldb/API/SBStructuredData.h"
 %include "lldb/API/SBSymbol.h"
 %include "lldb/API/SBSymbolContext.h"
 %include "lldb/API/SBSymbolContextList.h"

 %include "./interface/SBFunctionExtensions.i"
 %include "./interface/SBInstructionExtensions.i"
 %include "./interface/SBInstructionListExtensions.i"
 %include "./interface/SBLineEntryExtensions.i"
 %include "./interface/SBMemoryRegionInfoExtensions.i"
 %include "./interface/SBModuleExtensions.i"
 %include "./interface/SBModuleSpecExtensions.i"
 %include "./interface/SBProcessExtensions.i"
+%include "./interface/SBScriptObjectExtensions.i"
 %include "./interface/SBSectionExtensions.i"
 %include "./interface/SBStreamExtensions.i"
 %include "./interface/SBStringListExtensions.i"
 %include "./interface/SBSymbolExtensions.i"
 %include "./interface/SBSymbolContextExtensions.i"
 %include "./interface/SBSymbolContextListExtensions.i"
 %include "./interface/SBTargetExtensions.i"
 %include "./interface/SBThreadExtensions.i"

lldb/bindings/python/python-typemaps.swig

if (PythonList::Check($input)) {
     $1 = (($input == Py_None) ? 1 : 0);
   }
 }
 
 %typemap(freearg) char** {
   free((char *) $1);
 }
 
-%typemap(out) lldb::ScriptedObject {
+%typecheck(SWIG_TYPECHECK_POINTER) lldb::ScriptObjectPtr {
+  PythonObject obj(PyRefType::Borrowed, $input);
+  if (!obj.IsValid()) {
+    PyErr_Clear();
+    $1 = 0;
+  } else {
+    $1 = 1;
+  }
+}
+
+%typemap(in) lldb::ScriptObjectPtr {
+  if ($input == Py_None) {
+    $1 = nullptr;
+  } else {
+    PythonObject obj(PyRefType::Borrowed, $input);
+    if (!obj.IsValid()) {
+      PyErr_SetString(PyExc_TypeError, "Script object is not valid");
+      SWIG_fail;
+    }
+
+    auto lldb_module = PythonModule::Import("lldb");
+    if (!lldb_module) {
+      std::string err_msg = llvm::toString(lldb_module.takeError());
+      PyErr_SetString(PyExc_TypeError, err_msg.c_str());
+      SWIG_fail;
+    }
+
+    auto sb_structured_data_class = lldb_module.get().Get("SBStructuredData");
+    if (!sb_structured_data_class) {
+      std::string err_msg = llvm::toString(sb_structured_data_class.takeError());
+      PyErr_SetString(PyExc_TypeError, err_msg.c_str());
+      SWIG_fail;
+    }
+
+    if (obj.IsInstance(sb_structured_data_class.get())) {
+      $1 = obj.get();
+    } else {
+      auto type = obj.GetType();
+      if (!type) {
+        std::string err_msg = llvm::toString(type.takeError());
+        PyErr_SetString(PyExc_TypeError, err_msg.c_str());
+        SWIG_fail;
+      }
+
+      auto type_name = As<std::string>(type.get().GetAttribute("__name__"));
+      if (!type_name) {
+        std::string err_msg = llvm::toString(type_name.takeError());
+        PyErr_SetString(PyExc_TypeError, err_msg.c_str());
+        SWIG_fail;
+      }
+
+      if (llvm::StringRef(type_name.get()).startswith("SB")) {
+        std::string error_msg = "Input type is invalid: " + type_name.get();
+        PyErr_SetString(PyExc_TypeError, error_msg.c_str());
+        SWIG_fail;
+      } else {
+        $1 = obj.get();
+      }
+    }
+  }
+}
+
+%typemap(out) lldb::ScriptObjectPtr {
+  $result = (PyObject*) $1;
+  if (!$result)
+    $result = Py_None;
+  Py_INCREF($result);
+}
+
+%typemap(out) lldb::SBScriptObject {
   $result = nullptr;
-  if (const void* impl = $1)
+  if (const void* impl = $1.GetPointer())
     $result = (PyObject*) impl;
   if (!$result) {
     $result = Py_None;
     Py_INCREF(Py_None);
   } else {
     Py_INCREF($result);
   }
 }
 
 %typemap(out) char** {
   int len;
   int i;
   len = 0;
   while ($1[len])
     len++;
   PythonList list(len);
   for (i = 0; i < len; i++)
     list.SetItemAtIndex(i, PythonString($1[i]));
   $result = list.release();
 }
 
 %typemap(in) lldb::tid_t {
   PythonObject obj = Retain<PythonObject>($input);
   lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
   if (PyErr_Occurred())
     SWIG_fail;
   $1 = value;

lldb/include/lldb/API/SBDebugger.h

protected:
   SBDebugger(const lldb::DebuggerSP &debugger_sp);
 
 private:
   friend class SBCommandInterpreter;
   friend class SBInputReader;
   friend class SBListener;
   friend class SBProcess;
   friend class SBSourceManager;
+  friend class SBStructuredData;
   friend class SBTarget;
   friend class SBTrace;
 
   lldb::SBTarget FindTargetWithLLDBProcess(const lldb::ProcessSP &processSP);
 
   void reset(const lldb::DebuggerSP &debugger_sp);
 
   lldb_private::Debugger *get() const;

lldb/include/lldb/API/SBDefines.h

 class LLDB_API SBModule;
 class LLDB_API SBModuleSpec;
 class LLDB_API SBModuleSpecList;
 class LLDB_API SBPlatform;
 class LLDB_API SBProcess;
 class LLDB_API SBProcessInfo;
 class LLDB_API SBQueue;
 class LLDB_API SBQueueItem;
+class LLDB_API SBScriptObject;
 class LLDB_API SBSection;
 class LLDB_API SBSourceManager;
 class LLDB_API SBStream;
 class LLDB_API SBStringList;
 class LLDB_API SBStructuredData;
 class LLDB_API SBSymbol;
 class LLDB_API SBSymbolContext;
 class LLDB_API SBSymbolContextList;
typedef bool (*SBBreakpointHitCallback)(void *baton, SBProcess &process,
                                         lldb::SBBreakpointLocation &location);
 
 typedef void (*SBDebuggerDestroyCallback)(lldb::user_id_t debugger_id,
                                           void *baton);
 
 typedef SBError (*SBPlatformLocateModuleCallback)(
     void *baton, const SBModuleSpec &module_spec, SBFileSpec &module_file_spec,
     SBFileSpec &symbol_file_spec);
-
-typedef void *ScriptedObject;
 }
 
 #endif // LLDB_API_SBDEFINES_H

lldb/include/lldb/API/SBProcess.h

#endif
   ///     want to deallocate.
   ///
   /// \return
   ///     An error object describes any errors that occurred while
   ///     deallocating.
   ///
   lldb::SBError DeallocateMemory(lldb::addr_t ptr);
 
-  lldb::ScriptedObject GetScriptedImplementation();
+  lldb::SBScriptObject GetScriptedImplementation();
 
 protected:
   friend class SBAddress;
   friend class SBBreakpoint;
   friend class SBBreakpointCallbackBaton;
   friend class SBBreakpointLocation;
   friend class SBCommandInterpreter;
   friend class SBDebugger;

lldb/include/lldb/API/SBScriptObject.h

+//===-- SBScriptObject.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_API_SBSCRIPTOBJECT_H
+#define LLDB_API_SBSCRIPTOBJECT_H
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb_private {
+class ScriptObject;
+}
+
+namespace lldb {
+
+class LLDB_API SBScriptObject {
+public:
+  SBScriptObject(const ScriptObjectPtr ptr, lldb::ScriptLanguage lang);
+
+  SBScriptObject(const lldb::SBScriptObject &rhs);
+
+  ~SBScriptObject();
+
+  const lldb::SBScriptObject &operator=(const lldb::SBScriptObject &rhs);
+
+  explicit operator bool() const;
+
+  bool operator!=(const SBScriptObject &rhs) const;
+
+  bool IsValid() const;
+
+  lldb::ScriptObjectPtr GetPointer() const;
+
+  lldb::ScriptLanguage GetLanguage() const;
+
+protected:
+  friend class SBStructuredData;
+
+  lldb_private::ScriptObject *get();
+
+  lldb_private::ScriptObject &ref();
+
+  const lldb_private::ScriptObject &ref() const;
+
+private:
+  std::unique_ptr<lldb_private::ScriptObject> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_API_SBSCRIPTOBJECT_H

lldb/include/lldb/API/SBStructuredData.h

 //===-- SBStructuredData.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_API_SBSTRUCTUREDDATA_H
 #define LLDB_API_SBSTRUCTUREDDATA_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
+#include "lldb/API/SBScriptObject.h"
 
 namespace lldb_private {
 namespace python {
 class SWIGBridge;
 }
 namespace lua {
 class SWIGBridge;
 }
 } // namespace lldb_private
 
 namespace lldb {
 
 class SBStructuredData {
 public:
   SBStructuredData();
 
   SBStructuredData(const lldb::SBStructuredData &rhs);
 
+  SBStructuredData(const lldb::SBScriptObject obj,
+                   const lldb::SBDebugger &debugger);
+
   ~SBStructuredData();
 
   lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   lldb::SBError SetFromJSON(lldb::SBStream &stream);
 
   lldb::SBError SetFromJSON(const char *json);
 
   void Clear();
public:
   ///     to write the complete string value, (\a dst_len - 1) bytes of the
   ///     string value will be written at \a dst followed by a null character.
   ///
   /// \return
   ///     Returns the byte size needed to completely write the string value at
   ///     \a dst in all cases.
   size_t GetStringValue(char *dst, size_t dst_len) const;
 
+  /// Return the generic pointer if this data structure is a generic type.
+  lldb::SBScriptObject GetGenericValue() const;
+
 protected:
   friend class SBAttachInfo;
   friend class SBLaunchInfo;
   friend class SBDebugger;
   friend class SBTarget;
   friend class SBProcess;
   friend class SBThread;
   friend class SBThreadPlan;

lldb/include/lldb/Core/StructuredDataImpl.h

size_t GetStringValue(char *dst, size_t dst_len) const {
 
     if (!dst || !dst_len) {
       char s[1];
       return (::snprintf(s, 1, "%s", result.data()));
     }
     return (::snprintf(dst, dst_len, "%s", result.data()));
   }
 
+  void *GetGenericValue() const {
+    if (!m_data_sp)
+      return nullptr;
+
+    StructuredData::Generic *generic_data = m_data_sp->GetAsGeneric();
+    if (!generic_data)
+      return nullptr;
+
+    return generic_data->GetValue();
+  }
+
   StructuredData::ObjectSP GetObjectSP() const { return m_data_sp; }
 
 private:
   lldb::StructuredDataPluginWP m_plugin_wp;
   StructuredData::ObjectSP m_data_sp;
 };
 } // namespace lldb_private
 #endif

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadedCommunication.h"
 #include "lldb/Host/PseudoTerminal.h"
+#include "lldb/Interpreter/ScriptObject.h"
 #include "lldb/Interpreter/ScriptedPlatformInterface.h"
 #include "lldb/Interpreter/ScriptedProcessInterface.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 #include <optional>
 
public:
   virtual lldb::ScriptedProcessInterfaceUP CreateScriptedProcessInterface() {
     return std::make_unique<ScriptedProcessInterface>();
   }
 
   ScriptedPlatformInterface &GetScriptedPlatformInterface() {
     return *m_scripted_platform_interface_up;
   }
 
+  virtual StructuredData::ObjectSP
+  CreateStructuredDataFromScriptObject(ScriptObject obj) {
+    return {};
+  }
+
   lldb::DataExtractorSP
   GetDataExtractorFromSBData(const lldb::SBData &data) const;
 
   Status GetStatusFromSBError(const lldb::SBError &error) const;
 
   lldb::BreakpointSP
   GetOpaqueTypeFromSBBreakpoint(const lldb::SBBreakpoint &breakpoint) const;
 

lldb/include/lldb/Interpreter/ScriptObject.h

+//===-- ScriptObject.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_INTERPRETER_SCRIPTOBJECT_H
+#define LLDB_INTERPRETER_SCRIPTOBJECT_H
+
+#include "lldb/lldb-types.h"
+
+namespace lldb_private {
+class ScriptObject {
+public:
+  ScriptObject(lldb::ScriptObjectPtr ptr, lldb::ScriptLanguage lang)
+      : m_ptr(ptr), m_language(lang) {}
+
+  operator bool() const { return m_ptr != nullptr; }
+
+  const void *GetPointer() const { return m_ptr; }
+
+  lldb::ScriptLanguage GetLanguage() const { return m_language; }
+
+private:
+  const void *m_ptr;
+  lldb::ScriptLanguage m_language;
+};
+} // namespace lldb_private
+
+#endif // LLDB_INTERPRETER_SCRIPTOBJECT_H

lldb/include/lldb/lldb-types.h

 #define LLDB_INVALID_HOST_THREAD ((lldb::thread_t)NULL)
 #define LLDB_INVALID_PIPE ((lldb::pipe_t)-1)
 
 typedef void (*LogOutputCallback)(const char *, void *baton);
 typedef bool (*CommandOverrideCallback)(void *baton, const char **argv);
 typedef bool (*ExpressionCancelCallback)(ExpressionEvaluationPhase phase,
                                          void *baton);
 
+typedef void *ScriptObjectPtr;
+
 typedef uint64_t addr_t;
 typedef uint64_t user_id_t;
 typedef uint64_t pid_t;
 typedef uint64_t tid_t;
 typedef uint64_t offset_t;
 typedef int32_t break_id_t;
 typedef int32_t watch_id_t;
 typedef void *opaque_compiler_type_t;
 typedef uint64_t queue_id_t;
 typedef uint32_t cpu_id_t; // CPU core id
 
 } // namespace lldb
 
 #endif // LLDB_LLDB_TYPES_H

lldb/source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED ${option_framework}
   SBModule.cpp
   SBModuleSpec.cpp
   SBPlatform.cpp
   SBProcess.cpp
   SBProcessInfo.cpp
   SBQueue.cpp
   SBQueueItem.cpp
   SBReproducer.cpp
+  SBScriptObject.cpp
   SBSection.cpp
   SBSourceManager.cpp
   SBStream.cpp
   SBStringList.cpp
   SBStructuredData.cpp
   SBSymbol.cpp
   SBSymbolContext.cpp
   SBSymbolContextList.cpp

lldb/source/API/SBProcess.cpp

 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/API/SBMemoryRegionInfoList.h"
+#include "lldb/API/SBScriptObject.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBUnixSignals.h"
 
if (stop_locker.TryLock(&process_sp->GetRunLock())) {
       sb_error.SetErrorString("process is running");
     }
   } else {
     sb_error.SetErrorString("SBProcess is invalid");
   }
   return sb_error;
 }
 
-ScriptedObject SBProcess::GetScriptedImplementation() {
+lldb::SBScriptObject SBProcess::GetScriptedImplementation() {
   LLDB_INSTRUMENT_VA(this);
   ProcessSP process_sp(GetSP());
-  return (process_sp) ? process_sp->GetImplementation() : nullptr;
+  return lldb::SBScriptObject((process_sp) ? process_sp->GetImplementation()
+                                           : nullptr,
+                              eScriptLanguageDefault);
 }

lldb/source/API/SBScriptObject.cpp

+//===-- SBScriptObject.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/API/SBScriptObject.h"
+
+#include "Utils.h"
+
+#include "lldb/Interpreter/ScriptObject.h"
+#include "lldb/Utility/Instrumentation.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBScriptObject::SBScriptObject(const ScriptObjectPtr ptr,
+                               lldb::ScriptLanguage lang)
+    : m_opaque_up(std::make_unique<lldb_private::ScriptObject>(ptr, lang)) {
+  LLDB_INSTRUMENT_VA(this, ptr, lang);
+}
+
+SBScriptObject::SBScriptObject(const SBScriptObject &rhs)
+    : m_opaque_up(new ScriptObject(nullptr, eScriptLanguageNone)) {
+  LLDB_INSTRUMENT_VA(this, rhs);
+
+  m_opaque_up = clone(rhs.m_opaque_up);
+}
+SBScriptObject::~SBScriptObject() = default;
+
+const SBScriptObject &SBScriptObject::operator=(const SBScriptObject &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
+
+  if (this != &rhs)
+    m_opaque_up = clone(rhs.m_opaque_up);
+  return *this;
+}
+
+bool SBScriptObject::operator!=(const SBScriptObject &rhs) const {
+  LLDB_INSTRUMENT_VA(this, rhs);
+
+  return !(m_opaque_up == rhs.m_opaque_up);
+}
+
+bool SBScriptObject::IsValid() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return this->operator bool();
+}
+
+SBScriptObject::operator bool() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up != nullptr && m_opaque_up->operator bool();
+}
+
+lldb::ScriptObjectPtr SBScriptObject::GetPointer() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up ? const_cast<void *>(m_opaque_up->GetPointer()) : nullptr;
+}
+
+lldb::ScriptLanguage SBScriptObject::GetLanguage() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up ? m_opaque_up->GetLanguage() : eScriptLanguageNone;
+}
+
+ScriptObject &SBScriptObject::ref() {
+  if (m_opaque_up == nullptr)
+    m_opaque_up = std::make_unique<ScriptObject>(nullptr, eScriptLanguageNone);
+  return *m_opaque_up;
+}
+
+const ScriptObject &SBScriptObject::ref() const {
+  // This object should already have checked with "IsValid()" prior to calling
+  // this function. In case you didn't we will assert and die to let you know.
+  assert(m_opaque_up.get());
+  return *m_opaque_up;
+}
+
+ScriptObject *SBScriptObject::get() { return m_opaque_up.get(); }

lldb/source/API/SBStructuredData.cpp

 //===-- SBStructuredData.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/API/SBStructuredData.h"
-#include "lldb/Core/StructuredDataImpl.h"
-#include "lldb/Utility/Instrumentation.h"
 
+#include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBScriptObject.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/StructuredDataImpl.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Event.h"
+#include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark--
 #pragma mark SBStructuredData
 
 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
   LLDB_INSTRUMENT_VA(this);
 }
 
 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
     : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
   LLDB_INSTRUMENT_VA(this, rhs);
 }
 
+SBStructuredData::SBStructuredData(const lldb::SBScriptObject obj,
+                                   const lldb::SBDebugger &debugger) {
+  LLDB_INSTRUMENT_VA(this, obj, debugger);
+
+  if (!obj.IsValid())
+    return;
+
+  ScriptInterpreter *interpreter =
+      debugger.m_opaque_sp->GetScriptInterpreter(true, obj.GetLanguage());
+
+  if (!interpreter)
+    return;
+
+  StructuredDataImplUP impl_up = std::make_unique<StructuredDataImpl>(
+      interpreter->CreateStructuredDataFromScriptObject(obj.ref()));
+  if (impl_up && impl_up->IsValid())
+    m_impl_up.reset(impl_up.release());
+}
+
 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
     : m_impl_up(new StructuredDataImpl(event_sp)) {
   LLDB_INSTRUMENT_VA(this, event_sp);
 }
 
 SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
     : m_impl_up(new StructuredDataImpl(impl)) {
   LLDB_INSTRUMENT_VA(this, impl);
 }
 
 SBStructuredData::~SBStructuredData() = default;
 
 SBStructuredData &SBStructuredData::
 operator=(const lldb::SBStructuredData &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   *m_impl_up = *rhs.m_impl_up;
   return *this;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
   LLDB_INSTRUMENT_VA(this, stream);
 
   lldb::SBError error;
 
bool SBStructuredData::GetBooleanValue(bool fail_value) const {
   return m_impl_up->GetBooleanValue(fail_value);
 }
 
 size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
   LLDB_INSTRUMENT_VA(this, dst, dst_len);
 
   return m_impl_up->GetStringValue(dst, dst_len);
 }
+
+lldb::SBScriptObject SBStructuredData::GetGenericValue() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return {m_impl_up->GetGenericValue(), eScriptLanguageDefault};
+}

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

llvm::Expected<PythonObject> GetAttribute(const llvm::Twine &name) const {
     if (!m_py_obj)
       return nullDeref();
     PyObject *obj = PyObject_GetAttrString(m_py_obj, NullTerminated(name));
     if (!obj)
       return exception();
     return python::Take<PythonObject>(obj);
   }
 
+  llvm::Expected<PythonObject> GetType() const {
+    if (!m_py_obj)
+      return nullDeref();
+    PyObject *obj = PyObject_Type(m_py_obj);
+    if (!obj)
+      return exception();
+    return python::Take<PythonObject>(obj);
+  }
+
   llvm::Expected<bool> IsTrue() {
     if (!m_py_obj)
       return nullDeref();
     int r = PyObject_IsTrue(m_py_obj);
     if (r < 0)
       return exception();
     return !!r;
   }

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

lldb::ValueObjectListSP ScriptInterpreterPythonImpl::GetRecognizedArguments(
   return ValueObjectListSP();
 }
 
 ScriptedProcessInterfaceUP
 ScriptInterpreterPythonImpl::CreateScriptedProcessInterface() {
   return std::make_unique<ScriptedProcessPythonInterface>(*this);
 }
 
+StructuredData::ObjectSP
+ScriptInterpreterPythonImpl::CreateStructuredDataFromScriptObject(
+    ScriptObject obj) {
+  void *ptr = const_cast<void *>(obj.GetPointer());
+  PythonObject py_obj(PyRefType::Borrowed, static_cast<PyObject *>(ptr));
+  if (!py_obj.IsValid() || py_obj.IsNone())
+    return {};
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
+  return py_obj.CreateStructuredObject();
+}
+
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::OSPlugin_CreatePluginObject(
     const char *class_name, lldb::ProcessSP process_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!process_sp)
     return StructuredData::GenericSP();

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

public:
   CreateScriptCommandObject(const char *class_name) override;
 
   StructuredData::ObjectSP
   CreateScriptedThreadPlan(const char *class_name,
                            const StructuredDataImpl &args_data,
                            std::string &error_str,
                            lldb::ThreadPlanSP thread_plan) override;
 
+  StructuredData::ObjectSP
+  CreateStructuredDataFromScriptObject(ScriptObject obj) 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,

lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py

def structured_data_api_test(self):
         self.double_struct_test(dict_struct)
 
         # Tests for boolean data type
         self.bool_struct_test(dict_struct)
 
         # Tests for array data type
         self.array_struct_test(dict_struct)
 
+        s.Clear()
+        self.assertSuccess(example.GetAsJSON(s))
+        py_obj = json.loads(s.GetData())
+        self.assertTrue(py_obj)
+        self.assertIn("key_dict", py_obj)
+
+        py_dict = py_obj["key_dict"]
+        self.assertEqual(py_dict["key_string"], "STRING")
+        self.assertEqual(py_dict["key_uint"], 0xFFFFFFFF00000000)
+        self.assertEqual(py_dict["key_sint"], -42)
+        self.assertEqual(py_dict["key_float"], 2.99)
+        self.assertEqual(py_dict["key_bool"], True)
+        self.assertEqual(py_dict["key_array"], ["23", "arr"])
+
+        class MyRandomClass:
+            payload = "foo"
+
+        py_dict["key_generic"] = MyRandomClass()
+
+        stp = lldb.SBScriptObject(py_dict, lldb.eScriptLanguagePython)
+        self.assertEqual(stp.ptr, py_dict)
+
+        sd = lldb.SBStructuredData(stp, self.dbg)
+        self.assertTrue(sd.IsValid())
+        self.assertEqual(sd.GetSize(), len(py_dict))
+
+        generic_sd = sd.GetValueForKey("key_generic")
+        self.assertTrue(generic_sd.IsValid())
+        self.assertEqual(generic_sd.GetType(), lldb.eStructuredDataTypeGeneric)
+
+        my_random_class = generic_sd.GetGenericValue()
+        self.assertTrue(my_random_class)
+        self.assertEqual(my_random_class.payload, MyRandomClass.payload)
+
     def invalid_struct_test(self, example):
         invalid_struct = lldb.SBStructuredData()
         invalid_struct = example.GetValueForKey("invalid_key")
         if invalid_struct.IsValid():
             self.fail("An invalid object should have been returned")
 
         # Check Type API
         if not invalid_struct.GetType() == lldb.eStructuredDataTypeInvalid: