Delete ScriptInterpreterObject

[zturner]

Summary

This is some preliminary work as discussed in the previous patch to get Python to be able to properly be split from the rest of the code.

This patch completely deletes ScriptInterpreterObject, and instead coverts ScriptInterpreter and ScriptInterpreterPython to use objects in StructuredData instead. To support this, a new category of StructuredData object is created, a "Generic" category which holds a void*. In PythonDataObjects, we then create a subclass of StructuredData::Generic called StructuredPythonObject whose job is just to Addref and Decref the void* on construction and destruction.

All methods in ScriptInterpreterPython now return StructuredData objects instead of PythonDictionary, PythonList, etc. To support this, the various PythonDataObject classes contain methods to convert them the corresponding StructuredData types. So the Python methods behave as normal, but instead of returning a PythonObject directly, they just convert first.

The only tricky part of this was with container types like PythonList and PythonDictionary. For this, we had to convert the contained elements *and* the container itself, since a client won't be able to use a StructuredList whose members are PythonList void*s, for example.

The rest of the code in this patch is just fixup stuff to get things compiling with StructuredData objects instead of Python objects.

Tested on Windows and Linux, no regressions. Will test on Mac when I can, but my machine is having technical difficulties. But since I didn't see any issues on Linux, I don't expect anything serious.

One thing I'm not sure of is how to test OperatingSystemPython and DynamicRegisterInfo. I don't really know what these are or how they're used. Are there tests for these things in-tree? Should I expect that if all the linux tests pass, that these are ok?

[clayborg]

So does this need to be applied after patches 1 and 2 from before?

[zturner]

Before. This is totally independent of patches 1 and 2. Apply this on a
clean repo and then don't apply 1 and 2. This can go in independently.

[zturner]

I tried building and running the Run Testsuite target in Xcode but it says
it can't find module lldb and that lldb.py needs to be in the Framework
path etc. I suspect I'm just doing this the wrong way since everything
works on Linux.

[zturner]

Rebase against ToT

[zturner]

Did you have a chance to try this out?

[clayborg]

Not yet, I am trying to get to it but I have been really busy with other work related stuff lately. Sorry for the delay.

[zturner]

Rebase against ToT again.

[zturner]

Rebase against ToT again, a bunch of more changes just went in for ScriptInterpreter.

[zturner]

Hi Greg, any chance you could get to this this week? Now that i have gtest
working it's of even more importance, because this patch will allow us to
stop linking Python into the unittest exe, which greatly slows its link
time and has some other unwanted side effects on windows.

I think it should be fairly straightforward. No regressions on linux/win,
and compiles on Mac. Only thing I'm not sure about is if
OperatingSystemPython is exercised by linux test suite, because there were
some changes there

[zturner]

Rebase against ToT (r232380)

[zturner]

The last rebase introduced a compiler error. This update fixes it.

[clayborg]

So the operating system plugin isn't working with this. To test this you can debug any program and stop at main and type:

(lldb) settings set target.process.python-os-plugin-path /Volumes/work/gclayton/Documents/src/lldb/trunk/examples/python/operating_system.py
(lldb) thread list

It should then display extra threads that is got from the operating_system.py:

(lldb) settings set target.process.python-os-plugin-path /Volumes/work/gclayton/Documents/src/lldb/trunk/examples/python/operating_system.py
(lldb) thread list 
Process 55813 stopped
* thread #1: tid = 0x219d30, 0x0000000100000b96 a.out main(argc=1, argv=0x00007fff5fbff8a8, envp=0x00007fff5fbff8b8, aapl=0x00007fff5fbff9e8) + 70, stop reason = breakpoint 1.1, queue = com.apple.main-thread
  thread #2: tid = 0x111111111, 0x0000000000000011, name = one, queue = queue1
  thread #3: tid = 0x222222222, 0x0000000000000075, name = two, queue = queue2
  thread #4: tid = 0x333333333, 0x0000000100000000 a.out _mh_execute_header, name = three, queue = queue3
(lldb) settings clear target.process.python-os-plugin-path
(lldb) thread list
Process 55813 stopped
* thread #1: tid = 0x219d30, 0x0000000100000b96 a.out main(argc=1, argv=0x00007fff5fbff8a8, envp=0x00007fff5fbff8b8, aapl=0x00007fff5fbff9e8) + 70, stop reason = breakpoint 1.1, queue = com.apple.main-thread

I will add a test for this.

[zturner]

Fixes some related to OperatingSystemPython.

[clayborg]

I added a test that can be used to test the Python OS plugin:

% svn commit
Adding         python_os_plugin
Adding         python_os_plugin/Makefile
Adding         python_os_plugin/TestPythonOSPlugin.py
Adding         python_os_plugin/main.c
Adding         python_os_plugin/operating_system.py
Transmitting file data ....
Committed revision 232401.

[clayborg]

If you run this test on MacOSX, it crashes:

% cd test
% ./dotest.py -t -v functionalities/plugins/python_os_plugin

[clayborg]

The test passes prior to these changes.

[zturner]

Yea I'm looking into this right now. I wasn't sure if it was crashing
because OperatingSystemPython had unrelated portability issues on Windows,
so I was reproing this on Linux right now. In any case, it looks like
there's still a few more issues.

[zturner]

Hi Greg,

I think I've fixed the remainder of the issues. The problem this time was that the RegisterData defined in operating_system.py is a string with embedded nulls, and all of PythonString's getters and setters were not written to correctly handle this. So I changed all of the const char*'s here to be StringRefs (since we specifically need to support strings with embedded nulls). Here's a run on Linux with my patch applied.

zturner@zturner-goobuntu:/usr/local/google_ssd/src/llvm/build/ninja$ bin/lldb
(lldb) file a.out
Current executable set to 'a.out' (x86_64).
(lldb) break set -n main
Breakpoint 1: where = a.out`main, address = 0x00000000004004f0
(lldb) run
Process 1681 launched: '/usr/local/google_ssd/src/llvm/build/ninja/a.out' (x86_64)
Process 1681 stopped
* thread #1: tid = 1681, 0x00000000004004f0 a.out`main, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x00000000004004f0 a.out`main
a.out`main:
->  0x4004f0 <+0>: int3   
    0x4004f1 <+1>: movq   %rsp, %rbp
    0x4004f4 <+4>: movl   $0x0, %eax
    0x4004f9 <+9>: movl   $0x0, -0x4(%rbp)
(lldb) settings set target.process.python-os-plugin-path /usr/local/google_ssd/src/llvm/tools/lldb/examples/python/operating_system.py
(lldb) thread list
Process 1681 stopped
* thread #1: tid = 1681, 0x00000000004004f0 a.out`main, name = 'a.out', stop reason = breakpoint 1.1
  thread #2: tid = 4581298449, 0x0000000000000011, name = 'one', queue = 'queue1'
  thread #3: tid = 9162596898, 0x0000000000000075, name = 'two', queue = 'queue2'
  thread #4: tid = 13743895347, name = 'three', queue = 'queue3'
(lldb)

Note this still doesn't work on Windows because operating_system.py checks the triple and only returns valid information for x86-64, which I haven't added support for yet. Also, I ran the new test on Linux and it passes.

[clayborg]

Which strings have embedded NULLs??? I don't see any.

[zturner]

In D8128#141677, @clayborg wrote:

Which strings have embedded NULLs??? I don't see any.

It's the calls to struct.pack() in get_register_data(). For example, this line:

struct.pack('21Q',1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)

says "there are 21 items of type Q following, where Q means uint64. Format them as such and return the result as a string". So you get a bunch of 0s in the resulting string.

[clayborg]

Ahhh, I see. I am running the test suite now with these changes on MacOSX.

[zturner]

By the way, I still have trouble running tests on OSX. I'm not really sure
what the recommended workflow is. Could we add a section to the website
called "Running LLDB Tests"? I created a bug for it with some things that
would be useful to have documented in such a page:

https://llvm.org/bugs/show_bug.cgi?id=22887

We wouldn't need to tackle this all at once, but it would be nice if I
didn't have to keep asking you to run the test suite on OSX for me.

[clayborg]

Test suite ran cleanly on MacOSX.

[zturner]

Very nice. Do you plan to review the diff or are you ok with this as is?

[clayborg]

Looks good as is.

include/lldb/Core/StructuredData.h

     class Boolean;
     class String;
     class Dictionary;
+    class Generic;
 
     typedef std::shared_ptr<Object> ObjectSP;
     typedef std::shared_ptr<Array> ArraySP;
+    typedef std::shared_ptr<Integer> IntegerSP;
+    typedef std::shared_ptr<Float> FloatSP;
+    typedef std::shared_ptr<Boolean> BooleanSP;
+    typedef std::shared_ptr<String> StringSP;
     typedef std::shared_ptr<Dictionary> DictionarySP;
+    typedef std::shared_ptr<Generic> GenericSP;
 
-    enum class Type {
+    enum class Type
+    {
         eTypeInvalid = -1,
         eTypeNull = 0,
+        eTypeGeneric,
         eTypeArray,
         eTypeInteger,
         eTypeFloat,

         {
         }
 
+        virtual bool
+        IsValid() const
+        {
+            return true;
+        }
+
         virtual void
         Clear ()
         {

             return NULL;
         }
 
+        Generic *
+        GetAsGeneric()
+        {
+            if (m_type == Type::eTypeGeneric)
+                return (Generic *)this;
+            return NULL;
+        }
+
         ObjectSP
         GetObjectForDotSeparatedPath (llvm::StringRef path);
 
+        void DumpToStdout() const;
+
         virtual void
         Dump (Stream &s) const = 0; 
 

         }
 
         size_t
-        GetSize()
+        GetSize() const
         {
             return m_items.size();
         }

         }
 
         ObjectSP
-        GetItemAtIndex (size_t idx)
+        GetItemAtIndex(size_t idx) const
         {
+            assert(idx < GetSize());
             if (idx < m_items.size())
                 return m_items[idx];
             return ObjectSP();
         }
 
+        template <class IntType>
+        bool
+        GetItemAtIndexAsInteger(size_t idx, IntType &result) const
+        {
+            ObjectSP value = GetItemAtIndex(idx);
+            if (auto int_value = value->GetAsInteger())
+            {
+                result = static_cast<IntType>(int_value->GetValue());
+                return true;
+            }
+            return false;
+        }
+
+        template <class IntType>
+        bool
+        GetItemAtIndexAsInteger(size_t idx, IntType &result, IntType default_val) const
+        {
+            bool success = GetItemAtIndexAsInteger(idx, result);
+            if (!success)
+                result = default_val;
+            return success;
+        }
+
+        bool
+        GetItemAtIndexAsString(size_t idx, std::string &result) const
+        {
+            ObjectSP value = GetItemAtIndex(idx);
+            if (auto string_value = value->GetAsString())
+            {
+                result = string_value->GetValue();
+                return true;
+            }
+            return false;
+        }
+
+        bool
+        GetItemAtIndexAsString(size_t idx, std::string &result, const std::string &default_val) const
+        {
+            bool success = GetItemAtIndexAsString(idx, result);
+            if (!success)
+                result = default_val;
+            return success;
+        }
+
+        bool
+        GetItemAtIndexAsString(size_t idx, ConstString &result) const
+        {
+            ObjectSP value = GetItemAtIndex(idx);
+            if (!value)
+                return false;
+            if (auto string_value = value->GetAsString())
+            {
+                result = ConstString(string_value->GetValue());
+                return true;
+            }
+            return false;
+        }
+
+        bool
+        GetItemAtIndexAsString(size_t idx, ConstString &result, const char *default_val) const
+        {
+            bool success = GetItemAtIndexAsString(idx, result);
+            if (!success)
+                result.SetCString(default_val);
+            return success;
+        }
+
+        bool
+        GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const
+        {
+            ObjectSP value = GetItemAtIndex(idx);
+            result = value->GetAsDictionary();
+            return (result != nullptr);
+        }
+
+        bool
+        GetItemAtIndexAsArray(size_t idx, Array *&result) const
+        {
+            ObjectSP value = GetItemAtIndex(idx);
+            result = value->GetAsArray();
+            return (result != nullptr);
+        }
+
         void
         Push(ObjectSP item)
         {

             m_items.push_back(item);
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        void Dump(Stream &s) const override;
 
     protected:
         typedef std::vector<ObjectSP> collection;

             return m_value;
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        void Dump(Stream &s) const override;
 
     protected:
         uint64_t m_value;

             return m_value;
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        void Dump(Stream &s) const override;
 
     protected:
         double m_value;

             return m_value;
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        void Dump(Stream &s) const override;
 
     protected:
         bool m_value;

             return m_value;
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        void Dump(Stream &s) const override;
 
     protected:
         std::string m_value;

         virtual ~Dictionary()
         {
         }
+
         size_t
-        GetSize()
+        GetSize() const
         {
             return m_dict.size();
         }
 
         ObjectSP
-        GetKeys()
+        GetKeys() const
         {
             ObjectSP object_sp(new Array ());
             Array *array = object_sp->GetAsArray();

         }
 
         ObjectSP
-        GetValueForKey (const char *key)
+        GetValueForKey(const char *key) const
         {
             ObjectSP value_sp;
             if (key)

             return value_sp;
         }
 
+        template <class IntType>
         bool
-        HasKey (const char *key)
+        GetValueForKeyAsInteger(const char *key, IntType &result) const
         {
-            ConstString key_cs (key);
-            collection::const_iterator search = m_dict.find(key_cs);
-            if (search != m_dict.end())
+            ObjectSP value = GetValueForKey(key);
+            if (!value)
+                return false;
+            if (auto int_value = value->GetAsInteger())
             {
+                result = static_cast<IntType>(int_value->GetValue());
                 return true;
             }
-            else
+            return false;
+        }
+
+        template <class IntType>
+        bool
+        GetValueForKeyAsInteger(const char *key, IntType &result, IntType default_val) const
+        {
+            bool success = GetValueForKeyAsInteger<IntType>(key, result);
+            if (!success)
+                result = default_val;
+            return success;
+        }
+
+        bool
+        GetValueForKeyAsString(const char *key, std::string &result) const
+        {
+            ObjectSP value = GetValueForKey(key);
+            if (!value)
+                return false;
+            if (auto string_value = value->GetAsString())
             {
+                result = string_value->GetValue();
+                return true;
+            }
+            return false;
+        }
+
+        bool
+        GetValueForKeyAsString(const char *key, std::string &result, const std::string &default_val) const
+        {
+            bool success = GetValueForKeyAsString(key, result);
+            if (!success)
+                result = default_val;
+            return success;
+        }
+
+        bool
+        GetValueForKeyAsString(const char *key, ConstString &result) const
+        {
+            ObjectSP value = GetValueForKey(key);
+            if (!value)
                 return false;
+            if (auto string_value = value->GetAsString())
+            {
+                result = ConstString(string_value->GetValue());
+                return true;
             }
+            return false;
+        }
+
+        bool
+        GetValueForKeyAsString(const char *key, ConstString &result, const char *default_val) const
+        {
+            bool success = GetValueForKeyAsString(key, result);
+            if (!success)
+                result.SetCString(default_val);
+            return success;
+        }
+
+        bool
+        GetValueForKeyAsDictionary(const char *key, Dictionary *&result) const
+        {
+            result = nullptr;
+            ObjectSP value = GetValueForKey(key);
+            if (!value)
+                return false;
+            result = value->GetAsDictionary();
+            return true;
+        }
+
+        bool
+        GetValueForKeyAsArray(const char *key, Array *&result) const
+        {
+            result = nullptr;
+            ObjectSP value = GetValueForKey(key);
+            if (!value)
+                return false;
+            result = value->GetAsArray();
+            return true;
+        }
+
+        bool
+        HasKey(const char *key) const
+        {
+            ConstString key_cs(key);
+            collection::const_iterator search = m_dict.find(key_cs);
+            return search != m_dict.end();
         }
 
         void

             AddItem (key, val_obj);
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        void Dump(Stream &s) const override;
 
     protected:
         typedef std::map<ConstString, ObjectSP> collection;

         {
         }
 
-        virtual void
-        Dump (Stream &s) const;
+        bool
+        IsValid() const override
+        {
+            return false;
+        }
+
+        void Dump(Stream &s) const override;
 
     protected:
     };
 
+    class Generic : public Object
+    {
+      public:
+        explicit Generic(void *object = nullptr)
+            : Object(Type::eTypeGeneric)
+            , m_object(object)
+        {
+        }
+
+        void
+        SetValue(void *value)
+        {
+            m_object = value;
+        }
+
+        void *
+        GetValue() const
+        {
+            return m_object;
+        }
+
+        bool
+        IsValid() const override
+        {
+            return m_object != nullptr;
+        }
+
+        void Dump(Stream &s) const override;
+
+      private:
+        void *m_object;
+    };
 
     static ObjectSP
     ParseJSON (std::string json_text);

include/lldb/DataFormatters/TypeSummary.h

 
 #include "lldb/Core/Error.h"
 #include "lldb/Core/FormatEntity.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ValueObject.h"
-#include "lldb/Interpreter/ScriptInterpreterPython.h"
 #include "lldb/Symbol/Type.h"
 
 namespace lldb_private {

     {
         std::string m_function_name;
         std::string m_python_script;
-        lldb::ScriptInterpreterObjectSP m_script_function_sp;
-        
+        StructuredData::ObjectSP m_script_function_sp;
         ScriptSummaryFormat(const TypeSummaryImpl::Flags& flags,
                             const char *function_name,
                             const char* python_script = NULL);

include/lldb/DataFormatters/TypeSynthetic.h

 #include "lldb/lldb-public.h"
 #include "lldb/lldb-enumerations.h"
 
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ValueObject.h"
 
 namespace lldb_private {

         {
         private:
             std::string m_python_class;
-            lldb::ScriptInterpreterObjectSP m_wrapper_sp;
+            StructuredData::ObjectSP m_wrapper_sp;
             ScriptInterpreter *m_interpreter;
         public:
             

include/lldb/Interpreter/PythonDataObjects.h

 // Project includes
 #include "lldb/lldb-defines.h"
 #include "lldb/Core/ConstString.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Interpreter/OptionValue.h"
 #include "lldb/lldb-python.h"
 
 namespace lldb_private {
-    
+class PythonString;
+class PythonList;
+class PythonDictionary;
+class PythonObject;
+class PythonInteger;
+
+class StructuredPythonObject : public StructuredData::Generic
+{
+  public:
+    StructuredPythonObject()
+        : StructuredData::Generic()
+    {
+    }
+
+    StructuredPythonObject(void *obj)
+        : StructuredData::Generic(obj)
+    {
+        Py_XINCREF(GetValue());
+    }
+
+    virtual ~StructuredPythonObject()
+    {
+        if (Py_IsInitialized())
+            Py_XDECREF(GetValue());
+        SetValue(nullptr);
+    }
+
+    bool
+    IsValid() const override
+    {
+        return GetValue() && GetValue() != Py_None;
+    }
+
+    void Dump(Stream &s) const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
+};
+
+enum class PyObjectType
+{
+    Unknown,
+    None,
+    Integer,
+    Dictionary,
+    List,
+    String
+};
+
     class PythonObject
     {
     public:

         {
             Reset (rhs.m_py_obj);
         }
-        
-        explicit PythonObject (const lldb::ScriptInterpreterObjectSP &script_object_sp);
 
         virtual
         ~PythonObject ()

             return m_py_obj;
         }
 
+        PyObjectType GetObjectType() const;
+
         PythonString
         Repr ();
         

         
         bool
         IsNULLOrNone () const;
-        
+        StructuredData::ObjectSP CreateStructuredObject() const;
+
     protected:
         PyObject* m_py_obj;
     };

     class PythonString: public PythonObject
     {
     public:
-        
         PythonString ();
         PythonString (PyObject *o);
         PythonString (const PythonObject &object);
-        PythonString (const lldb::ScriptInterpreterObjectSP &script_object_sp);
         PythonString (const char* string);
         virtual ~PythonString ();
-        
         virtual bool
         Reset (PyObject* py_obj = NULL);
 

         size_t
         GetSize() const;
 
-        void
-        SetString (const char* string);        
+        void SetString(const char *string);
+
+        StructuredData::StringSP CreateStructuredString() const;
     };
     
     class PythonInteger: public PythonObject

         PythonInteger ();
         PythonInteger (PyObject* py_obj);
         PythonInteger (const PythonObject &object);
-        PythonInteger (const lldb::ScriptInterpreterObjectSP &script_object_sp);
         PythonInteger (int64_t value);
         virtual ~PythonInteger ();
         
         virtual bool
         Reset (PyObject* py_obj = NULL);
-        
-        int64_t
-        GetInteger();
-        
+        int64_t GetInteger() const;
+
         void
         SetInteger (int64_t value);
+
+        StructuredData::IntegerSP CreateStructuredInteger() const;
     };
     
     class PythonList: public PythonObject

         PythonList (bool create_empty);
         PythonList (PyObject* py_obj);
         PythonList (const PythonObject &object);
-        PythonList (const lldb::ScriptInterpreterObjectSP &script_object_sp);
         PythonList (uint32_t count);
         virtual ~PythonList ();
         
         virtual bool
         Reset (PyObject* py_obj = NULL);
-        
-        uint32_t
-        GetSize();
-        
-        PythonObject
-        GetItemAtIndex (uint32_t index);
-        
+        uint32_t GetSize() const;
+
+        PythonObject GetItemAtIndex(uint32_t index) const;
+
         void
         SetItemAtIndex (uint32_t index, const PythonObject &object);
         
         void
         AppendItem (const PythonObject &object);
+
+        StructuredData::ArraySP CreateStructuredArray() const;
     };
     
     class PythonDictionary: public PythonObject

         explicit PythonDictionary (bool create_empty);
         PythonDictionary (PyObject* object);
         PythonDictionary (const PythonObject &object);
-        PythonDictionary (const lldb::ScriptInterpreterObjectSP &script_object_sp);
         virtual ~PythonDictionary ();
         
         virtual bool
         Reset (PyObject* object = NULL);
-        
-        uint32_t GetSize();
-        
+        uint32_t GetSize() const;
         PythonObject
         GetItemForKey (const PythonString &key) const;
         

 
         void
         SetItemForKey (const PythonString &key, const PythonObject& value);
+
+        StructuredData::DictionarySP CreateStructuredDictionary() const;
     };
     
 } // namespace lldb_private

include/lldb/Interpreter/ScriptInterpreter.h

 
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Error.h"
+#include "lldb/Core/StructuredData.h"
 
 #include "lldb/Utility/PseudoTerminal.h"
 
 
 namespace lldb_private {
-
-class ScriptInterpreterObject
-{
-public:
-    ScriptInterpreterObject() :
-    m_object(NULL)
-    {}
-    
-    ScriptInterpreterObject(void* obj) :
-    m_object(obj)
-    {}
-    
-    ScriptInterpreterObject(const ScriptInterpreterObject& rhs)
-    : m_object(rhs.m_object)
-    {}
-    
-    virtual void*
-    GetObject()
-    {
-        return m_object;
-    }
-    
-    explicit operator bool ()
-    {
-        return m_object != NULL;
-    }
-    
-    ScriptInterpreterObject&
-    operator = (const ScriptInterpreterObject& rhs)
-    {
-        if (this != &rhs)
-            m_object = rhs.m_object;
-        return *this;
-    }
-        
-    virtual
-    ~ScriptInterpreterObject()
-    {}
-    
-protected:
-    void* m_object;
-};
     
 class ScriptInterpreterLocker
 {

     {
         return false;
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
-    CreateSyntheticScriptedProvider (const char *class_name,
-                                     lldb::ValueObjectSP valobj)
+    virtual StructuredData::ObjectSP
+    CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ObjectSP();
     }
 
-    virtual lldb::ScriptInterpreterObjectSP
+    virtual StructuredData::GenericSP
     CreateScriptCommandObject (const char *class_name)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::GenericSP();
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
+    virtual StructuredData::GenericSP
     OSPlugin_CreatePluginObject (const char *class_name,
                                  lldb::ProcessSP process_sp)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::GenericSP();
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
-    OSPlugin_RegisterInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp)
+    virtual StructuredData::DictionarySP
+    OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
-    OSPlugin_ThreadsInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp)
+    virtual StructuredData::ArraySP
+    OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ArraySP();
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
-    OSPlugin_RegisterContextData (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
-                                  lldb::tid_t thread_id)
+    virtual StructuredData::StringSP
+    OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t thread_id)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::StringSP();
     }
 
-    virtual lldb::ScriptInterpreterObjectSP
-    OSPlugin_CreateThread (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
-                           lldb::tid_t tid,
-                           lldb::addr_t context)
+    virtual StructuredData::DictionarySP
+    OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid, lldb::addr_t context)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
-    CreateScriptedThreadPlan (const char *class_name,
-                              lldb::ThreadPlanSP thread_plan_sp)
+    virtual StructuredData::ObjectSP
+    CreateScriptedThreadPlan(const char *class_name, lldb::ThreadPlanSP thread_plan_sp)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ObjectSP();
     }
 
     virtual bool
-    ScriptedThreadPlanExplainsStop (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                    Event *event,
-                                    bool &script_error)
+    ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
     {
         script_error = true;
         return true;
     }
 
     virtual bool
-    ScriptedThreadPlanShouldStop (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                  Event *event,
-                                  bool &script_error)
+    ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
     {
         script_error = true;
         return true;
     }
 
     virtual lldb::StateType
-    ScriptedThreadPlanGetRunState (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                   bool &script_error)
+    ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp, bool &script_error)
     {
         script_error = true;
         return lldb::eStateStepping;
     }
 
-    virtual lldb::ScriptInterpreterObjectSP
-    LoadPluginModule (const FileSpec& file_spec,
-                     lldb_private::Error& error)
+    virtual StructuredData::ObjectSP
+    LoadPluginModule(const FileSpec &file_spec, lldb_private::Error &error)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ObjectSP();
     }
-    
-    virtual lldb::ScriptInterpreterObjectSP
-    GetDynamicSettings (lldb::ScriptInterpreterObjectSP plugin_module_sp,
-                        Target* target,
-                        const char* setting_name,
-                        lldb_private::Error& error)
+    virtual StructuredData::DictionarySP
+    GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name, lldb_private::Error &error)
     {
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
 
     virtual Error

     {
         return;
     }
-    
     virtual bool
-    GetScriptedSummary (const char *function_name,
-                        lldb::ValueObjectSP valobj,
-                        lldb::ScriptInterpreterObjectSP& callee_wrapper_sp,
-                        const TypeSummaryOptions& options,
-                        std::string& retval)
+    GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj, StructuredData::ObjectSP &callee_wrapper_sp,
+                       const TypeSummaryOptions &options, std::string &retval)
     {
         return false;
     }

     {
         // Clean up any ref counts to SBObjects that might be in global variables
     }
-    
     virtual size_t
-    CalculateNumChildren (const lldb::ScriptInterpreterObjectSP& implementor)
+    CalculateNumChildren(const StructuredData::ObjectSP &implementor)
     {
         return 0;
     }
-    
     virtual lldb::ValueObjectSP
-    GetChildAtIndex (const lldb::ScriptInterpreterObjectSP& implementor, uint32_t idx)
+    GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx)
     {
         return lldb::ValueObjectSP();
     }
-    
     virtual int
-    GetIndexOfChildWithName (const lldb::ScriptInterpreterObjectSP& implementor, const char* child_name)
+    GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name)
     {
         return UINT32_MAX;
     }
-    
     virtual bool
-    UpdateSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor)
+    UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor)
     {
         return false;
     }
-    
     virtual bool
-    MightHaveChildrenSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor)
+    MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor)
     {
         return true;
     }
-    
     virtual lldb::ValueObjectSP
-    GetSyntheticValue (const lldb::ScriptInterpreterObjectSP& implementor)
+    GetSyntheticValue(const StructuredData::ObjectSP &implementor)
     {
         return nullptr;
     }

     }
     
     virtual bool
-    RunScriptBasedCommand (lldb::ScriptInterpreterObjectSP impl_obj_sp,
+    RunScriptBasedCommand (StructuredData::GenericSP impl_obj_sp,
                            const char* args,
                            ScriptedCommandSynchronicity synchronicity,
                            lldb_private::CommandReturnObject& cmd_retobj,

     }
 
     virtual bool
-    LoadScriptingModule (const char* filename,
-                         bool can_reload,
-                         bool init_session,
-                         lldb_private::Error& error,
-                         lldb::ScriptInterpreterObjectSP* module_sp = nullptr)
+    LoadScriptingModule(const char *filename, bool can_reload, bool init_session, lldb_private::Error &error,
+                        StructuredData::ObjectSP *module_sp = nullptr)
     {
         error.SetErrorString("loading unimplemented");
         return false;

     {
         return false;
     }
-
-    virtual lldb::ScriptInterpreterObjectSP
-    MakeScriptObject (void* object)
-    {
-        return lldb::ScriptInterpreterObjectSP(new ScriptInterpreterObject(object));
-    }
     
     virtual std::unique_ptr<ScriptInterpreterLocker>
     AcquireInterpreterLock ();

include/lldb/Interpreter/ScriptInterpreterPython.h

     
     bool
     GenerateScriptAliasFunction (StringList &input, std::string& output) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    CreateSyntheticScriptedProvider (const char *class_name,
-                                     lldb::ValueObjectSP valobj) override;
 
-    lldb::ScriptInterpreterObjectSP
-    CreateScriptCommandObject (const char *class_name) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    CreateScriptedThreadPlan (const char *class_name,
-                              lldb::ThreadPlanSP thread_plan) override;
+    StructuredData::ObjectSP CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj) override;
+
+    StructuredData::GenericSP CreateScriptCommandObject (const char *class_name) override;
+
+    StructuredData::ObjectSP CreateScriptedThreadPlan(const char *class_name, 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;
+    lldb::StateType ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp, bool &script_error) override;
+
+    StructuredData::GenericSP OSPlugin_CreatePluginObject(const char *class_name, lldb::ProcessSP process_sp) override;
+
+    StructuredData::DictionarySP OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
+
+    StructuredData::ArraySP OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
+
+    StructuredData::StringSP OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t thread_id) override;
+
+    StructuredData::DictionarySP OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid,
+                                                       lldb::addr_t context) override;
+
+    StructuredData::ObjectSP LoadPluginModule(const FileSpec &file_spec, lldb_private::Error &error) override;
+
+    StructuredData::DictionarySP GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name,
+                                                    lldb_private::Error &error) override;
+
+    size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor) override;
+
+    lldb::ValueObjectSP GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) override;
+
+    int GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name) override;
+
+    bool UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor) override;
+
+    bool MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor) override;
+
+    lldb::ValueObjectSP GetSyntheticValue(const StructuredData::ObjectSP &implementor) override;
 
-    bool
-    ScriptedThreadPlanExplainsStop (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                    Event *event,
-                                    bool &script_error) override;
-    bool
-    ScriptedThreadPlanShouldStop (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                  Event *event,
-                                  bool &script_error) override;
-    lldb::StateType
-    ScriptedThreadPlanGetRunState (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                   bool &script_error) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    OSPlugin_CreatePluginObject (const char *class_name,
-                                 lldb::ProcessSP process_sp) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    OSPlugin_RegisterInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    OSPlugin_ThreadsInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    OSPlugin_RegisterContextData (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
-                                  lldb::tid_t thread_id) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    OSPlugin_CreateThread (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
-                           lldb::tid_t tid,
-                           lldb::addr_t context) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    LoadPluginModule (const FileSpec& file_spec,
-                      lldb_private::Error& error) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    GetDynamicSettings (lldb::ScriptInterpreterObjectSP plugin_module_sp,
-                        Target* target,
-                        const char* setting_name,
-                        lldb_private::Error& error) override;
-    
-    size_t
-    CalculateNumChildren (const lldb::ScriptInterpreterObjectSP& implementor) override;
-    
-    lldb::ValueObjectSP
-    GetChildAtIndex (const lldb::ScriptInterpreterObjectSP& implementor, uint32_t idx) override;
-    
-    int
-    GetIndexOfChildWithName (const lldb::ScriptInterpreterObjectSP& implementor, const char* child_name) override;
-    
-    bool
-    UpdateSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor) override;
-    
-    bool
-    MightHaveChildrenSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor) override;
-    
-    lldb::ValueObjectSP
-    GetSyntheticValue (const lldb::ScriptInterpreterObjectSP& implementor) override;
-    
     bool
     RunScriptBasedCommand(const char* impl_function,
                           const char* args,

                           const lldb_private::ExecutionContext& exe_ctx) override;
     
     bool
-    RunScriptBasedCommand (lldb::ScriptInterpreterObjectSP impl_obj_sp,
+    RunScriptBasedCommand (StructuredData::GenericSP impl_obj_sp,
                            const char* args,
                            ScriptedCommandSynchronicity synchronicity,
                            lldb_private::CommandReturnObject& cmd_retobj,

     WatchpointCallbackFunction (void *baton, 
                                 StoppointCallbackContext *context, 
                                 lldb::user_id_t watch_id);
-    
-    bool
-    GetScriptedSummary (const char *function_name,
-                        lldb::ValueObjectSP valobj,
-                        lldb::ScriptInterpreterObjectSP& callee_wrapper_sp,
-                        const TypeSummaryOptions& options,
-                        std::string& retval) override;
-    
+    bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj, StructuredData::ObjectSP &callee_wrapper_sp,
+                            const TypeSummaryOptions &options, std::string &retval) override;
+
     void
     Clear () override;
 

                             ValueObject* value,
                             std::string& output,
                             Error& error) override;
-    
-    bool
-    LoadScriptingModule (const char* filename,
-                         bool can_reload,
-                         bool init_session,
-                         lldb_private::Error& error,
-                         lldb::ScriptInterpreterObjectSP* module_sp = nullptr) override;
-    
+    bool LoadScriptingModule(const char *filename, bool can_reload, bool init_session, lldb_private::Error &error,
+                             StructuredData::ObjectSP *module_sp = nullptr) override;
+
     bool
     IsReservedWord (const char* word) override;
-    
-    lldb::ScriptInterpreterObjectSP
-    MakeScriptObject (void* object) override;
-    
     std::unique_ptr<ScriptInterpreterLocker>
     AcquireInterpreterLock () override;
     

         ~SynchronicityHandler();
     };
     
-    class ScriptInterpreterPythonObject : public ScriptInterpreterObject
-    {
-    public:
-        ScriptInterpreterPythonObject() :
-        ScriptInterpreterObject()
-        {}
-        
-        ScriptInterpreterPythonObject(void* obj) :
-        ScriptInterpreterObject(obj)
-        {
-            Py_XINCREF(m_object);
-        }
-        
-        explicit operator bool ()
-        {
-            return m_object && m_object != Py_None;
-        }
-        
-        
-        virtual
-        ~ScriptInterpreterPythonObject()
-        {
-            if (Py_IsInitialized())
-                Py_XDECREF(m_object);
-            m_object = NULL;
-        }
-        private:
-            DISALLOW_COPY_AND_ASSIGN (ScriptInterpreterPythonObject);
-    };
 public:
   class Locker : public ScriptInterpreterLocker
   {

include/lldb/Target/ThreadPlanPython.h

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UserID.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"

     GetPlanRunState ();
 
 private:
-    std::string                     m_class_name;
-    lldb::ScriptInterpreterObjectSP m_implementation_sp;
+  std::string m_class_name;
+  StructuredData::ObjectSP m_implementation_sp;
 
     DISALLOW_COPY_AND_ASSIGN(ThreadPlanPython);
 };

include/lldb/lldb-forward.h

 class   ProcessLaunchInfo;
 class   Property;
 struct  PropertyDefinition;
-class   PythonArray;
-class   PythonDictionary;
-class   PythonInteger;
-class   PythonObject;
-class   PythonString;
 class   RegisterCheckpoint;
 class   RegisterContext;
 class   RegisterLocation;

 class   Scalar;
 class   ScriptInterpreter;
 class   ScriptInterpreterLocker;
-class   ScriptInterpreterObject;
 #ifndef LLDB_DISABLE_PYTHON
 class   ScriptInterpreterPython;
 struct  ScriptSummaryFormat;

     typedef std::shared_ptr<lldb_private::Queue> QueueSP;
     typedef std::weak_ptr<lldb_private::Queue> QueueWP;
     typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;
-    typedef std::shared_ptr<lldb_private::ScriptInterpreterObject> ScriptInterpreterObjectSP;
 #ifndef LLDB_DISABLE_PYTHON
     typedef std::shared_ptr<lldb_private::ScriptSummaryFormat> ScriptSummaryFormatSP;
 #endif // #ifndef LLDB_DISABLE_PYTHON

source/Commands/CommandObjectCommands.cpp

 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
-#include "lldb/Interpreter/ScriptInterpreterPython.h"
 
 using namespace lldb;
 using namespace lldb_private;

 class CommandObjectScriptingObject : public CommandObjectRaw
 {
 private:
-    lldb::ScriptInterpreterObjectSP m_cmd_obj_sp;
+    StructuredData::GenericSP m_cmd_obj_sp;
     ScriptedCommandSynchronicity m_synchro;
     bool m_fetched_help_short:1;
     bool m_fetched_help_long:1;

     
     CommandObjectScriptingObject (CommandInterpreter &interpreter,
                                   std::string name,
-                                  lldb::ScriptInterpreterObjectSP cmd_obj_sp,
+                                  StructuredData::GenericSP cmd_obj_sp,
                                   ScriptedCommandSynchronicity synch) :
     CommandObjectRaw (interpreter,
                       name.c_str(),

         return true;
     }
     
-    lldb::ScriptInterpreterObjectSP
+    StructuredData::GenericSP
     GetImplementingObject ()
     {
         return m_cmd_obj_sp;

source/Core/StructuredData.cpp

 #include <stdlib.h>
 #include <inttypes.h>
 
+#include "lldb/Core/StreamString.h"
+
 using namespace lldb_private;
 
 

 }
 
 void
-StructuredData::Array::Dump (Stream &s) const
+StructuredData::Object::DumpToStdout() const
+{
+    StreamString stream;
+    Dump(stream);
+    printf("%s", stream.GetString().c_str());
+}
+
+void
+StructuredData::Array::Dump(Stream &s) const
 {
     s << "[";
     const size_t arrsize = m_items.size();

 {
     s << "null";
 }
+
+void
+StructuredData::Generic::Dump(Stream &s) const
+{
+    s << "0x" << m_object;
+}

source/DataFormatters/TypeSynthetic.cpp

 bool
 ScriptedSyntheticChildren::FrontEnd::IsValid ()
 {
-    return m_wrapper_sp.get() != nullptr && m_wrapper_sp->operator bool() && m_interpreter != nullptr;
+    return (m_wrapper_sp && m_wrapper_sp->IsValid() && m_interpreter);
 }
 
 size_t

source/Interpreter/PythonDataObjects.cpp

 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/PythonDataObjects.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Interpreter/ScriptInterpreterPython.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
+void
+StructuredPythonObject::Dump(Stream &s) const
+{
+    s << "Python Obj: 0x" << GetValue();
+}
+
 //----------------------------------------------------------------------
 // PythonObject
 //----------------------------------------------------------------------
-PythonObject::PythonObject (const lldb::ScriptInterpreterObjectSP &script_object_sp) :
-    m_py_obj (nullptr)
-{
-    if (script_object_sp)
-        Reset ((PyObject *)script_object_sp->GetObject());
-}
 
 void
 PythonObject::Dump (Stream &strm) const

         strm.PutCString ("NULL");
 }
 
+PyObjectType
+PythonObject::GetObjectType() const
+{
+    if (IsNULLOrNone())
+        return PyObjectType::None;
+
+    if (PyList_Check(m_py_obj))
+        return PyObjectType::List;
+    if (PyDict_Check(m_py_obj))
+        return PyObjectType::Dictionary;
+    if (PyString_Check(m_py_obj))
+        return PyObjectType::String;
+    if (PyInt_Check(m_py_obj))
+        return PyObjectType::Integer;
+    return PyObjectType::Unknown;
+}
+
 PythonString
 PythonObject::Repr ()
 {

     return ((m_py_obj == nullptr) || (m_py_obj == Py_None));
 }
 
+StructuredData::ObjectSP
+PythonObject::CreateStructuredObject() const
+{
+    switch (GetObjectType())
+    {
+        case PyObjectType::Dictionary:
+            return PythonDictionary(m_py_obj).CreateStructuredDictionary();
+        case PyObjectType::Integer:
+            return PythonInteger(m_py_obj).CreateStructuredInteger();
+        case PyObjectType::List:
+            return PythonList(m_py_obj).CreateStructuredArray();
+        case PyObjectType::String:
+            return PythonString(m_py_obj).CreateStructuredString();
+        case PyObjectType::None:
+            return StructuredData::ObjectSP();
+        default:
+            return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
+    }
+}
+
 //----------------------------------------------------------------------
 // PythonString
 //----------------------------------------------------------------------

     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonString::PythonString (const lldb::ScriptInterpreterObjectSP &script_object_sp) :
-    PythonObject()
-{
-    if (script_object_sp)
-        Reset((PyObject *)script_object_sp->GetObject()); // Use "Reset()" to ensure that py_obj is a string
-}
-
 PythonString::PythonString (const char* string) :
     PythonObject(PyString_FromString(string))
 {

     PythonObject::Reset(PyString_FromString(string));
 }
 
+StructuredData::StringSP
+PythonString::CreateStructuredString() const
+{
+    StructuredData::StringSP result(new StructuredData::String);
+    result->SetValue(GetString());
+    return result;
+}
+
 //----------------------------------------------------------------------
 // PythonInteger
 //----------------------------------------------------------------------

     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a integer type
 }
 
-PythonInteger::PythonInteger (const lldb::ScriptInterpreterObjectSP &script_object_sp) :
-    PythonObject()
-{
-    if (script_object_sp)
-        Reset((PyObject *)script_object_sp->GetObject()); // Use "Reset()" to ensure that py_obj is a string
-}
-
 PythonInteger::PythonInteger (int64_t value) :
     PythonObject()
 {

 }
 
 int64_t
-PythonInteger::GetInteger()
+PythonInteger::GetInteger() const
 {
     if (m_py_obj)
     {

     PythonObject::Reset(PyLong_FromLongLong(value));
 }
 
+StructuredData::IntegerSP
+PythonInteger::CreateStructuredInteger() const
+{
+    StructuredData::IntegerSP result(new StructuredData::Integer);
+    result->SetValue(GetInteger());
+    return result;
+}
+
 //----------------------------------------------------------------------
 // PythonList
 //----------------------------------------------------------------------

     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a list
 }
 
-PythonList::PythonList (const lldb::ScriptInterpreterObjectSP &script_object_sp) :
-    PythonObject()
-{
-    if (script_object_sp)
-        Reset((PyObject *)script_object_sp->GetObject()); // Use "Reset()" to ensure that py_obj is a list
-}
-
 PythonList::~PythonList ()
 {
 }

 }
 
 uint32_t
-PythonList::GetSize()
+PythonList::GetSize() const
 {
     if (m_py_obj)
         return PyList_GET_SIZE(m_py_obj);

 }
 
 PythonObject
-PythonList::GetItemAtIndex (uint32_t index)
+PythonList::GetItemAtIndex(uint32_t index) const
 {
     if (m_py_obj)
         return PythonObject(PyList_GetItem(m_py_obj, index));

         PyList_Append(m_py_obj, object.get());
 }
 
+StructuredData::ArraySP
+PythonList::CreateStructuredArray() const
+{
+    StructuredData::ArraySP result(new StructuredData::Array);
+    uint32_t count = GetSize();
+    for (uint32_t i = 0; i < count; ++i)
+    {
+        PythonObject obj = GetItemAtIndex(i);
+        result->AddItem(StructuredData::ObjectSP(new StructuredPythonObject(obj.get())));
+    }
+    return result;
+}
+
 //----------------------------------------------------------------------
 // PythonDictionary
 //----------------------------------------------------------------------

     Reset(object.get()); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
-PythonDictionary::PythonDictionary (const lldb::ScriptInterpreterObjectSP &script_object_sp) :
-    PythonObject ()
-{
-    if (script_object_sp)
-        Reset((PyObject *)script_object_sp->GetObject()); // Use "Reset()" to ensure that py_obj is a dictionary
-}
-
 PythonDictionary::~PythonDictionary ()
 {
 }

 }
 
 uint32_t
-PythonDictionary::GetSize()
+PythonDictionary::GetSize() const
 {
     if (m_py_obj)
         return PyDict_Size(m_py_obj);

         PyDict_SetItem(m_py_obj, key.get(), value.get());
 }
 
+StructuredData::DictionarySP
+PythonDictionary::CreateStructuredDictionary() const
+{
+    StructuredData::DictionarySP result(new StructuredData::Dictionary);
+    PythonList keys(GetKeys());
+    uint32_t num_keys = keys.GetSize();
+    for (uint32_t i = 0; i < num_keys; ++i)
+    {
+        PythonObject key = keys.GetItemAtIndex(i);
+        PythonString key_str = key.Str();
+        PythonObject value = GetItemForKey(key);
+        StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
+        result->AddItem(key_str.GetString(), structured_value);
+    }
+    return result;
+}
+
 #endif

source/Interpreter/ScriptInterpreterPython.cpp

     return true;
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::OSPlugin_CreatePluginObject (const char *class_name, lldb::ProcessSP process_sp)
+StructuredData::GenericSP
+ScriptInterpreterPython::OSPlugin_CreatePluginObject(const char *class_name, lldb::ProcessSP process_sp)
 {
     if (class_name == nullptr || class_name[0] == '\0')
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::GenericSP();
     if (!process_sp)
-        return lldb::ScriptInterpreterObjectSP();
-        
+        return StructuredData::GenericSP();
     void* ret_val;
     
     {

                                               m_dictionary_name.c_str(),
                                               process_sp);
     }
-    
-    return MakeScriptObject(ret_val);
+    return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::OSPlugin_RegisterInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp)
+StructuredData::DictionarySP
+ScriptInterpreterPython::OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp)
 {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::NoSTDIN,

     static char callee_name[] = "get_register_info";
     
     if (!os_plugin_object_sp)
-        return lldb::ScriptInterpreterObjectSP();
-    
-    PyObject* implementor = (PyObject*)os_plugin_object_sp->GetObject();
-    
+        return StructuredData::DictionarySP();
+    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+    if (!generic)
+        return nullptr;
+
+    PyObject *implementor = (PyObject *)generic->GetValue();
+
     if (implementor == nullptr || implementor == Py_None)
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::DictionarySP();
     PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
     
     if (PyErr_Occurred())

     if (pmeth == nullptr || pmeth == Py_None)
     {
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
     
     if (PyCallable_Check(pmeth) == 0)

         }
         
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
     
     if (PyErr_Occurred())

         PyErr_Print();
         PyErr_Clear();
     }
-    
-    return MakeScriptObject(py_return);
+    PythonDictionary result_dict(py_return);
+    return result_dict.CreateStructuredDictionary();
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::OSPlugin_ThreadsInfo (lldb::ScriptInterpreterObjectSP os_plugin_object_sp)
+StructuredData::ArraySP
+ScriptInterpreterPython::OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp)
 {
     Locker py_lock (this,
                     Locker::AcquireLock | Locker::NoSTDIN,
                     Locker::FreeLock);
 
     static char callee_name[] = "get_thread_info";
-    
     if (!os_plugin_object_sp)
-        return lldb::ScriptInterpreterObjectSP();
-    
-    PyObject* implementor = (PyObject*)os_plugin_object_sp->GetObject();
-    
+        return StructuredData::ArraySP();
+    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+    if (!generic)
+        return nullptr;
+    PyObject *implementor = (PyObject *)generic->GetValue();
+
     if (implementor == nullptr || implementor == Py_None)
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::ArraySP();
     PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
     
     if (PyErr_Occurred())

     if (pmeth == nullptr || pmeth == Py_None)
     {
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ArraySP();
     }
     
     if (PyCallable_Check(pmeth) == 0)

         }
         
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ArraySP();
     }
     
     if (PyErr_Occurred())

         PyErr_Print();
         PyErr_Clear();
     }
-    
-    return MakeScriptObject(py_return);
+    PythonList ResultList(py_return);
+    return ResultList.CreateStructuredArray();
 }
 
 // GetPythonValueFormatString provides a system independent type safe way to

 template <> const char *GetPythonValueFormatString (float t)            { return "f"; }
 template <> const char *GetPythonValueFormatString (double t)           { return "d"; }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::OSPlugin_RegisterContextData (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
-                                                       lldb::tid_t tid)
+StructuredData::StringSP
+ScriptInterpreterPython::OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid)
 {
     Locker py_lock (this,
                     Locker::AcquireLock | Locker::NoSTDIN,

     static char *param_format = const_cast<char *>(GetPythonValueFormatString(tid));
     
     if (!os_plugin_object_sp)
-        return lldb::ScriptInterpreterObjectSP();
-    
-    PyObject* implementor = (PyObject*)os_plugin_object_sp->GetObject();
-    
+        return StructuredData::StringSP();
+    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+    if (!generic)
+        return nullptr;
+    PyObject *implementor = (PyObject *)generic->GetValue();
+
     if (implementor == nullptr || implementor == Py_None)
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::StringSP();
 
     PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
     

     if (pmeth == nullptr || pmeth == Py_None)
     {
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::StringSP();
     }
     
     if (PyCallable_Check(pmeth) == 0)

         }
         
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::StringSP();
     }
     
     if (PyErr_Occurred())

         PyErr_Print();
         PyErr_Clear();
     }
-    
-    return MakeScriptObject(py_return);
+    PythonString result_string(py_return);
+    return result_string.CreateStructuredString();
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::OSPlugin_CreateThread (lldb::ScriptInterpreterObjectSP os_plugin_object_sp,
-                                                lldb::tid_t tid,
-                                                lldb::addr_t context)
+StructuredData::DictionarySP
+ScriptInterpreterPython::OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid, lldb::addr_t context)
 {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::NoSTDIN,

     param_format += GetPythonValueFormatString(context);
     
     if (!os_plugin_object_sp)
-        return lldb::ScriptInterpreterObjectSP();
-    
-    PyObject* implementor = (PyObject*)os_plugin_object_sp->GetObject();
-    
+        return StructuredData::DictionarySP();
+    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+    if (!generic)
+        return nullptr;
+    PyObject *implementor = (PyObject *)generic->GetValue();
+
     if (implementor == nullptr || implementor == Py_None)
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::DictionarySP();
     PyObject* pmeth  = PyObject_GetAttrString(implementor, callee_name);
     
     if (PyErr_Occurred())

     if (pmeth == nullptr || pmeth == Py_None)
     {
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
     
     if (PyCallable_Check(pmeth) == 0)

         }
         
         Py_XDECREF(pmeth);
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::DictionarySP();
     }
     
     if (PyErr_Occurred())

         PyErr_Print();
         PyErr_Clear();
     }
-    
-    return MakeScriptObject(py_return);
+    PythonDictionary result_dict(py_return);
+    return result_dict.CreateStructuredDictionary();
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::CreateScriptedThreadPlan (const char *class_name,
-                              lldb::ThreadPlanSP thread_plan_sp)
+StructuredData::ObjectSP
+ScriptInterpreterPython::CreateScriptedThreadPlan(const char *class_name, lldb::ThreadPlanSP thread_plan_sp)
 {
     if (class_name == nullptr || class_name[0] == '\0')
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::ObjectSP();
     if (!thread_plan_sp.get())
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ObjectSP();
 
     Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
     ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
     ScriptInterpreterPython *python_interpreter = static_cast<ScriptInterpreterPython *>(script_interpreter);
     
     if (!script_interpreter)
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::ObjectSP();
     void* ret_val;
 
     {

                                              python_interpreter->m_dictionary_name.c_str(),
                                              thread_plan_sp);
     }
-    
-    return MakeScriptObject(ret_val);
+    return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
 bool
-ScriptInterpreterPython::ScriptedThreadPlanExplainsStop (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                Event *event,
-                                bool &script_error)
+ScriptInterpreterPython::ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
 {
     bool explains_stop = true;
+    StructuredData::Generic *generic = nullptr;
     if (implementor_sp)
+        generic = implementor_sp->GetAsGeneric();
+    if (generic)
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        explains_stop = g_swig_call_thread_plan (implementor_sp->GetObject(), "explains_stop", event, script_error);
+        explains_stop = g_swig_call_thread_plan(generic->GetValue(), "explains_stop", event, script_error);
         if (script_error)
             return true;
     }

 }
 
 bool
-ScriptInterpreterPython::ScriptedThreadPlanShouldStop (lldb::ScriptInterpreterObjectSP implementor_sp,
-                              Event *event,
-                              bool &script_error)
+ScriptInterpreterPython::ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp, Event *event, bool &script_error)
 {
     bool should_stop = true;
+    StructuredData::Generic *generic = nullptr;
     if (implementor_sp)
+        generic = implementor_sp->GetAsGeneric();
+    if (generic)
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        should_stop = g_swig_call_thread_plan (implementor_sp->GetObject(), "should_stop", event, script_error);
+        should_stop = g_swig_call_thread_plan(generic->GetValue(), "should_stop", event, script_error);
         if (script_error)
             return true;
     }

 }
 
 lldb::StateType
-ScriptInterpreterPython::ScriptedThreadPlanGetRunState (lldb::ScriptInterpreterObjectSP implementor_sp,
-                                                        bool &script_error)
+ScriptInterpreterPython::ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp, bool &script_error)
 {
     bool should_step = false;
+    StructuredData::Generic *generic = nullptr;
     if (implementor_sp)
+        generic = implementor_sp->GetAsGeneric();
+    if (generic)
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        should_step = g_swig_call_thread_plan (implementor_sp->GetObject(), "should_step", NULL, script_error);
+        should_step = g_swig_call_thread_plan(generic->GetValue(), "should_step", NULL, script_error);
         if (script_error)
             should_step = true;
     }

         return lldb::eStateRunning;
 }
 
-
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::LoadPluginModule (const FileSpec& file_spec,
-                                           lldb_private::Error& error)
+StructuredData::ObjectSP
+ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec, lldb_private::Error &error)
 {
     if (!file_spec.Exists())
     {
         error.SetErrorString("no such file");
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::ObjectSP();
     }
 
-    ScriptInterpreterObjectSP module_sp;
-    
+    StructuredData::ObjectSP module_sp;
     if (LoadScriptingModule(file_spec.GetPath().c_str(),true,true,error,&module_sp))
         return module_sp;
-    
-    return lldb::ScriptInterpreterObjectSP();
+    return StructuredData::ObjectSP();
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::GetDynamicSettings (lldb::ScriptInterpreterObjectSP plugin_module_sp,
-                                             Target* target,
-                                             const char* setting_name,
-                                             lldb_private::Error& error)
+StructuredData::DictionarySP
+ScriptInterpreterPython::GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name,
+                                            lldb_private::Error &error)
 {
-    if (!plugin_module_sp || !target || !setting_name || !setting_name[0])
-        return lldb::ScriptInterpreterObjectSP();
-    
-    if (!g_swig_plugin_get)
-        return lldb::ScriptInterpreterObjectSP();
-    
+    if (!plugin_module_sp || !target || !setting_name || !setting_name[0] || !g_swig_plugin_get)
+        return StructuredData::DictionarySP();
+    StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
+    if (!generic)
+        return StructuredData::DictionarySP();
     PyObject *reply_pyobj = nullptr;
     
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
         TargetSP target_sp(target->shared_from_this());
-        reply_pyobj = (PyObject*)g_swig_plugin_get(plugin_module_sp->GetObject(),setting_name,target_sp);
+        reply_pyobj = (PyObject *)g_swig_plugin_get(generic->GetValue(), setting_name, target_sp);
     }
-    
-    return MakeScriptObject(reply_pyobj);
+    PythonDictionary py_dict(reply_pyobj);
+
+    return py_dict.CreateStructuredDictionary();
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::CreateSyntheticScriptedProvider (const char *class_name,
-                                                          lldb::ValueObjectSP valobj)
+StructuredData::ObjectSP
+ScriptInterpreterPython::CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
 {
     if (class_name == nullptr || class_name[0] == '\0')
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::ObjectSP();
     if (!valobj.get())
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::ObjectSP();
     ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
     Target *target = exe_ctx.GetTargetPtr();
     
     if (!target)
-        return lldb::ScriptInterpreterObjectSP();
-    
+        return StructuredData::ObjectSP();
     Debugger &debugger = target->GetDebugger();
     ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
     ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
     
     if (!script_interpreter)
-        return lldb::ScriptInterpreterObjectSP();
-    
-    void* ret_val;
+        return StructuredData::ObjectSP();
+    void *ret_val = nullptr;
 
     {
         Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);

                                            python_interpreter->m_dictionary_name.c_str(),
                                            valobj);
     }
-    
-    return MakeScriptObject(ret_val);
+    return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
-lldb::ScriptInterpreterObjectSP
+StructuredData::GenericSP
 ScriptInterpreterPython::CreateScriptCommandObject (const char *class_name)
 {
     DebuggerSP debugger_sp(GetCommandInterpreter().GetDebugger().shared_from_this());
     
     if (class_name == nullptr || class_name[0] == '\0')
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::GenericSP();
     
     if (!debugger_sp.get())
-        return lldb::ScriptInterpreterObjectSP();
+        return StructuredData::GenericSP();
     
     void* ret_val;
     

                                      debugger_sp);
     }
     
-    return MakeScriptObject(ret_val);
+    return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
 bool

 }
 
 bool
-ScriptInterpreterPython::GetScriptedSummary (const char *python_function_name,
-                                             lldb::ValueObjectSP valobj,
-                                             lldb::ScriptInterpreterObjectSP& callee_wrapper_sp,
-                                             const TypeSummaryOptions& options,
-                                             std::string& retval)
+ScriptInterpreterPython::GetScriptedSummary(const char *python_function_name, lldb::ValueObjectSP valobj,
+                                            StructuredData::ObjectSP &callee_wrapper_sp, const TypeSummaryOptions &options,
+                                            std::string &retval)
 {
     
     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);

         retval.assign("<no object>");
         return false;
     }
-        
-    void* old_callee = (callee_wrapper_sp ? callee_wrapper_sp->GetObject() : nullptr);
+    void *old_callee = nullptr;
+    StructuredData::Generic *generic = nullptr;
+    if (callee_wrapper_sp)
+    {
+        generic = callee_wrapper_sp->GetAsGeneric();
+        if (generic)
+            old_callee = generic->GetValue();
+    }
     void* new_callee = old_callee;
     
     bool ret_val;
-    if (python_function_name 
-        && *python_function_name)
+    if (python_function_name && *python_function_name)
     {
         {
             Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);

     }
     
     if (new_callee && old_callee != new_callee)
-        callee_wrapper_sp = MakeScriptObject(new_callee);
-    
+        callee_wrapper_sp.reset(new StructuredPythonObject(new_callee));
     return ret_val;
-    
 }
 
 void

 }
 
 size_t
-ScriptInterpreterPython::CalculateNumChildren (const lldb::ScriptInterpreterObjectSP& implementor_sp)
+ScriptInterpreterPython::CalculateNumChildren(const StructuredData::ObjectSP &implementor_sp)
 {
     if (!implementor_sp)
         return 0;
-    
-    void* implementor = implementor_sp->GetObject();
-    
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return 0;
+    void *implementor = generic->GetValue();
     if (!implementor)
         return 0;
     

 }
 
 lldb::ValueObjectSP
-ScriptInterpreterPython::GetChildAtIndex (const lldb::ScriptInterpreterObjectSP& implementor_sp, uint32_t idx)
+ScriptInterpreterPython::GetChildAtIndex(const StructuredData::ObjectSP &implementor_sp, uint32_t idx)
 {
     if (!implementor_sp)
         return lldb::ValueObjectSP();
-    
-    void* implementor = implementor_sp->GetObject();
-    
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return lldb::ValueObjectSP();
+    void *implementor = generic->GetValue();
     if (!implementor)
         return lldb::ValueObjectSP();
     

 }
 
 int
-ScriptInterpreterPython::GetIndexOfChildWithName (const lldb::ScriptInterpreterObjectSP& implementor_sp, const char* child_name)
+ScriptInterpreterPython::GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor_sp, const char *child_name)
 {
     if (!implementor_sp)
         return UINT32_MAX;
-    
-    void* implementor = implementor_sp->GetObject();
-    
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return UINT32_MAX;
+    void *implementor = generic->GetValue();
     if (!implementor)
         return UINT32_MAX;
     

 }
 
 bool
-ScriptInterpreterPython::UpdateSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor_sp)
+ScriptInterpreterPython::UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor_sp)
 {
     bool ret_val = false;
     
     if (!implementor_sp)
         return ret_val;
-    
-    void* implementor = implementor_sp->GetObject();
-    
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return ret_val;
+    void *implementor = generic->GetValue();
     if (!implementor)
         return ret_val;
     

 }
 
 bool
-ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance (const lldb::ScriptInterpreterObjectSP& implementor_sp)
+ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor_sp)
 {
     bool ret_val = false;
     
     if (!implementor_sp)
         return ret_val;
-    
-    void* implementor = implementor_sp->GetObject();
-    
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return ret_val;
+    void *implementor = generic->GetValue();
     if (!implementor)
         return ret_val;
     

 }
 
 lldb::ValueObjectSP
-ScriptInterpreterPython::GetSyntheticValue (const lldb::ScriptInterpreterObjectSP& implementor_sp)
+ScriptInterpreterPython::GetSyntheticValue(const StructuredData::ObjectSP &implementor_sp)
 {
     lldb::ValueObjectSP ret_val(nullptr);
     
     if (!implementor_sp)
         return ret_val;
-    
-    void* implementor = implementor_sp->GetObject();
-    
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return ret_val;
+    void *implementor = generic->GetValue();
     if (!implementor)
         return ret_val;
     

 }
 
 bool
-ScriptInterpreterPython::LoadScriptingModule (const char* pathname,
-                                              bool can_reload,
-                                              bool init_session,
-                                              lldb_private::Error& error,
-                                              lldb::ScriptInterpreterObjectSP* module_sp)
+ScriptInterpreterPython::LoadScriptingModule(const char *pathname, bool can_reload, bool init_session, lldb_private::Error &error,
+                                             StructuredData::ObjectSP *module_sp)
 {
     if (!pathname || !pathname[0])
     {

             command_stream.Printf("%s",basename.c_str());
             void* module_pyobj = nullptr;
             if (ExecuteOneLineWithReturn(command_stream.GetData(),ScriptInterpreter::eScriptReturnTypeOpaqueObject,&module_pyobj) && module_pyobj)
-                *module_sp = MakeScriptObject(module_pyobj);
+                module_sp->reset(new StructuredPythonObject(module_pyobj));
         }
         
         return true;

     return false;
 }
 
-lldb::ScriptInterpreterObjectSP
-ScriptInterpreterPython::MakeScriptObject (void* object)
-{
-    return lldb::ScriptInterpreterObjectSP(new ScriptInterpreterPythonObject(object));
-}
-
 ScriptInterpreterPython::SynchronicityHandler::SynchronicityHandler (lldb::DebuggerSP debugger_sp,
                                                                      ScriptedCommandSynchronicity synchro) :
     m_debugger_sp(debugger_sp),

 }
 
 bool
-ScriptInterpreterPython::RunScriptBasedCommand (lldb::ScriptInterpreterObjectSP impl_obj_sp,
+ScriptInterpreterPython::RunScriptBasedCommand (StructuredData::GenericSP impl_obj_sp,
                                                 const char* args,
                                                 ScriptedCommandSynchronicity synchronicity,
                                                 lldb_private::CommandReturnObject& cmd_retobj,
                                                 Error& error,
                                                 const lldb_private::ExecutionContext& exe_ctx)
 {
-    if (!impl_obj_sp || !impl_obj_sp->GetObject())
+    if (!impl_obj_sp || !impl_obj_sp->IsValid())
     {
         error.SetErrorString("no function to execute");
         return false;

         SynchronicityHandler synch_handler(debugger_sp,
                                            synchronicity);
         
-        ret_val = g_swig_call_command_object      (impl_obj_sp->GetObject(),
+        ret_val = g_swig_call_command_object      (impl_obj_sp->GetValue(),
                                                    debugger_sp,
                                                    args,
                                                    cmd_retobj,

source/Plugins/OperatingSystem/Python/OperatingSystemPython.h

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
-#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/OperatingSystem.h"
 
 class DynamicRegisterInfo;
 
+namespace lldb_private
+{
+class ScriptInterpreter;
+}
+
 class OperatingSystemPython : public lldb_private::OperatingSystem
 {
 public:

     
     bool IsValid() const
     {
-        return m_python_object_sp && m_python_object_sp->GetObject() != NULL;
+        return m_python_object_sp && m_python_object_sp->IsValid();
     }
-    
-    lldb::ThreadSP
-    CreateThreadFromThreadInfo (lldb_private::PythonDictionary &thread_dict,
-                                lldb_private::ThreadList &core_thread_list,
-                                lldb_private::ThreadList &old_thread_list,
-                                std::vector<bool> &core_used_map,
-                                bool *did_create_ptr);
+    lldb::ThreadSP CreateThreadFromThreadInfo(lldb_private::StructuredData::Dictionary &thread_dict,
+                                              lldb_private::ThreadList &core_thread_list, lldb_private::ThreadList &old_thread_list,
+                                              std::vector<bool> &core_used_map, bool *did_create_ptr);
 
     DynamicRegisterInfo *
     GetDynamicRegisterInfo ();

     lldb::ValueObjectSP m_thread_list_valobj_sp;
     std::unique_ptr<DynamicRegisterInfo> m_register_info_ap;
     lldb_private::ScriptInterpreter *m_interpreter;
-    lldb::ScriptInterpreterObjectSP m_python_object_sp;
-    
+    lldb_private::StructuredData::ObjectSP m_python_object_sp;
 };
 
 #endif // #ifndef liblldb_OperatingSystemPython_h_

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Interpreter/PythonDataObjects.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Symbol/ClangNamespaceDecl.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/VariableList.h"

                     os_plugin_class_name.erase (py_extension_pos);
                 // Add ".OperatingSystemPlugIn" to the module name to get a string like "modulename.OperatingSystemPlugIn"
                 os_plugin_class_name += ".OperatingSystemPlugIn";
-                ScriptInterpreterObjectSP object_sp = m_interpreter->OSPlugin_CreatePluginObject(os_plugin_class_name.c_str(), process->CalculateProcess());
-                if (object_sp && object_sp->GetObject())
+                StructuredData::ObjectSP object_sp =
+                    m_interpreter->OSPlugin_CreatePluginObject(os_plugin_class_name.c_str(), process->CalculateProcess());
+                if (object_sp && object_sp->IsValid())
                     m_python_object_sp = object_sp;
             }
         }

         
         if (log)
             log->Printf ("OperatingSystemPython::GetDynamicRegisterInfo() fetching thread register definitions from python for pid %" PRIu64, m_process->GetID());
-        
-        PythonDictionary dictionary(m_interpreter->OSPlugin_RegisterInfo(m_python_object_sp));
+        StructuredData::DictionarySP dictionary = m_interpreter->OSPlugin_RegisterInfo(m_python_object_sp);
         if (!dictionary)
             return NULL;
-        
-        m_register_info_ap.reset (new DynamicRegisterInfo (dictionary, m_process->GetTarget().GetArchitecture().GetByteOrder()));
+        m_register_info_ap.reset(new DynamicRegisterInfo(*dictionary, m_process->GetTarget().GetArchitecture().GetByteOrder()));
         assert (m_register_info_ap->GetNumRegisters() > 0);
         assert (m_register_info_ap->GetNumRegisterSets() > 0);
     }

     // lldb_private::Process subclass, no memory threads will be in this list.
     
     auto lock = m_interpreter->AcquireInterpreterLock(); // to make sure threads_list stays alive
-    PythonList threads_list(m_interpreter->OSPlugin_ThreadsInfo(m_python_object_sp));
-    
+    StructuredData::ArraySP threads_list = m_interpreter->OSPlugin_ThreadsInfo(m_python_object_sp);
     const uint32_t num_cores = core_thread_list.GetSize(false);
     
     // Make a map so we can keep track of which cores were used from the

         if (log)
         {
             StreamString strm;
-            threads_list.Dump(strm);
+            threads_list->Dump(strm);
             log->Printf("threads_list = %s", strm.GetString().c_str());
         }
-        uint32_t i;
-        const uint32_t num_threads = threads_list.GetSize();
-        if (num_threads > 0)
+
+        const uint32_t num_threads = threads_list->GetSize();
+        for (uint32_t i = 0; i < num_threads; ++i)
         {
-            for (i=0; i<num_threads; ++i)
+            StructuredData::ObjectSP thread_dict_obj = threads_list->GetItemAtIndex(i);
+            if (auto thread_dict = thread_dict_obj->GetAsDictionary())
             {
-                PythonDictionary thread_dict(threads_list.GetItemAtIndex(i));
-                if (thread_dict)
-                {
-                    ThreadSP thread_sp (CreateThreadFromThreadInfo (thread_dict, core_thread_list, old_thread_list, core_used_map, NULL));
-                    if (thread_sp)
-                        new_thread_list.AddThread(thread_sp);
-                }
+                ThreadSP thread_sp(CreateThreadFromThreadInfo(*thread_dict, core_thread_list, old_thread_list, core_used_map, NULL));
+                if (thread_sp)
+                    new_thread_list.AddThread(thread_sp);
             }
         }
     }

 }
 
 ThreadSP
-OperatingSystemPython::CreateThreadFromThreadInfo (PythonDictionary &thread_dict,
-                                                   ThreadList &core_thread_list,
-                                                   ThreadList &old_thread_list,
-                                                   std::vector<bool> &core_used_map,
-                                                   bool *did_create_ptr)
+OperatingSystemPython::CreateThreadFromThreadInfo(StructuredData::Dictionary &thread_dict, ThreadList &core_thread_list,
+                                                  ThreadList &old_thread_list, std::vector<bool> &core_used_map, bool *did_create_ptr)
 {
     ThreadSP thread_sp;
-    if (thread_dict)
+    tid_t tid = LLDB_INVALID_THREAD_ID;
+    if (!thread_dict.GetValueForKeyAsInteger("tid", tid))
+        return ThreadSP();
+
+    uint32_t core_number;
+    addr_t reg_data_addr;
+    std::string name;
+    std::string queue;
+
+    thread_dict.GetValueForKeyAsInteger("core", core_number, UINT32_MAX);
+    thread_dict.GetValueForKeyAsInteger("register_data_addr", reg_data_addr, LLDB_INVALID_ADDRESS);
+    thread_dict.GetValueForKeyAsString("name", name);
+    thread_dict.GetValueForKeyAsString("queue", queue);
+
+    // See if a thread already exists for "tid"
+    thread_sp = old_thread_list.FindThreadByID(tid, false);
+    if (thread_sp)
     {
-        PythonString tid_pystr("tid");
-        const tid_t tid = thread_dict.GetItemForKeyAsInteger (tid_pystr, LLDB_INVALID_THREAD_ID);
-        if (tid != LLDB_INVALID_THREAD_ID)
+        // A thread already does exist for "tid", make sure it was an operating system
+        // plug-in generated thread.
+        if (!IsOperatingSystemPluginThread(thread_sp))
         {
-            PythonString core_pystr("core");
-            PythonString name_pystr("name");
-            PythonString queue_pystr("queue");
-            //PythonString state_pystr("state");
-            //PythonString stop_reason_pystr("stop_reason");
-            PythonString reg_data_addr_pystr ("register_data_addr");
-            
-            const uint32_t core_number = thread_dict.GetItemForKeyAsInteger (core_pystr, UINT32_MAX);
-            const addr_t reg_data_addr = thread_dict.GetItemForKeyAsInteger (reg_data_addr_pystr, LLDB_INVALID_ADDRESS);
-            const char *name = thread_dict.GetItemForKeyAsString (name_pystr);
-            const char *queue = thread_dict.GetItemForKeyAsString (queue_pystr);
-            //const char *state = thread_dict.GetItemForKeyAsString (state_pystr);
-            //const char *stop_reason = thread_dict.GetItemForKeyAsString (stop_reason_pystr);
-            
-            // See if a thread already exists for "tid"
-            thread_sp = old_thread_list.FindThreadByID (tid, false);
-            if (thread_sp)
-            {
-                // A thread already does exist for "tid", make sure it was an operating system
-                // plug-in generated thread.
-                if (!IsOperatingSystemPluginThread(thread_sp))
-                {
-                    // We have thread ID overlap between the protocol threads and the
-                    // operating system threads, clear the thread so we create an
-                    // operating system thread for this.
-                    thread_sp.reset();
-                }
-            }
-    
-            if (!thread_sp)
+            // We have thread ID overlap between the protocol threads and the
+            // operating system threads, clear the thread so we create an
+            // operating system thread for this.
+            thread_sp.reset();
+        }
+    }
+    if (!thread_sp)
+    {
+        if (did_create_ptr)
+            *did_create_ptr = true;
+        thread_sp.reset(new ThreadMemory(*m_process, tid, name.c_str(), queue.c_str(), reg_data_addr));
+    }
+    if (core_number < core_thread_list.GetSize(false))
+    {
+        ThreadSP core_thread_sp(core_thread_list.GetThreadAtIndex(core_number, false));
+        if (core_thread_sp)
+        {
+            // Keep track of which cores were set as the backing thread for memory threads...
+            if (core_number < core_used_map.size())
+                core_used_map[core_number] = true;
+
+            ThreadSP backing_core_thread_sp(core_thread_sp->GetBackingThread());
+            if (backing_core_thread_sp)
             {
-                if (did_create_ptr)
-                    *did_create_ptr = true;
-                thread_sp.reset (new ThreadMemory (*m_process,
-                                                   tid,
-                                                   name,
-                                                   queue,
-                                                   reg_data_addr));
-                
+                thread_sp->SetBackingThread(backing_core_thread_sp);
             }
-            
-            if (core_number < core_thread_list.GetSize(false))
+            else
             {
-                ThreadSP core_thread_sp (core_thread_list.GetThreadAtIndex(core_number, false));
-                if (core_thread_sp)
-                {
-                    // Keep track of which cores were set as the backing thread for memory threads...
-                    if (core_number < core_used_map.size())
-                        core_used_map[core_number] = true;
-
-                    ThreadSP backing_core_thread_sp (core_thread_sp->GetBackingThread());
-                    if (backing_core_thread_sp)
-                    {
-                        thread_sp->SetBackingThread(backing_core_thread_sp);
-                    }
-                    else
-                    {
-                        thread_sp->SetBackingThread(core_thread_sp);
-                    }
-                }
+                thread_sp->SetBackingThread(core_thread_sp);
             }
         }
     }

                          thread->GetID(),
                          thread->GetProtocolID());
 
-        PythonString reg_context_data(m_interpreter->OSPlugin_RegisterContextData (m_python_object_sp, thread->GetID()));
+        StructuredData::StringSP reg_context_data = m_interpreter->OSPlugin_RegisterContextData(m_python_object_sp, thread->GetID());
         if (reg_context_data)
         {
-            DataBufferSP data_sp (new DataBufferHeap (reg_context_data.GetString(),
-                                                      reg_context_data.GetSize()));
+            std::string value = reg_context_data->GetValue();
+            DataBufferSP data_sp(new DataBufferHeap(value.c_str(), value.length()));
             if (data_sp->GetByteSize())
             {
                 RegisterContextMemory *reg_ctx_memory = new RegisterContextMemory (*thread, 0, *GetDynamicRegisterInfo (), LLDB_INVALID_ADDRESS);

         Mutex::Locker api_locker (target.GetAPIMutex());
         
         auto lock = m_interpreter->AcquireInterpreterLock(); // to make sure thread_info_dict stays alive
-        PythonDictionary thread_info_dict (m_interpreter->OSPlugin_CreateThread(m_python_object_sp, tid, context));
+        StructuredData::DictionarySP thread_info_dict = m_interpreter->OSPlugin_CreateThread(m_python_object_sp, tid, context);
         std::vector<bool> core_used_map;
         if (thread_info_dict)
         {
             ThreadList core_threads(m_process);
             ThreadList &thread_list = m_process->GetThreadList();
             bool did_create = false;
-            ThreadSP thread_sp (CreateThreadFromThreadInfo (thread_info_dict, core_threads, thread_list, core_used_map, &did_create));
+            ThreadSP thread_sp(CreateThreadFromThreadInfo(*thread_info_dict, core_threads, thread_list, core_used_map, &did_create));
             if (did_create)
                 thread_list.AddThread(thread_sp);
             return thread_sp;

source/Plugins/Process/Utility/DynamicRegisterInfo.h

 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ConstString.h"
+#include "lldb/Core/StructuredData.h"
 
 class DynamicRegisterInfo
 {
 public:
     DynamicRegisterInfo ();
 
-    DynamicRegisterInfo (const lldb_private::PythonDictionary &dict,
-                         lldb::ByteOrder byte_order);
-    
+    DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict, lldb::ByteOrder byte_order);
+
     virtual 
     ~DynamicRegisterInfo ();
 
-    size_t
-    SetRegisterInfo (const lldb_private::PythonDictionary &dict,
-                     lldb::ByteOrder byte_order);
+    size_t SetRegisterInfo(const lldb_private::StructuredData::Dictionary &dict, lldb::ByteOrder byte_order);
 
     void
     AddRegister (lldb_private::RegisterInfo &reg_info, 

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

 #include "lldb/Host/StringConvert.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/DataFormatters/FormatManager.h"
 
-#ifndef LLDB_DISABLE_PYTHON
-#include "lldb/Interpreter/PythonDataObjects.h"
-#endif
-
 using namespace lldb;
 using namespace lldb_private;
 

 {
 }
 
-DynamicRegisterInfo::DynamicRegisterInfo (const lldb_private::PythonDictionary &dict, ByteOrder byte_order) :
-    m_regs (),
-    m_sets (),
-    m_set_reg_nums (),
-    m_set_names (),
-    m_value_regs_map (),
-    m_invalidate_regs_map (),
-    m_reg_data_byte_size (0),
-    m_finalized (false)
+DynamicRegisterInfo::DynamicRegisterInfo(const StructuredData::Dictionary &dict, ByteOrder byte_order)
+    : m_regs()
+    , m_sets()
+    , m_set_reg_nums()
+    , m_set_names()
+    , m_value_regs_map()
+    , m_invalidate_regs_map()
+    , m_reg_data_byte_size(0)
+    , m_finalized(false)
 {
     SetRegisterInfo (dict, byte_order);
 }

 {
 }
 
-
 size_t
-DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict,
-                                      ByteOrder byte_order)
+DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict, ByteOrder byte_order)
 {
     assert(!m_finalized);
-#ifndef LLDB_DISABLE_PYTHON
-    PythonList sets (dict.GetItemForKey("sets"));
-    if (sets)
+    StructuredData::Array *sets = nullptr;
+    if (dict.GetValueForKeyAsArray("sets", sets))
     {
-        const uint32_t num_sets = sets.GetSize();
+        const uint32_t num_sets = sets->GetSize();
         for (uint32_t i=0; i<num_sets; ++i)
         {
-            PythonString py_set_name(sets.GetItemAtIndex(i));
+            std::string set_name_str;
             ConstString set_name;
-            if (py_set_name)
-                set_name.SetCString(py_set_name.GetString());
+            if (sets->GetItemAtIndexAsString(i, set_name_str))
+                set_name.SetCString(set_name_str.c_str());
             if (set_name)
             {
                 RegisterSet new_set = { set_name.AsCString(), NULL, 0, NULL };

         }
         m_set_reg_nums.resize(m_sets.size());
     }
-    PythonList regs (dict.GetItemForKey("registers"));
-    if (regs)
-    {
-        const uint32_t num_regs = regs.GetSize();
-        PythonString name_pystr("name");
-        PythonString altname_pystr("alt-name");
-        PythonString bitsize_pystr("bitsize");
-        PythonString offset_pystr("offset");
-        PythonString encoding_pystr("encoding");
-        PythonString format_pystr("format");
-        PythonString set_pystr("set");
-        PythonString gcc_pystr("gcc");
-        PythonString dwarf_pystr("dwarf");
-        PythonString generic_pystr("generic");
-        PythonString slice_pystr("slice");
-        PythonString composite_pystr("composite");
-        PythonString invalidate_regs_pystr("invalidate-regs");
-        
+    StructuredData::Array *regs = nullptr;
+    if (!dict.GetValueForKeyAsArray("registers", regs))
+        return 0;
+
+    const uint32_t num_regs = regs->GetSize();
 //        typedef std::map<std::string, std::vector<std::string> > InvalidateNameMap;
 //        InvalidateNameMap invalidate_map;
-        for (uint32_t i=0; i<num_regs; ++i)
+    for (uint32_t i = 0; i < num_regs; ++i)
+    {
+        StructuredData::Dictionary *reg_info_dict = nullptr;
+        if (!regs->GetItemAtIndexAsDictionary(i, reg_info_dict))
         {
-            PythonDictionary reg_info_dict(regs.GetItemAtIndex(i));
-            if (reg_info_dict)
-            {
-                // { 'name':'rcx'       , 'bitsize' :  64, 'offset' :  16, 'encoding':'uint'  , 'format':'hex'         , 'set': 0, 'gcc' : 2, 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
-                RegisterInfo reg_info;
-                std::vector<uint32_t> value_regs;
-                std::vector<uint32_t> invalidate_regs;
-                memset(&reg_info, 0, sizeof(reg_info));
-                
-                reg_info.name = ConstString (reg_info_dict.GetItemForKeyAsString(name_pystr)).GetCString();
-                if (reg_info.name == NULL)
-                {
-                    Clear();
-                    printf("error: registers must have valid names\n");
-                    reg_info_dict.Dump();
-                    return 0;
-                }
-                    
-                reg_info.alt_name = ConstString (reg_info_dict.GetItemForKeyAsString(altname_pystr)).GetCString();
-                
-                reg_info.byte_offset = reg_info_dict.GetItemForKeyAsInteger(offset_pystr, UINT32_MAX);
+            Clear();
+            printf("error: items in the 'registers' array must be dictionaries\n");
+            regs->DumpToStdout();
+            return 0;
+        }
+
+        // { 'name':'rcx'       , 'bitsize' :  64, 'offset' :  16, 'encoding':'uint'  , 'format':'hex'         , 'set': 0, 'gcc' : 2,
+        // 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
+        RegisterInfo reg_info;
+        std::vector<uint32_t> value_regs;
+        std::vector<uint32_t> invalidate_regs;
+        memset(&reg_info, 0, sizeof(reg_info));
+
+        ConstString name_val;
+        ConstString alt_name_val;
+        if (!reg_info_dict->GetValueForKeyAsString("name", name_val, nullptr))
+        {
+            Clear();
+            printf("error: registers must have valid names and offsets\n");
+            reg_info_dict->DumpToStdout();
+            return 0;
+        }
+        reg_info.name = name_val.GetCString();
+        reg_info_dict->GetValueForKeyAsString("alt-name", alt_name_val, nullptr);
+        reg_info.alt_name = alt_name_val.GetCString();
 
-                if (reg_info.byte_offset == UINT32_MAX)
+        reg_info_dict->GetValueForKeyAsInteger("offset", reg_info.byte_offset, UINT32_MAX);
+
+        if (reg_info.byte_offset == UINT32_MAX)
+        {
+            // No offset for this register, see if the register has a value expression
+            // which indicates this register is part of another register. Value expressions
+            // are things like "rax[31:0]" which state that the current register's value
+            // is in a concrete register "rax" in bits 31:0. If there is a value expression
+            // we can calculate the offset
+            bool success = false;
+            std::string slice_str;
+            if (reg_info_dict->GetValueForKeyAsString("slice", slice_str, nullptr))
+            {
+                // Slices use the following format:
+                //  REGNAME[MSBIT:LSBIT]
+                // REGNAME - name of the register to grab a slice of
+                // MSBIT - the most significant bit at which the current register value starts at
+                // LSBIT - the least significant bit at which the current register value ends at
+                static RegularExpression g_bitfield_regex("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]");
+                RegularExpression::Match regex_match(3);
+                if (g_bitfield_regex.Execute(slice_str.c_str(), &regex_match))
                 {
-                    // No offset for this register, see if the register has a value expression
-                    // which indicates this register is part of another register. Value expressions
-                    // are things like "rax[31:0]" which state that the current register's value
-                    // is in a concrete register "rax" in bits 31:0. If there is a value expression
-                    // we can calculate the offset
-                    bool success = false;
-                    const char *slice_cstr = reg_info_dict.GetItemForKeyAsString(slice_pystr);
-                    if (slice_cstr)
+                    llvm::StringRef reg_name_str;
+                    std::string msbit_str;
+                    std::string lsbit_str;
+                    if (regex_match.GetMatchAtIndex(slice_str.c_str(), 1, reg_name_str) &&
+                        regex_match.GetMatchAtIndex(slice_str.c_str(), 2, msbit_str) &&
+                        regex_match.GetMatchAtIndex(slice_str.c_str(), 3, lsbit_str))
                     {
-                        // Slices use the following format:
-                        //  REGNAME[MSBIT:LSBIT]
-                        // REGNAME - name of the register to grab a slice of
-                        // MSBIT - the most significant bit at which the current register value starts at
-                        // LSBIT - the least significant bit at which the current register value ends at
-                        static RegularExpression g_bitfield_regex("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]");
-                        RegularExpression::Match regex_match(3);
-                        if (g_bitfield_regex.Execute(slice_cstr, &regex_match))
+                        const uint32_t msbit = StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
+                        const uint32_t lsbit = StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
+                        if (msbit != UINT32_MAX && lsbit != UINT32_MAX)
                         {
-                            llvm::StringRef reg_name_str;
-                            std::string msbit_str;
-                            std::string lsbit_str;
-                            if (regex_match.GetMatchAtIndex(slice_cstr, 1, reg_name_str) &&
-                                regex_match.GetMatchAtIndex(slice_cstr, 2, msbit_str) &&
-                                regex_match.GetMatchAtIndex(slice_cstr, 3, lsbit_str))
+                            if (msbit > lsbit)
                             {
-                                const uint32_t msbit = StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
-                                const uint32_t lsbit = StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
-                                if (msbit != UINT32_MAX && lsbit != UINT32_MAX)
+                                const uint32_t msbyte = msbit / 8;
+                                const uint32_t lsbyte = lsbit / 8;
+
+                                ConstString containing_reg_name(reg_name_str);
+
+                                RegisterInfo *containing_reg_info = GetRegisterInfo(containing_reg_name);
+                                if (containing_reg_info)
                                 {
-                                    if (msbit > lsbit)
+                                    const uint32_t max_bit = containing_reg_info->byte_size * 8;
+                                    if (msbit < max_bit && lsbit < max_bit)
                                     {
-                                        const uint32_t msbyte = msbit / 8;
-                                        const uint32_t lsbyte = lsbit / 8;
+                                        m_invalidate_regs_map[containing_reg_info->kinds[eRegisterKindLLDB]].push_back(i);
+                                        m_value_regs_map[i].push_back(containing_reg_info->kinds[eRegisterKindLLDB]);
+                                        m_invalidate_regs_map[i].push_back(containing_reg_info->kinds[eRegisterKindLLDB]);
 
-                                        ConstString containing_reg_name(reg_name_str);
-                                        
-                                        RegisterInfo *containing_reg_info = GetRegisterInfo (containing_reg_name);
-                                        if (containing_reg_info)
+                                        if (byte_order == eByteOrderLittle)
+                                        {
+                                            success = true;
+                                            reg_info.byte_offset = containing_reg_info->byte_offset + lsbyte;
+                                        }
+                                        else if (byte_order == eByteOrderBig)
                                         {
-                                            const uint32_t max_bit = containing_reg_info->byte_size * 8;
-                                            if (msbit < max_bit && lsbit < max_bit)
-                                            {
-                                                m_invalidate_regs_map[containing_reg_info->kinds[eRegisterKindLLDB]].push_back(i);
-                                                m_value_regs_map[i].push_back(containing_reg_info->kinds[eRegisterKindLLDB]);
-                                                m_invalidate_regs_map[i].push_back(containing_reg_info->kinds[eRegisterKindLLDB]);
-                                                
-                                                if (byte_order == eByteOrderLittle)
-                                                {
-                                                    success = true;
-                                                    reg_info.byte_offset = containing_reg_info->byte_offset + lsbyte;
-                                                }
-                                                else if (byte_order == eByteOrderBig)
-                                                {
-                                                    success = true;
-                                                    reg_info.byte_offset = containing_reg_info->byte_offset + msbyte;
-                                                }
-                                                else
-                                                {
-                                                    assert(!"Invalid byte order");
-                                                }
-                                            }
-                                            else
-                                            {
-                                                if (msbit > max_bit)
-                                                    printf("error: msbit (%u) must be less than the bitsize of the register (%u)\n", msbit, max_bit);
-                                                else
-                                                    printf("error: lsbit (%u) must be less than the bitsize of the register (%u)\n", lsbit, max_bit);
-                                            }
+                                            success = true;
+                                            reg_info.byte_offset = containing_reg_info->byte_offset + msbyte;
                                         }
                                         else
                                         {
-                                            printf("error: invalid concrete register \"%s\"\n", containing_reg_name.GetCString());
+                                            assert(!"Invalid byte order");
                                         }
                                     }
                                     else
                                     {
-                                        printf("error: msbit (%u) must be greater than lsbit (%u)\n", msbit, lsbit);
+                                        if (msbit > max_bit)
+                                            printf("error: msbit (%u) must be less than the bitsize of the register (%u)\n", msbit,
+                                                   max_bit);
+                                        else
+                                            printf("error: lsbit (%u) must be less than the bitsize of the register (%u)\n", lsbit,
+                                                   max_bit);
                                     }
                                 }
                                 else
                                 {
-                                    printf("error: msbit (%u) and lsbit (%u) must be valid\n", msbit, lsbit);
+                                    printf("error: invalid concrete register \"%s\"\n", containing_reg_name.GetCString());
                                 }
                             }
                             else
                             {
-                                // TODO: print error invalid slice string that doesn't follow the format
-                                printf("error: failed to extract regex matches for parsing the register bitfield regex\n");
-
+                                printf("error: msbit (%u) must be greater than lsbit (%u)\n", msbit, lsbit);
                             }
                         }
                         else
                         {
-                            // TODO: print error invalid slice string that doesn't follow the format
-                            printf("error: failed to match against register bitfield regex\n");
+                            printf("error: msbit (%u) and lsbit (%u) must be valid\n", msbit, lsbit);
                         }
                     }
                     else
                     {
-                        PythonList composite_reg_list (reg_info_dict.GetItemForKey(composite_pystr));
-                        if (composite_reg_list)
+                        // TODO: print error invalid slice string that doesn't follow the format
+                        printf("error: failed to extract regex matches for parsing the register bitfield regex\n");
+                    }
+                }
+                else
+                {
+                    // TODO: print error invalid slice string that doesn't follow the format
+                    printf("error: failed to match against register bitfield regex\n");
+                }
+            }
+            else
+            {
+                StructuredData::Array *composite_reg_list = nullptr;
+                if (reg_info_dict->GetValueForKeyAsArray("composite", composite_reg_list))
+                {
+                    const size_t num_composite_regs = composite_reg_list->GetSize();
+                    if (num_composite_regs > 0)
+                    {
+                        uint32_t composite_offset = UINT32_MAX;
+                        for (uint32_t composite_idx = 0; composite_idx < num_composite_regs; ++composite_idx)
                         {
-                            const size_t num_composite_regs = composite_reg_list.GetSize();
-                            if (num_composite_regs > 0)
+                            ConstString composite_reg_name;
+                            if (composite_reg_list->GetItemAtIndexAsString(composite_idx, composite_reg_name, nullptr))
                             {
-                                uint32_t composite_offset = UINT32_MAX;
-                                for (uint32_t composite_idx=0; composite_idx<num_composite_regs; ++composite_idx)
-                                {
-                                    PythonString composite_reg_name_pystr(composite_reg_list.GetItemAtIndex(composite_idx));
-                                    if (composite_reg_name_pystr)
-                                    {
-                                        ConstString composite_reg_name(composite_reg_name_pystr.GetString());
-                                        if (composite_reg_name)
-                                        {
-                                            RegisterInfo *composite_reg_info = GetRegisterInfo (composite_reg_name);
-                                            if (composite_reg_info)
-                                            {
-                                                if (composite_offset > composite_reg_info->byte_offset)
-                                                    composite_offset = composite_reg_info->byte_offset;
-                                                m_value_regs_map[i].push_back(composite_reg_info->kinds[eRegisterKindLLDB]);
-                                                m_invalidate_regs_map[composite_reg_info->kinds[eRegisterKindLLDB]].push_back(i);
-                                                m_invalidate_regs_map[i].push_back(composite_reg_info->kinds[eRegisterKindLLDB]);
-                                            }
-                                            else
-                                            {
-                                                // TODO: print error invalid slice string that doesn't follow the format
-                                                printf("error: failed to find composite register by name: \"%s\"\n", composite_reg_name.GetCString());
-                                            }
-                                        }
-                                        else
-                                        {
-                                            printf("error: 'composite' key contained an empty string\n");
-                                        }
-                                    }
-                                    else
-                                    {
-                                        printf("error: 'composite' list value wasn't a python string\n");
-                                    }
-                                }
-                                if (composite_offset != UINT32_MAX)
+                                RegisterInfo *composite_reg_info = GetRegisterInfo(composite_reg_name);
+                                if (composite_reg_info)
                                 {
-                                    reg_info.byte_offset = composite_offset;
-                                    success = m_value_regs_map.find(i) != m_value_regs_map.end();
+                                    composite_offset = std::min(composite_offset, composite_reg_info->byte_offset);
+                                    m_value_regs_map[i].push_back(composite_reg_info->kinds[eRegisterKindLLDB]);
+                                    m_invalidate_regs_map[composite_reg_info->kinds[eRegisterKindLLDB]].push_back(i);
+                                    m_invalidate_regs_map[i].push_back(composite_reg_info->kinds[eRegisterKindLLDB]);
                                 }
                                 else
                                 {
-                                    printf("error: 'composite' registers must specify at least one real register\n");
+                                    // TODO: print error invalid slice string that doesn't follow the format
+                                    printf("error: failed to find composite register by name: \"%s\"\n", composite_reg_name.GetCString());
                                 }
                             }
                             else
                             {
-                                printf("error: 'composite' list was empty\n");
+                                printf("error: 'composite' list value wasn't a python string\n");
                             }
                         }
+                        if (composite_offset != UINT32_MAX)
+                        {
+                            reg_info.byte_offset = composite_offset;
+                            success = m_value_regs_map.find(i) != m_value_regs_map.end();
+                        }
+                        else
+                        {
+                            printf("error: 'composite' registers must specify at least one real register\n");
+                        }
                     }
-                    
-                    
-                    if (!success)
+                    else
                     {
-                        Clear();
-                        reg_info_dict.Dump();
-                        return 0;
+                        printf("error: 'composite' list was empty\n");
                     }
                 }
-                const int64_t bitsize = reg_info_dict.GetItemForKeyAsInteger(bitsize_pystr, 0);
-                if (bitsize == 0)
-                {
-                    Clear();
-                    printf("error: invalid or missing 'bitsize' key/value pair in register dictionary\n");
-                    reg_info_dict.Dump();
-                    return 0;
-                }
+            }
 
-                reg_info.byte_size =  bitsize / 8;
-                
-                const char *format_cstr = reg_info_dict.GetItemForKeyAsString(format_pystr);
-                if (format_cstr)
-                {
-                    if (Args::StringToFormat(format_cstr, reg_info.format, NULL).Fail())
-                    {
-                        Clear();
-                        printf("error: invalid 'format' value in register dictionary\n");
-                        reg_info_dict.Dump();
-                        return 0;
-                    }
-                }
-                else
-                {
-                    reg_info.format = (Format)reg_info_dict.GetItemForKeyAsInteger (format_pystr, eFormatHex);
-                }
-                
-                const char *encoding_cstr = reg_info_dict.GetItemForKeyAsString(encoding_pystr);
-                if (encoding_cstr)
-                    reg_info.encoding = Args::StringToEncoding (encoding_cstr, eEncodingUint);
-                else
-                    reg_info.encoding = (Encoding)reg_info_dict.GetItemForKeyAsInteger (encoding_pystr, eEncodingUint);
+            if (!success)
+            {
+                Clear();
+                reg_info_dict->DumpToStdout();
+                return 0;
+            }
+        }
 
-                const int64_t set = reg_info_dict.GetItemForKeyAsInteger(set_pystr, -1);
-                if (static_cast<size_t>(set) >= m_sets.size())
-                {
-                    Clear();
-                    printf("error: invalid 'set' value in register dictionary, valid values are 0 - %i\n", (int)set);
-                    reg_info_dict.Dump();
-                    return 0;
-                }
+        int64_t bitsize = 0;
+        if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize))
+            printf("error: invalid or missing 'bitsize' key/value pair in register dictionary\n");
+            reg_info_dict->DumpToStdout();
 
-                // Fill in the register numbers
-                reg_info.kinds[lldb::eRegisterKindLLDB]    = i;
-                reg_info.kinds[lldb::eRegisterKindGDB]     = i;
-                reg_info.kinds[lldb::eRegisterKindGCC]     = reg_info_dict.GetItemForKeyAsInteger(gcc_pystr, LLDB_INVALID_REGNUM);
-                reg_info.kinds[lldb::eRegisterKindDWARF]   = reg_info_dict.GetItemForKeyAsInteger(dwarf_pystr, LLDB_INVALID_REGNUM);
-                const char *generic_cstr = reg_info_dict.GetItemForKeyAsString(generic_pystr);
-                if (generic_cstr)
-                    reg_info.kinds[lldb::eRegisterKindGeneric] = Args::StringToGenericRegister (generic_cstr);
-                else
-                    reg_info.kinds[lldb::eRegisterKindGeneric] = reg_info_dict.GetItemForKeyAsInteger(generic_pystr, LLDB_INVALID_REGNUM);
+        reg_info.byte_size = bitsize / 8;
+
+        std::string format_str;
+        if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr))
+        {
+            if (Args::StringToFormat(format_str.c_str(), reg_info.format, NULL).Fail())
+            {
+                Clear();
+                printf("error: invalid 'format' value in register dictionary\n");
+                reg_info_dict->DumpToStdout();
+                return 0;
+            }
+        }
+        else
+        {
+            reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format, eFormatHex);
+        }
+
+        std::string encoding_str;
+        if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
+            reg_info.encoding = Args::StringToEncoding(encoding_str.c_str(), eEncodingUint);
+        else
+            reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding, eEncodingUint);
 
-                // Check if this register invalidates any other register values when it is modified
-                PythonList invalidate_reg_list (reg_info_dict.GetItemForKey(invalidate_regs_pystr));
-                if (invalidate_reg_list)
+        size_t set = 0;
+        if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) || set >= m_sets.size())
+        {
+            Clear();
+            printf("error: invalid 'set' value in register dictionary, valid values are 0 - %i\n", (int)set);
+            reg_info_dict->DumpToStdout();
+            return 0;
+        }
+
+        // Fill in the register numbers
+        reg_info.kinds[lldb::eRegisterKindLLDB] = i;
+        reg_info.kinds[lldb::eRegisterKindGDB] = i;
+        reg_info_dict->GetValueForKeyAsInteger("gcc", reg_info.kinds[lldb::eRegisterKindGCC], LLDB_INVALID_REGNUM);
+        reg_info_dict->GetValueForKeyAsInteger("dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM);
+        std::string generic_str;
+        if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
+            reg_info.kinds[lldb::eRegisterKindGeneric] = Args::StringToGenericRegister(generic_str.c_str());
+        else
+            reg_info_dict->GetValueForKeyAsInteger("generic", reg_info.kinds[lldb::eRegisterKindGeneric], LLDB_INVALID_REGNUM);
+
+        // Check if this register invalidates any other register values when it is modified
+        StructuredData::Array *invalidate_reg_list = nullptr;
+        if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs", invalidate_reg_list))
+        {
+            const size_t num_regs = invalidate_reg_list->GetSize();
+            if (num_regs > 0)
+            {
+                for (uint32_t idx = 0; idx < num_regs; ++idx)
                 {
-                    const size_t num_regs = invalidate_reg_list.GetSize();
-                    if (num_regs > 0)
+                    ConstString invalidate_reg_name;
+                    uint64_t invalidate_reg_num;
+                    if (invalidate_reg_list->GetItemAtIndexAsString(idx, invalidate_reg_name))
                     {
-                        for (uint32_t idx=0; idx<num_regs; ++idx)
+                        RegisterInfo *invalidate_reg_info = GetRegisterInfo(invalidate_reg_name);
+                        if (invalidate_reg_info)
                         {
-                            PythonObject invalidate_reg_object (invalidate_reg_list.GetItemAtIndex(idx));
-                            PythonString invalidate_reg_name_pystr(invalidate_reg_object);
-                            if (invalidate_reg_name_pystr)
-                            {
-                                ConstString invalidate_reg_name(invalidate_reg_name_pystr.GetString());
-                                if (invalidate_reg_name)
-                                {
-                                    RegisterInfo *invalidate_reg_info = GetRegisterInfo (invalidate_reg_name);
-                                    if (invalidate_reg_info)
-                                    {
-                                        m_invalidate_regs_map[i].push_back(invalidate_reg_info->kinds[eRegisterKindLLDB]);
-                                    }
-                                    else
-                                    {
-                                        // TODO: print error invalid slice string that doesn't follow the format
-                                        printf("error: failed to find a 'invalidate-regs' register for \"%s\" while parsing register \"%s\"\n", invalidate_reg_name.GetCString(), reg_info.name);
-                                    }
-                                }
-                                else
-                                {
-                                    printf("error: 'invalidate-regs' list value was an empty string\n");
-                                }
-                            }
-                            else
-                            {
-                                PythonInteger invalidate_reg_num(invalidate_reg_object);
-
-                                if (invalidate_reg_num)
-                                {
-                                    const int64_t r = invalidate_reg_num.GetInteger();
-                                    if (r != static_cast<int64_t>(UINT64_MAX))
-                                        m_invalidate_regs_map[i].push_back(r);
-                                    else
-                                        printf("error: 'invalidate-regs' list value wasn't a valid integer\n");
-                                }
-                                else
-                                {
-                                    printf("error: 'invalidate-regs' list value wasn't a python string or integer\n");
-                                }
-                            }
+                            m_invalidate_regs_map[i].push_back(invalidate_reg_info->kinds[eRegisterKindLLDB]);
+                        }
+                        else
+                            // TODO: print error invalid slice string that doesn't follow the format
+                            printf("error: failed to find a 'invalidate-regs' register for \"%s\" while parsing register \"%s\"\n",
+                                   invalidate_reg_name.GetCString(), reg_info.name);
                         }
                     }
+                    else if (invalidate_reg_list->GetItemAtIndexAsInteger(idx, invalidate_reg_num))
+                    {
+                        if (invalidate_reg_num != UINT64_MAX)
+                            m_invalidate_regs_map[i].push_back(invalidate_reg_num);
+                        else
+                            printf("error: 'invalidate-regs' list value wasn't a valid integer\n");
+                    }
                     else
                     {
-                        printf("error: 'invalidate-regs' contained an empty list\n");
+                        printf("error: 'invalidate-regs' list value wasn't a python string or integer\n");
                     }
                 }
-
-                // Calculate the register offset
-                const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
-                if (m_reg_data_byte_size < end_reg_offset)
-                    m_reg_data_byte_size = end_reg_offset;
-
-                m_regs.push_back (reg_info);
-                m_set_reg_nums[set].push_back(i);
-
             }
             else
             {
-                Clear();
-                printf("error: items in the 'registers' array must be dictionaries\n");
-                regs.Dump();
-                return 0;
+                printf("error: 'invalidate-regs' contained an empty list\n");
             }
         }
-        Finalize ();
+
+        // Calculate the register offset
+        const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
+        if (m_reg_data_byte_size < end_reg_offset)
+            m_reg_data_byte_size = end_reg_offset;
+
+        m_regs.push_back(reg_info);
+        m_set_reg_nums[set].push_back(i);
     }
-#endif
+    Finalize();
     return m_regs.size();
 }
 

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 
     bool
     ParsePythonTargetDefinition(const lldb_private::FileSpec &target_definition_fspec);
-    
-    bool
-    ParseRegisters(lldb_private::ScriptInterpreterObject *registers_array);
 
     const lldb::DataBufferSP
     GetAuxvData() override;

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
-#ifndef LLDB_DISABLE_PYTHON
-#include "lldb/Interpreter/PythonDataObjects.h"
-#endif
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Target.h"

 bool
 ProcessGDBRemote::ParsePythonTargetDefinition(const FileSpec &target_definition_fspec)
 {
-#ifndef LLDB_DISABLE_PYTHON
     ScriptInterpreter *interpreter = GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
     Error error;
-    lldb::ScriptInterpreterObjectSP module_object_sp (interpreter->LoadPluginModule(target_definition_fspec, error));
+    StructuredData::ObjectSP module_object_sp(interpreter->LoadPluginModule(target_definition_fspec, error));
     if (module_object_sp)
     {
-        lldb::ScriptInterpreterObjectSP target_definition_sp (interpreter->GetDynamicSettings(module_object_sp,
-                                                                                              &GetTarget(),
-                                                                                              "gdb-server-target-definition",
-                                                                                              error));
-        
-        PythonDictionary target_dict(target_definition_sp);
+        StructuredData::DictionarySP target_definition_sp(
+            interpreter->GetDynamicSettings(module_object_sp, &GetTarget(), "gdb-server-target-definition", error));
 
-        if (target_dict)
+        if (target_definition_sp)
         {
-            PythonDictionary host_info_dict (target_dict.GetItemForKey("host-info"));
-            if (host_info_dict)
+            StructuredData::ObjectSP target_object(target_definition_sp->GetValueForKey("host-info"));
+            if (target_object)
             {
-                ArchSpec host_arch (host_info_dict.GetItemForKeyAsString(PythonString("triple")));
-                
-                if (!host_arch.IsCompatibleMatch(GetTarget().GetArchitecture()))
+                if (auto host_info_dict = target_object->GetAsDictionary())
                 {
-                    GetTarget().SetArchitecture(host_arch);
+                    StructuredData::ObjectSP triple_value = host_info_dict->GetValueForKey("triple");
+                    if (auto triple_string_value = triple_value->GetAsString())
+                    {
+                        std::string triple_string = triple_string_value->GetValue();
+                        ArchSpec host_arch(triple_string.c_str());
+                        if (!host_arch.IsCompatibleMatch(GetTarget().GetArchitecture()))
+                        {
+                            GetTarget().SetArchitecture(host_arch);
+                        }
+                    }
                 }
-                    
             }
-            m_breakpoint_pc_offset = target_dict.GetItemForKeyAsInteger("breakpoint-pc-offset", 0);
+            m_breakpoint_pc_offset = 0;
+            StructuredData::ObjectSP breakpoint_pc_offset_value = target_definition_sp->GetValueForKey("breakpoint-pc-offset");
+            if (breakpoint_pc_offset_value)
+            {
+                if (auto breakpoint_pc_int_value = breakpoint_pc_offset_value->GetAsInteger())
+                    m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue();
+            }
 
-            if (m_register_info.SetRegisterInfo (target_dict, GetTarget().GetArchitecture().GetByteOrder()) > 0)
+            if (m_register_info.SetRegisterInfo(*target_definition_sp, GetTarget().GetArchitecture().GetByteOrder()) > 0)
             {
                 return true;
             }
         }
     }
-#endif
     return false;
 }
 

source/Target/ThreadPlanPython.cpp

 #include "lldb/Core/State.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
-#include "lldb/Interpreter/ScriptInterpreterPython.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"