Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release:

MFC r309142 (by emaste):

Add WITH_LLD_AS_LD build knob

If set it installs LLD as /usr/bin/ld.  LLD (as of version 3.9) is not
capable of linking the world and kernel, but can self-host and link many
substantial applications. GNU ld continues to be used for the world and
kernel build, regardless of how this knob is set.

It is on by default for arm64, and off for all other CPU architectures.

Sponsored by:	The FreeBSD Foundation

MFC r310840:

Reapply 310775, now it also builds correctly if lldb is disabled:

Move llvm-objdump from CLANG_EXTRAS to installed by default

We currently install three tools from binutils 2.17.50: as, ld, and
objdump. Work is underway to migrate to a permissively-licensed
tool-chain, with one goal being the retirement of binutils 2.17.50.

LLVM's llvm-objdump is intended to be compatible with GNU objdump
although it is currently missing some options and may have formatting
differences. Enable it by default for testing and further investigation.
It may later be changed to install as /usr/bin/objdump, it becomes a
fully viable replacement.

Reviewed by:	emaste
Differential Revision:	https://reviews.freebsd.org/D8879

MFC r312855 (by emaste):

Rename LLD_AS_LD to LLD_IS_LD, for consistency with CLANG_IS_CC

Reported by:	Dan McGregor <dan.mcgregor usask.ca>

MFC r313559 | glebius | 2017-02-10 18:34:48 +0100 (Fri, 10 Feb 2017) | 5 lines

Don't check struct rtentry on FreeBSD, it is an internal kernel structure.
On other systems it may be API structure for SIOCADDRT/SIOCDELRT.

Reviewed by:	emaste, dim

MFC r314152 (by jkim):

Remove an assembler flag, which is redundant since r309124.  The upstream
took care of it by introducing a macro NO_EXEC_STACK_DIRECTIVE.

http://llvm.org/viewvc/llvm-project?rev=273500&view=rev

Reviewed by:	dim

MFC r314564:

Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
4.0.0 (branches/release_40 296509).  The release will follow soon.

Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11
support to build; see UPDATING for more information.

Also note that as of 4.0.0, lld should be able to link the base system
on amd64 and aarch64.  See the WITH_LLD_IS_LLD setting in src.conf(5).
Though please be aware that this is work in progress.

Release notes for llvm, clang and lld will be available here:
<http://releases.llvm.org/4.0.0/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/clang/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/lld/docs/ReleaseNotes.html>

Thanks to Ed Maste, Jan Beich, Antoine Brodin and Eric Fiselier for
their help.

Relnotes:	yes
Exp-run:	antoine
PR:		215969, 216008

MFC r314708:

For now, revert r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

This commit is the cause of excessive compile times on skein_block.c
(and possibly other files) during kernel builds on amd64.

We never saw the problematic behavior described in this upstream commit,
so for now it is better to revert it.  An upstream bug has been filed
here: https://bugs.llvm.org/show_bug.cgi?id=32142

Reported by:	mjg

MFC r314795:

Reapply r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

Pull in r296992 from upstream llvm trunk (by Sanjoy Das):

  [SCEV] Decrease the recursion threshold for CompareValueComplexity

  Fixes PR32142.

  r287232 accidentally increased the recursion threshold for
  CompareValueComplexity from 2 to 32.  This change reverses that
  change by introducing a separate flag for CompareValueComplexity's
  threshold.

The latter revision fixes the excessive compile times for skein_block.c.

MFC r314907 | mmel | 2017-03-08 12:40:27 +0100 (Wed, 08 Mar 2017) | 7 lines

Unbreak ARMv6 world.

The new compiler_rt library imported with clang 4.0.0 have several fatal
issues (non-functional __udivsi3 for example) with ARM specific instrict
functions. As temporary workaround, until upstream solve these problems,
disable all thumb[1][2] related feature.

MFC r315016:

Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release.
We were already very close to the last release candidate, so this is a
pretty minor update.

Relnotes:	yes

MFC r316005:

Revert r314907, and pull in r298713 from upstream compiler-rt trunk (by
Weiming Zhao):

  builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA.

  Summary:
  Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation
  mode (-mthumb, -marm), it reflect's capability of given CPU.

  Due to this:
   - use  __tbumb__ and __thumb2__ insteand of __ARM_ARCH_ISA_THUMB
   - use '.thumb' directive consistently  in all affected files
   - decorate all thumb functions using
     DEFINE_COMPILERRT_THUMB_FUNCTION()

  ---------
  Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 !

  Reviewers: weimingz, rengolin, compnerd

  Subscribers: aemerson, dim

  Differential Revision: https://reviews.llvm.org/D30938

Discussed with:	mmel

7 files changed, 4456 insertions, 4934 deletions

diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
index 1fdf4c7..f3453f2 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
@@ -1,4 +1,5 @@
-//===-- PythonDataObjects.cpp ------------------------------------*- C++ -*-===//
+//===-- PythonDataObjects.cpp ------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -13,7 +14,6 @@
 
 #else
 
-#include "lldb-python.h"
 #include "PythonDataObjects.h"
 #include "ScriptInterpreterPython.h"
 
@@ -31,1273 +31,1020 @@
 using namespace lldb_private;
 using namespace lldb;
 
-void
-StructuredPythonObject::Dump(Stream &s) const
-{
-    s << "Python Obj: 0x" << GetValue();
+void StructuredPythonObject::Dump(Stream &s, bool pretty_print) const {
+  s << "Python Obj: 0x" << GetValue();
 }
 
 //----------------------------------------------------------------------
 // PythonObject
 //----------------------------------------------------------------------
 
-void
-PythonObject::Dump(Stream &strm) const
-{
-    if (m_py_obj)
-    {
-        FILE *file = ::tmpfile();
-        if (file)
-        {
-            ::PyObject_Print (m_py_obj, file, 0);
-            const long length = ftell (file);
-            if (length)
-            {
-                ::rewind(file);
-                std::vector<char> file_contents (length,'\0');
-                const size_t length_read = ::fread (file_contents.data(), 1, file_contents.size(), file);
-                if (length_read > 0)
-                    strm.Write (file_contents.data(), length_read);
-            }
-            ::fclose (file);
-        }
+void PythonObject::Dump(Stream &strm) const {
+  if (m_py_obj) {
+    FILE *file = ::tmpfile();
+    if (file) {
+      ::PyObject_Print(m_py_obj, file, 0);
+      const long length = ftell(file);
+      if (length) {
+        ::rewind(file);
+        std::vector<char> file_contents(length, '\0');
+        const size_t length_read =
+            ::fread(file_contents.data(), 1, file_contents.size(), file);
+        if (length_read > 0)
+          strm.Write(file_contents.data(), length_read);
+      }
+      ::fclose(file);
     }
-    else
-        strm.PutCString ("NULL");
-}
-
-PyObjectType
-PythonObject::GetObjectType() const
-{
-    if (!IsAllocated())
-        return PyObjectType::None;
-
-    if (PythonModule::Check(m_py_obj))
-        return PyObjectType::Module;
-    if (PythonList::Check(m_py_obj))
-        return PyObjectType::List;
-    if (PythonTuple::Check(m_py_obj))
-        return PyObjectType::Tuple;
-    if (PythonDictionary::Check(m_py_obj))
-        return PyObjectType::Dictionary;
-    if (PythonString::Check(m_py_obj))
-        return PyObjectType::String;
+  } else
+    strm.PutCString("NULL");
+}
+
+PyObjectType PythonObject::GetObjectType() const {
+  if (!IsAllocated())
+    return PyObjectType::None;
+
+  if (PythonModule::Check(m_py_obj))
+    return PyObjectType::Module;
+  if (PythonList::Check(m_py_obj))
+    return PyObjectType::List;
+  if (PythonTuple::Check(m_py_obj))
+    return PyObjectType::Tuple;
+  if (PythonDictionary::Check(m_py_obj))
+    return PyObjectType::Dictionary;
+  if (PythonString::Check(m_py_obj))
+    return PyObjectType::String;
 #if PY_MAJOR_VERSION >= 3
-    if (PythonBytes::Check(m_py_obj))
-        return PyObjectType::Bytes;
+  if (PythonBytes::Check(m_py_obj))
+    return PyObjectType::Bytes;
 #endif
-    if (PythonByteArray::Check(m_py_obj))
-        return PyObjectType::ByteArray;
-    if (PythonInteger::Check(m_py_obj))
-        return PyObjectType::Integer;
-    if (PythonFile::Check(m_py_obj))
-        return PyObjectType::File;
-    if (PythonCallable::Check(m_py_obj))
-        return PyObjectType::Callable;
-    return PyObjectType::Unknown;
-}
-
-PythonString
-PythonObject::Repr() const
-{
-    if (!m_py_obj)
-        return PythonString();
-    PyObject *repr = PyObject_Repr(m_py_obj);
-    if (!repr)
-        return PythonString();
-    return PythonString(PyRefType::Owned, repr);
-}
-
-PythonString
-PythonObject::Str() const
-{
-    if (!m_py_obj)
-        return PythonString();
-    PyObject *str = PyObject_Str(m_py_obj);
-    if (!str)
-        return PythonString();
-    return PythonString(PyRefType::Owned, str);
+  if (PythonByteArray::Check(m_py_obj))
+    return PyObjectType::ByteArray;
+  if (PythonInteger::Check(m_py_obj))
+    return PyObjectType::Integer;
+  if (PythonFile::Check(m_py_obj))
+    return PyObjectType::File;
+  if (PythonCallable::Check(m_py_obj))
+    return PyObjectType::Callable;
+  return PyObjectType::Unknown;
+}
+
+PythonString PythonObject::Repr() const {
+  if (!m_py_obj)
+    return PythonString();
+  PyObject *repr = PyObject_Repr(m_py_obj);
+  if (!repr)
+    return PythonString();
+  return PythonString(PyRefType::Owned, repr);
+}
+
+PythonString PythonObject::Str() const {
+  if (!m_py_obj)
+    return PythonString();
+  PyObject *str = PyObject_Str(m_py_obj);
+  if (!str)
+    return PythonString();
+  return PythonString(PyRefType::Owned, str);
 }
 
 PythonObject
-PythonObject::ResolveNameWithDictionary(llvm::StringRef name, const PythonDictionary &dict)
-{
-    size_t dot_pos = name.find_first_of('.');
-    llvm::StringRef piece = name.substr(0, dot_pos);
-    PythonObject result = dict.GetItemForKey(PythonString(piece));
-    if (dot_pos == llvm::StringRef::npos)
-    {
-        // There was no dot, we're done.
-        return result;
-    }
+PythonObject::ResolveNameWithDictionary(llvm::StringRef name,
+                                        const PythonDictionary &dict) {
+  size_t dot_pos = name.find_first_of('.');
+  llvm::StringRef piece = name.substr(0, dot_pos);
+  PythonObject result = dict.GetItemForKey(PythonString(piece));
+  if (dot_pos == llvm::StringRef::npos) {
+    // There was no dot, we're done.
+    return result;
+  }
+
+  // There was a dot.  The remaining portion of the name should be looked up in
+  // the context of the object that was found in the dictionary.
+  return result.ResolveName(name.substr(dot_pos + 1));
+}
+
+PythonObject PythonObject::ResolveName(llvm::StringRef name) const {
+  // Resolve the name in the context of the specified object.  If,
+  // for example, `this` refers to a PyModule, then this will look for
+  // `name` in this module.  If `this` refers to a PyType, then it will
+  // resolve `name` as an attribute of that type.  If `this` refers to
+  // an instance of an object, then it will resolve `name` as the value
+  // of the specified field.
+  //
+  // This function handles dotted names so that, for example, if `m_py_obj`
+  // refers to the `sys` module, and `name` == "path.append", then it
+  // will find the function `sys.path.append`.
+
+  size_t dot_pos = name.find_first_of('.');
+  if (dot_pos == llvm::StringRef::npos) {
+    // No dots in the name, we should be able to find the value immediately
+    // as an attribute of `m_py_obj`.
+    return GetAttributeValue(name);
+  }
+
+  // Look up the first piece of the name, and resolve the rest as a child of
+  // that.
+  PythonObject parent = ResolveName(name.substr(0, dot_pos));
+  if (!parent.IsAllocated())
+    return PythonObject();
 
-    // There was a dot.  The remaining portion of the name should be looked up in
-    // the context of the object that was found in the dictionary.
-    return result.ResolveName(name.substr(dot_pos + 1));
+  // Tail recursion.. should be optimized by the compiler
+  return parent.ResolveName(name.substr(dot_pos + 1));
 }
 
-PythonObject
-PythonObject::ResolveName(llvm::StringRef name) const
-{
-    // Resolve the name in the context of the specified object.  If,
-    // for example, `this` refers to a PyModule, then this will look for
-    // `name` in this module.  If `this` refers to a PyType, then it will
-    // resolve `name` as an attribute of that type.  If `this` refers to
-    // an instance of an object, then it will resolve `name` as the value
-    // of the specified field.
-    //
-    // This function handles dotted names so that, for example, if `m_py_obj`
-    // refers to the `sys` module, and `name` == "path.append", then it
-    // will find the function `sys.path.append`.
-
-    size_t dot_pos = name.find_first_of('.');
-    if (dot_pos == llvm::StringRef::npos)
-    {
-        // No dots in the name, we should be able to find the value immediately
-        // as an attribute of `m_py_obj`.
-        return GetAttributeValue(name);
-    }
+bool PythonObject::HasAttribute(llvm::StringRef attr) const {
+  if (!IsValid())
+    return false;
+  PythonString py_attr(attr);
+  return !!PyObject_HasAttr(m_py_obj, py_attr.get());
+}
 
-    // Look up the first piece of the name, and resolve the rest as a child of that.
-    PythonObject parent = ResolveName(name.substr(0, dot_pos));
-    if (!parent.IsAllocated())
-        return PythonObject();
+PythonObject PythonObject::GetAttributeValue(llvm::StringRef attr) const {
+  if (!IsValid())
+    return PythonObject();
 
-    // Tail recursion.. should be optimized by the compiler
-    return parent.ResolveName(name.substr(dot_pos + 1));
-}
+  PythonString py_attr(attr);
+  if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
+    return PythonObject();
 
-bool
-PythonObject::HasAttribute(llvm::StringRef attr) const
-{
-    if (!IsValid())
-        return false;
-    PythonString py_attr(attr);
-    return !!PyObject_HasAttr(m_py_obj, py_attr.get());
+  return PythonObject(PyRefType::Owned,
+                      PyObject_GetAttr(m_py_obj, py_attr.get()));
 }
 
-PythonObject
-PythonObject::GetAttributeValue(llvm::StringRef attr) const
-{
-    if (!IsValid())
-        return PythonObject();
-
-    PythonString py_attr(attr);
-    if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
-        return PythonObject();
-
-    return PythonObject(PyRefType::Owned,
-        PyObject_GetAttr(m_py_obj, py_attr.get()));
-}
-
-bool
-PythonObject::IsNone() const
-{
-    return m_py_obj == Py_None;
-}
-
-bool
-PythonObject::IsValid() const
-{
-    return m_py_obj != nullptr;
-}
-
-bool
-PythonObject::IsAllocated() const
-{
-    return IsValid() && !IsNone();
-}
-
-StructuredData::ObjectSP
-PythonObject::CreateStructuredObject() const
-{
-    switch (GetObjectType())
-    {
-        case PyObjectType::Dictionary:
-            return PythonDictionary(PyRefType::Borrowed, m_py_obj).CreateStructuredDictionary();
-        case PyObjectType::Integer:
-            return PythonInteger(PyRefType::Borrowed, m_py_obj).CreateStructuredInteger();
-        case PyObjectType::List:
-            return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
-        case PyObjectType::String:
-            return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
-        case PyObjectType::Bytes:
-            return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
-        case PyObjectType::ByteArray:
-            return PythonByteArray(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
-        case PyObjectType::None:
-            return StructuredData::ObjectSP();
-        default:
-            return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
-    }
+bool PythonObject::IsNone() const { return m_py_obj == Py_None; }
+
+bool PythonObject::IsValid() const { return m_py_obj != nullptr; }
+
+bool PythonObject::IsAllocated() const { return IsValid() && !IsNone(); }
+
+StructuredData::ObjectSP PythonObject::CreateStructuredObject() const {
+  switch (GetObjectType()) {
+  case PyObjectType::Dictionary:
+    return PythonDictionary(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredDictionary();
+  case PyObjectType::Integer:
+    return PythonInteger(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredInteger();
+  case PyObjectType::List:
+    return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
+  case PyObjectType::String:
+    return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
+  case PyObjectType::Bytes:
+    return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
+  case PyObjectType::ByteArray:
+    return PythonByteArray(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredString();
+  case PyObjectType::None:
+    return StructuredData::ObjectSP();
+  default:
+    return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
+  }
 }
 
 //----------------------------------------------------------------------
 // PythonString
 //----------------------------------------------------------------------
-PythonBytes::PythonBytes() : PythonObject()
-{
-}
+PythonBytes::PythonBytes() : PythonObject() {}
 
-PythonBytes::PythonBytes(llvm::ArrayRef<uint8_t> bytes) : PythonObject()
-{
-    SetBytes(bytes);
+PythonBytes::PythonBytes(llvm::ArrayRef<uint8_t> bytes) : PythonObject() {
+  SetBytes(bytes);
 }
 
-PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) : PythonObject()
-{
-    SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
+PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) : PythonObject() {
+  SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
 }
 
-PythonBytes::PythonBytes(PyRefType type, PyObject *py_obj) : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
+PythonBytes::PythonBytes(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonBytes::PythonBytes(const PythonBytes &object) : PythonObject(object)
-{
-}
+PythonBytes::PythonBytes(const PythonBytes &object) : PythonObject(object) {}
 
-PythonBytes::~PythonBytes()
-{
-}
+PythonBytes::~PythonBytes() {}
 
-bool
-PythonBytes::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    if (PyBytes_Check(py_obj))
-        return true;
+bool PythonBytes::Check(PyObject *py_obj) {
+  if (!py_obj)
     return false;
+  if (PyBytes_Check(py_obj))
+    return true;
+  return false;
 }
 
-void
-PythonBytes::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonBytes::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonBytes::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonBytes::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-llvm::ArrayRef<uint8_t>
-PythonBytes::GetBytes() const
-{
-    if (!IsValid())
-        return llvm::ArrayRef<uint8_t>();
+llvm::ArrayRef<uint8_t> PythonBytes::GetBytes() const {
+  if (!IsValid())
+    return llvm::ArrayRef<uint8_t>();
 
-    Py_ssize_t size;
-    char *c;
+  Py_ssize_t size;
+  char *c;
 
-    PyBytes_AsStringAndSize(m_py_obj, &c, &size);
-    return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
+  PyBytes_AsStringAndSize(m_py_obj, &c, &size);
+  return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
 }
 
-size_t
-PythonBytes::GetSize() const
-{
-    if (!IsValid())
-        return 0;
-    return PyBytes_Size(m_py_obj);
+size_t PythonBytes::GetSize() const {
+  if (!IsValid())
+    return 0;
+  return PyBytes_Size(m_py_obj);
 }
 
-void
-PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes)
-{
-    const char *data = reinterpret_cast<const char *>(bytes.data());
-    PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
-    PythonObject::Reset(PyRefType::Owned, py_bytes);
+void PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes) {
+  const char *data = reinterpret_cast<const char *>(bytes.data());
+  PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
+  PythonObject::Reset(PyRefType::Owned, py_bytes);
 }
 
-StructuredData::StringSP
-PythonBytes::CreateStructuredString() const
-{
-    StructuredData::StringSP result(new StructuredData::String);
-    Py_ssize_t size;
-    char *c;
-    PyBytes_AsStringAndSize(m_py_obj, &c, &size);
-    result->SetValue(std::string(c, size));
-    return result;
+StructuredData::StringSP PythonBytes::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  Py_ssize_t size;
+  char *c;
+  PyBytes_AsStringAndSize(m_py_obj, &c, &size);
+  result->SetValue(std::string(c, size));
+  return result;
 }
 
-PythonByteArray::PythonByteArray(llvm::ArrayRef<uint8_t> bytes) : PythonByteArray(bytes.data(), bytes.size())
-{
-}
+PythonByteArray::PythonByteArray(llvm::ArrayRef<uint8_t> bytes)
+    : PythonByteArray(bytes.data(), bytes.size()) {}
 
-PythonByteArray::PythonByteArray(const uint8_t *bytes, size_t length)
-{
-    const char *str = reinterpret_cast<const char *>(bytes);
-    Reset(PyRefType::Owned, PyByteArray_FromStringAndSize(str, length));
+PythonByteArray::PythonByteArray(const uint8_t *bytes, size_t length) {
+  const char *str = reinterpret_cast<const char *>(bytes);
+  Reset(PyRefType::Owned, PyByteArray_FromStringAndSize(str, length));
 }
 
-PythonByteArray::PythonByteArray(PyRefType type, PyObject *o)
-{
-    Reset(type, o);
+PythonByteArray::PythonByteArray(PyRefType type, PyObject *o) {
+  Reset(type, o);
 }
 
-PythonByteArray::PythonByteArray(const PythonBytes &object) : PythonObject(object)
-{
-}
+PythonByteArray::PythonByteArray(const PythonBytes &object)
+    : PythonObject(object) {}
 
-PythonByteArray::~PythonByteArray()
-{
-}
+PythonByteArray::~PythonByteArray() {}
 
-bool
-PythonByteArray::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    if (PyByteArray_Check(py_obj))
-        return true;
+bool PythonByteArray::Check(PyObject *py_obj) {
+  if (!py_obj)
     return false;
+  if (PyByteArray_Check(py_obj))
+    return true;
+  return false;
 }
 
-void
-PythonByteArray::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonByteArray::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonByteArray::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonByteArray::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-llvm::ArrayRef<uint8_t>
-PythonByteArray::GetBytes() const
-{
-    if (!IsValid())
-        return llvm::ArrayRef<uint8_t>();
+llvm::ArrayRef<uint8_t> PythonByteArray::GetBytes() const {
+  if (!IsValid())
+    return llvm::ArrayRef<uint8_t>();
 
-    char *c = PyByteArray_AsString(m_py_obj);
-    size_t size = GetSize();
-    return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
+  char *c = PyByteArray_AsString(m_py_obj);
+  size_t size = GetSize();
+  return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
 }
 
-size_t
-PythonByteArray::GetSize() const
-{
-    if (!IsValid())
-        return 0;
+size_t PythonByteArray::GetSize() const {
+  if (!IsValid())
+    return 0;
 
-    return PyByteArray_Size(m_py_obj);
+  return PyByteArray_Size(m_py_obj);
 }
 
-StructuredData::StringSP
-PythonByteArray::CreateStructuredString() const
-{
-    StructuredData::StringSP result(new StructuredData::String);
-    llvm::ArrayRef<uint8_t> bytes = GetBytes();
-    const char *str = reinterpret_cast<const char *>(bytes.data());
-    result->SetValue(std::string(str, bytes.size()));
-    return result;
+StructuredData::StringSP PythonByteArray::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  llvm::ArrayRef<uint8_t> bytes = GetBytes();
+  const char *str = reinterpret_cast<const char *>(bytes.data());
+  result->SetValue(std::string(str, bytes.size()));
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonString
 //----------------------------------------------------------------------
 
-PythonString::PythonString(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
+PythonString::PythonString(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
 }
 
-PythonString::PythonString(const PythonString &object)
-    : PythonObject(object)
-{
-}
+PythonString::PythonString(const PythonString &object) : PythonObject(object) {}
 
-PythonString::PythonString(llvm::StringRef string)
-    : PythonObject()
-{
-    SetString(string);
+PythonString::PythonString(llvm::StringRef string) : PythonObject() {
+  SetString(string);
 }
 
-PythonString::PythonString(const char *string)
-    : PythonObject()
-{
-    SetString(llvm::StringRef(string));
+PythonString::PythonString(const char *string) : PythonObject() {
+  SetString(llvm::StringRef(string));
 }
 
-PythonString::PythonString()
-    : PythonObject()
-{
-}
+PythonString::PythonString() : PythonObject() {}
 
-PythonString::~PythonString ()
-{
-}
+PythonString::~PythonString() {}
 
-bool
-PythonString::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonString::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    if (PyUnicode_Check(py_obj))
-        return true;
+  if (PyUnicode_Check(py_obj))
+    return true;
 #if PY_MAJOR_VERSION < 3
-    if (PyString_Check(py_obj))
-        return true;
+  if (PyString_Check(py_obj))
+    return true;
 #endif
-    return false;
+  return false;
 }
 
-void
-PythonString::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonString::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonString::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonString::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 #if PY_MAJOR_VERSION < 3
-    // In Python 2, Don't store PyUnicode objects directly, because we need
-    // access to their underlying character buffers which Python 2 doesn't
-    // provide.
-    if (PyUnicode_Check(py_obj))
-        result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(result.get()));
+  // In Python 2, Don't store PyUnicode objects directly, because we need
+  // access to their underlying character buffers which Python 2 doesn't
+  // provide.
+  if (PyUnicode_Check(py_obj))
+    result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(result.get()));
 #endif
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-llvm::StringRef
-PythonString::GetString() const
-{
-    if (!IsValid())
-        return llvm::StringRef();
+llvm::StringRef PythonString::GetString() const {
+  if (!IsValid())
+    return llvm::StringRef();
 
-    Py_ssize_t size;
-    char *c;
+  Py_ssize_t size;
+  char *c;
 
 #if PY_MAJOR_VERSION >= 3
-    c = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
+  c = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
 #else
-    PyString_AsStringAndSize(m_py_obj, &c, &size);
+  PyString_AsStringAndSize(m_py_obj, &c, &size);
 #endif
-    return llvm::StringRef(c, size);
+  return llvm::StringRef(c, size);
 }
 
-size_t
-PythonString::GetSize() const
-{
-    if (IsValid())
-    {
+size_t PythonString::GetSize() const {
+  if (IsValid()) {
 #if PY_MAJOR_VERSION >= 3
-        return PyUnicode_GetSize(m_py_obj);
+    return PyUnicode_GetSize(m_py_obj);
 #else
-        return PyString_Size(m_py_obj);
+    return PyString_Size(m_py_obj);
 #endif
-    }
-    return 0;
+  }
+  return 0;
 }
 
-void
-PythonString::SetString (llvm::StringRef string)
-{
+void PythonString::SetString(llvm::StringRef string) {
 #if PY_MAJOR_VERSION >= 3
-    PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
-    PythonObject::Reset(PyRefType::Owned, unicode);
+  PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
+  PythonObject::Reset(PyRefType::Owned, unicode);
 #else
-    PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
-    PythonObject::Reset(PyRefType::Owned, str);
+  PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
+  PythonObject::Reset(PyRefType::Owned, str);
 #endif
 }
 
-StructuredData::StringSP
-PythonString::CreateStructuredString() const
-{
-    StructuredData::StringSP result(new StructuredData::String);
-    result->SetValue(GetString());
-    return result;
+StructuredData::StringSP PythonString::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  result->SetValue(GetString());
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonInteger
 //----------------------------------------------------------------------
 
-PythonInteger::PythonInteger()
-    : PythonObject()
-{
-
-}
+PythonInteger::PythonInteger() : PythonObject() {}
 
 PythonInteger::PythonInteger(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a integer type
+    : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a integer type
 }
 
 PythonInteger::PythonInteger(const PythonInteger &object)
-    : PythonObject(object)
-{
-}
+    : PythonObject(object) {}
 
-PythonInteger::PythonInteger(int64_t value)
-    : PythonObject()
-{
-    SetInteger(value);
+PythonInteger::PythonInteger(int64_t value) : PythonObject() {
+  SetInteger(value);
 }
 
+PythonInteger::~PythonInteger() {}
 
-PythonInteger::~PythonInteger ()
-{
-}
-
-bool
-PythonInteger::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonInteger::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
 #if PY_MAJOR_VERSION >= 3
-    // Python 3 does not have PyInt_Check.  There is only one type of
-    // integral value, long.
-    return PyLong_Check(py_obj);
+  // Python 3 does not have PyInt_Check.  There is only one type of
+  // integral value, long.
+  return PyLong_Check(py_obj);
 #else
-    return PyLong_Check(py_obj) || PyInt_Check(py_obj);
+  return PyLong_Check(py_obj) || PyInt_Check(py_obj);
 #endif
 }
 
-void
-PythonInteger::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonInteger::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonInteger::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonInteger::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
 #if PY_MAJOR_VERSION < 3
-    // Always store this as a PyLong, which makes interoperability between
-    // Python 2.x and Python 3.x easier.  This is only necessary in 2.x,
-    // since 3.x doesn't even have a PyInt.
-    if (PyInt_Check(py_obj))
-    {
-        // Since we converted the original object to a different type, the new
-        // object is an owned object regardless of the ownership semantics requested
-        // by the user.
-        result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
-    }
+  // Always store this as a PyLong, which makes interoperability between
+  // Python 2.x and Python 3.x easier.  This is only necessary in 2.x,
+  // since 3.x doesn't even have a PyInt.
+  if (PyInt_Check(py_obj)) {
+    // Since we converted the original object to a different type, the new
+    // object is an owned object regardless of the ownership semantics requested
+    // by the user.
+    result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
+  }
 #endif
 
-    assert(PyLong_Check(result.get()) && "Couldn't get a PyLong from this PyObject");
-
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
-}
-
-int64_t
-PythonInteger::GetInteger() const
-{
-    if (m_py_obj)
-    {
-        assert(PyLong_Check(m_py_obj) && "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
-
-        return PyLong_AsLongLong(m_py_obj);
+  assert(PyLong_Check(result.get()) &&
+         "Couldn't get a PyLong from this PyObject");
+
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
+}
+
+int64_t PythonInteger::GetInteger() const {
+  if (m_py_obj) {
+    assert(PyLong_Check(m_py_obj) &&
+           "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
+
+    int overflow = 0;
+    int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
+    if (overflow != 0) {
+      // We got an integer that overflows, like 18446744072853913392L
+      // we can't use PyLong_AsLongLong() as it will return
+      // 0xffffffffffffffff. If we use the unsigned long long
+      // it will work as expected.
+      const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
+      result = static_cast<int64_t>(uval);
     }
-    return UINT64_MAX;
+    return result;
+  }
+  return UINT64_MAX;
 }
 
-void
-PythonInteger::SetInteger(int64_t value)
-{
-    PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
+void PythonInteger::SetInteger(int64_t value) {
+  PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
 }
 
-StructuredData::IntegerSP
-PythonInteger::CreateStructuredInteger() const
-{
-    StructuredData::IntegerSP result(new StructuredData::Integer);
-    result->SetValue(GetInteger());
-    return result;
+StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
+  StructuredData::IntegerSP result(new StructuredData::Integer);
+  result->SetValue(GetInteger());
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonList
 //----------------------------------------------------------------------
 
-PythonList::PythonList(PyInitialValue value)
-    : PythonObject()
-{
-    if (value == PyInitialValue::Empty)
-        Reset(PyRefType::Owned, PyList_New(0));
+PythonList::PythonList(PyInitialValue value) : PythonObject() {
+  if (value == PyInitialValue::Empty)
+    Reset(PyRefType::Owned, PyList_New(0));
 }
 
-PythonList::PythonList(int list_size)
-    : PythonObject()
-{
-    Reset(PyRefType::Owned, PyList_New(list_size));
+PythonList::PythonList(int list_size) : PythonObject() {
+  Reset(PyRefType::Owned, PyList_New(list_size));
 }
 
-PythonList::PythonList(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a list
+PythonList::PythonList(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a list
 }
 
-PythonList::PythonList(const PythonList &list)
-    : PythonObject(list)
-{
-}
+PythonList::PythonList(const PythonList &list) : PythonObject(list) {}
 
-PythonList::~PythonList ()
-{
-}
+PythonList::~PythonList() {}
 
-bool
-PythonList::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    return PyList_Check(py_obj);
+bool PythonList::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyList_Check(py_obj);
 }
 
-void
-PythonList::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonList::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonList::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonList::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-uint32_t
-PythonList::GetSize() const
-{
-    if (IsValid())
-        return PyList_GET_SIZE(m_py_obj);
-    return 0;
+uint32_t PythonList::GetSize() const {
+  if (IsValid())
+    return PyList_GET_SIZE(m_py_obj);
+  return 0;
 }
 
-PythonObject
-PythonList::GetItemAtIndex(uint32_t index) const
-{
-    if (IsValid())
-        return PythonObject(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
-    return PythonObject();
+PythonObject PythonList::GetItemAtIndex(uint32_t index) const {
+  if (IsValid())
+    return PythonObject(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
+  return PythonObject();
 }
 
-void
-PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object)
-{
-    if (IsAllocated() && object.IsValid())
-    {
-        // PyList_SetItem is documented to "steal" a reference, so we need to
-        // convert it to an owned reference by incrementing it.
-        Py_INCREF(object.get());
-        PyList_SetItem(m_py_obj, index, object.get());
-    }
+void PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object) {
+  if (IsAllocated() && object.IsValid()) {
+    // PyList_SetItem is documented to "steal" a reference, so we need to
+    // convert it to an owned reference by incrementing it.
+    Py_INCREF(object.get());
+    PyList_SetItem(m_py_obj, index, object.get());
+  }
 }
 
-void
-PythonList::AppendItem(const PythonObject &object)
-{
-    if (IsAllocated() && object.IsValid())
-    {
-        // `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
-        // here like we do with `PyList_SetItem`.
-        PyList_Append(m_py_obj, object.get());
-    }
+void PythonList::AppendItem(const PythonObject &object) {
+  if (IsAllocated() && object.IsValid()) {
+    // `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
+    // here like we do with `PyList_SetItem`.
+    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(obj.CreateStructuredObject());
-    }
-    return result;
+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(obj.CreateStructuredObject());
+  }
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonTuple
 //----------------------------------------------------------------------
 
-PythonTuple::PythonTuple(PyInitialValue value)
-    : PythonObject()
-{
-    if (value == PyInitialValue::Empty)
-        Reset(PyRefType::Owned, PyTuple_New(0));
+PythonTuple::PythonTuple(PyInitialValue value) : PythonObject() {
+  if (value == PyInitialValue::Empty)
+    Reset(PyRefType::Owned, PyTuple_New(0));
 }
 
-PythonTuple::PythonTuple(int tuple_size)
-    : PythonObject()
-{
-    Reset(PyRefType::Owned, PyTuple_New(tuple_size));
+PythonTuple::PythonTuple(int tuple_size) : PythonObject() {
+  Reset(PyRefType::Owned, PyTuple_New(tuple_size));
 }
 
-PythonTuple::PythonTuple(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a tuple
+PythonTuple::PythonTuple(PyRefType type, PyObject *py_obj) : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a tuple
 }
 
-PythonTuple::PythonTuple(const PythonTuple &tuple)
-    : PythonObject(tuple)
-{
-}
+PythonTuple::PythonTuple(const PythonTuple &tuple) : PythonObject(tuple) {}
 
-PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects)
-{
-    m_py_obj = PyTuple_New(objects.size());
+PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects) {
+  m_py_obj = PyTuple_New(objects.size());
 
-    uint32_t idx = 0;
-    for (auto object : objects)
-    {
-        if (object.IsValid())
-            SetItemAtIndex(idx, object);
-        idx++;
-    }
+  uint32_t idx = 0;
+  for (auto object : objects) {
+    if (object.IsValid())
+      SetItemAtIndex(idx, object);
+    idx++;
+  }
 }
 
-PythonTuple::PythonTuple(std::initializer_list<PyObject*> objects)
-{
-    m_py_obj = PyTuple_New(objects.size());
+PythonTuple::PythonTuple(std::initializer_list<PyObject *> objects) {
+  m_py_obj = PyTuple_New(objects.size());
 
-    uint32_t idx = 0;
-    for (auto py_object : objects)
-    {
-        PythonObject object(PyRefType::Borrowed, py_object);
-        if (object.IsValid())
-            SetItemAtIndex(idx, object);
-        idx++;
-    }
+  uint32_t idx = 0;
+  for (auto py_object : objects) {
+    PythonObject object(PyRefType::Borrowed, py_object);
+    if (object.IsValid())
+      SetItemAtIndex(idx, object);
+    idx++;
+  }
 }
 
-PythonTuple::~PythonTuple()
-{
-}
+PythonTuple::~PythonTuple() {}
 
-bool
-PythonTuple::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
-    return PyTuple_Check(py_obj);
+bool PythonTuple::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyTuple_Check(py_obj);
 }
 
-void
-PythonTuple::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonTuple::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonTuple::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonTuple::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-uint32_t
-PythonTuple::GetSize() const
-{
-    if (IsValid())
-        return PyTuple_GET_SIZE(m_py_obj);
-    return 0;
+uint32_t PythonTuple::GetSize() const {
+  if (IsValid())
+    return PyTuple_GET_SIZE(m_py_obj);
+  return 0;
 }
 
-PythonObject
-PythonTuple::GetItemAtIndex(uint32_t index) const
-{
-    if (IsValid())
-        return PythonObject(PyRefType::Borrowed, PyTuple_GetItem(m_py_obj, index));
-    return PythonObject();
+PythonObject PythonTuple::GetItemAtIndex(uint32_t index) const {
+  if (IsValid())
+    return PythonObject(PyRefType::Borrowed, PyTuple_GetItem(m_py_obj, index));
+  return PythonObject();
 }
 
-void
-PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object)
-{
-    if (IsAllocated() && object.IsValid())
-    {
-        // PyTuple_SetItem is documented to "steal" a reference, so we need to
-        // convert it to an owned reference by incrementing it.
-        Py_INCREF(object.get());
-        PyTuple_SetItem(m_py_obj, index, object.get());
-    }
+void PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object) {
+  if (IsAllocated() && object.IsValid()) {
+    // PyTuple_SetItem is documented to "steal" a reference, so we need to
+    // convert it to an owned reference by incrementing it.
+    Py_INCREF(object.get());
+    PyTuple_SetItem(m_py_obj, index, object.get());
+  }
 }
 
-StructuredData::ArraySP
-PythonTuple::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(obj.CreateStructuredObject());
-    }
-    return result;
+StructuredData::ArraySP PythonTuple::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(obj.CreateStructuredObject());
+  }
+  return result;
 }
 
 //----------------------------------------------------------------------
 // PythonDictionary
 //----------------------------------------------------------------------
 
-PythonDictionary::PythonDictionary(PyInitialValue value)
-    : PythonObject()
-{
-    if (value == PyInitialValue::Empty)
-        Reset(PyRefType::Owned, PyDict_New());
+PythonDictionary::PythonDictionary(PyInitialValue value) : PythonObject() {
+  if (value == PyInitialValue::Empty)
+    Reset(PyRefType::Owned, PyDict_New());
 }
 
 PythonDictionary::PythonDictionary(PyRefType type, PyObject *py_obj)
-    : PythonObject()
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
+    : PythonObject() {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
 }
 
 PythonDictionary::PythonDictionary(const PythonDictionary &object)
-    : PythonObject(object)
-{
-}
+    : PythonObject(object) {}
 
-PythonDictionary::~PythonDictionary ()
-{
-}
+PythonDictionary::~PythonDictionary() {}
 
-bool
-PythonDictionary::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonDictionary::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    return PyDict_Check(py_obj);
+  return PyDict_Check(py_obj);
 }
 
-void
-PythonDictionary::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonDictionary::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonDictionary::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonDictionary::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-uint32_t
-PythonDictionary::GetSize() const
-{
-    if (IsValid())
-        return PyDict_Size(m_py_obj);
-    return 0;
+uint32_t PythonDictionary::GetSize() const {
+  if (IsValid())
+    return PyDict_Size(m_py_obj);
+  return 0;
 }
 
-PythonList
-PythonDictionary::GetKeys() const
-{
-    if (IsValid())
-        return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
-    return PythonList(PyInitialValue::Invalid);
+PythonList PythonDictionary::GetKeys() const {
+  if (IsValid())
+    return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
+  return PythonList(PyInitialValue::Invalid);
 }
 
-PythonObject
-PythonDictionary::GetItemForKey(const PythonObject &key) const
-{
-    if (IsAllocated() && key.IsValid())
-        return PythonObject(PyRefType::Borrowed, PyDict_GetItem(m_py_obj, key.get()));
-    return PythonObject();
+PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
+  if (IsAllocated() && key.IsValid())
+    return PythonObject(PyRefType::Borrowed,
+                        PyDict_GetItem(m_py_obj, key.get()));
+  return PythonObject();
 }
 
-void
-PythonDictionary::SetItemForKey(const PythonObject &key, const PythonObject &value)
-{
-    if (IsAllocated() && key.IsValid() && value.IsValid())
-        PyDict_SetItem(m_py_obj, key.get(), value.get());
+void PythonDictionary::SetItemForKey(const PythonObject &key,
+                                     const PythonObject &value) {
+  if (IsAllocated() && key.IsValid() && value.IsValid())
+    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);
-        PythonObject value = GetItemForKey(key);
-        StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
-        result->AddItem(key.Str().GetString(), structured_value);
-    }
-    return result;
+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);
+    PythonObject value = GetItemForKey(key);
+    StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
+    result->AddItem(key.Str().GetString(), structured_value);
+  }
+  return result;
 }
 
-PythonModule::PythonModule() : PythonObject()
-{
-}
+PythonModule::PythonModule() : PythonObject() {}
 
-PythonModule::PythonModule(PyRefType type, PyObject *py_obj)
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a module
+PythonModule::PythonModule(PyRefType type, PyObject *py_obj) {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a module
 }
 
-PythonModule::PythonModule(const PythonModule &dict) : PythonObject(dict)
-{
-}
+PythonModule::PythonModule(const PythonModule &dict) : PythonObject(dict) {}
 
-PythonModule::~PythonModule()
-{
-}
+PythonModule::~PythonModule() {}
 
-PythonModule
-PythonModule::BuiltinsModule()
-{
+PythonModule PythonModule::BuiltinsModule() {
 #if PY_MAJOR_VERSION >= 3
-    return AddModule("builtins");
+  return AddModule("builtins");
 #else
-    return AddModule("__builtin__");
+  return AddModule("__builtin__");
 #endif
 }
 
-PythonModule
-PythonModule::MainModule()
-{
-    return AddModule("__main__");
-}
+PythonModule PythonModule::MainModule() { return AddModule("__main__"); }
 
-PythonModule
-PythonModule::AddModule(llvm::StringRef module)
-{
-    std::string str = module.str();
-    return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
+PythonModule PythonModule::AddModule(llvm::StringRef module) {
+  std::string str = module.str();
+  return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
 }
 
-
-PythonModule
-PythonModule::ImportModule(llvm::StringRef module)
-{
-    std::string str = module.str();
-    return PythonModule(PyRefType::Owned, PyImport_ImportModule(str.c_str()));
+PythonModule PythonModule::ImportModule(llvm::StringRef module) {
+  std::string str = module.str();
+  return PythonModule(PyRefType::Owned, PyImport_ImportModule(str.c_str()));
 }
 
-bool
-PythonModule::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonModule::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    return PyModule_Check(py_obj);
+  return PyModule_Check(py_obj);
 }
 
-void
-PythonModule::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonModule::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonModule::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonModule::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-PythonDictionary
-PythonModule::GetDictionary() const
-{
-    return PythonDictionary(PyRefType::Borrowed, PyModule_GetDict(m_py_obj));
+PythonDictionary PythonModule::GetDictionary() const {
+  return PythonDictionary(PyRefType::Borrowed, PyModule_GetDict(m_py_obj));
 }
 
-PythonCallable::PythonCallable() : PythonObject()
-{
-}
+PythonCallable::PythonCallable() : PythonObject() {}
 
-PythonCallable::PythonCallable(PyRefType type, PyObject *py_obj)
-{
-    Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a callable
+PythonCallable::PythonCallable(PyRefType type, PyObject *py_obj) {
+  Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a callable
 }
 
 PythonCallable::PythonCallable(const PythonCallable &callable)
-    : PythonObject(callable)
-{
-}
+    : PythonObject(callable) {}
 
-PythonCallable::~PythonCallable()
-{
-}
+PythonCallable::~PythonCallable() {}
 
-bool
-PythonCallable::Check(PyObject *py_obj)
-{
-    if (!py_obj)
-        return false;
+bool PythonCallable::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
 
-    return PyCallable_Check(py_obj);
+  return PyCallable_Check(py_obj);
 }
 
-void
-PythonCallable::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonCallable::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonCallable::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonCallable::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
-    // back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls
+  // back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
+PythonCallable::ArgInfo PythonCallable::GetNumArguments() const {
+  ArgInfo result = {0, false, false, false};
+  if (!IsValid())
+    return result;
 
-PythonCallable::ArgInfo
-PythonCallable::GetNumArguments() const
-{
-    ArgInfo result = { 0, false, false, false };
-    if (!IsValid())
-        return result;
-
-    PyObject *py_func_obj = m_py_obj;
-    if (PyMethod_Check(py_func_obj))
-    {
-        py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);
-        PythonObject im_self = GetAttributeValue("im_self");
-        if (im_self.IsValid() && !im_self.IsNone())
+  PyObject *py_func_obj = m_py_obj;
+  if (PyMethod_Check(py_func_obj)) {
+    py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);
+    PythonObject im_self = GetAttributeValue("im_self");
+    if (im_self.IsValid() && !im_self.IsNone())
+      result.is_bound_method = true;
+  } else {
+    // see if this is a callable object with an __call__ method
+    if (!PyFunction_Check(py_func_obj)) {
+      PythonObject __call__ = GetAttributeValue("__call__");
+      if (__call__.IsValid()) {
+        auto __callable__ = __call__.AsType<PythonCallable>();
+        if (__callable__.IsValid()) {
+          py_func_obj = PyMethod_GET_FUNCTION(__callable__.get());
+          PythonObject im_self = GetAttributeValue("im_self");
+          if (im_self.IsValid() && !im_self.IsNone())
             result.is_bound_method = true;
-    }
-    else
-    {
-        // see if this is a callable object with an __call__ method
-        if (!PyFunction_Check(py_func_obj))
-        {
-            PythonObject __call__ = GetAttributeValue("__call__");
-            if (__call__.IsValid())
-            {
-                auto __callable__ = __call__.AsType<PythonCallable>();
-                if (__callable__.IsValid())
-                {
-                    py_func_obj = PyMethod_GET_FUNCTION(__callable__.get());
-                    PythonObject im_self = GetAttributeValue("im_self");
-                    if (im_self.IsValid() && !im_self.IsNone())
-                        result.is_bound_method = true;
-                }
-            }
         }
+      }
     }
+  }
 
-    if (!py_func_obj)
-        return result;
-
-    PyCodeObject* code = (PyCodeObject*)PyFunction_GET_CODE(py_func_obj);
-    if (!code)
-        return result;
+  if (!py_func_obj)
+    return result;
 
-    result.count = code->co_argcount;
-    result.has_varargs = !!(code->co_flags & CO_VARARGS);
-    result.has_kwargs = !!(code->co_flags & CO_VARKEYWORDS);
+  PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(py_func_obj);
+  if (!code)
     return result;
-}
 
-PythonObject
-PythonCallable::operator ()()
-{
-    return PythonObject(PyRefType::Owned,
-        PyObject_CallObject(m_py_obj, nullptr));
+  result.count = code->co_argcount;
+  result.has_varargs = !!(code->co_flags & CO_VARARGS);
+  result.has_kwargs = !!(code->co_flags & CO_VARKEYWORDS);
+  return result;
 }
 
-PythonObject
-PythonCallable::operator ()(std::initializer_list<PyObject*> args)
-{
-    PythonTuple arg_tuple(args);
-    return PythonObject(PyRefType::Owned,
-        PyObject_CallObject(m_py_obj, arg_tuple.get()));
+PythonObject PythonCallable::operator()() {
+  return PythonObject(PyRefType::Owned, PyObject_CallObject(m_py_obj, nullptr));
 }
 
-PythonObject
-PythonCallable::operator ()(std::initializer_list<PythonObject> args)
-{
-    PythonTuple arg_tuple(args);
-    return PythonObject(PyRefType::Owned,
-        PyObject_CallObject(m_py_obj, arg_tuple.get()));
+PythonObject PythonCallable::
+operator()(std::initializer_list<PyObject *> args) {
+  PythonTuple arg_tuple(args);
+  return PythonObject(PyRefType::Owned,
+                      PyObject_CallObject(m_py_obj, arg_tuple.get()));
 }
 
-PythonFile::PythonFile()
-    : PythonObject()
-{
+PythonObject PythonCallable::
+operator()(std::initializer_list<PythonObject> args) {
+  PythonTuple arg_tuple(args);
+  return PythonObject(PyRefType::Owned,
+                      PyObject_CallObject(m_py_obj, arg_tuple.get()));
 }
 
-PythonFile::PythonFile(File &file, const char *mode)
-{
-    Reset(file, mode);
-}
+PythonFile::PythonFile() : PythonObject() {}
 
-PythonFile::PythonFile(const char *path, const char *mode)
-{
-    lldb_private::File file(path, GetOptionsFromMode(mode));
-    Reset(file, mode);
-}
+PythonFile::PythonFile(File &file, const char *mode) { Reset(file, mode); }
 
-PythonFile::PythonFile(PyRefType type, PyObject *o)
-{
-    Reset(type, o);
+PythonFile::PythonFile(const char *path, const char *mode) {
+  lldb_private::File file(path, GetOptionsFromMode(mode));
+  Reset(file, mode);
 }
 
-PythonFile::~PythonFile()
-{
-}
+PythonFile::PythonFile(PyRefType type, PyObject *o) { Reset(type, o); }
 
-bool
-PythonFile::Check(PyObject *py_obj)
-{
+PythonFile::~PythonFile() {}
+
+bool PythonFile::Check(PyObject *py_obj) {
 #if PY_MAJOR_VERSION < 3
-    return PyFile_Check(py_obj);
+  return PyFile_Check(py_obj);
 #else
-    // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
-    // first-class object type anymore.  `PyFile_FromFd` is just a thin wrapper
-    // over `io.open()`, which returns some object derived from `io.IOBase`.
-    // As a result, the only way to detect a file in Python 3 is to check whether
-    // it inherits from `io.IOBase`.  Since it is possible for non-files to also
-    // inherit from `io.IOBase`, we additionally verify that it has the `fileno`
-    // attribute, which should guarantee that it is backed by the file system.
-    PythonObject io_module(PyRefType::Owned, PyImport_ImportModule("io"));
-    PythonDictionary io_dict(PyRefType::Borrowed, PyModule_GetDict(io_module.get()));
-    PythonObject io_base_class = io_dict.GetItemForKey(PythonString("IOBase"));
-
-    PythonObject object_type(PyRefType::Owned, PyObject_Type(py_obj));
-
-    if (1 != PyObject_IsSubclass(object_type.get(), io_base_class.get()))
-        return false;
-    if (!object_type.HasAttribute("fileno"))
-        return false;
+  // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
+  // first-class object type anymore.  `PyFile_FromFd` is just a thin wrapper
+  // over `io.open()`, which returns some object derived from `io.IOBase`.
+  // As a result, the only way to detect a file in Python 3 is to check whether
+  // it inherits from `io.IOBase`.  Since it is possible for non-files to also
+  // inherit from `io.IOBase`, we additionally verify that it has the `fileno`
+  // attribute, which should guarantee that it is backed by the file system.
+  PythonObject io_module(PyRefType::Owned, PyImport_ImportModule("io"));
+  PythonDictionary io_dict(PyRefType::Borrowed,
+                           PyModule_GetDict(io_module.get()));
+  PythonObject io_base_class = io_dict.GetItemForKey(PythonString("IOBase"));
+
+  PythonObject object_type(PyRefType::Owned, PyObject_Type(py_obj));
+
+  if (1 != PyObject_IsSubclass(object_type.get(), io_base_class.get()))
+    return false;
+  if (!object_type.HasAttribute("fileno"))
+    return false;
 
-    return true;
+  return true;
 #endif
 }
 
-void
-PythonFile::Reset(PyRefType type, PyObject *py_obj)
-{
-    // Grab the desired reference type so that if we end up rejecting
-    // `py_obj` it still gets decremented if necessary.
-    PythonObject result(type, py_obj);
+void PythonFile::Reset(PyRefType type, PyObject *py_obj) {
+  // Grab the desired reference type so that if we end up rejecting
+  // `py_obj` it still gets decremented if necessary.
+  PythonObject result(type, py_obj);
 
-    if (!PythonFile::Check(py_obj))
-    {
-        PythonObject::Reset();
-        return;
-    }
+  if (!PythonFile::Check(py_obj)) {
+    PythonObject::Reset();
+    return;
+  }
 
-    // Calling PythonObject::Reset(const PythonObject&) will lead to stack
-    // overflow since it calls back into the virtual implementation.
-    PythonObject::Reset(PyRefType::Borrowed, result.get());
+  // Calling PythonObject::Reset(const PythonObject&) will lead to stack
+  // overflow since it calls back into the virtual implementation.
+  PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
-void
-PythonFile::Reset(File &file, const char *mode)
-{
-    if (!file.IsValid())
-    {
-        Reset();
-        return;
-    }
+void PythonFile::Reset(File &file, const char *mode) {
+  if (!file.IsValid()) {
+    Reset();
+    return;
+  }
 
-    char *cmode = const_cast<char *>(mode);
+  char *cmode = const_cast<char *>(mode);
 #if PY_MAJOR_VERSION >= 3
-    Reset(PyRefType::Owned,
-        PyFile_FromFd(file.GetDescriptor(), nullptr, cmode, -1, nullptr, "ignore", nullptr, 0));
+  Reset(PyRefType::Owned, PyFile_FromFd(file.GetDescriptor(), nullptr, cmode,
+                                        -1, nullptr, "ignore", nullptr, 0));
 #else
-    // Read through the Python source, doesn't seem to modify these strings
-    Reset(PyRefType::Owned,
-        PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode, nullptr));
+  // Read through the Python source, doesn't seem to modify these strings
+  Reset(PyRefType::Owned,
+        PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode,
+                        nullptr));
 #endif
 }
 
-uint32_t
-PythonFile::GetOptionsFromMode(llvm::StringRef mode)
-{
-    if (mode.empty())
-        return 0;
-
-    return llvm::StringSwitch<uint32_t>(mode.str().c_str())
-    .Case("r",   File::eOpenOptionRead)
-    .Case("w",   File::eOpenOptionWrite)
-    .Case("a",   File::eOpenOptionWrite|File::eOpenOptionAppend|File::eOpenOptionCanCreate)
-    .Case("r+",  File::eOpenOptionRead|File::eOpenOptionWrite)
-    .Case("w+",  File::eOpenOptionRead|File::eOpenOptionWrite|File::eOpenOptionCanCreate|File::eOpenOptionTruncate)
-    .Case("a+",  File::eOpenOptionRead|File::eOpenOptionWrite|File::eOpenOptionAppend|File::eOpenOptionCanCreate)
-    .Default(0);
-}
+uint32_t PythonFile::GetOptionsFromMode(llvm::StringRef mode) {
+  if (mode.empty())
+    return 0;
 
-bool
-PythonFile::GetUnderlyingFile(File &file) const
-{
-    if (!IsValid())
-        return false;
+  return llvm::StringSwitch<uint32_t>(mode.str())
+      .Case("r", File::eOpenOptionRead)
+      .Case("w", File::eOpenOptionWrite)
+      .Case("a", File::eOpenOptionWrite | File::eOpenOptionAppend |
+                     File::eOpenOptionCanCreate)
+      .Case("r+", File::eOpenOptionRead | File::eOpenOptionWrite)
+      .Case("w+", File::eOpenOptionRead | File::eOpenOptionWrite |
+                      File::eOpenOptionCanCreate | File::eOpenOptionTruncate)
+      .Case("a+", File::eOpenOptionRead | File::eOpenOptionWrite |
+                      File::eOpenOptionAppend | File::eOpenOptionCanCreate)
+      .Default(0);
+}
+
+bool PythonFile::GetUnderlyingFile(File &file) const {
+  if (!IsValid())
+    return false;
 
-    file.Close();
-    // We don't own the file descriptor returned by this function, make sure the
-    // File object knows about that.
-    file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false);
-    PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
-    file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString()));
-    return file.IsValid();
+  file.Close();
+  // We don't own the file descriptor returned by this function, make sure the
+  // File object knows about that.
+  file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false);
+  PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
+  file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString()));
+  return file.IsValid();
 }
 
-
 #endif
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h
index 78245a9..b84996c 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h
@@ -12,16 +12,19 @@
 
 #ifndef LLDB_DISABLE_PYTHON
 
+// LLDB Python header must be included first
+#include "lldb-python.h"
+
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/lldb-defines.h"
 #include "lldb/Core/ConstString.h"
-#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/Flags.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/OptionValue.h"
+#include "lldb/lldb-defines.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
@@ -33,536 +36,434 @@ class PythonList;
 class PythonDictionary;
 class PythonInteger;
 
-class StructuredPythonObject : public StructuredData::Generic
-{
+class StructuredPythonObject : public StructuredData::Generic {
 public:
-    StructuredPythonObject()
-        : StructuredData::Generic()
-    {
-    }
-
-    StructuredPythonObject(void *obj)
-        : StructuredData::Generic(obj)
-    {
-        Py_XINCREF(GetValue());
-    }
-
-    ~StructuredPythonObject() override
-    {
-        if (Py_IsInitialized())
-            Py_XDECREF(GetValue());
-        SetValue(nullptr);
-    }
-
-    bool
-    IsValid() const override
-    {
-        return GetValue() && GetValue() != Py_None;
-    }
-
-    void Dump(Stream &s) const override;
+  StructuredPythonObject() : StructuredData::Generic() {}
+
+  StructuredPythonObject(void *obj) : StructuredData::Generic(obj) {
+    Py_XINCREF(GetValue());
+  }
+
+  ~StructuredPythonObject() override {
+    if (Py_IsInitialized())
+      Py_XDECREF(GetValue());
+    SetValue(nullptr);
+  }
+
+  bool IsValid() const override { return GetValue() && GetValue() != Py_None; }
+
+  void Dump(Stream &s, bool pretty_print = true) const override;
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
+  DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
 };
 
-enum class PyObjectType
-{
-    Unknown,
-    None,
-    Integer,
-    Dictionary,
-    List,
-    String,
-    Bytes,
-    ByteArray,
-    Module,
-    Callable,
-    Tuple,
-    File
+enum class PyObjectType {
+  Unknown,
+  None,
+  Integer,
+  Dictionary,
+  List,
+  String,
+  Bytes,
+  ByteArray,
+  Module,
+  Callable,
+  Tuple,
+  File
 };
 
-enum class PyRefType
-{
-    Borrowed, // We are not given ownership of the incoming PyObject.
-              // We cannot safely hold it without calling Py_INCREF.
-    Owned     // We have ownership of the incoming PyObject.  We should
-              // not call Py_INCREF.
+enum class PyRefType {
+  Borrowed, // We are not given ownership of the incoming PyObject.
+            // We cannot safely hold it without calling Py_INCREF.
+  Owned     // We have ownership of the incoming PyObject.  We should
+            // not call Py_INCREF.
 };
 
-enum class PyInitialValue
-{
-    Invalid,
-    Empty
-};
+enum class PyInitialValue { Invalid, Empty };
 
-class PythonObject
-{
+class PythonObject {
 public:
-    PythonObject()
-        : m_py_obj(nullptr)
-    {
-    }
-
-    PythonObject(PyRefType type, PyObject *py_obj)
-        : m_py_obj(nullptr)
-    {
-        Reset(type, py_obj);
-    }
-
-    PythonObject(const PythonObject &rhs)
-        : m_py_obj(nullptr)
-    {
-        Reset(rhs);
-    }
-
-    virtual ~PythonObject()
-    {
-        Reset();
-    }
-
-    void
-    Reset()
-    {
-        // Avoid calling the virtual method since it's not necessary
-        // to actually validate the type of the PyObject if we're
-        // just setting to null.
-        if (Py_IsInitialized())
-            Py_XDECREF(m_py_obj);
-        m_py_obj = nullptr;
-    }
-
-    void
-    Reset(const PythonObject &rhs)
-    {
-        // Avoid calling the virtual method if it's not necessary
-        // to actually validate the type of the PyObject.
-        if (!rhs.IsValid())
-            Reset();
-        else
-            Reset(PyRefType::Borrowed, rhs.m_py_obj);
-    }
-
-    // PythonObject is implicitly convertible to PyObject *, which will call the
-    // wrong overload.  We want to explicitly disallow this, since a PyObject
-    // *always* owns its reference.  Therefore the overload which takes a
-    // PyRefType doesn't make sense, and the copy constructor should be used.
-    void
-    Reset(PyRefType type, const PythonObject &ref) = delete;
-
-    virtual void
-    Reset(PyRefType type, PyObject *py_obj)
-    {
-        if (py_obj == m_py_obj)
-            return;
-
-        if (Py_IsInitialized())
-            Py_XDECREF(m_py_obj);
-
-        m_py_obj = py_obj;
-
-        // If this is a borrowed reference, we need to convert it to
-        // an owned reference by incrementing it.  If it is an owned
-        // reference (for example the caller allocated it with PyDict_New()
-        // then we must *not* increment it.
-        if (Py_IsInitialized() && type == PyRefType::Borrowed)
-            Py_XINCREF(m_py_obj);
-    }
-        
-    void
-    Dump () const
-    {
-        if (m_py_obj)
-            _PyObject_Dump (m_py_obj);
-        else
-            puts ("NULL");
-    }
-        
-    void
-    Dump (Stream &strm) const;
-
-    PyObject*
-    get() const
-    {
-        return m_py_obj;
-    }
-
-    PyObject*
-    release()
-    {
-        PyObject *result = m_py_obj;
-        m_py_obj = nullptr;
-        return result;
-    }
-
-    PythonObject &
-    operator=(const PythonObject &other)
-    {
-        Reset(PyRefType::Borrowed, other.get());
-        return *this;
-    }
-
-    PyObjectType
-    GetObjectType() const;
-
-    PythonString
-    Repr() const;
-
-    PythonString
-    Str() const;
-
-    static PythonObject
-    ResolveNameWithDictionary(llvm::StringRef name, const PythonDictionary &dict);
-
-    template<typename T>
-    static T
-    ResolveNameWithDictionary(llvm::StringRef name, const PythonDictionary &dict)
-    {
-        return ResolveNameWithDictionary(name, dict).AsType<T>();
-    }
-
-    PythonObject
-    ResolveName(llvm::StringRef name) const;
-
-    template<typename T>
-    T
-    ResolveName(llvm::StringRef name) const
-    {
-        return ResolveName(name).AsType<T>();
-    }
-
-    bool
-    HasAttribute(llvm::StringRef attribute) const;
-
-    PythonObject
-    GetAttributeValue(llvm::StringRef attribute) const;
-
-    bool
-    IsValid() const;
-
-    bool
-    IsAllocated() const;
-
-    bool
-    IsNone() const;
-
-    template<typename T>
-    T AsType() const
-    {
-        if (!T::Check(m_py_obj))
-            return T();
-        return T(PyRefType::Borrowed, m_py_obj);
-    }
-
-    StructuredData::ObjectSP
-    CreateStructuredObject() const;
+  PythonObject() : m_py_obj(nullptr) {}
+
+  PythonObject(PyRefType type, PyObject *py_obj) : m_py_obj(nullptr) {
+    Reset(type, py_obj);
+  }
+
+  PythonObject(const PythonObject &rhs) : m_py_obj(nullptr) { Reset(rhs); }
+
+  virtual ~PythonObject() { Reset(); }
+
+  void Reset() {
+    // Avoid calling the virtual method since it's not necessary
+    // to actually validate the type of the PyObject if we're
+    // just setting to null.
+    if (Py_IsInitialized())
+      Py_XDECREF(m_py_obj);
+    m_py_obj = nullptr;
+  }
+
+  void Reset(const PythonObject &rhs) {
+    // Avoid calling the virtual method if it's not necessary
+    // to actually validate the type of the PyObject.
+    if (!rhs.IsValid())
+      Reset();
+    else
+      Reset(PyRefType::Borrowed, rhs.m_py_obj);
+  }
+
+  // PythonObject is implicitly convertible to PyObject *, which will call the
+  // wrong overload.  We want to explicitly disallow this, since a PyObject
+  // *always* owns its reference.  Therefore the overload which takes a
+  // PyRefType doesn't make sense, and the copy constructor should be used.
+  void Reset(PyRefType type, const PythonObject &ref) = delete;
+
+  virtual void Reset(PyRefType type, PyObject *py_obj) {
+    if (py_obj == m_py_obj)
+      return;
+
+    if (Py_IsInitialized())
+      Py_XDECREF(m_py_obj);
+
+    m_py_obj = py_obj;
+
+    // If this is a borrowed reference, we need to convert it to
+    // an owned reference by incrementing it.  If it is an owned
+    // reference (for example the caller allocated it with PyDict_New()
+    // then we must *not* increment it.
+    if (Py_IsInitialized() && type == PyRefType::Borrowed)
+      Py_XINCREF(m_py_obj);
+  }
+
+  void Dump() const {
+    if (m_py_obj)
+      _PyObject_Dump(m_py_obj);
+    else
+      puts("NULL");
+  }
+
+  void Dump(Stream &strm) const;
+
+  PyObject *get() const { return m_py_obj; }
+
+  PyObject *release() {
+    PyObject *result = m_py_obj;
+    m_py_obj = nullptr;
+    return result;
+  }
+
+  PythonObject &operator=(const PythonObject &other) {
+    Reset(PyRefType::Borrowed, other.get());
+    return *this;
+  }
+
+  PyObjectType GetObjectType() const;
+
+  PythonString Repr() const;
+
+  PythonString Str() const;
+
+  static PythonObject ResolveNameWithDictionary(llvm::StringRef name,
+                                                const PythonDictionary &dict);
+
+  template <typename T>
+  static T ResolveNameWithDictionary(llvm::StringRef name,
+                                     const PythonDictionary &dict) {
+    return ResolveNameWithDictionary(name, dict).AsType<T>();
+  }
+
+  PythonObject ResolveName(llvm::StringRef name) const;
+
+  template <typename T> T ResolveName(llvm::StringRef name) const {
+    return ResolveName(name).AsType<T>();
+  }
+
+  bool HasAttribute(llvm::StringRef attribute) const;
+
+  PythonObject GetAttributeValue(llvm::StringRef attribute) const;
+
+  bool IsValid() const;
+
+  bool IsAllocated() const;
+
+  bool IsNone() const;
+
+  template <typename T> T AsType() const {
+    if (!T::Check(m_py_obj))
+      return T();
+    return T(PyRefType::Borrowed, m_py_obj);
+  }
+
+  StructuredData::ObjectSP CreateStructuredObject() const;
 
 protected:
-    PyObject* m_py_obj;
+  PyObject *m_py_obj;
 };
 
-class PythonBytes : public PythonObject
-{
+class PythonBytes : public PythonObject {
 public:
-    PythonBytes();
-    explicit PythonBytes(llvm::ArrayRef<uint8_t> bytes);
-    PythonBytes(const uint8_t *bytes, size_t length);
-    PythonBytes(PyRefType type, PyObject *o);
-    PythonBytes(const PythonBytes &object);
+  PythonBytes();
+  explicit PythonBytes(llvm::ArrayRef<uint8_t> bytes);
+  PythonBytes(const uint8_t *bytes, size_t length);
+  PythonBytes(PyRefType type, PyObject *o);
+  PythonBytes(const PythonBytes &object);
 
-    ~PythonBytes() override;
+  ~PythonBytes() override;
 
-    static bool
-    Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void
-    Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    llvm::ArrayRef<uint8_t>
-    GetBytes() const;
+  llvm::ArrayRef<uint8_t> GetBytes() const;
 
-    size_t
-    GetSize() const;
+  size_t GetSize() const;
 
-    void
-    SetBytes(llvm::ArrayRef<uint8_t> stringbytes);
+  void SetBytes(llvm::ArrayRef<uint8_t> stringbytes);
 
-    StructuredData::StringSP
-    CreateStructuredString() const;
+  StructuredData::StringSP CreateStructuredString() const;
 };
 
-class PythonByteArray : public PythonObject
-{
+class PythonByteArray : public PythonObject {
 public:
-    PythonByteArray();
-    explicit PythonByteArray(llvm::ArrayRef<uint8_t> bytes);
-    PythonByteArray(const uint8_t *bytes, size_t length);
-    PythonByteArray(PyRefType type, PyObject *o);
-    PythonByteArray(const PythonBytes &object);
+  PythonByteArray();
+  explicit PythonByteArray(llvm::ArrayRef<uint8_t> bytes);
+  PythonByteArray(const uint8_t *bytes, size_t length);
+  PythonByteArray(PyRefType type, PyObject *o);
+  PythonByteArray(const PythonBytes &object);
 
-    ~PythonByteArray() override;
+  ~PythonByteArray() override;
 
-    static bool
-    Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void
-    Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    llvm::ArrayRef<uint8_t>
-    GetBytes() const;
+  llvm::ArrayRef<uint8_t> GetBytes() const;
 
-    size_t
-    GetSize() const;
+  size_t GetSize() const;
 
-    void
-    SetBytes(llvm::ArrayRef<uint8_t> stringbytes);
+  void SetBytes(llvm::ArrayRef<uint8_t> stringbytes);
 
-    StructuredData::StringSP
-    CreateStructuredString() const;
+  StructuredData::StringSP CreateStructuredString() const;
 };
 
-class PythonString : public PythonObject
-{
+class PythonString : public PythonObject {
 public:
-    PythonString();
-    explicit PythonString(llvm::StringRef string);
-    explicit PythonString(const char *string);
-    PythonString(PyRefType type, PyObject *o);
-    PythonString(const PythonString &object);
+  PythonString();
+  explicit PythonString(llvm::StringRef string);
+  explicit PythonString(const char *string);
+  PythonString(PyRefType type, PyObject *o);
+  PythonString(const PythonString &object);
 
-    ~PythonString() override;
+  ~PythonString() override;
 
-    static bool Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    llvm::StringRef
-    GetString() const;
+  llvm::StringRef GetString() const;
 
-    size_t
-    GetSize() const;
+  size_t GetSize() const;
 
-    void SetString(llvm::StringRef string);
+  void SetString(llvm::StringRef string);
 
-    StructuredData::StringSP CreateStructuredString() const;
+  StructuredData::StringSP CreateStructuredString() const;
 };
 
-class PythonInteger : public PythonObject
-{
+class PythonInteger : public PythonObject {
 public:
-    PythonInteger();
-    explicit PythonInteger(int64_t value);
-    PythonInteger(PyRefType type, PyObject *o);
-    PythonInteger(const PythonInteger &object);
+  PythonInteger();
+  explicit PythonInteger(int64_t value);
+  PythonInteger(PyRefType type, PyObject *o);
+  PythonInteger(const PythonInteger &object);
 
-    ~PythonInteger() override;
+  ~PythonInteger() override;
 
-    static bool Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    int64_t GetInteger() const;
+  int64_t GetInteger() const;
 
-    void
-    SetInteger (int64_t value);
+  void SetInteger(int64_t value);
 
-    StructuredData::IntegerSP CreateStructuredInteger() const;
+  StructuredData::IntegerSP CreateStructuredInteger() const;
 };
 
-class PythonList : public PythonObject
-{
+class PythonList : public PythonObject {
 public:
-    PythonList() {}
-    explicit PythonList(PyInitialValue value);
-    explicit PythonList(int list_size);
-    PythonList(PyRefType type, PyObject *o);
-    PythonList(const PythonList &list);
+  PythonList() {}
+  explicit PythonList(PyInitialValue value);
+  explicit PythonList(int list_size);
+  PythonList(PyRefType type, PyObject *o);
+  PythonList(const PythonList &list);
 
-    ~PythonList() override;
+  ~PythonList() override;
 
-    static bool Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    uint32_t GetSize() const;
+  uint32_t GetSize() const;
 
-    PythonObject GetItemAtIndex(uint32_t index) const;
+  PythonObject GetItemAtIndex(uint32_t index) const;
 
-    void SetItemAtIndex(uint32_t index, const PythonObject &object);
+  void SetItemAtIndex(uint32_t index, const PythonObject &object);
 
-    void AppendItem(const PythonObject &object);
+  void AppendItem(const PythonObject &object);
 
-    StructuredData::ArraySP CreateStructuredArray() const;
+  StructuredData::ArraySP CreateStructuredArray() const;
 };
 
-class PythonTuple : public PythonObject
-{
+class PythonTuple : public PythonObject {
 public:
-    PythonTuple() {}
-    explicit PythonTuple(PyInitialValue value);
-    explicit PythonTuple(int tuple_size);
-    PythonTuple(PyRefType type, PyObject *o);
-    PythonTuple(const PythonTuple &tuple);
-    PythonTuple(std::initializer_list<PythonObject> objects);
-    PythonTuple(std::initializer_list<PyObject*> objects);
+  PythonTuple() {}
+  explicit PythonTuple(PyInitialValue value);
+  explicit PythonTuple(int tuple_size);
+  PythonTuple(PyRefType type, PyObject *o);
+  PythonTuple(const PythonTuple &tuple);
+  PythonTuple(std::initializer_list<PythonObject> objects);
+  PythonTuple(std::initializer_list<PyObject *> objects);
 
-    ~PythonTuple() override;
+  ~PythonTuple() override;
 
-    static bool Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    uint32_t GetSize() const;
+  uint32_t GetSize() const;
 
-    PythonObject GetItemAtIndex(uint32_t index) const;
+  PythonObject GetItemAtIndex(uint32_t index) const;
 
-    void SetItemAtIndex(uint32_t index, const PythonObject &object);
+  void SetItemAtIndex(uint32_t index, const PythonObject &object);
 
-    StructuredData::ArraySP CreateStructuredArray() const;
+  StructuredData::ArraySP CreateStructuredArray() const;
 };
 
-class PythonDictionary : public PythonObject
-{
+class PythonDictionary : public PythonObject {
 public:
-    PythonDictionary() {}
-    explicit PythonDictionary(PyInitialValue value);
-    PythonDictionary(PyRefType type, PyObject *o);
-    PythonDictionary(const PythonDictionary &dict);
+  PythonDictionary() {}
+  explicit PythonDictionary(PyInitialValue value);
+  PythonDictionary(PyRefType type, PyObject *o);
+  PythonDictionary(const PythonDictionary &dict);
 
-    ~PythonDictionary() override;
+  ~PythonDictionary() override;
 
-    static bool Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    uint32_t GetSize() const;
+  uint32_t GetSize() const;
 
-    PythonList GetKeys() const;
+  PythonList GetKeys() const;
 
-    PythonObject GetItemForKey(const PythonObject &key) const;
-    void SetItemForKey(const PythonObject &key, const PythonObject &value);
+  PythonObject GetItemForKey(const PythonObject &key) const;
+  void SetItemForKey(const PythonObject &key, const PythonObject &value);
 
-    StructuredData::DictionarySP CreateStructuredDictionary() const;
+  StructuredData::DictionarySP CreateStructuredDictionary() const;
 };
 
-class PythonModule : public PythonObject
-{
-  public:
-    PythonModule();
-    PythonModule(PyRefType type, PyObject *o);
-    PythonModule(const PythonModule &dict);
+class PythonModule : public PythonObject {
+public:
+  PythonModule();
+  PythonModule(PyRefType type, PyObject *o);
+  PythonModule(const PythonModule &dict);
 
-    ~PythonModule() override;
+  ~PythonModule() override;
 
-    static bool Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    static PythonModule
-    BuiltinsModule();
+  static PythonModule BuiltinsModule();
 
-    static PythonModule
-    MainModule();
+  static PythonModule MainModule();
 
-    static PythonModule
-    AddModule(llvm::StringRef module);
+  static PythonModule AddModule(llvm::StringRef module);
 
-    static PythonModule
-    ImportModule(llvm::StringRef module);
+  static PythonModule ImportModule(llvm::StringRef module);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    PythonDictionary GetDictionary() const;
+  PythonDictionary GetDictionary() const;
 };
 
-class PythonCallable : public PythonObject
-{
+class PythonCallable : public PythonObject {
 public:
-    struct ArgInfo {
-        size_t count;
-        bool is_bound_method : 1;
-        bool has_varargs : 1;
-        bool has_kwargs : 1;
-    };
+  struct ArgInfo {
+    size_t count;
+    bool is_bound_method : 1;
+    bool has_varargs : 1;
+    bool has_kwargs : 1;
+  };
 
-    PythonCallable();
-    PythonCallable(PyRefType type, PyObject *o);
-    PythonCallable(const PythonCallable &dict);
+  PythonCallable();
+  PythonCallable(PyRefType type, PyObject *o);
+  PythonCallable(const PythonCallable &dict);
 
-    ~PythonCallable() override;
+  ~PythonCallable() override;
 
-    static bool
-    Check(PyObject *py_obj);
+  static bool Check(PyObject *py_obj);
 
-    // Bring in the no-argument base class version
-    using PythonObject::Reset;
+  // Bring in the no-argument base class version
+  using PythonObject::Reset;
 
-    void
-    Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(PyRefType type, PyObject *py_obj) override;
 
-    ArgInfo
-    GetNumArguments() const;
+  ArgInfo GetNumArguments() const;
 
-    PythonObject
-    operator ()();
+  PythonObject operator()();
 
-    PythonObject
-    operator ()(std::initializer_list<PyObject*> args);
+  PythonObject operator()(std::initializer_list<PyObject *> args);
 
-    PythonObject
-    operator ()(std::initializer_list<PythonObject> args);
+  PythonObject operator()(std::initializer_list<PythonObject> args);
 
-    template<typename Arg, typename... Args>
-    PythonObject
-    operator ()(const Arg &arg, Args... args)
-    {
-        return operator()({ arg, args... });
-    }
+  template <typename Arg, typename... Args>
+  PythonObject operator()(const Arg &arg, Args... args) {
+    return operator()({arg, args...});
+  }
 };
 
+class PythonFile : public PythonObject {
+public:
+  PythonFile();
+  PythonFile(File &file, const char *mode);
+  PythonFile(const char *path, const char *mode);
+  PythonFile(PyRefType type, PyObject *o);
 
-class PythonFile : public PythonObject
-{
-  public:
-    PythonFile();
-    PythonFile(File &file, const char *mode);
-    PythonFile(const char *path, const char *mode);
-    PythonFile(PyRefType type, PyObject *o);
+  ~PythonFile() override;
 
-    ~PythonFile() override;
+  static bool Check(PyObject *py_obj);
 
-    static bool Check(PyObject *py_obj);
+  using PythonObject::Reset;
 
-    using PythonObject::Reset;
+  void Reset(PyRefType type, PyObject *py_obj) override;
+  void Reset(File &file, const char *mode);
 
-    void Reset(PyRefType type, PyObject *py_obj) override;
-    void Reset(File &file, const char *mode);
+  static uint32_t GetOptionsFromMode(llvm::StringRef mode);
 
-    static uint32_t GetOptionsFromMode(llvm::StringRef mode);
-    
-    bool GetUnderlyingFile(File &file) const;
+  bool GetUnderlyingFile(File &file) const;
 };
 
 } // namespace lldb_private
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp
index 2cbd85b..4d956d5 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.cpp
@@ -9,7 +9,9 @@
 
 #ifndef LLDB_DISABLE_PYTHON
 
+// LLDB Python header must be included first
 #include "lldb-python.h"
+
 #include "PythonExceptionState.h"
 
 #include "llvm/ADT/StringRef.h"
@@ -18,184 +20,152 @@
 using namespace lldb_private;
 
 PythonExceptionState::PythonExceptionState(bool restore_on_exit)
-    : m_restore_on_exit(restore_on_exit)
-{
-    Acquire(restore_on_exit);
+    : m_restore_on_exit(restore_on_exit) {
+  Acquire(restore_on_exit);
 }
 
-PythonExceptionState::~PythonExceptionState()
-{
-    if (m_restore_on_exit)
-        Restore();
+PythonExceptionState::~PythonExceptionState() {
+  if (m_restore_on_exit)
+    Restore();
 }
 
-void
-PythonExceptionState::Acquire(bool restore_on_exit)
-{
-    // If a state is already acquired, the user needs to decide whether they
-    // want to discard or restore it.  Don't allow the potential silent
-    // loss of a valid state.
-    assert(!IsError());
-
-    if (!HasErrorOccurred())
-        return;
-
-    PyObject *py_type = nullptr;
-    PyObject *py_value = nullptr;
-    PyObject *py_traceback = nullptr;
-    PyErr_Fetch(&py_type, &py_value, &py_traceback);
-    // PyErr_Fetch clears the error flag.
-    assert(!HasErrorOccurred());
-
-    // Ownership of the objects returned by `PyErr_Fetch` is transferred
-    // to us.
-    m_type.Reset(PyRefType::Owned, py_type);
-    m_value.Reset(PyRefType::Owned, py_value);
-    m_traceback.Reset(PyRefType::Owned, py_traceback);
-    m_restore_on_exit = restore_on_exit;
+void PythonExceptionState::Acquire(bool restore_on_exit) {
+  // If a state is already acquired, the user needs to decide whether they
+  // want to discard or restore it.  Don't allow the potential silent
+  // loss of a valid state.
+  assert(!IsError());
+
+  if (!HasErrorOccurred())
+    return;
+
+  PyObject *py_type = nullptr;
+  PyObject *py_value = nullptr;
+  PyObject *py_traceback = nullptr;
+  PyErr_Fetch(&py_type, &py_value, &py_traceback);
+  // PyErr_Fetch clears the error flag.
+  assert(!HasErrorOccurred());
+
+  // Ownership of the objects returned by `PyErr_Fetch` is transferred
+  // to us.
+  m_type.Reset(PyRefType::Owned, py_type);
+  m_value.Reset(PyRefType::Owned, py_value);
+  m_traceback.Reset(PyRefType::Owned, py_traceback);
+  m_restore_on_exit = restore_on_exit;
 }
 
-void
-PythonExceptionState::Restore()
-{
-    if (m_type.IsValid())
-    {
-        // The documentation for PyErr_Restore says "Do not pass a null type and
-        // non-null value or traceback.  So only restore if type was non-null
-        // to begin with.  In this case we're passing ownership back to Python
-        // so release them all.
-        PyErr_Restore(m_type.release(), m_value.release(), m_traceback.release());
-    }
-
-    // After we restore, we should not hold onto the exception state.  Demand that
-    // it be re-acquired.
-    Discard();
+void PythonExceptionState::Restore() {
+  if (m_type.IsValid()) {
+    // The documentation for PyErr_Restore says "Do not pass a null type and
+    // non-null value or traceback.  So only restore if type was non-null
+    // to begin with.  In this case we're passing ownership back to Python
+    // so release them all.
+    PyErr_Restore(m_type.release(), m_value.release(), m_traceback.release());
+  }
+
+  // After we restore, we should not hold onto the exception state.  Demand that
+  // it be re-acquired.
+  Discard();
 }
 
-void
-PythonExceptionState::Discard()
-{
-    m_type.Reset();
-    m_value.Reset();
-    m_traceback.Reset();
+void PythonExceptionState::Discard() {
+  m_type.Reset();
+  m_value.Reset();
+  m_traceback.Reset();
 }
 
-void
-PythonExceptionState::Reset()
-{
-    if (m_restore_on_exit)
-        Restore();
-    else
-        Discard();
-}
-
-bool
-PythonExceptionState::HasErrorOccurred()
-{
-    return PyErr_Occurred();
-}
-
-bool
-PythonExceptionState::IsError() const
-{
-    return m_type.IsValid() || m_value.IsValid() || m_traceback.IsValid();
-}
-
-PythonObject
-PythonExceptionState::GetType() const
-{
-    return m_type;
+void PythonExceptionState::Reset() {
+  if (m_restore_on_exit)
+    Restore();
+  else
+    Discard();
 }
 
-PythonObject
-PythonExceptionState::GetValue() const
-{
-    return m_value;
-}
+bool PythonExceptionState::HasErrorOccurred() { return PyErr_Occurred(); }
 
-PythonObject
-PythonExceptionState::GetTraceback() const
-{
-    return m_traceback;
+bool PythonExceptionState::IsError() const {
+  return m_type.IsValid() || m_value.IsValid() || m_traceback.IsValid();
 }
 
-std::string
-PythonExceptionState::Format() const
-{
-    // Don't allow this function to modify the error state.
-    PythonExceptionState state(true);
-
-    std::string backtrace = ReadBacktrace();
-    if (!IsError())
-        return std::string();
-
-    // It's possible that ReadPythonBacktrace generated another exception.
-    // If this happens we have to clear the exception, because otherwise
-    // PyObject_Str() will assert below.  That's why we needed to do the
-    // save / restore at the beginning of this function.
-    PythonExceptionState bt_error_state(false);
-
-    std::string error_string;
-    llvm::raw_string_ostream error_stream(error_string);
-    error_stream << m_value.Str().GetString() << "\n";
-
-    if (!bt_error_state.IsError())
-    {
-        // If we were able to read the backtrace, just append it.
-        error_stream << backtrace << "\n";
-    }
-    else
-    {
-        // Otherwise, append some information about why we were unable to
-        // obtain the backtrace.
-        PythonString bt_error = bt_error_state.GetValue().Str();
-        error_stream << "An error occurred while retrieving the backtrace: " << bt_error.GetString() << "\n";
-    }
-    return error_stream.str();
+PythonObject PythonExceptionState::GetType() const { return m_type; }
+
+PythonObject PythonExceptionState::GetValue() const { return m_value; }
+
+PythonObject PythonExceptionState::GetTraceback() const { return m_traceback; }
+
+std::string PythonExceptionState::Format() const {
+  // Don't allow this function to modify the error state.
+  PythonExceptionState state(true);
+
+  std::string backtrace = ReadBacktrace();
+  if (!IsError())
+    return std::string();
+
+  // It's possible that ReadPythonBacktrace generated another exception.
+  // If this happens we have to clear the exception, because otherwise
+  // PyObject_Str() will assert below.  That's why we needed to do the
+  // save / restore at the beginning of this function.
+  PythonExceptionState bt_error_state(false);
+
+  std::string error_string;
+  llvm::raw_string_ostream error_stream(error_string);
+  error_stream << m_value.Str().GetString() << "\n";
+
+  if (!bt_error_state.IsError()) {
+    // If we were able to read the backtrace, just append it.
+    error_stream << backtrace << "\n";
+  } else {
+    // Otherwise, append some information about why we were unable to
+    // obtain the backtrace.
+    PythonString bt_error = bt_error_state.GetValue().Str();
+    error_stream << "An error occurred while retrieving the backtrace: "
+                 << bt_error.GetString() << "\n";
+  }
+  return error_stream.str();
 }
 
-std::string
-PythonExceptionState::ReadBacktrace() const
-{
-    std::string retval("backtrace unavailable");
+std::string PythonExceptionState::ReadBacktrace() const {
+  std::string retval("backtrace unavailable");
 
-    auto traceback_module = PythonModule::ImportModule("traceback");
+  auto traceback_module = PythonModule::ImportModule("traceback");
 #if PY_MAJOR_VERSION >= 3
-    auto stringIO_module = PythonModule::ImportModule("io");
+  auto stringIO_module = PythonModule::ImportModule("io");
 #else
-    auto stringIO_module = PythonModule::ImportModule("StringIO");
+  auto stringIO_module = PythonModule::ImportModule("StringIO");
 #endif
-    if (!m_traceback.IsAllocated())
-        return retval;
+  if (!m_traceback.IsAllocated())
+    return retval;
 
-    if (!traceback_module.IsAllocated() || !stringIO_module.IsAllocated())
-        return retval;
+  if (!traceback_module.IsAllocated() || !stringIO_module.IsAllocated())
+    return retval;
 
-    auto stringIO_builder = stringIO_module.ResolveName<PythonCallable>("StringIO");
-    if (!stringIO_builder.IsAllocated())
-        return retval;
+  auto stringIO_builder =
+      stringIO_module.ResolveName<PythonCallable>("StringIO");
+  if (!stringIO_builder.IsAllocated())
+    return retval;
 
-    auto stringIO_buffer = stringIO_builder();
-    if (!stringIO_buffer.IsAllocated())
-        return retval;
+  auto stringIO_buffer = stringIO_builder();
+  if (!stringIO_buffer.IsAllocated())
+    return retval;
 
-    auto printTB = traceback_module.ResolveName<PythonCallable>("print_tb");
-    if (!printTB.IsAllocated())
-        return retval;
+  auto printTB = traceback_module.ResolveName<PythonCallable>("print_tb");
+  if (!printTB.IsAllocated())
+    return retval;
 
-    auto printTB_result = printTB(m_traceback.get(), Py_None, stringIO_buffer.get());
-    auto stringIO_getvalue = stringIO_buffer.ResolveName<PythonCallable>("getvalue");
-    if (!stringIO_getvalue.IsAllocated())
-        return retval;
+  auto printTB_result =
+      printTB(m_traceback.get(), Py_None, stringIO_buffer.get());
+  auto stringIO_getvalue =
+      stringIO_buffer.ResolveName<PythonCallable>("getvalue");
+  if (!stringIO_getvalue.IsAllocated())
+    return retval;
 
-    auto printTB_string = stringIO_getvalue().AsType<PythonString>();
-    if (!printTB_string.IsAllocated())
-        return retval;
+  auto printTB_string = stringIO_getvalue().AsType<PythonString>();
+  if (!printTB_string.IsAllocated())
+    return retval;
 
-    llvm::StringRef string_data(printTB_string.GetString());
-    retval.assign(string_data.data(), string_data.size());
+  llvm::StringRef string_data(printTB_string.GetString());
+  retval.assign(string_data.data(), string_data.size());
 
-    return retval;
+  return retval;
 }
 
 #endif
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.h b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.h
index c74e52b..20f4b4c 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonExceptionState.h
@@ -14,54 +14,41 @@
 
 #include "PythonDataObjects.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
 
-class PythonExceptionState
-{
-  public:
-    explicit PythonExceptionState(bool restore_on_exit);
-    ~PythonExceptionState();
+class PythonExceptionState {
+public:
+  explicit PythonExceptionState(bool restore_on_exit);
+  ~PythonExceptionState();
 
-    void
-    Acquire(bool restore_on_exit);
+  void Acquire(bool restore_on_exit);
 
-    void
-    Restore();
+  void Restore();
 
-    void
-    Discard();
+  void Discard();
 
-    void
-    Reset();
+  void Reset();
 
-    static bool
-    HasErrorOccurred();
+  static bool HasErrorOccurred();
 
-    bool
-    IsError() const;
+  bool IsError() const;
 
-    PythonObject
-    GetType() const;
+  PythonObject GetType() const;
 
-    PythonObject
-    GetValue() const;
+  PythonObject GetValue() const;
 
-    PythonObject
-    GetTraceback() const;
+  PythonObject GetTraceback() const;
 
-    std::string
-    Format() const;
+  std::string Format() const;
 
-  private:
-    std::string
-    ReadBacktrace() const;
+private:
+  std::string ReadBacktrace() const;
 
-    bool m_restore_on_exit;
+  bool m_restore_on_exit;
 
-    PythonObject m_type;
-    PythonObject m_value;
-    PythonObject m_traceback;
+  PythonObject m_type;
+  PythonObject m_value;
+  PythonObject m_traceback;
 };
 }
 
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
index 7881673..357b48e 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
@@ -13,13 +13,15 @@
 
 #else
 
+// LLDB Python header must be included first
 #include "lldb-python.h"
-#include "ScriptInterpreterPython.h"
+
 #include "PythonDataObjects.h"
 #include "PythonExceptionState.h"
+#include "ScriptInterpreterPython.h"
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #include <mutex>
 #include <string>
@@ -47,1574 +49,1548 @@
 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
 #endif
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
-static ScriptInterpreterPython::SWIGBreakpointCallbackFunction g_swig_breakpoint_callback = nullptr;
-static ScriptInterpreterPython::SWIGWatchpointCallbackFunction g_swig_watchpoint_callback = nullptr;
-static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction g_swig_typescript_callback = nullptr;
-static ScriptInterpreterPython::SWIGPythonCreateSyntheticProvider g_swig_synthetic_script = nullptr;
-static ScriptInterpreterPython::SWIGPythonCreateCommandObject g_swig_create_cmd = nullptr;
-static ScriptInterpreterPython::SWIGPythonCalculateNumChildren g_swig_calc_children = nullptr;
-static ScriptInterpreterPython::SWIGPythonGetChildAtIndex g_swig_get_child_index = nullptr;
-static ScriptInterpreterPython::SWIGPythonGetIndexOfChildWithName g_swig_get_index_child = nullptr;
-static ScriptInterpreterPython::SWIGPythonCastPyObjectToSBValue g_swig_cast_to_sbvalue  = nullptr;
-static ScriptInterpreterPython::SWIGPythonGetValueObjectSPFromSBValue g_swig_get_valobj_sp_from_sbvalue = nullptr;
-static ScriptInterpreterPython::SWIGPythonUpdateSynthProviderInstance g_swig_update_provider = nullptr;
-static ScriptInterpreterPython::SWIGPythonMightHaveChildrenSynthProviderInstance g_swig_mighthavechildren_provider = nullptr;
-static ScriptInterpreterPython::SWIGPythonGetValueSynthProviderInstance g_swig_getvalue_provider = nullptr;
-static ScriptInterpreterPython::SWIGPythonCallCommand g_swig_call_command = nullptr;
-static ScriptInterpreterPython::SWIGPythonCallCommandObject g_swig_call_command_object = nullptr;
-static ScriptInterpreterPython::SWIGPythonCallModuleInit g_swig_call_module_init = nullptr;
-static ScriptInterpreterPython::SWIGPythonCreateOSPlugin g_swig_create_os_plugin = nullptr;
-static ScriptInterpreterPython::SWIGPythonScriptKeyword_Process g_swig_run_script_keyword_process = nullptr;
-static ScriptInterpreterPython::SWIGPythonScriptKeyword_Thread g_swig_run_script_keyword_thread = nullptr;
-static ScriptInterpreterPython::SWIGPythonScriptKeyword_Target g_swig_run_script_keyword_target = nullptr;
-static ScriptInterpreterPython::SWIGPythonScriptKeyword_Frame g_swig_run_script_keyword_frame = nullptr;
-static ScriptInterpreterPython::SWIGPythonScriptKeyword_Value g_swig_run_script_keyword_value = nullptr;
-static ScriptInterpreterPython::SWIGPython_GetDynamicSetting g_swig_plugin_get = nullptr;
-static ScriptInterpreterPython::SWIGPythonCreateScriptedThreadPlan g_swig_thread_plan_script = nullptr;
-static ScriptInterpreterPython::SWIGPythonCallThreadPlan g_swig_call_thread_plan = nullptr;
+static ScriptInterpreterPython::SWIGBreakpointCallbackFunction
+    g_swig_breakpoint_callback = nullptr;
+static ScriptInterpreterPython::SWIGWatchpointCallbackFunction
+    g_swig_watchpoint_callback = nullptr;
+static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction
+    g_swig_typescript_callback = nullptr;
+static ScriptInterpreterPython::SWIGPythonCreateSyntheticProvider
+    g_swig_synthetic_script = nullptr;
+static ScriptInterpreterPython::SWIGPythonCreateCommandObject
+    g_swig_create_cmd = nullptr;
+static ScriptInterpreterPython::SWIGPythonCalculateNumChildren
+    g_swig_calc_children = nullptr;
+static ScriptInterpreterPython::SWIGPythonGetChildAtIndex
+    g_swig_get_child_index = nullptr;
+static ScriptInterpreterPython::SWIGPythonGetIndexOfChildWithName
+    g_swig_get_index_child = nullptr;
+static ScriptInterpreterPython::SWIGPythonCastPyObjectToSBValue
+    g_swig_cast_to_sbvalue = nullptr;
+static ScriptInterpreterPython::SWIGPythonGetValueObjectSPFromSBValue
+    g_swig_get_valobj_sp_from_sbvalue = nullptr;
+static ScriptInterpreterPython::SWIGPythonUpdateSynthProviderInstance
+    g_swig_update_provider = nullptr;
+static ScriptInterpreterPython::SWIGPythonMightHaveChildrenSynthProviderInstance
+    g_swig_mighthavechildren_provider = nullptr;
+static ScriptInterpreterPython::SWIGPythonGetValueSynthProviderInstance
+    g_swig_getvalue_provider = nullptr;
+static ScriptInterpreterPython::SWIGPythonCallCommand g_swig_call_command =
+    nullptr;
+static ScriptInterpreterPython::SWIGPythonCallCommandObject
+    g_swig_call_command_object = nullptr;
+static ScriptInterpreterPython::SWIGPythonCallModuleInit
+    g_swig_call_module_init = nullptr;
+static ScriptInterpreterPython::SWIGPythonCreateOSPlugin
+    g_swig_create_os_plugin = nullptr;
+static ScriptInterpreterPython::SWIGPythonScriptKeyword_Process
+    g_swig_run_script_keyword_process = nullptr;
+static ScriptInterpreterPython::SWIGPythonScriptKeyword_Thread
+    g_swig_run_script_keyword_thread = nullptr;
+static ScriptInterpreterPython::SWIGPythonScriptKeyword_Target
+    g_swig_run_script_keyword_target = nullptr;
+static ScriptInterpreterPython::SWIGPythonScriptKeyword_Frame
+    g_swig_run_script_keyword_frame = nullptr;
+static ScriptInterpreterPython::SWIGPythonScriptKeyword_Value
+    g_swig_run_script_keyword_value = nullptr;
+static ScriptInterpreterPython::SWIGPython_GetDynamicSetting g_swig_plugin_get =
+    nullptr;
+static ScriptInterpreterPython::SWIGPythonCreateScriptedThreadPlan
+    g_swig_thread_plan_script = nullptr;
+static ScriptInterpreterPython::SWIGPythonCallThreadPlan
+    g_swig_call_thread_plan = nullptr;
 
 static bool g_initialized = false;
 
-namespace
-{
+namespace {
 
 // Initializing Python is not a straightforward process.  We cannot control what
 // external code may have done before getting to this point in LLDB, including
 // potentially having already initialized Python, so we need to do a lot of work
 // to ensure that the existing state of the system is maintained across our
-// initialization.  We do this by using an RAII pattern where we save off initial
-// state at the beginning, and restore it at the end 
-struct InitializePythonRAII
-{
+// initialization.  We do this by using an RAII pattern where we save off
+// initial
+// state at the beginning, and restore it at the end
+struct InitializePythonRAII {
 public:
-    InitializePythonRAII() :
-        m_gil_state(PyGILState_UNLOCKED),
-        m_was_already_initialized(false)
-    {
-        // Python will muck with STDIN terminal state, so save off any current TTY
-        // settings so we can restore them.
-        m_stdin_tty_state.Save(STDIN_FILENO, false);
+  InitializePythonRAII()
+      : m_gil_state(PyGILState_UNLOCKED), m_was_already_initialized(false) {
+    // Python will muck with STDIN terminal state, so save off any current TTY
+    // settings so we can restore them.
+    m_stdin_tty_state.Save(STDIN_FILENO, false);
 
-        InitializePythonHome();
+    InitializePythonHome();
 
-        // Python < 3.2 and Python >= 3.2 reversed the ordering requirements for
-        // calling `Py_Initialize` and `PyEval_InitThreads`.  < 3.2 requires that you
-        // call `PyEval_InitThreads` first, and >= 3.2 requires that you call it last.
+// Python < 3.2 and Python >= 3.2 reversed the ordering requirements for
+// calling `Py_Initialize` and `PyEval_InitThreads`.  < 3.2 requires that you
+// call `PyEval_InitThreads` first, and >= 3.2 requires that you call it last.
 #if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 2) || (PY_MAJOR_VERSION > 3)
-        Py_InitializeEx(0);
-        InitializeThreadsPrivate();
+    Py_InitializeEx(0);
+    InitializeThreadsPrivate();
 #else
-        InitializeThreadsPrivate();
-        Py_InitializeEx(0);
+    InitializeThreadsPrivate();
+    Py_InitializeEx(0);
 #endif
-    }
+  }
 
-    ~InitializePythonRAII()
-    {
-        if (m_was_already_initialized)
-        {
-            Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
+  ~InitializePythonRAII() {
+    if (m_was_already_initialized) {
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
+                                                      LIBLLDB_LOG_VERBOSE));
 
-            if (log)
-            {
-                log->Printf("Releasing PyGILState. Returning to state = %slocked\n",
-                    m_was_already_initialized == PyGILState_UNLOCKED ? "un" : "");
-            }
-            PyGILState_Release(m_gil_state);
-        }
-        else
-        {
-            // We initialized the threads in this function, just unlock the GIL.
-            PyEval_SaveThread();
-        }
-
-        m_stdin_tty_state.Restore();
+      if (log) {
+        log->Printf("Releasing PyGILState. Returning to state = %slocked\n",
+                    m_was_already_initialized == PyGILState_UNLOCKED ? "un"
+                                                                     : "");
+      }
+      PyGILState_Release(m_gil_state);
+    } else {
+      // We initialized the threads in this function, just unlock the GIL.
+      PyEval_SaveThread();
     }
 
+    m_stdin_tty_state.Restore();
+  }
+
 private:
-    void InitializePythonHome()
-    {
+  void InitializePythonHome() {
 #if defined(LLDB_PYTHON_HOME)
 #if PY_MAJOR_VERSION >= 3
-        size_t size = 0;
-        static wchar_t *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
+    size_t size = 0;
+    static wchar_t *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
 #else
-        static char g_python_home[] = LLDB_PYTHON_HOME;
+    static char g_python_home[] = LLDB_PYTHON_HOME;
 #endif
-        Py_SetPythonHome(g_python_home);
+    Py_SetPythonHome(g_python_home);
 #endif
-    }
+  }
 
-    void InitializeThreadsPrivate()
-    {
-        if (PyEval_ThreadsInitialized())
-        {
-            Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
+  void InitializeThreadsPrivate() {
+    if (PyEval_ThreadsInitialized()) {
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
+                                                      LIBLLDB_LOG_VERBOSE));
 
-            m_was_already_initialized = true;
-            m_gil_state = PyGILState_Ensure();
-            if (log)
-            {
-                log->Printf("Ensured PyGILState. Previous state = %slocked\n",
+      m_was_already_initialized = true;
+      m_gil_state = PyGILState_Ensure();
+      if (log) {
+        log->Printf("Ensured PyGILState. Previous state = %slocked\n",
                     m_gil_state == PyGILState_UNLOCKED ? "un" : "");
-            }
-            return;
-        }
-
-        // InitThreads acquires the GIL if it hasn't been called before.
-        PyEval_InitThreads();
+      }
+      return;
     }
 
-    TerminalState m_stdin_tty_state;
-    PyGILState_STATE m_gil_state;
-    bool m_was_already_initialized;
-};
+    // InitThreads acquires the GIL if it hasn't been called before.
+    PyEval_InitThreads();
+  }
 
+  TerminalState m_stdin_tty_state;
+  PyGILState_STATE m_gil_state;
+  bool m_was_already_initialized;
+};
 }
 
-ScriptInterpreterPython::Locker::Locker (ScriptInterpreterPython *py_interpreter,
-                                         uint16_t on_entry,
-                                         uint16_t on_leave,
-                                         FILE *in,
-                                         FILE *out,
-                                         FILE *err) :
-    ScriptInterpreterLocker (),
-    m_teardown_session( (on_leave & TearDownSession) == TearDownSession ),
-    m_python_interpreter(py_interpreter)
-{
-    DoAcquireLock();
-    if ((on_entry & InitSession) == InitSession)
-    {
-        if (DoInitSession(on_entry, in, out, err) == false)
-        {
-            // Don't teardown the session if we didn't init it.
-            m_teardown_session = false;
-        }
-    }
+ScriptInterpreterPython::Locker::Locker(ScriptInterpreterPython *py_interpreter,
+                                        uint16_t on_entry, uint16_t on_leave,
+                                        FILE *in, FILE *out, FILE *err)
+    : ScriptInterpreterLocker(),
+      m_teardown_session((on_leave & TearDownSession) == TearDownSession),
+      m_python_interpreter(py_interpreter) {
+  DoAcquireLock();
+  if ((on_entry & InitSession) == InitSession) {
+    if (DoInitSession(on_entry, in, out, err) == false) {
+      // Don't teardown the session if we didn't init it.
+      m_teardown_session = false;
+    }
+  }
+}
+
+bool ScriptInterpreterPython::Locker::DoAcquireLock() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
+                                                  LIBLLDB_LOG_VERBOSE));
+  m_GILState = PyGILState_Ensure();
+  if (log)
+    log->Printf("Ensured PyGILState. Previous state = %slocked\n",
+                m_GILState == PyGILState_UNLOCKED ? "un" : "");
+
+  // we need to save the thread state when we first start the command
+  // because we might decide to interrupt it while some action is taking
+  // place outside of Python (e.g. printing to screen, waiting for the network,
+  // ...)
+  // in that case, _PyThreadState_Current will be NULL - and we would be unable
+  // to set the asynchronous exception - not a desirable situation
+  m_python_interpreter->SetThreadState(PyThreadState_Get());
+  m_python_interpreter->IncrementLockCount();
+  return true;
+}
+
+bool ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags,
+                                                    FILE *in, FILE *out,
+                                                    FILE *err) {
+  if (!m_python_interpreter)
+    return false;
+  return m_python_interpreter->EnterSession(on_entry_flags, in, out, err);
 }
 
-bool
-ScriptInterpreterPython::Locker::DoAcquireLock()
-{
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
-    m_GILState = PyGILState_Ensure();
-    if (log)
-        log->Printf("Ensured PyGILState. Previous state = %slocked\n", m_GILState == PyGILState_UNLOCKED ? "un" : "");
-
-    // we need to save the thread state when we first start the command
-    // because we might decide to interrupt it while some action is taking
-    // place outside of Python (e.g. printing to screen, waiting for the network, ...)
-    // in that case, _PyThreadState_Current will be NULL - and we would be unable
-    // to set the asynchronous exception - not a desirable situation
-    m_python_interpreter->SetThreadState(PyThreadState_Get());
-    m_python_interpreter->IncrementLockCount();
-    return true;
+bool ScriptInterpreterPython::Locker::DoFreeLock() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
+                                                  LIBLLDB_LOG_VERBOSE));
+  if (log)
+    log->Printf("Releasing PyGILState. Returning to state = %slocked\n",
+                m_GILState == PyGILState_UNLOCKED ? "un" : "");
+  PyGILState_Release(m_GILState);
+  m_python_interpreter->DecrementLockCount();
+  return true;
 }
 
-bool
-ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err)
-{
-    if (!m_python_interpreter)
-        return false;
-    return m_python_interpreter->EnterSession (on_entry_flags, in, out, err);
-}
+bool ScriptInterpreterPython::Locker::DoTearDownSession() {
+  if (!m_python_interpreter)
+    return false;
+  m_python_interpreter->LeaveSession();
+  return true;
+}
+
+ScriptInterpreterPython::Locker::~Locker() {
+  if (m_teardown_session)
+    DoTearDownSession();
+  DoFreeLock();
+}
+
+ScriptInterpreterPython::ScriptInterpreterPython(
+    CommandInterpreter &interpreter)
+    : ScriptInterpreter(interpreter, eScriptLanguagePython),
+      IOHandlerDelegateMultiline("DONE"), m_saved_stdin(), m_saved_stdout(),
+      m_saved_stderr(), m_main_module(), m_lldb_module(),
+      m_session_dict(PyInitialValue::Invalid),
+      m_sys_module_dict(PyInitialValue::Invalid), m_run_one_line_function(),
+      m_run_one_line_str_global(),
+      m_dictionary_name(
+          interpreter.GetDebugger().GetInstanceName().AsCString()),
+      m_terminal_state(), m_active_io_handler(eIOHandlerNone),
+      m_session_is_active(false), m_pty_slave_is_open(false),
+      m_valid_session(true), m_lock_count(0), m_command_thread_state(nullptr) {
+  InitializePrivate();
+
+  m_dictionary_name.append("_dict");
+  StreamString run_string;
+  run_string.Printf("%s = dict()", m_dictionary_name.c_str());
+
+  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
+                ScriptInterpreterPython::Locker::FreeAcquiredLock);
+  PyRun_SimpleString(run_string.GetData());
+
+  run_string.Clear();
+  run_string.Printf(
+      "run_one_line (%s, 'import copy, keyword, os, re, sys, uuid, lldb')",
+      m_dictionary_name.c_str());
+  PyRun_SimpleString(run_string.GetData());
+
+  // Reloading modules requires a different syntax in Python 2 and Python 3.
+  // This provides
+  // a consistent syntax no matter what version of Python.
+  run_string.Clear();
+  run_string.Printf("run_one_line (%s, 'from six.moves import reload_module')",
+                    m_dictionary_name.c_str());
+  PyRun_SimpleString(run_string.GetData());
+
+  // WARNING: temporary code that loads Cocoa formatters - this should be done
+  // on a per-platform basis rather than loading the whole set
+  // and letting the individual formatter classes exploit APIs to check whether
+  // they can/cannot do their task
+  run_string.Clear();
+  run_string.Printf(
+      "run_one_line (%s, 'import lldb.formatters, lldb.formatters.cpp, pydoc')",
+      m_dictionary_name.c_str());
+  PyRun_SimpleString(run_string.GetData());
+  run_string.Clear();
+
+  run_string.Printf("run_one_line (%s, 'import lldb.embedded_interpreter; from "
+                    "lldb.embedded_interpreter import run_python_interpreter; "
+                    "from lldb.embedded_interpreter import run_one_line')",
+                    m_dictionary_name.c_str());
+  PyRun_SimpleString(run_string.GetData());
+  run_string.Clear();
+
+  run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64
+                    "; pydoc.pager = pydoc.plainpager')",
+                    m_dictionary_name.c_str(),
+                    interpreter.GetDebugger().GetID());
+  PyRun_SimpleString(run_string.GetData());
+}
+
+ScriptInterpreterPython::~ScriptInterpreterPython() {
+  // the session dictionary may hold objects with complex state
+  // which means that they may need to be torn down with some level of smarts
+  // and that, in turn, requires a valid thread state
+  // force Python to procure itself such a thread state, nuke the session
+  // dictionary
+  // and then release it for others to use and proceed with the rest of the
+  // shutdown
+  auto gil_state = PyGILState_Ensure();
+  m_session_dict.Reset();
+  PyGILState_Release(gil_state);
+}
+
+void ScriptInterpreterPython::Initialize() {
+  static std::once_flag g_once_flag;
+
+  std::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  lldb::eScriptLanguagePython, CreateInstance);
+  });
+}
+
+void ScriptInterpreterPython::Terminate() {}
 
-bool
-ScriptInterpreterPython::Locker::DoFreeLock()
-{
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT | LIBLLDB_LOG_VERBOSE));
-    if (log)
-        log->Printf("Releasing PyGILState. Returning to state = %slocked\n", m_GILState == PyGILState_UNLOCKED ? "un" : "");
-    PyGILState_Release(m_GILState);
-    m_python_interpreter->DecrementLockCount();
-    return true;
+lldb::ScriptInterpreterSP
+ScriptInterpreterPython::CreateInstance(CommandInterpreter &interpreter) {
+  return std::make_shared<ScriptInterpreterPython>(interpreter);
 }
 
-bool
-ScriptInterpreterPython::Locker::DoTearDownSession()
-{
-    if (!m_python_interpreter)
-        return false;
-    m_python_interpreter->LeaveSession ();
-    return true;
+lldb_private::ConstString ScriptInterpreterPython::GetPluginNameStatic() {
+  static ConstString g_name("script-python");
+  return g_name;
 }
 
-ScriptInterpreterPython::Locker::~Locker()
-{
-    if (m_teardown_session)
-        DoTearDownSession();
-    DoFreeLock();
-}
-
-ScriptInterpreterPython::ScriptInterpreterPython(CommandInterpreter &interpreter) :
-    ScriptInterpreter(interpreter, eScriptLanguagePython),
-    IOHandlerDelegateMultiline("DONE"),
-    m_saved_stdin(),
-    m_saved_stdout(),
-    m_saved_stderr(),
-    m_main_module(),
-    m_lldb_module(),
-    m_session_dict(PyInitialValue::Invalid),
-    m_sys_module_dict(PyInitialValue::Invalid),
-    m_run_one_line_function(),
-    m_run_one_line_str_global(),
-    m_dictionary_name(interpreter.GetDebugger().GetInstanceName().AsCString()),
-    m_terminal_state(),
-    m_active_io_handler(eIOHandlerNone),
-    m_session_is_active(false),
-    m_pty_slave_is_open(false),
-    m_valid_session(true),
-    m_lock_count(0),
-    m_command_thread_state(nullptr)
-{
-    InitializePrivate();
-
-    m_dictionary_name.append("_dict");
-    StreamString run_string;
-    run_string.Printf ("%s = dict()", m_dictionary_name.c_str());
-
-    Locker locker(this,
-                  ScriptInterpreterPython::Locker::AcquireLock,
-                  ScriptInterpreterPython::Locker::FreeAcquiredLock);
-    PyRun_SimpleString (run_string.GetData());
-
-    run_string.Clear();
-    run_string.Printf ("run_one_line (%s, 'import copy, keyword, os, re, sys, uuid, lldb')", m_dictionary_name.c_str());
-    PyRun_SimpleString (run_string.GetData());
-
-    // Reloading modules requires a different syntax in Python 2 and Python 3.  This provides
-    // a consistent syntax no matter what version of Python.
-    run_string.Clear();
-    run_string.Printf("run_one_line (%s, 'from six.moves import reload_module')", m_dictionary_name.c_str());
-    PyRun_SimpleString(run_string.GetData());
-
-    // WARNING: temporary code that loads Cocoa formatters - this should be done on a per-platform basis rather than loading the whole set
-    // and letting the individual formatter classes exploit APIs to check whether they can/cannot do their task
-    run_string.Clear();
-    run_string.Printf ("run_one_line (%s, 'import lldb.formatters, lldb.formatters.cpp, pydoc')", m_dictionary_name.c_str());
-    PyRun_SimpleString (run_string.GetData());
-    run_string.Clear();
-
-    run_string.Printf ("run_one_line (%s, 'import lldb.embedded_interpreter; from lldb.embedded_interpreter import run_python_interpreter; from lldb.embedded_interpreter import run_one_line')", m_dictionary_name.c_str());
-    PyRun_SimpleString (run_string.GetData());
-    run_string.Clear();
-    
-    run_string.Printf ("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64 "; pydoc.pager = pydoc.plainpager')", m_dictionary_name.c_str(),
-                       interpreter.GetDebugger().GetID());
-    PyRun_SimpleString (run_string.GetData());
-}
-
-ScriptInterpreterPython::~ScriptInterpreterPython ()
-{
-    // the session dictionary may hold objects with complex state
-    // which means that they may need to be torn down with some level of smarts
-    // and that, in turn, requires a valid thread state
-    // force Python to procure itself such a thread state, nuke the session dictionary
-    // and then release it for others to use and proceed with the rest of the shutdown
-    auto gil_state = PyGILState_Ensure();
-    m_session_dict.Reset();
-    PyGILState_Release(gil_state);
-}
-
-void
-ScriptInterpreterPython::Initialize()
-{
-    static std::once_flag g_once_flag;
-
-    std::call_once(g_once_flag, []()
-    {
-        PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                      GetPluginDescriptionStatic(),
-                                      lldb::eScriptLanguagePython,
-                                      CreateInstance);
-    });
+const char *ScriptInterpreterPython::GetPluginDescriptionStatic() {
+  return "Embedded Python interpreter";
 }
-    
-void
-ScriptInterpreterPython::Terminate()
-{
 
+lldb_private::ConstString ScriptInterpreterPython::GetPluginName() {
+  return GetPluginNameStatic();
 }
-    
-lldb::ScriptInterpreterSP
-ScriptInterpreterPython::CreateInstance(CommandInterpreter &interpreter)
-{
-    return std::make_shared<ScriptInterpreterPython>(interpreter);
-}
-    
-lldb_private::ConstString
-ScriptInterpreterPython::GetPluginNameStatic()
-{
-    static ConstString g_name("script-python");
-    return g_name;
-}
-
-const char *
-ScriptInterpreterPython::GetPluginDescriptionStatic()
-{
-    return "Embedded Python interpreter";
-}
-    
-lldb_private::ConstString
-ScriptInterpreterPython::GetPluginName()
-{
-    return GetPluginNameStatic();
-}
-    
-uint32_t
-ScriptInterpreterPython::GetPluginVersion()
-{
-    return 1;
-}
-
-void
-ScriptInterpreterPython::IOHandlerActivated (IOHandler &io_handler)
-{
-    const char *instructions = nullptr;
-    
-    switch (m_active_io_handler)
-    {
-    case eIOHandlerNone:
-            break;
-    case eIOHandlerBreakpoint:
-            instructions = R"(Enter your Python command(s). Type 'DONE' to end.
+
+uint32_t ScriptInterpreterPython::GetPluginVersion() { return 1; }
+
+void ScriptInterpreterPython::IOHandlerActivated(IOHandler &io_handler) {
+  const char *instructions = nullptr;
+
+  switch (m_active_io_handler) {
+  case eIOHandlerNone:
+    break;
+  case eIOHandlerBreakpoint:
+    instructions = R"(Enter your Python command(s). Type 'DONE' to end.
 def function (frame, bp_loc, internal_dict):
     """frame: the lldb.SBFrame for the location at which you stopped
        bp_loc: an lldb.SBBreakpointLocation for the breakpoint location information
        internal_dict: an LLDB support object not to be used"""
 )";
-            break;
-    case eIOHandlerWatchpoint:
-            instructions = "Enter your Python command(s). Type 'DONE' to end.\n";
-            break;
-    }
-    
-    if (instructions)
-    {
-        StreamFileSP output_sp(io_handler.GetOutputStreamFile());
-        if (output_sp)
-        {
-            output_sp->PutCString(instructions);
-            output_sp->Flush();
-        }
-    }
-}
-
-void
-ScriptInterpreterPython::IOHandlerInputComplete (IOHandler &io_handler, std::string &data)
-{
-    io_handler.SetIsDone(true);
-    bool batch_mode = m_interpreter.GetBatchCommandMode();
-
-    switch (m_active_io_handler)
-    {
-    case eIOHandlerNone:
-        break;
-    case eIOHandlerBreakpoint:
-        {
-            std::vector<BreakpointOptions *> *bp_options_vec = (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
-            for (auto bp_options : *bp_options_vec)
-            {
-                if (!bp_options)
-                    continue;
-                    
-                std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
-                if (data_ap.get())
-                {
-                    data_ap->user_source.SplitIntoLines(data);
-                    
-                    if (GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source).Success())
-                    {
-                        BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
-                        bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
-                    }
-                    else if (!batch_mode)
-                    {
-                        StreamFileSP error_sp = io_handler.GetErrorStreamFile();
-                        if (error_sp)
-                        {
-                            error_sp->Printf ("Warning: No command attached to breakpoint.\n");
-                            error_sp->Flush();
-                        }
-                    }
-                }
-            }
-            m_active_io_handler = eIOHandlerNone;
-        }
+    break;
+  case eIOHandlerWatchpoint:
+    instructions = "Enter your Python command(s). Type 'DONE' to end.\n";
+    break;
+  }
+
+  if (instructions) {
+    StreamFileSP output_sp(io_handler.GetOutputStreamFile());
+    if (output_sp) {
+      output_sp->PutCString(instructions);
+      output_sp->Flush();
+    }
+  }
+}
+
+void ScriptInterpreterPython::IOHandlerInputComplete(IOHandler &io_handler,
+                                                     std::string &data) {
+  io_handler.SetIsDone(true);
+  bool batch_mode = m_interpreter.GetBatchCommandMode();
+
+  switch (m_active_io_handler) {
+  case eIOHandlerNone:
+    break;
+  case eIOHandlerBreakpoint: {
+    std::vector<BreakpointOptions *> *bp_options_vec =
+        (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
+    for (auto bp_options : *bp_options_vec) {
+      if (!bp_options)
+        continue;
+
+      auto data_ap = llvm::make_unique<CommandDataPython>();
+      if (!data_ap)
         break;
-    case eIOHandlerWatchpoint:
-        {
-            WatchpointOptions *wp_options = (WatchpointOptions *)io_handler.GetUserData();
-            std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
-            if (data_ap.get())
-            {
-                data_ap->user_source.SplitIntoLines(data);
-                
-                if (GenerateWatchpointCommandCallbackData (data_ap->user_source, data_ap->script_source))
-                {
-                    BatonSP baton_sp (new WatchpointOptions::CommandBaton (data_ap.release()));
-                    wp_options->SetCallback (ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
-                }
-                else if (!batch_mode)
-                {
-                    StreamFileSP error_sp = io_handler.GetErrorStreamFile();
-                    if (error_sp)
-                    {
-                        error_sp->Printf ("Warning: No command attached to breakpoint.\n");
-                        error_sp->Flush();
-                    }
-                }
-            }
-            m_active_io_handler = eIOHandlerNone;
+      data_ap->user_source.SplitIntoLines(data);
+
+      if (GenerateBreakpointCommandCallbackData(data_ap->user_source,
+                                                data_ap->script_source)
+              .Success()) {
+        auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>(
+            std::move(data_ap));
+        bp_options->SetCallback(
+            ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
+      } else if (!batch_mode) {
+        StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+        if (error_sp) {
+          error_sp->Printf("Warning: No command attached to breakpoint.\n");
+          error_sp->Flush();
         }
-        break;
-    }
-}
-
-
-void
-ScriptInterpreterPython::ResetOutputFileHandle (FILE *fh)
-{
-}
-
-void
-ScriptInterpreterPython::SaveTerminalState (int fd)
-{
-    // Python mucks with the terminal state of STDIN. If we can possibly avoid
-    // this by setting the file handles up correctly prior to entering the
-    // interpreter we should. For now we save and restore the terminal state
-    // on the input file handle.
-    m_terminal_state.Save (fd, false);
-}
-
-void
-ScriptInterpreterPython::RestoreTerminalState ()
-{
-    // Python mucks with the terminal state of STDIN. If we can possibly avoid
-    // this by setting the file handles up correctly prior to entering the
-    // interpreter we should. For now we save and restore the terminal state
-    // on the input file handle.
-    m_terminal_state.Restore();
-}
-
-void
-ScriptInterpreterPython::LeaveSession ()
-{
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
+      }
+    }
+    m_active_io_handler = eIOHandlerNone;
+  } break;
+  case eIOHandlerWatchpoint: {
+    WatchpointOptions *wp_options =
+        (WatchpointOptions *)io_handler.GetUserData();
+    auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>();
+    data_ap->user_source.SplitIntoLines(data);
+
+    if (GenerateWatchpointCommandCallbackData(data_ap->user_source,
+                                              data_ap->script_source)) {
+      auto baton_sp =
+          std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap));
+      wp_options->SetCallback(
+          ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
+    } else if (!batch_mode) {
+      StreamFileSP error_sp = io_handler.GetErrorStreamFile();
+      if (error_sp) {
+        error_sp->Printf("Warning: No command attached to breakpoint.\n");
+        error_sp->Flush();
+      }
+    }
+    m_active_io_handler = eIOHandlerNone;
+  } break;
+  }
+}
+
+void ScriptInterpreterPython::ResetOutputFileHandle(FILE *fh) {}
+
+void ScriptInterpreterPython::SaveTerminalState(int fd) {
+  // Python mucks with the terminal state of STDIN. If we can possibly avoid
+  // this by setting the file handles up correctly prior to entering the
+  // interpreter we should. For now we save and restore the terminal state
+  // on the input file handle.
+  m_terminal_state.Save(fd, false);
+}
+
+void ScriptInterpreterPython::RestoreTerminalState() {
+  // Python mucks with the terminal state of STDIN. If we can possibly avoid
+  // this by setting the file handles up correctly prior to entering the
+  // interpreter we should. For now we save and restore the terminal state
+  // on the input file handle.
+  m_terminal_state.Restore();
+}
+
+void ScriptInterpreterPython::LeaveSession() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+  if (log)
+    log->PutCString("ScriptInterpreterPython::LeaveSession()");
+
+  // checking that we have a valid thread state - since we use our own threading
+  // and locking
+  // in some (rare) cases during cleanup Python may end up believing we have no
+  // thread state
+  // and PyImport_AddModule will crash if that is the case - since that seems to
+  // only happen
+  // when destroying the SBDebugger, we can make do without clearing up stdout
+  // and stderr
+
+  // rdar://problem/11292882
+  // When the current thread state is NULL, PyThreadState_Get() issues a fatal
+  // error.
+  if (PyThreadState_GetDict()) {
+    PythonDictionary &sys_module_dict = GetSysModuleDictionary();
+    if (sys_module_dict.IsValid()) {
+      if (m_saved_stdin.IsValid()) {
+        sys_module_dict.SetItemForKey(PythonString("stdin"), m_saved_stdin);
+        m_saved_stdin.Reset();
+      }
+      if (m_saved_stdout.IsValid()) {
+        sys_module_dict.SetItemForKey(PythonString("stdout"), m_saved_stdout);
+        m_saved_stdout.Reset();
+      }
+      if (m_saved_stderr.IsValid()) {
+        sys_module_dict.SetItemForKey(PythonString("stderr"), m_saved_stderr);
+        m_saved_stderr.Reset();
+      }
+    }
+  }
+
+  m_session_is_active = false;
+}
+
+bool ScriptInterpreterPython::SetStdHandle(File &file, const char *py_name,
+                                           PythonFile &save_file,
+                                           const char *mode) {
+  if (file.IsValid()) {
+    // Flush the file before giving it to python to avoid interleaved output.
+    file.Flush();
+
+    PythonDictionary &sys_module_dict = GetSysModuleDictionary();
+
+    save_file = sys_module_dict.GetItemForKey(PythonString(py_name))
+                    .AsType<PythonFile>();
+
+    PythonFile new_file(file, mode);
+    sys_module_dict.SetItemForKey(PythonString(py_name), new_file);
+    return true;
+  } else
+    save_file.Reset();
+  return false;
+}
+
+bool ScriptInterpreterPython::EnterSession(uint16_t on_entry_flags, FILE *in,
+                                           FILE *out, FILE *err) {
+  // If we have already entered the session, without having officially 'left'
+  // it, then there is no need to
+  // 'enter' it again.
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+  if (m_session_is_active) {
     if (log)
-        log->PutCString("ScriptInterpreterPython::LeaveSession()");
+      log->Printf(
+          "ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16
+          ") session is already active, returning without doing anything",
+          on_entry_flags);
+    return false;
+  }
+
+  if (log)
+    log->Printf(
+        "ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ")",
+        on_entry_flags);
+
+  m_session_is_active = true;
+
+  StreamString run_string;
+
+  if (on_entry_flags & Locker::InitGlobals) {
+    run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
+                      m_dictionary_name.c_str(),
+                      GetCommandInterpreter().GetDebugger().GetID());
+    run_string.Printf(
+        "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
+        GetCommandInterpreter().GetDebugger().GetID());
+    run_string.PutCString("; lldb.target = lldb.debugger.GetSelectedTarget()");
+    run_string.PutCString("; lldb.process = lldb.target.GetProcess()");
+    run_string.PutCString("; lldb.thread = lldb.process.GetSelectedThread ()");
+    run_string.PutCString("; lldb.frame = lldb.thread.GetSelectedFrame ()");
+    run_string.PutCString("')");
+  } else {
+    // If we aren't initing the globals, we should still always set the debugger
+    // (since that is always unique.)
+    run_string.Printf("run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64,
+                      m_dictionary_name.c_str(),
+                      GetCommandInterpreter().GetDebugger().GetID());
+    run_string.Printf(
+        "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
+        GetCommandInterpreter().GetDebugger().GetID());
+    run_string.PutCString("')");
+  }
+
+  PyRun_SimpleString(run_string.GetData());
+  run_string.Clear();
+
+  PythonDictionary &sys_module_dict = GetSysModuleDictionary();
+  if (sys_module_dict.IsValid()) {
+    File in_file(in, false);
+    File out_file(out, false);
+    File err_file(err, false);
+
+    lldb::StreamFileSP in_sp;
+    lldb::StreamFileSP out_sp;
+    lldb::StreamFileSP err_sp;
+    if (!in_file.IsValid() || !out_file.IsValid() || !err_file.IsValid())
+      m_interpreter.GetDebugger().AdoptTopIOHandlerFilesIfInvalid(in_sp, out_sp,
+                                                                  err_sp);
+
+    if (on_entry_flags & Locker::NoSTDIN) {
+      m_saved_stdin.Reset();
+    } else {
+      if (!SetStdHandle(in_file, "stdin", m_saved_stdin, "r")) {
+        if (in_sp)
+          SetStdHandle(in_sp->GetFile(), "stdin", m_saved_stdin, "r");
+      }
+    }
+
+    if (!SetStdHandle(out_file, "stdout", m_saved_stdout, "w")) {
+      if (out_sp)
+        SetStdHandle(out_sp->GetFile(), "stdout", m_saved_stdout, "w");
+    }
+
+    if (!SetStdHandle(err_file, "stderr", m_saved_stderr, "w")) {
+      if (err_sp)
+        SetStdHandle(err_sp->GetFile(), "stderr", m_saved_stderr, "w");
+    }
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  return true;
+}
+
+PythonObject &ScriptInterpreterPython::GetMainModule() {
+  if (!m_main_module.IsValid())
+    m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
+  return m_main_module;
+}
+
+PythonDictionary &ScriptInterpreterPython::GetSessionDictionary() {
+  if (m_session_dict.IsValid())
+    return m_session_dict;
 
-    // checking that we have a valid thread state - since we use our own threading and locking
-    // in some (rare) cases during cleanup Python may end up believing we have no thread state
-    // and PyImport_AddModule will crash if that is the case - since that seems to only happen
-    // when destroying the SBDebugger, we can make do without clearing up stdout and stderr
+  PythonObject &main_module = GetMainModule();
+  if (!main_module.IsValid())
+    return m_session_dict;
 
-    // rdar://problem/11292882
-    // When the current thread state is NULL, PyThreadState_Get() issues a fatal error.
-    if (PyThreadState_GetDict())
-    {
-        PythonDictionary &sys_module_dict = GetSysModuleDictionary ();
-        if (sys_module_dict.IsValid())
-        {
-            if (m_saved_stdin.IsValid())
-            {
-                sys_module_dict.SetItemForKey(PythonString("stdin"), m_saved_stdin);
-                m_saved_stdin.Reset ();
-            }
-            if (m_saved_stdout.IsValid())
-            {
-                sys_module_dict.SetItemForKey(PythonString("stdout"), m_saved_stdout);
-                m_saved_stdout.Reset ();
-            }
-            if (m_saved_stderr.IsValid())
-            {
-                sys_module_dict.SetItemForKey(PythonString("stderr"), m_saved_stderr);
-                m_saved_stderr.Reset ();
-            }
-        }
-    }
+  PythonDictionary main_dict(PyRefType::Borrowed,
+                             PyModule_GetDict(main_module.get()));
+  if (!main_dict.IsValid())
+    return m_session_dict;
 
-    m_session_is_active = false;
+  PythonObject item = main_dict.GetItemForKey(PythonString(m_dictionary_name));
+  m_session_dict.Reset(PyRefType::Borrowed, item.get());
+  return m_session_dict;
 }
 
-bool
-ScriptInterpreterPython::SetStdHandle(File &file, const char *py_name, PythonFile &save_file, const char *mode)
-{
-    if (file.IsValid())
-    {
-        // Flush the file before giving it to python to avoid interleaved output.
-        file.Flush();
-
-        PythonDictionary &sys_module_dict = GetSysModuleDictionary();
-
-        save_file = sys_module_dict.GetItemForKey(PythonString(py_name)).AsType<PythonFile>();
+PythonDictionary &ScriptInterpreterPython::GetSysModuleDictionary() {
+  if (m_sys_module_dict.IsValid())
+    return m_sys_module_dict;
 
-        PythonFile new_file(file, mode);
-        sys_module_dict.SetItemForKey(PythonString(py_name), new_file);
-        return true;
-    }
-    else
-        save_file.Reset();
-    return false;
+  PythonObject sys_module(PyRefType::Borrowed, PyImport_AddModule("sys"));
+  if (sys_module.IsValid())
+    m_sys_module_dict.Reset(PyRefType::Borrowed,
+                            PyModule_GetDict(sys_module.get()));
+  return m_sys_module_dict;
 }
 
-bool
-ScriptInterpreterPython::EnterSession (uint16_t on_entry_flags,
-                                       FILE *in,
-                                       FILE *out,
-                                       FILE *err)
-{
-    // If we have already entered the session, without having officially 'left' it, then there is no need to 
-    // 'enter' it again.
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
-    if (m_session_is_active)
-    {
-        if (log)
-            log->Printf("ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ") session is already active, returning without doing anything", on_entry_flags);
-        return false;
-    }
-
-    if (log)
-        log->Printf("ScriptInterpreterPython::EnterSession(on_entry_flags=0x%" PRIx16 ")", on_entry_flags);
-    
-
-    m_session_is_active = true;
-
-    StreamString run_string;
-
-    if (on_entry_flags & Locker::InitGlobals)
-    {
-        run_string.Printf (    "run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64, m_dictionary_name.c_str(), GetCommandInterpreter().GetDebugger().GetID());
-        run_string.Printf (    "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")", GetCommandInterpreter().GetDebugger().GetID());
-        run_string.PutCString ("; lldb.target = lldb.debugger.GetSelectedTarget()");
-        run_string.PutCString ("; lldb.process = lldb.target.GetProcess()");
-        run_string.PutCString ("; lldb.thread = lldb.process.GetSelectedThread ()");
-        run_string.PutCString ("; lldb.frame = lldb.thread.GetSelectedFrame ()");
-        run_string.PutCString ("')");
-    }
-    else
-    {
-        // If we aren't initing the globals, we should still always set the debugger (since that is always unique.)
-        run_string.Printf (    "run_one_line (%s, 'lldb.debugger_unique_id = %" PRIu64, m_dictionary_name.c_str(), GetCommandInterpreter().GetDebugger().GetID());
-        run_string.Printf (    "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")", GetCommandInterpreter().GetDebugger().GetID());
-        run_string.PutCString ("')");
-    }
-
-    PyRun_SimpleString (run_string.GetData());
-    run_string.Clear();
-
-    PythonDictionary &sys_module_dict = GetSysModuleDictionary ();
-    if (sys_module_dict.IsValid())
-    {
-        File in_file(in, false);
-        File out_file(out, false);
-        File err_file(err, false);
-
-        lldb::StreamFileSP in_sp;
-        lldb::StreamFileSP out_sp;
-        lldb::StreamFileSP err_sp;
-        if (!in_file.IsValid() || !out_file.IsValid() || !err_file.IsValid())
-            m_interpreter.GetDebugger().AdoptTopIOHandlerFilesIfInvalid (in_sp, out_sp, err_sp);
-
-
-        if (on_entry_flags & Locker::NoSTDIN)
-        {
-            m_saved_stdin.Reset();
-        }
-        else
-        {
-            if (!SetStdHandle(in_file, "stdin", m_saved_stdin, "r"))
-            {
-                if (in_sp)
-                    SetStdHandle(in_sp->GetFile(), "stdin", m_saved_stdin, "r");
-            }
-        }
+static std::string GenerateUniqueName(const char *base_name_wanted,
+                                      uint32_t &functions_counter,
+                                      const void *name_token = nullptr) {
+  StreamString sstr;
 
-        if (!SetStdHandle(out_file, "stdout", m_saved_stdout, "w"))
-        {
-            if (out_sp)
-                SetStdHandle(out_sp->GetFile(), "stdout", m_saved_stdout, "w");
-        }
+  if (!base_name_wanted)
+    return std::string();
 
-        if (!SetStdHandle(err_file, "stderr", m_saved_stderr, "w"))
-        {
-            if (err_sp)
-                SetStdHandle(err_sp->GetFile(), "stderr", m_saved_stderr, "w");
-        }
-    }
+  if (!name_token)
+    sstr.Printf("%s_%d", base_name_wanted, functions_counter++);
+  else
+    sstr.Printf("%s_%p", base_name_wanted, name_token);
 
-    if (PyErr_Occurred())
-        PyErr_Clear ();
-    
-    return true;
-}
-
-PythonObject &
-ScriptInterpreterPython::GetMainModule()
-{
-    if (!m_main_module.IsValid())
-        m_main_module.Reset(PyRefType::Borrowed, PyImport_AddModule("__main__"));
-    return m_main_module;
+  return sstr.GetString();
 }
 
-PythonDictionary &
-ScriptInterpreterPython::GetSessionDictionary ()
-{
-    if (m_session_dict.IsValid())
-        return m_session_dict;
+bool ScriptInterpreterPython::GetEmbeddedInterpreterModuleObjects() {
+  if (m_run_one_line_function.IsValid())
+    return true;
 
-    PythonObject &main_module = GetMainModule();
-    if (!main_module.IsValid())
-        return m_session_dict;
+  PythonObject module(PyRefType::Borrowed,
+                      PyImport_AddModule("lldb.embedded_interpreter"));
+  if (!module.IsValid())
+    return false;
 
-    PythonDictionary main_dict(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
-    if (!main_dict.IsValid())
-        return m_session_dict;
+  PythonDictionary module_dict(PyRefType::Borrowed,
+                               PyModule_GetDict(module.get()));
+  if (!module_dict.IsValid())
+    return false;
 
-    PythonObject item = main_dict.GetItemForKey(PythonString(m_dictionary_name));
-    m_session_dict.Reset(PyRefType::Borrowed, item.get());
-    return m_session_dict;
+  m_run_one_line_function =
+      module_dict.GetItemForKey(PythonString("run_one_line"));
+  m_run_one_line_str_global =
+      module_dict.GetItemForKey(PythonString("g_run_one_line_str"));
+  return m_run_one_line_function.IsValid();
 }
 
-PythonDictionary &
-ScriptInterpreterPython::GetSysModuleDictionary ()
-{
-    if (m_sys_module_dict.IsValid())
-        return m_sys_module_dict;
-
-    PythonObject sys_module(PyRefType::Borrowed, PyImport_AddModule("sys"));
-    if (sys_module.IsValid())
-        m_sys_module_dict.Reset(PyRefType::Borrowed, PyModule_GetDict(sys_module.get()));
-    return m_sys_module_dict;
+static void ReadThreadBytesReceived(void *baton, const void *src,
+                                    size_t src_len) {
+  if (src && src_len) {
+    Stream *strm = (Stream *)baton;
+    strm->Write(src, src_len);
+    strm->Flush();
+  }
 }
 
-static std::string
-GenerateUniqueName (const char* base_name_wanted,
-                    uint32_t& functions_counter,
-                    const void* name_token = nullptr)
-{
-    StreamString sstr;
-    
-    if (!base_name_wanted)
-        return std::string();
-    
-    if (!name_token)
-        sstr.Printf ("%s_%d", base_name_wanted, functions_counter++);
-    else
-        sstr.Printf ("%s_%p", base_name_wanted, name_token);
-    
-    return sstr.GetString();
-}
-
-bool
-ScriptInterpreterPython::GetEmbeddedInterpreterModuleObjects ()
-{
-    if (m_run_one_line_function.IsValid())
-        return true;
-
-    PythonObject module(PyRefType::Borrowed, PyImport_AddModule ("lldb.embedded_interpreter"));
-    if (!module.IsValid())
-        return false;
-
-    PythonDictionary module_dict(PyRefType::Borrowed, PyModule_GetDict(module.get()));
-    if (!module_dict.IsValid())
-        return false;
-
-    m_run_one_line_function = module_dict.GetItemForKey(PythonString("run_one_line"));
-    m_run_one_line_str_global = module_dict.GetItemForKey(PythonString("g_run_one_line_str"));
-    return m_run_one_line_function.IsValid();
-}
-
-static void
-ReadThreadBytesReceived(void *baton, const void *src, size_t src_len)
-{
-    if (src && src_len)
-    {
-        Stream *strm = (Stream *)baton;
-        strm->Write(src, src_len);
-        strm->Flush();
-    }
-}
+bool ScriptInterpreterPython::ExecuteOneLine(
+    const char *command, CommandReturnObject *result,
+    const ExecuteScriptOptions &options) {
+  if (!m_valid_session)
+    return false;
 
-bool
-ScriptInterpreterPython::ExecuteOneLine (const char *command, CommandReturnObject *result, const ExecuteScriptOptions &options)
-{
-    if (!m_valid_session)
-        return false;
-    
-    if (command && command[0])
-    {
-        // We want to call run_one_line, passing in the dictionary and the command string.  We cannot do this through
-        // PyRun_SimpleString here because the command string may contain escaped characters, and putting it inside
-        // another string to pass to PyRun_SimpleString messes up the escaping.  So we use the following more complicated
-        // method to pass the command string directly down to Python.
-        Debugger &debugger = m_interpreter.GetDebugger();
-        
-        StreamFileSP input_file_sp;
-        StreamFileSP output_file_sp;
-        StreamFileSP error_file_sp;
-        Communication output_comm ("lldb.ScriptInterpreterPython.ExecuteOneLine.comm");
-        bool join_read_thread = false;
-        if (options.GetEnableIO())
-        {
-            if (result)
-            {
-                input_file_sp = debugger.GetInputFile();
-                // Set output to a temporary file so we can forward the results on to the result object
-                
-                Pipe pipe;
-                Error pipe_result = pipe.CreateNew(false);
-                if (pipe_result.Success())
-                {
+  if (command && command[0]) {
+    // We want to call run_one_line, passing in the dictionary and the command
+    // string.  We cannot do this through
+    // PyRun_SimpleString here because the command string may contain escaped
+    // characters, and putting it inside
+    // another string to pass to PyRun_SimpleString messes up the escaping.  So
+    // we use the following more complicated
+    // method to pass the command string directly down to Python.
+    Debugger &debugger = m_interpreter.GetDebugger();
+
+    StreamFileSP input_file_sp;
+    StreamFileSP output_file_sp;
+    StreamFileSP error_file_sp;
+    Communication output_comm(
+        "lldb.ScriptInterpreterPython.ExecuteOneLine.comm");
+    bool join_read_thread = false;
+    if (options.GetEnableIO()) {
+      if (result) {
+        input_file_sp = debugger.GetInputFile();
+        // Set output to a temporary file so we can forward the results on to
+        // the result object
+
+        Pipe pipe;
+        Error pipe_result = pipe.CreateNew(false);
+        if (pipe_result.Success()) {
 #if defined(_WIN32)
-                    lldb::file_t read_file = pipe.GetReadNativeHandle();
-                    pipe.ReleaseReadFileDescriptor();
-                    std::unique_ptr<ConnectionGenericFile> conn_ap(new ConnectionGenericFile(read_file, true));
+          lldb::file_t read_file = pipe.GetReadNativeHandle();
+          pipe.ReleaseReadFileDescriptor();
+          std::unique_ptr<ConnectionGenericFile> conn_ap(
+              new ConnectionGenericFile(read_file, true));
 #else
-                    std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor(pipe.ReleaseReadFileDescriptor(), true));
+          std::unique_ptr<ConnectionFileDescriptor> conn_ap(
+              new ConnectionFileDescriptor(pipe.ReleaseReadFileDescriptor(),
+                                           true));
 #endif
-                    if (conn_ap->IsConnected())
-                    {
-                        output_comm.SetConnection(conn_ap.release());
-                        output_comm.SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived, &result->GetOutputStream());
-                        output_comm.StartReadThread();
-                        join_read_thread = true;
-                        FILE *outfile_handle = fdopen (pipe.ReleaseWriteFileDescriptor(), "w");
-                        output_file_sp.reset(new StreamFile(outfile_handle, true));
-                        error_file_sp = output_file_sp;
-                        if (outfile_handle)
-                            ::setbuf (outfile_handle, nullptr);
-                        
-                        result->SetImmediateOutputFile(debugger.GetOutputFile()->GetFile().GetStream());
-                        result->SetImmediateErrorFile(debugger.GetErrorFile()->GetFile().GetStream());
-                    }
-                }
-            }
-            if (!input_file_sp || !output_file_sp || !error_file_sp)
-                debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp, error_file_sp);
-        }
-        else
-        {
-            input_file_sp.reset (new StreamFile ());
-            input_file_sp->GetFile().Open(FileSystem::DEV_NULL, File::eOpenOptionRead);
-            output_file_sp.reset (new StreamFile ());
-            output_file_sp->GetFile().Open(FileSystem::DEV_NULL, File::eOpenOptionWrite);
+          if (conn_ap->IsConnected()) {
+            output_comm.SetConnection(conn_ap.release());
+            output_comm.SetReadThreadBytesReceivedCallback(
+                ReadThreadBytesReceived, &result->GetOutputStream());
+            output_comm.StartReadThread();
+            join_read_thread = true;
+            FILE *outfile_handle =
+                fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
+            output_file_sp.reset(new StreamFile(outfile_handle, true));
             error_file_sp = output_file_sp;
+            if (outfile_handle)
+              ::setbuf(outfile_handle, nullptr);
+
+            result->SetImmediateOutputFile(
+                debugger.GetOutputFile()->GetFile().GetStream());
+            result->SetImmediateErrorFile(
+                debugger.GetErrorFile()->GetFile().GetStream());
+          }
         }
-
-        FILE *in_file = input_file_sp->GetFile().GetStream();
-        FILE *out_file = output_file_sp->GetFile().GetStream();
-        FILE *err_file = error_file_sp->GetFile().GetStream();
-        bool success = false;
-        {
-            // WARNING!  It's imperative that this RAII scope be as tight as possible.  In particular, the
-            // scope must end *before* we try to join the read thread.  The reason for this is that a
-            // pre-requisite for joining the read thread is that we close the write handle (to break the
-            // pipe and cause it to wake up and exit).  But acquiring the GIL as below will redirect Python's
-            // stdio to use this same handle.  If we close the handle while Python is still using it, bad
-            // things will happen.
-            Locker locker(this,
-                          ScriptInterpreterPython::Locker::AcquireLock |
-                          ScriptInterpreterPython::Locker::InitSession |
-                          (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) |
-                          ((result && result->GetInteractive()) ? 0: Locker::NoSTDIN),
-                          ScriptInterpreterPython::Locker::FreeAcquiredLock |
-                          ScriptInterpreterPython::Locker::TearDownSession,
-                          in_file,
-                          out_file,
-                          err_file);
-        
-            // Find the correct script interpreter dictionary in the main module.
-            PythonDictionary &session_dict = GetSessionDictionary ();
-            if (session_dict.IsValid())
-            {
-                if (GetEmbeddedInterpreterModuleObjects ())
-                {
-                    if (PyCallable_Check(m_run_one_line_function.get()))
-                    {
-                        PythonObject pargs(PyRefType::Owned, Py_BuildValue("(Os)", session_dict.get(), command));
-                        if (pargs.IsValid())
-                        {
-                            PythonObject return_value(PyRefType::Owned,
-                                PyObject_CallObject(m_run_one_line_function.get(), pargs.get()));
-                            if (return_value.IsValid())
-                                success = true;
-                            else if (options.GetMaskoutErrors() && PyErr_Occurred ())
-                            {
-                                PyErr_Print();
-                                PyErr_Clear();
-                            }
-                        }
-                    }
-                }
+      }
+      if (!input_file_sp || !output_file_sp || !error_file_sp)
+        debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp,
+                                                 error_file_sp);
+    } else {
+      input_file_sp.reset(new StreamFile());
+      input_file_sp->GetFile().Open(FileSystem::DEV_NULL,
+                                    File::eOpenOptionRead);
+      output_file_sp.reset(new StreamFile());
+      output_file_sp->GetFile().Open(FileSystem::DEV_NULL,
+                                     File::eOpenOptionWrite);
+      error_file_sp = output_file_sp;
+    }
+
+    FILE *in_file = input_file_sp->GetFile().GetStream();
+    FILE *out_file = output_file_sp->GetFile().GetStream();
+    FILE *err_file = error_file_sp->GetFile().GetStream();
+    bool success = false;
+    {
+      // WARNING!  It's imperative that this RAII scope be as tight as possible.
+      // In particular, the
+      // scope must end *before* we try to join the read thread.  The reason for
+      // this is that a
+      // pre-requisite for joining the read thread is that we close the write
+      // handle (to break the
+      // pipe and cause it to wake up and exit).  But acquiring the GIL as below
+      // will redirect Python's
+      // stdio to use this same handle.  If we close the handle while Python is
+      // still using it, bad
+      // things will happen.
+      Locker locker(
+          this,
+          ScriptInterpreterPython::Locker::AcquireLock |
+              ScriptInterpreterPython::Locker::InitSession |
+              (options.GetSetLLDBGlobals()
+                   ? ScriptInterpreterPython::Locker::InitGlobals
+                   : 0) |
+              ((result && result->GetInteractive()) ? 0 : Locker::NoSTDIN),
+          ScriptInterpreterPython::Locker::FreeAcquiredLock |
+              ScriptInterpreterPython::Locker::TearDownSession,
+          in_file, out_file, err_file);
+
+      // Find the correct script interpreter dictionary in the main module.
+      PythonDictionary &session_dict = GetSessionDictionary();
+      if (session_dict.IsValid()) {
+        if (GetEmbeddedInterpreterModuleObjects()) {
+          if (PyCallable_Check(m_run_one_line_function.get())) {
+            PythonObject pargs(
+                PyRefType::Owned,
+                Py_BuildValue("(Os)", session_dict.get(), command));
+            if (pargs.IsValid()) {
+              PythonObject return_value(
+                  PyRefType::Owned,
+                  PyObject_CallObject(m_run_one_line_function.get(),
+                                      pargs.get()));
+              if (return_value.IsValid())
+                success = true;
+              else if (options.GetMaskoutErrors() && PyErr_Occurred()) {
+                PyErr_Print();
+                PyErr_Clear();
+              }
             }
-
-            // Flush our output and error file handles
-            ::fflush (out_file);
-            if (out_file != err_file)
-                ::fflush (err_file);
+          }
         }
-        
-        if (join_read_thread)
-        {
-            // Close the write end of the pipe since we are done with our
-            // one line script. This should cause the read thread that
-            // output_comm is using to exit
-            output_file_sp->GetFile().Close();
-            // The close above should cause this thread to exit when it gets
-            // to the end of file, so let it get all its data
-            output_comm.JoinReadThread();
-            // Now we can close the read end of the pipe
-            output_comm.Disconnect();
-        }
-        
-        
-        if (success)
-            return true;
-
-        // The one-liner failed.  Append the error message.
-        if (result)
-            result->AppendErrorWithFormat ("python failed attempting to evaluate '%s'\n", command);
-        return false;
+      }
+
+      // Flush our output and error file handles
+      ::fflush(out_file);
+      if (out_file != err_file)
+        ::fflush(err_file);
     }
 
+    if (join_read_thread) {
+      // Close the write end of the pipe since we are done with our
+      // one line script. This should cause the read thread that
+      // output_comm is using to exit
+      output_file_sp->GetFile().Close();
+      // The close above should cause this thread to exit when it gets
+      // to the end of file, so let it get all its data
+      output_comm.JoinReadThread();
+      // Now we can close the read end of the pipe
+      output_comm.Disconnect();
+    }
+
+    if (success)
+      return true;
+
+    // The one-liner failed.  Append the error message.
     if (result)
-        result->AppendError ("empty command passed to python\n");
+      result->AppendErrorWithFormat(
+          "python failed attempting to evaluate '%s'\n", command);
     return false;
-}
+  }
 
+  if (result)
+    result->AppendError("empty command passed to python\n");
+  return false;
+}
 
-class IOHandlerPythonInterpreter :
-    public IOHandler
-{
+class IOHandlerPythonInterpreter : public IOHandler {
 public:
-    
-    IOHandlerPythonInterpreter (Debugger &debugger,
-                                ScriptInterpreterPython *python) :
-        IOHandler (debugger, IOHandler::Type::PythonInterpreter),
-        m_python(python)
-    {
-        
-    }
-    
-    ~IOHandlerPythonInterpreter() override
-    {
-        
-    }
-    
-    ConstString
-    GetControlSequence (char ch) override
-    {
-        if (ch == 'd')
-            return ConstString("quit()\n");
-        return ConstString();
-    }
-
-    void
-    Run () override
-    {
-        if (m_python)
-        {
-            int stdin_fd = GetInputFD();
-            if (stdin_fd >= 0)
-            {
-                Terminal terminal(stdin_fd);
-                TerminalState terminal_state;
-                const bool is_a_tty = terminal.IsATerminal();
-                
-                if (is_a_tty)
-                {
-                    terminal_state.Save (stdin_fd, false);
-                    terminal.SetCanonical(false);
-                    terminal.SetEcho(true);
-                }
-                
-                ScriptInterpreterPython::Locker locker (m_python,
-                                                        ScriptInterpreterPython::Locker::AcquireLock |
-                                                        ScriptInterpreterPython::Locker::InitSession |
-                                                        ScriptInterpreterPython::Locker::InitGlobals,
-                                                        ScriptInterpreterPython::Locker::FreeAcquiredLock |
-                                                        ScriptInterpreterPython::Locker::TearDownSession);
-
-                // The following call drops into the embedded interpreter loop and stays there until the
-                // user chooses to exit from the Python interpreter.
-                // This embedded interpreter will, as any Python code that performs I/O, unlock the GIL before
-                // a system call that can hang, and lock it when the syscall has returned.
-                
-                // We need to surround the call to the embedded interpreter with calls to PyGILState_Ensure and
-                // PyGILState_Release (using the Locker above). This is because Python has a global lock which must be held whenever we want
-                // to touch any Python objects. Otherwise, if the user calls Python code, the interpreter state will be off,
-                // and things could hang (it's happened before).
-                
-                StreamString run_string;
-                run_string.Printf ("run_python_interpreter (%s)", m_python->GetDictionaryName ());
-                PyRun_SimpleString (run_string.GetData());
-                
-                if (is_a_tty)
-                    terminal_state.Restore();
-            }
+  IOHandlerPythonInterpreter(Debugger &debugger,
+                             ScriptInterpreterPython *python)
+      : IOHandler(debugger, IOHandler::Type::PythonInterpreter),
+        m_python(python) {}
+
+  ~IOHandlerPythonInterpreter() override {}
+
+  ConstString GetControlSequence(char ch) override {
+    if (ch == 'd')
+      return ConstString("quit()\n");
+    return ConstString();
+  }
+
+  void Run() override {
+    if (m_python) {
+      int stdin_fd = GetInputFD();
+      if (stdin_fd >= 0) {
+        Terminal terminal(stdin_fd);
+        TerminalState terminal_state;
+        const bool is_a_tty = terminal.IsATerminal();
+
+        if (is_a_tty) {
+          terminal_state.Save(stdin_fd, false);
+          terminal.SetCanonical(false);
+          terminal.SetEcho(true);
         }
-        SetIsDone(true);
-    }
 
-    void
-    Cancel () override
-    {
-        
-    }
+        ScriptInterpreterPython::Locker locker(
+            m_python, ScriptInterpreterPython::Locker::AcquireLock |
+                          ScriptInterpreterPython::Locker::InitSession |
+                          ScriptInterpreterPython::Locker::InitGlobals,
+            ScriptInterpreterPython::Locker::FreeAcquiredLock |
+                ScriptInterpreterPython::Locker::TearDownSession);
 
-    bool
-    Interrupt () override
-    {
-        return m_python->Interrupt();
-    }
-    
-    void
-    GotEOF() override
-    {
-        
-    }
-protected:
-    ScriptInterpreterPython *m_python;
-};
+        // The following call drops into the embedded interpreter loop and stays
+        // there until the
+        // user chooses to exit from the Python interpreter.
+        // This embedded interpreter will, as any Python code that performs I/O,
+        // unlock the GIL before
+        // a system call that can hang, and lock it when the syscall has
+        // returned.
 
+        // We need to surround the call to the embedded interpreter with calls
+        // to PyGILState_Ensure and
+        // PyGILState_Release (using the Locker above). This is because Python
+        // has a global lock which must be held whenever we want
+        // to touch any Python objects. Otherwise, if the user calls Python
+        // code, the interpreter state will be off,
+        // and things could hang (it's happened before).
 
-void
-ScriptInterpreterPython::ExecuteInterpreterLoop ()
-{
-    Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
+        StreamString run_string;
+        run_string.Printf("run_python_interpreter (%s)",
+                          m_python->GetDictionaryName());
+        PyRun_SimpleString(run_string.GetData());
 
-    Debugger &debugger = GetCommandInterpreter().GetDebugger();
+        if (is_a_tty)
+          terminal_state.Restore();
+      }
+    }
+    SetIsDone(true);
+  }
 
-    // At the moment, the only time the debugger does not have an input file handle is when this is called
-    // directly from Python, in which case it is both dangerous and unnecessary (not to mention confusing) to
-    // try to embed a running interpreter loop inside the already running Python interpreter loop, so we won't
-    // do it.
+  void Cancel() override {}
 
-    if (!debugger.GetInputFile()->GetFile().IsValid())
-        return;
+  bool Interrupt() override { return m_python->Interrupt(); }
 
-    IOHandlerSP io_handler_sp (new IOHandlerPythonInterpreter (debugger, this));
-    if (io_handler_sp)
-    {
-        debugger.PushIOHandler(io_handler_sp);
-    }
-}
+  void GotEOF() override {}
 
-bool
-ScriptInterpreterPython::Interrupt()
-{
-    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SCRIPT));
+protected:
+  ScriptInterpreterPython *m_python;
+};
 
-    if (IsExecutingPython())
-    {
-        PyThreadState *state = PyThreadState_GET();
-        if (!state)
-            state = GetThreadState();
-        if (state)
-        {
-            long tid = state->thread_id;
-            PyThreadState_Swap(state);
-            int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
-            if (log)
-                log->Printf("ScriptInterpreterPython::Interrupt() sending PyExc_KeyboardInterrupt (tid = %li, num_threads = %i)...", tid, num_threads);
-            return true;
-        }
-    }
-    if (log)
-        log->Printf("ScriptInterpreterPython::Interrupt() python code not running, can't interrupt");
-    return false;
+void ScriptInterpreterPython::ExecuteInterpreterLoop() {
+  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
 
-}
-bool
-ScriptInterpreterPython::ExecuteOneLineWithReturn (const char *in_string,
-                                                   ScriptInterpreter::ScriptReturnType return_type,
-                                                   void *ret_value,
-                                                   const ExecuteScriptOptions &options)
-{
-
-    Locker locker(this,
-                  ScriptInterpreterPython::Locker::AcquireLock | ScriptInterpreterPython::Locker::InitSession | (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) | Locker::NoSTDIN,
-                  ScriptInterpreterPython::Locker::FreeAcquiredLock | ScriptInterpreterPython::Locker::TearDownSession);
-
-    PythonObject py_return;
-    PythonObject &main_module = GetMainModule();
-    PythonDictionary globals(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
-    PythonObject py_error;
-    bool ret_success = false;
-    int success;
-    
-    PythonDictionary locals = GetSessionDictionary ();
-    
-    if (!locals.IsValid())
-    {
-        locals.Reset(PyRefType::Owned, PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
-    }
-        
-    if (!locals.IsValid())
-        locals = globals;
-
-    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-    if (py_error.IsValid())
-        PyErr_Clear();
-    
-    if (in_string != nullptr)
-    {
-        { // scope for PythonInputReaderManager
-            //PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
-            py_return.Reset(PyRefType::Owned, PyRun_String(in_string, Py_eval_input, globals.get(), locals.get()));
-            if (!py_return.IsValid())
-            {
-                py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-                if (py_error.IsValid())
-                    PyErr_Clear();
-
-                py_return.Reset(PyRefType::Owned, PyRun_String(in_string, Py_single_input, globals.get(), locals.get()));
-            }
-        }
+  Debugger &debugger = GetCommandInterpreter().GetDebugger();
 
-        if (py_return.IsValid())
-        {
-            switch (return_type)
-            {
-                case eScriptReturnTypeCharPtr: // "char *"
-                {
-                    const char format[3] = "s#";
-                    success = PyArg_Parse (py_return.get(), format, (char **) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return == Py_None
-                {
-                    const char format[3] = "z";
-                    success = PyArg_Parse (py_return.get(), format, (char **) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeBool:
-                {
-                    const char format[2] = "b";
-                    success = PyArg_Parse (py_return.get(), format, (bool *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeShortInt:
-                {
-                    const char format[2] = "h";
-                    success = PyArg_Parse (py_return.get(), format, (short *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeShortIntUnsigned:
-                {
-                    const char format[2] = "H";
-                    success = PyArg_Parse (py_return.get(), format, (unsigned short *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeInt:
-                {
-                    const char format[2] = "i";
-                    success = PyArg_Parse (py_return.get(), format, (int *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeIntUnsigned:
-                {
-                    const char format[2] = "I";
-                    success = PyArg_Parse (py_return.get(), format, (unsigned int *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeLongInt:
-                {
-                    const char format[2] = "l";
-                    success = PyArg_Parse (py_return.get(), format, (long *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeLongIntUnsigned:
-                {
-                    const char format[2] = "k";
-                    success = PyArg_Parse (py_return.get(), format, (unsigned long *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeLongLong:
-                {
-                    const char format[2] = "L";
-                    success = PyArg_Parse (py_return.get(), format, (long long *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeLongLongUnsigned:
-                {
-                    const char format[2] = "K";
-                    success = PyArg_Parse (py_return.get(), format, (unsigned long long *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeFloat:
-                {
-                    const char format[2] = "f";
-                    success = PyArg_Parse (py_return.get(), format, (float *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeDouble:
-                {
-                    const char format[2] = "d";
-                    success = PyArg_Parse (py_return.get(), format, (double *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeChar:
-                {
-                    const char format[2] = "c";
-                    success = PyArg_Parse (py_return.get(), format, (char *) ret_value);
-                    break;
-                }
-                case eScriptReturnTypeOpaqueObject:
-                {
-                    success = true;
-                    PyObject *saved_value = py_return.get();
-                    Py_XINCREF(saved_value);
-                    *((PyObject **)ret_value) = saved_value;
-                    break;
-                }
-            }
+  // At the moment, the only time the debugger does not have an input file
+  // handle is when this is called
+  // directly from Python, in which case it is both dangerous and unnecessary
+  // (not to mention confusing) to
+  // try to embed a running interpreter loop inside the already running Python
+  // interpreter loop, so we won't
+  // do it.
 
-            if (success)
-                ret_success = true;
-            else
-                ret_success = false;
-        }
-    }
+  if (!debugger.GetInputFile()->GetFile().IsValid())
+    return;
 
-    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-    if (py_error.IsValid())
-    {
-        ret_success = false;
-        if (options.GetMaskoutErrors())
+  IOHandlerSP io_handler_sp(new IOHandlerPythonInterpreter(debugger, this));
+  if (io_handler_sp) {
+    debugger.PushIOHandler(io_handler_sp);
+  }
+}
+
+bool ScriptInterpreterPython::Interrupt() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+
+  if (IsExecutingPython()) {
+    PyThreadState *state = PyThreadState_GET();
+    if (!state)
+      state = GetThreadState();
+    if (state) {
+      long tid = state->thread_id;
+      PyThreadState_Swap(state);
+      int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
+      if (log)
+        log->Printf("ScriptInterpreterPython::Interrupt() sending "
+                    "PyExc_KeyboardInterrupt (tid = %li, num_threads = %i)...",
+                    tid, num_threads);
+      return true;
+    }
+  }
+  if (log)
+    log->Printf("ScriptInterpreterPython::Interrupt() python code not running, "
+                "can't interrupt");
+  return false;
+}
+bool ScriptInterpreterPython::ExecuteOneLineWithReturn(
+    const char *in_string, ScriptInterpreter::ScriptReturnType return_type,
+    void *ret_value, const ExecuteScriptOptions &options) {
+
+  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
+                          ScriptInterpreterPython::Locker::InitSession |
+                          (options.GetSetLLDBGlobals()
+                               ? ScriptInterpreterPython::Locker::InitGlobals
+                               : 0) |
+                          Locker::NoSTDIN,
+                ScriptInterpreterPython::Locker::FreeAcquiredLock |
+                    ScriptInterpreterPython::Locker::TearDownSession);
+
+  PythonObject py_return;
+  PythonObject &main_module = GetMainModule();
+  PythonDictionary globals(PyRefType::Borrowed,
+                           PyModule_GetDict(main_module.get()));
+  PythonObject py_error;
+  bool ret_success = false;
+  int success;
+
+  PythonDictionary locals = GetSessionDictionary();
+
+  if (!locals.IsValid()) {
+    locals.Reset(
+        PyRefType::Owned,
+        PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
+  }
+
+  if (!locals.IsValid())
+    locals = globals;
+
+  py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+  if (py_error.IsValid())
+    PyErr_Clear();
+
+  if (in_string != nullptr) {
+    { // scope for PythonInputReaderManager
+      // PythonInputReaderManager py_input(options.GetEnableIO() ? this : NULL);
+      py_return.Reset(
+          PyRefType::Owned,
+          PyRun_String(in_string, Py_eval_input, globals.get(), locals.get()));
+      if (!py_return.IsValid()) {
+        py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+        if (py_error.IsValid())
+          PyErr_Clear();
+
+        py_return.Reset(PyRefType::Owned,
+                        PyRun_String(in_string, Py_single_input, globals.get(),
+                                     locals.get()));
+      }
+    }
+
+    if (py_return.IsValid()) {
+      switch (return_type) {
+      case eScriptReturnTypeCharPtr: // "char *"
+      {
+        const char format[3] = "s#";
+        success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
+        break;
+      }
+      case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return ==
+                                           // Py_None
         {
-            if (PyErr_GivenExceptionMatches (py_error.get(), PyExc_SyntaxError))
-                PyErr_Print ();
-            PyErr_Clear();
+          const char format[3] = "z";
+          success = PyArg_Parse(py_return.get(), format, (char **)ret_value);
+          break;
         }
-    }
-
-    return ret_success;
-}
-
-Error
-ScriptInterpreterPython::ExecuteMultipleLines (const char *in_string, const ExecuteScriptOptions &options)
-{
-    Error error;
-    
-    Locker locker(this,
-                  ScriptInterpreterPython::Locker::AcquireLock      | ScriptInterpreterPython::Locker::InitSession | (options.GetSetLLDBGlobals() ? ScriptInterpreterPython::Locker::InitGlobals : 0) | Locker::NoSTDIN,
-                  ScriptInterpreterPython::Locker::FreeAcquiredLock | ScriptInterpreterPython::Locker::TearDownSession);
-
-    PythonObject return_value;
-    PythonObject &main_module = GetMainModule();
-    PythonDictionary globals(PyRefType::Borrowed, PyModule_GetDict(main_module.get()));
-    PythonObject py_error;
+      case eScriptReturnTypeBool: {
+        const char format[2] = "b";
+        success = PyArg_Parse(py_return.get(), format, (bool *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeShortInt: {
+        const char format[2] = "h";
+        success = PyArg_Parse(py_return.get(), format, (short *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeShortIntUnsigned: {
+        const char format[2] = "H";
+        success =
+            PyArg_Parse(py_return.get(), format, (unsigned short *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeInt: {
+        const char format[2] = "i";
+        success = PyArg_Parse(py_return.get(), format, (int *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeIntUnsigned: {
+        const char format[2] = "I";
+        success =
+            PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeLongInt: {
+        const char format[2] = "l";
+        success = PyArg_Parse(py_return.get(), format, (long *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeLongIntUnsigned: {
+        const char format[2] = "k";
+        success =
+            PyArg_Parse(py_return.get(), format, (unsigned long *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeLongLong: {
+        const char format[2] = "L";
+        success = PyArg_Parse(py_return.get(), format, (long long *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeLongLongUnsigned: {
+        const char format[2] = "K";
+        success = PyArg_Parse(py_return.get(), format,
+                              (unsigned long long *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeFloat: {
+        const char format[2] = "f";
+        success = PyArg_Parse(py_return.get(), format, (float *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeDouble: {
+        const char format[2] = "d";
+        success = PyArg_Parse(py_return.get(), format, (double *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeChar: {
+        const char format[2] = "c";
+        success = PyArg_Parse(py_return.get(), format, (char *)ret_value);
+        break;
+      }
+      case eScriptReturnTypeOpaqueObject: {
+        success = true;
+        PyObject *saved_value = py_return.get();
+        Py_XINCREF(saved_value);
+        *((PyObject **)ret_value) = saved_value;
+        break;
+      }
+      }
 
-    PythonDictionary locals = GetSessionDictionary();
+      if (success)
+        ret_success = true;
+      else
+        ret_success = false;
+    }
+  }
 
-    if (!locals.IsValid())
-        locals.Reset(PyRefType::Owned, PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
+  py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+  if (py_error.IsValid()) {
+    ret_success = false;
+    if (options.GetMaskoutErrors()) {
+      if (PyErr_GivenExceptionMatches(py_error.get(), PyExc_SyntaxError))
+        PyErr_Print();
+      PyErr_Clear();
+    }
+  }
 
-    if (!locals.IsValid())
-        locals = globals;
+  return ret_success;
+}
 
-    py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
-    if (py_error.IsValid())
-        PyErr_Clear();
-    
-    if (in_string != nullptr)
-    {
-        PythonObject code_object;
-        code_object.Reset(PyRefType::Owned, Py_CompileString(in_string, "temp.py", Py_file_input));
+Error ScriptInterpreterPython::ExecuteMultipleLines(
+    const char *in_string, const ExecuteScriptOptions &options) {
+  Error error;
 
-        if (code_object.IsValid())
-        {
-            // In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x, it takes
-            // a PyObject.  They are convertible (hence the function PyCode_Check(PyObject*), so
-            // we have to do the cast for Python 2.x
+  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock |
+                          ScriptInterpreterPython::Locker::InitSession |
+                          (options.GetSetLLDBGlobals()
+                               ? ScriptInterpreterPython::Locker::InitGlobals
+                               : 0) |
+                          Locker::NoSTDIN,
+                ScriptInterpreterPython::Locker::FreeAcquiredLock |
+                    ScriptInterpreterPython::Locker::TearDownSession);
+
+  PythonObject return_value;
+  PythonObject &main_module = GetMainModule();
+  PythonDictionary globals(PyRefType::Borrowed,
+                           PyModule_GetDict(main_module.get()));
+  PythonObject py_error;
+
+  PythonDictionary locals = GetSessionDictionary();
+
+  if (!locals.IsValid())
+    locals.Reset(
+        PyRefType::Owned,
+        PyObject_GetAttrString(globals.get(), m_dictionary_name.c_str()));
+
+  if (!locals.IsValid())
+    locals = globals;
+
+  py_error.Reset(PyRefType::Borrowed, PyErr_Occurred());
+  if (py_error.IsValid())
+    PyErr_Clear();
+
+  if (in_string != nullptr) {
+    PythonObject code_object;
+    code_object.Reset(PyRefType::Owned,
+                      Py_CompileString(in_string, "temp.py", Py_file_input));
+
+    if (code_object.IsValid()) {
+// In Python 2.x, PyEval_EvalCode takes a PyCodeObject, but in Python 3.x, it
+// takes
+// a PyObject.  They are convertible (hence the function
+// PyCode_Check(PyObject*), so
+// we have to do the cast for Python 2.x
 #if PY_MAJOR_VERSION >= 3
-            PyObject *py_code_obj = code_object.get();
+      PyObject *py_code_obj = code_object.get();
 #else
-            PyCodeObject *py_code_obj = reinterpret_cast<PyCodeObject *>(code_object.get());
+      PyCodeObject *py_code_obj =
+          reinterpret_cast<PyCodeObject *>(code_object.get());
 #endif
-            return_value.Reset(PyRefType::Owned, PyEval_EvalCode(py_code_obj, globals.get(), locals.get()));
-        }
+      return_value.Reset(
+          PyRefType::Owned,
+          PyEval_EvalCode(py_code_obj, globals.get(), locals.get()));
     }
+  }
 
-    PythonExceptionState exception_state(!options.GetMaskoutErrors());
-    if (exception_state.IsError())
-        error.SetErrorString(exception_state.Format().c_str());
+  PythonExceptionState exception_state(!options.GetMaskoutErrors());
+  if (exception_state.IsError())
+    error.SetErrorString(exception_state.Format().c_str());
 
-    return error;
+  return error;
 }
 
+void ScriptInterpreterPython::CollectDataForBreakpointCommandCallback(
+    std::vector<BreakpointOptions *> &bp_options_vec,
+    CommandReturnObject &result) {
+  m_active_io_handler = eIOHandlerBreakpoint;
+  m_interpreter.GetPythonCommandsFromIOHandler("    ", *this, true,
+                                               &bp_options_vec);
+}
 
-void
-ScriptInterpreterPython::CollectDataForBreakpointCommandCallback (std::vector<BreakpointOptions *> &bp_options_vec,
-                                                                  CommandReturnObject &result)
-{
-    m_active_io_handler = eIOHandlerBreakpoint;
-    m_interpreter.GetPythonCommandsFromIOHandler ("    ", *this, true, &bp_options_vec);
+void ScriptInterpreterPython::CollectDataForWatchpointCommandCallback(
+    WatchpointOptions *wp_options, CommandReturnObject &result) {
+  m_active_io_handler = eIOHandlerWatchpoint;
+  m_interpreter.GetPythonCommandsFromIOHandler("    ", *this, true, wp_options);
 }
 
-void
-ScriptInterpreterPython::CollectDataForWatchpointCommandCallback (WatchpointOptions *wp_options,
-                                                                  CommandReturnObject &result)
-{
-    m_active_io_handler = eIOHandlerWatchpoint;
-    m_interpreter.GetPythonCommandsFromIOHandler ("    ", *this, true, wp_options);
+void ScriptInterpreterPython::SetBreakpointCommandCallbackFunction(
+    BreakpointOptions *bp_options, const char *function_name) {
+  // For now just cons up a oneliner that calls the provided function.
+  std::string oneliner("return ");
+  oneliner += function_name;
+  oneliner += "(frame, bp_loc, internal_dict)";
+  m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback(
+      bp_options, oneliner.c_str());
 }
 
-void
-ScriptInterpreterPython::SetBreakpointCommandCallbackFunction (BreakpointOptions *bp_options,
-                                                               const char *function_name)
-{
-    // For now just cons up a oneliner that calls the provided function.
-    std::string oneliner("return ");
-    oneliner += function_name;
-    oneliner += "(frame, bp_loc, internal_dict)";
-    m_interpreter.GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
-                                                                        oneliner.c_str());
+Error ScriptInterpreterPython::SetBreakpointCommandCallback(
+    BreakpointOptions *bp_options,
+    std::unique_ptr<BreakpointOptions::CommandData> &cmd_data_up) {
+  Error error;
+  error = GenerateBreakpointCommandCallbackData(cmd_data_up->user_source,
+                                                cmd_data_up->script_source);
+  if (error.Fail()) {
+    return error;
+  }
+  auto baton_sp =
+      std::make_shared<BreakpointOptions::CommandBaton>(std::move(cmd_data_up));
+  bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
+                          baton_sp);
+  return error;
 }
 
 // Set a Python one-liner as the callback for the breakpoint.
-Error
-ScriptInterpreterPython::SetBreakpointCommandCallback (BreakpointOptions *bp_options,
-                                                       const char *command_body_text)
-{
-    std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
-
-    // Split the command_body_text into lines, and pass that to GenerateBreakpointCommandCallbackData.  That will
-    // wrap the body in an auto-generated function, and return the function name in script_source.  That is what
-    // the callback will actually invoke.
-    
-    data_ap->user_source.SplitIntoLines(command_body_text);
-    Error error = GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source);
-    if (error.Success())
-    {
-        BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
-        bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp);
-        return error;
-    }
-    else
-        return error;
+Error ScriptInterpreterPython::SetBreakpointCommandCallback(
+    BreakpointOptions *bp_options, const char *command_body_text) {
+  auto data_ap = llvm::make_unique<CommandDataPython>();
+
+  // Split the command_body_text into lines, and pass that to
+  // GenerateBreakpointCommandCallbackData.  That will
+  // wrap the body in an auto-generated function, and return the function name
+  // in script_source.  That is what
+  // the callback will actually invoke.
+
+  data_ap->user_source.SplitIntoLines(command_body_text);
+  Error error = GenerateBreakpointCommandCallbackData(data_ap->user_source,
+                                                      data_ap->script_source);
+  if (error.Success()) {
+    auto baton_sp =
+        std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_ap));
+    bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
+                            baton_sp);
+    return error;
+  } else
+    return error;
 }
 
 // Set a Python one-liner as the callback for the watchpoint.
-void
-ScriptInterpreterPython::SetWatchpointCommandCallback (WatchpointOptions *wp_options,
-                                                       const char *oneliner)
-{
-    std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
+void ScriptInterpreterPython::SetWatchpointCommandCallback(
+    WatchpointOptions *wp_options, const char *oneliner) {
+  auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>();
+
+  // It's necessary to set both user_source and script_source to the oneliner.
+  // The former is used to generate callback description (as in watchpoint
+  // command list)
+  // while the latter is used for Python to interpret during the actual
+  // callback.
+
+  data_ap->user_source.AppendString(oneliner);
+  data_ap->script_source.assign(oneliner);
+
+  if (GenerateWatchpointCommandCallbackData(data_ap->user_source,
+                                            data_ap->script_source)) {
+    auto baton_sp =
+        std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap));
+    wp_options->SetCallback(ScriptInterpreterPython::WatchpointCallbackFunction,
+                            baton_sp);
+  }
+
+  return;
+}
+
+Error ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter(
+    StringList &function_def) {
+  // Convert StringList to one long, newline delimited, const char *.
+  std::string function_def_string(function_def.CopyList());
+
+  Error error = ExecuteMultipleLines(
+      function_def_string.c_str(),
+      ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false));
+  return error;
+}
+
+Error ScriptInterpreterPython::GenerateFunction(const char *signature,
+                                                const StringList &input) {
+  Error error;
+  int num_lines = input.GetSize();
+  if (num_lines == 0) {
+    error.SetErrorString("No input data.");
+    return error;
+  }
 
-    // It's necessary to set both user_source and script_source to the oneliner.
-    // The former is used to generate callback description (as in watchpoint command list)
-    // while the latter is used for Python to interpret during the actual callback.
+  if (!signature || *signature == 0) {
+    error.SetErrorString("No output function name.");
+    return error;
+  }
+
+  StreamString sstr;
+  StringList auto_generated_function;
+  auto_generated_function.AppendString(signature);
+  auto_generated_function.AppendString(
+      "     global_dict = globals()"); // Grab the global dictionary
+  auto_generated_function.AppendString(
+      "     new_keys = internal_dict.keys()"); // Make a list of keys in the
+                                               // session dict
+  auto_generated_function.AppendString(
+      "     old_keys = global_dict.keys()"); // Save list of keys in global dict
+  auto_generated_function.AppendString(
+      "     global_dict.update (internal_dict)"); // Add the session dictionary
+                                                  // to the
+  // global dictionary.
+
+  // Wrap everything up inside the function, increasing the indentation.
+
+  auto_generated_function.AppendString("     if True:");
+  for (int i = 0; i < num_lines; ++i) {
+    sstr.Clear();
+    sstr.Printf("       %s", input.GetStringAtIndex(i));
+    auto_generated_function.AppendString(sstr.GetData());
+  }
+  auto_generated_function.AppendString(
+      "     for key in new_keys:"); // Iterate over all the keys from session
+                                    // dict
+  auto_generated_function.AppendString(
+      "         internal_dict[key] = global_dict[key]"); // Update session dict
+                                                         // values
+  auto_generated_function.AppendString(
+      "         if key not in old_keys:"); // If key was not originally in
+                                           // global dict
+  auto_generated_function.AppendString(
+      "             del global_dict[key]"); //  ...then remove key/value from
+                                            //  global dict
+
+  // Verify that the results are valid Python.
+
+  error = ExportFunctionDefinitionToInterpreter(auto_generated_function);
+
+  return error;
+}
+
+bool ScriptInterpreterPython::GenerateTypeScriptFunction(
+    StringList &user_input, std::string &output, const void *name_token) {
+  static uint32_t num_created_functions = 0;
+  user_input.RemoveBlankLines();
+  StreamString sstr;
+
+  // Check to see if we have any data; if not, just return.
+  if (user_input.GetSize() == 0)
+    return false;
 
-    data_ap->user_source.AppendString (oneliner);
-    data_ap->script_source.assign (oneliner);
+  // Take what the user wrote, wrap it all up inside one big auto-generated
+  // Python function, passing in the
+  // ValueObject as parameter to the function.
 
-    if (GenerateWatchpointCommandCallbackData (data_ap->user_source, data_ap->script_source))
-    {
-        BatonSP baton_sp (new WatchpointOptions::CommandBaton (data_ap.release()));
-        wp_options->SetCallback (ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp);
-    }
-    
-    return;
-}
+  std::string auto_generated_function_name(
+      GenerateUniqueName("lldb_autogen_python_type_print_func",
+                         num_created_functions, name_token));
+  sstr.Printf("def %s (valobj, internal_dict):",
+              auto_generated_function_name.c_str());
 
-Error
-ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter (StringList &function_def)
-{
-    // Convert StringList to one long, newline delimited, const char *.
-    std::string function_def_string(function_def.CopyList());
+  if (!GenerateFunction(sstr.GetData(), user_input).Success())
+    return false;
 
-    Error error = ExecuteMultipleLines (function_def_string.c_str(), ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false));
-    return error;
+  // Store the name of the auto-generated function to be called.
+  output.assign(auto_generated_function_name);
+  return true;
 }
 
-Error
-ScriptInterpreterPython::GenerateFunction(const char *signature, const StringList &input)
-{
-    Error error;
-    int num_lines = input.GetSize ();
-    if (num_lines == 0)
-    {
-        error.SetErrorString ("No input data.");
-        return error;
-    }
-    
-    if (!signature || *signature == 0)
-    {
-        error.SetErrorString("No output function name.");
-        return error;
-    }
+bool ScriptInterpreterPython::GenerateScriptAliasFunction(
+    StringList &user_input, std::string &output) {
+  static uint32_t num_created_functions = 0;
+  user_input.RemoveBlankLines();
+  StreamString sstr;
 
-    StreamString sstr;
-    StringList auto_generated_function;
-    auto_generated_function.AppendString (signature);
-    auto_generated_function.AppendString ("     global_dict = globals()");   // Grab the global dictionary
-    auto_generated_function.AppendString ("     new_keys = internal_dict.keys()");    // Make a list of keys in the session dict
-    auto_generated_function.AppendString ("     old_keys = global_dict.keys()"); // Save list of keys in global dict
-    auto_generated_function.AppendString ("     global_dict.update (internal_dict)"); // Add the session dictionary to the 
-    // global dictionary.
-    
-    // Wrap everything up inside the function, increasing the indentation.
-    
-    auto_generated_function.AppendString("     if True:");
-    for (int i = 0; i < num_lines; ++i)
-    {
-        sstr.Clear ();
-        sstr.Printf ("       %s", input.GetStringAtIndex (i));
-        auto_generated_function.AppendString (sstr.GetData());
-    }
-    auto_generated_function.AppendString ("     for key in new_keys:");  // Iterate over all the keys from session dict
-    auto_generated_function.AppendString ("         internal_dict[key] = global_dict[key]");  // Update session dict values
-    auto_generated_function.AppendString ("         if key not in old_keys:");       // If key was not originally in global dict
-    auto_generated_function.AppendString ("             del global_dict[key]");      //  ...then remove key/value from global dict
-    
-    // Verify that the results are valid Python.
-    
-    error = ExportFunctionDefinitionToInterpreter (auto_generated_function);
-    
-    return error;
-}
+  // Check to see if we have any data; if not, just return.
+  if (user_input.GetSize() == 0)
+    return false;
 
-bool
-ScriptInterpreterPython::GenerateTypeScriptFunction (StringList &user_input, std::string& output, const void* name_token)
-{
-    static uint32_t num_created_functions = 0;
-    user_input.RemoveBlankLines ();
-    StreamString sstr;
-    
-    // Check to see if we have any data; if not, just return.
-    if (user_input.GetSize() == 0)
-        return false;
-    
-    // Take what the user wrote, wrap it all up inside one big auto-generated Python function, passing in the
-    // ValueObject as parameter to the function.
-    
-    std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_type_print_func", num_created_functions, name_token));
-    sstr.Printf ("def %s (valobj, internal_dict):", auto_generated_function_name.c_str());
-    
-    if (!GenerateFunction(sstr.GetData(), user_input).Success())
-        return false;
+  std::string auto_generated_function_name(GenerateUniqueName(
+      "lldb_autogen_python_cmd_alias_func", num_created_functions));
 
-    // Store the name of the auto-generated function to be called.
-    output.assign(auto_generated_function_name);
-    return true;
-}
+  sstr.Printf("def %s (debugger, args, result, internal_dict):",
+              auto_generated_function_name.c_str());
 
-bool
-ScriptInterpreterPython::GenerateScriptAliasFunction (StringList &user_input, std::string &output)
-{
-    static uint32_t num_created_functions = 0;
-    user_input.RemoveBlankLines ();
-    StreamString sstr;
-    
-    // Check to see if we have any data; if not, just return.
-    if (user_input.GetSize() == 0)
-        return false;
-    
-    std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_cmd_alias_func", num_created_functions));
+  if (!GenerateFunction(sstr.GetData(), user_input).Success())
+    return false;
 
-    sstr.Printf ("def %s (debugger, args, result, internal_dict):", auto_generated_function_name.c_str());
-    
-    if (!GenerateFunction(sstr.GetData(),user_input).Success())
-        return false;
-    
-    // Store the name of the auto-generated function to be called.
-    output.assign(auto_generated_function_name);
-    return true;
+  // Store the name of the auto-generated function to be called.
+  output.assign(auto_generated_function_name);
+  return true;
 }
 
+bool ScriptInterpreterPython::GenerateTypeSynthClass(StringList &user_input,
+                                                     std::string &output,
+                                                     const void *name_token) {
+  static uint32_t num_created_classes = 0;
+  user_input.RemoveBlankLines();
+  int num_lines = user_input.GetSize();
+  StreamString sstr;
 
-bool
-ScriptInterpreterPython::GenerateTypeSynthClass (StringList &user_input, std::string &output, const void* name_token)
-{
-    static uint32_t num_created_classes = 0;
-    user_input.RemoveBlankLines ();
-    int num_lines = user_input.GetSize ();
-    StreamString sstr;
-    
-    // Check to see if we have any data; if not, just return.
-    if (user_input.GetSize() == 0)
-        return false;
-    
-    // Wrap all user input into a Python class
-    
-    std::string auto_generated_class_name(GenerateUniqueName("lldb_autogen_python_type_synth_class",num_created_classes,name_token));
-    
-    StringList auto_generated_class;
-    
-    // Create the function name & definition string.
-    
-    sstr.Printf ("class %s:", auto_generated_class_name.c_str());
-    auto_generated_class.AppendString (sstr.GetData());
-        
-    // Wrap everything up inside the class, increasing the indentation.
-    // we don't need to play any fancy indentation tricks here because there is no
-    // surrounding code whose indentation we need to honor
-    for (int i = 0; i < num_lines; ++i)
-    {
-        sstr.Clear ();
-        sstr.Printf ("     %s", user_input.GetStringAtIndex (i));
-        auto_generated_class.AppendString (sstr.GetData());
-    }
-    
-    
-    // Verify that the results are valid Python.
-    // (even though the method is ExportFunctionDefinitionToInterpreter, a class will actually be exported)
-    // (TODO: rename that method to ExportDefinitionToInterpreter)
-    if (!ExportFunctionDefinitionToInterpreter (auto_generated_class).Success())
-        return false;
-    
-    // Store the name of the auto-generated class
-    
-    output.assign(auto_generated_class_name);
-    return true;
-}
+  // Check to see if we have any data; if not, just return.
+  if (user_input.GetSize() == 0)
+    return false;
 
-StructuredData::GenericSP
-ScriptInterpreterPython::OSPlugin_CreatePluginObject(const char *class_name, lldb::ProcessSP process_sp)
-{
-    if (class_name == nullptr || class_name[0] == '\0')
-        return StructuredData::GenericSP();
+  // Wrap all user input into a Python class
 
-    if (!process_sp)
-        return StructuredData::GenericSP();
+  std::string auto_generated_class_name(GenerateUniqueName(
+      "lldb_autogen_python_type_synth_class", num_created_classes, name_token));
 
-    void* ret_val;
-    
-    {
-        Locker py_lock  (this,
-                         Locker::AcquireLock | Locker::NoSTDIN,
-                         Locker::FreeLock);
-        ret_val = g_swig_create_os_plugin    (class_name,
-                                              m_dictionary_name.c_str(),
-                                              process_sp);
-    }
+  StringList auto_generated_class;
+
+  // Create the function name & definition string.
 
-    return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+  sstr.Printf("class %s:", auto_generated_class_name.c_str());
+  auto_generated_class.AppendString(sstr.GetString());
+
+  // Wrap everything up inside the class, increasing the indentation.
+  // we don't need to play any fancy indentation tricks here because there is no
+  // surrounding code whose indentation we need to honor
+  for (int i = 0; i < num_lines; ++i) {
+    sstr.Clear();
+    sstr.Printf("     %s", user_input.GetStringAtIndex(i));
+    auto_generated_class.AppendString(sstr.GetString());
+  }
+
+  // Verify that the results are valid Python.
+  // (even though the method is ExportFunctionDefinitionToInterpreter, a class
+  // will actually be exported)
+  // (TODO: rename that method to ExportDefinitionToInterpreter)
+  if (!ExportFunctionDefinitionToInterpreter(auto_generated_class).Success())
+    return false;
+
+  // Store the name of the auto-generated class
+
+  output.assign(auto_generated_class_name);
+  return true;
 }
 
-StructuredData::DictionarySP
-ScriptInterpreterPython::OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp)
-{
-    Locker py_lock(this,
-                   Locker::AcquireLock | Locker::NoSTDIN,
+StructuredData::GenericSP ScriptInterpreterPython::OSPlugin_CreatePluginObject(
+    const char *class_name, lldb::ProcessSP process_sp) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::GenericSP();
+
+  if (!process_sp)
+    return StructuredData::GenericSP();
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
                    Locker::FreeLock);
-    
-    static char callee_name[] = "get_register_info";
-    
-    if (!os_plugin_object_sp)
-        return StructuredData::DictionarySP();
+    ret_val = g_swig_create_os_plugin(class_name, m_dictionary_name.c_str(),
+                                      process_sp);
+  }
 
-    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
-    if (!generic)
-        return nullptr;
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+}
 
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
+StructuredData::DictionarySP ScriptInterpreterPython::OSPlugin_RegisterInfo(
+    StructuredData::ObjectSP os_plugin_object_sp) {
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
-    if (!implementor.IsAllocated())
-        return StructuredData::DictionarySP();
+  static char callee_name[] = "get_register_info";
 
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+  if (!os_plugin_object_sp)
+    return StructuredData::DictionarySP();
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
 
-    if (!pmeth.IsAllocated())
-        return StructuredData::DictionarySP();
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        
-        return StructuredData::DictionarySP();
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
 
-    // if it fails, print the error but otherwise go on
+  if (!implementor.IsAllocated())
+    return StructuredData::DictionarySP();
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
+    return StructuredData::DictionarySP();
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
     if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
-    if (py_return.get())
-    {
-        PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
-        return result_dict.CreateStructuredDictionary();
-    }
+      PyErr_Clear();
+
     return StructuredData::DictionarySP();
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+  if (py_return.get()) {
+    PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
+    return result_dict.CreateStructuredDictionary();
+  }
+  return StructuredData::DictionarySP();
 }
 
-StructuredData::ArraySP
-ScriptInterpreterPython::OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin_object_sp)
-{
-    Locker py_lock (this,
-                    Locker::AcquireLock | Locker::NoSTDIN,
-                    Locker::FreeLock);
+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";
+  static char callee_name[] = "get_thread_info";
 
-    if (!os_plugin_object_sp)
-        return StructuredData::ArraySP();
+  if (!os_plugin_object_sp)
+    return StructuredData::ArraySP();
 
-    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
-    if (!generic)
-        return nullptr;
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
 
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
 
-    if (!implementor.IsAllocated())
-        return StructuredData::ArraySP();
+  if (!implementor.IsAllocated())
+    return StructuredData::ArraySP();
 
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+  if (PyErr_Occurred())
+    PyErr_Clear();
 
-    if (!pmeth.IsAllocated())
-        return StructuredData::ArraySP();
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        
-        return StructuredData::ArraySP();
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+  if (!pmeth.IsAllocated())
+    return StructuredData::ArraySP();
 
-    // if it fails, print the error but otherwise go on
+  if (PyCallable_Check(pmeth.get()) == 0) {
     if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
+      PyErr_Clear();
 
-    if (py_return.get())
-    {
-        PythonList result_list(PyRefType::Borrowed, py_return.get());
-        return result_list.CreateStructuredArray();
-    }
     return StructuredData::ArraySP();
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.get()) {
+    PythonList result_list(PyRefType::Borrowed, py_return.get());
+    return result_list.CreateStructuredArray();
+  }
+  return StructuredData::ArraySP();
 }
 
 // GetPythonValueFormatString provides a system independent type safe way to
@@ -1623,1620 +1599,1593 @@ ScriptInterpreterPython::OSPlugin_ThreadsInfo(StructuredData::ObjectSP os_plugin
 // as the underlying typedef for uint* types, size_t, off_t and other values
 // change.
 
-template <typename T>
-const char *GetPythonValueFormatString(T t)
-{
-    assert(!"Unhandled type passed to GetPythonValueFormatString(T), make a specialization of GetPythonValueFormatString() to support this type.");
-    return nullptr;
+template <typename T> const char *GetPythonValueFormatString(T t);
+template <> const char *GetPythonValueFormatString(char *) { return "s"; }
+template <> const char *GetPythonValueFormatString(char) { return "b"; }
+template <> const char *GetPythonValueFormatString(unsigned char) {
+  return "B";
 }
-template <> const char *GetPythonValueFormatString (char *)             { return "s"; }
-template <> const char *GetPythonValueFormatString (char)               { return "b"; }
-template <> const char *GetPythonValueFormatString (unsigned char)      { return "B"; }
-template <> const char *GetPythonValueFormatString (short)              { return "h"; }
-template <> const char *GetPythonValueFormatString (unsigned short)     { return "H"; }
-template <> const char *GetPythonValueFormatString (int)                { return "i"; }
-template <> const char *GetPythonValueFormatString (unsigned int)       { return "I"; }
-template <> const char *GetPythonValueFormatString (long)               { return "l"; }
-template <> const char *GetPythonValueFormatString (unsigned long)      { return "k"; }
-template <> const char *GetPythonValueFormatString (long long)          { return "L"; }
-template <> const char *GetPythonValueFormatString (unsigned long long) { return "K"; }
-template <> const char *GetPythonValueFormatString (float t)            { return "f"; }
-template <> const char *GetPythonValueFormatString (double t)           { return "d"; }
-
-StructuredData::StringSP
-ScriptInterpreterPython::OSPlugin_RegisterContextData(StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid)
-{
-    Locker py_lock (this,
-                    Locker::AcquireLock | Locker::NoSTDIN,
-                    Locker::FreeLock);
-
-    static char callee_name[] = "get_register_data";
-    static char *param_format = const_cast<char *>(GetPythonValueFormatString(tid));
-    
-    if (!os_plugin_object_sp)
-        return StructuredData::StringSP();
-
-    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
-    if (!generic)
-        return nullptr;
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
-
-    if (!implementor.IsAllocated())
-        return StructuredData::StringSP();
-
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+template <> const char *GetPythonValueFormatString(short) { return "h"; }
+template <> const char *GetPythonValueFormatString(unsigned short) {
+  return "H";
+}
+template <> const char *GetPythonValueFormatString(int) { return "i"; }
+template <> const char *GetPythonValueFormatString(unsigned int) { return "I"; }
+template <> const char *GetPythonValueFormatString(long) { return "l"; }
+template <> const char *GetPythonValueFormatString(unsigned long) {
+  return "k";
+}
+template <> const char *GetPythonValueFormatString(long long) { return "L"; }
+template <> const char *GetPythonValueFormatString(unsigned long long) {
+  return "K";
+}
+template <> const char *GetPythonValueFormatString(float t) { return "f"; }
+template <> const char *GetPythonValueFormatString(double t) { return "d"; }
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+StructuredData::StringSP ScriptInterpreterPython::OSPlugin_RegisterContextData(
+    StructuredData::ObjectSP os_plugin_object_sp, lldb::tid_t tid) {
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
-    if (!pmeth.IsAllocated())
-        return StructuredData::StringSP();
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        return StructuredData::StringSP();
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, param_format, tid));
+  static char callee_name[] = "get_register_data";
+  static char *param_format =
+      const_cast<char *>(GetPythonValueFormatString(tid));
 
-    // if it fails, print the error but otherwise go on
-    if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
+  if (!os_plugin_object_sp)
+    return StructuredData::StringSP();
 
-    if (py_return.get())
-    {
-        PythonBytes result(PyRefType::Borrowed, py_return.get());
-        return result.CreateStructuredString();
-    }
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  if (!implementor.IsAllocated())
+    return StructuredData::StringSP();
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
     return StructuredData::StringSP();
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
+    if (PyErr_Occurred())
+      PyErr_Clear();
+    return StructuredData::StringSP();
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, param_format, tid));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.get()) {
+    PythonBytes result(PyRefType::Borrowed, py_return.get());
+    return result.CreateStructuredString();
+  }
+  return StructuredData::StringSP();
 }
 
-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,
-                   Locker::FreeLock);
-    
-    static char callee_name[] = "create_thread";
-    std::string param_format;
-    param_format += GetPythonValueFormatString(tid);
-    param_format += GetPythonValueFormatString(context);
-    
-    if (!os_plugin_object_sp)
-        return StructuredData::DictionarySP();
+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, Locker::FreeLock);
 
-    StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
-    if (!generic)
-        return nullptr;
+  static char callee_name[] = "create_thread";
+  std::string param_format;
+  param_format += GetPythonValueFormatString(tid);
+  param_format += GetPythonValueFormatString(context);
 
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
+  if (!os_plugin_object_sp)
+    return StructuredData::DictionarySP();
 
-    if (!implementor.IsAllocated())
-        return StructuredData::DictionarySP();
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
 
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+  if (!implementor.IsAllocated())
+    return StructuredData::DictionarySP();
 
-    if (!pmeth.IsAllocated())
-        return StructuredData::DictionarySP();
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        return StructuredData::DictionarySP();
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, &param_format[0], tid, context));
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
 
-    // if it fails, print the error but otherwise go on
-    if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
+  if (PyErr_Occurred())
+    PyErr_Clear();
 
-    if (py_return.get())
-    {
-        PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
-        return result_dict.CreateStructuredDictionary();
-    }
+  if (!pmeth.IsAllocated())
+    return StructuredData::DictionarySP();
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
+    if (PyErr_Occurred())
+      PyErr_Clear();
     return StructuredData::DictionarySP();
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(PyRefType::Owned,
+                         PyObject_CallMethod(implementor.get(), callee_name,
+                                             &param_format[0], tid, context));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.get()) {
+    PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
+    return result_dict.CreateStructuredDictionary();
+  }
+  return StructuredData::DictionarySP();
 }
 
-StructuredData::ObjectSP
-ScriptInterpreterPython::CreateScriptedThreadPlan(const char *class_name, lldb::ThreadPlanSP thread_plan_sp)
-{
-    if (class_name == nullptr || class_name[0] == '\0')
-        return StructuredData::ObjectSP();
+StructuredData::ObjectSP ScriptInterpreterPython::CreateScriptedThreadPlan(
+    const char *class_name, lldb::ThreadPlanSP thread_plan_sp) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::ObjectSP();
 
-    if (!thread_plan_sp.get())
-        return StructuredData::ObjectSP();
+  if (!thread_plan_sp.get())
+    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 StructuredData::ObjectSP();
+  Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
+  ScriptInterpreter *script_interpreter =
+      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreterPython *python_interpreter =
+      static_cast<ScriptInterpreterPython *>(script_interpreter);
 
-    void* ret_val;
+  if (!script_interpreter)
+    return StructuredData::ObjectSP();
 
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        
-        ret_val = g_swig_thread_plan_script (class_name,
-                                             python_interpreter->m_dictionary_name.c_str(),
-                                             thread_plan_sp);
-    }
+  void *ret_val;
 
-    return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
-}
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
 
-bool
-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(generic->GetValue(), "explains_stop", event, script_error);
-        if (script_error)
-            return true;
-    }
-    return explains_stop;
-}
+    ret_val = g_swig_thread_plan_script(
+        class_name, python_interpreter->m_dictionary_name.c_str(),
+        thread_plan_sp);
+  }
 
-bool
-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(generic->GetValue(), "should_stop", event, script_error);
-        if (script_error)
-            return true;
-    }
-    return should_stop;
+  return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
-lldb::StateType
-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(generic->GetValue(), "should_step", NULL, script_error);
-        if (script_error)
-            should_step = true;
-    }
-    if (should_step)
-        return lldb::eStateStepping;
-    else
-        return lldb::eStateRunning;
+bool 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(
+        generic->GetValue(), "explains_stop", event, script_error);
+    if (script_error)
+      return true;
+  }
+  return explains_stop;
+}
+
+bool 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(generic->GetValue(), "should_stop",
+                                          event, script_error);
+    if (script_error)
+      return true;
+  }
+  return should_stop;
+}
+
+bool ScriptInterpreterPython::ScriptedThreadPlanIsStale(
+    StructuredData::ObjectSP implementor_sp, bool &script_error) {
+  bool is_stale = true;
+  StructuredData::Generic *generic = nullptr;
+  if (implementor_sp)
+    generic = implementor_sp->GetAsGeneric();
+  if (generic) {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    is_stale = g_swig_call_thread_plan(generic->GetValue(), "is_stale", nullptr,
+                                       script_error);
+    if (script_error)
+      return true;
+  }
+  return is_stale;
+}
+
+lldb::StateType 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(generic->GetValue(), "should_step",
+                                          NULL, script_error);
+    if (script_error)
+      should_step = true;
+  }
+  if (should_step)
+    return lldb::eStateStepping;
+  else
+    return lldb::eStateRunning;
 }
 
 StructuredData::ObjectSP
-ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec, lldb_private::Error &error)
-{
-    if (!file_spec.Exists())
-    {
-        error.SetErrorString("no such file");
-        return StructuredData::ObjectSP();
-    }
+ScriptInterpreterPython::LoadPluginModule(const FileSpec &file_spec,
+                                          lldb_private::Error &error) {
+  if (!file_spec.Exists()) {
+    error.SetErrorString("no such file");
+    return StructuredData::ObjectSP();
+  }
 
-    StructuredData::ObjectSP module_sp;
+  StructuredData::ObjectSP module_sp;
 
-    if (LoadScriptingModule(file_spec.GetPath().c_str(),true,true,error,&module_sp))
-        return module_sp;
+  if (LoadScriptingModule(file_spec.GetPath().c_str(), true, true, error,
+                          &module_sp))
+    return module_sp;
 
-    return StructuredData::ObjectSP();
+  return StructuredData::ObjectSP();
 }
 
-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] || !g_swig_plugin_get)
-        return StructuredData::DictionarySP();
-    StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
-    if (!generic)
-        return StructuredData::DictionarySP();
+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] ||
+      !g_swig_plugin_get)
+    return StructuredData::DictionarySP();
+  StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
+  if (!generic)
+    return StructuredData::DictionarySP();
 
-    PythonObject reply_pyobj;
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        TargetSP target_sp(target->shared_from_this());
-        reply_pyobj.Reset(PyRefType::Owned,
-                          (PyObject *)g_swig_plugin_get(generic->GetValue(), setting_name, target_sp));
-    }
+  PythonObject reply_pyobj;
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    TargetSP target_sp(target->shared_from_this());
+    reply_pyobj.Reset(PyRefType::Owned,
+                      (PyObject *)g_swig_plugin_get(generic->GetValue(),
+                                                    setting_name, target_sp));
+  }
 
-    PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj.get());
-    return py_dict.CreateStructuredDictionary();
+  PythonDictionary py_dict(PyRefType::Borrowed, reply_pyobj.get());
+  return py_dict.CreateStructuredDictionary();
 }
 
 StructuredData::ObjectSP
-ScriptInterpreterPython::CreateSyntheticScriptedProvider(const char *class_name, lldb::ValueObjectSP valobj)
-{
-    if (class_name == nullptr || class_name[0] == '\0')
-        return StructuredData::ObjectSP();
+ScriptInterpreterPython::CreateSyntheticScriptedProvider(
+    const char *class_name, lldb::ValueObjectSP valobj) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::ObjectSP();
 
-    if (!valobj.get())
-        return StructuredData::ObjectSP();
+  if (!valobj.get())
+    return StructuredData::ObjectSP();
 
-    ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
-    Target *target = exe_ctx.GetTargetPtr();
-    
-    if (!target)
-        return StructuredData::ObjectSP();
+  ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
+  Target *target = exe_ctx.GetTargetPtr();
 
-    Debugger &debugger = target->GetDebugger();
-    ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
-    ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
-    
-    if (!script_interpreter)
-        return StructuredData::ObjectSP();
+  if (!target)
+    return StructuredData::ObjectSP();
 
-    void *ret_val = nullptr;
+  Debugger &debugger = target->GetDebugger();
+  ScriptInterpreter *script_interpreter =
+      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreterPython *python_interpreter =
+      (ScriptInterpreterPython *)script_interpreter;
 
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_synthetic_script (class_name,
-                                           python_interpreter->m_dictionary_name.c_str(),
-                                           valobj);
-    }
+  if (!script_interpreter)
+    return StructuredData::ObjectSP();
+
+  void *ret_val = nullptr;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_synthetic_script(
+        class_name, python_interpreter->m_dictionary_name.c_str(), valobj);
+  }
 
-    return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
+  return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
 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 StructuredData::GenericSP();
-    
-    if (!debugger_sp.get())
-        return StructuredData::GenericSP();
-    
-    void* ret_val;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_create_cmd (class_name,
-                                     m_dictionary_name.c_str(),
-                                     debugger_sp);
-    }
-    
-    return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+ScriptInterpreterPython::CreateScriptCommandObject(const char *class_name) {
+  DebuggerSP debugger_sp(
+      GetCommandInterpreter().GetDebugger().shared_from_this());
+
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::GenericSP();
+
+  if (!debugger_sp.get())
+    return StructuredData::GenericSP();
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val =
+        g_swig_create_cmd(class_name, m_dictionary_name.c_str(), debugger_sp);
+  }
+
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
-bool
-ScriptInterpreterPython::GenerateTypeScriptFunction (const char* oneliner, std::string& output, const void* name_token)
-{
-    StringList input;
-    input.SplitIntoLines(oneliner, strlen(oneliner));
-    return GenerateTypeScriptFunction(input, output, name_token);
+bool ScriptInterpreterPython::GenerateTypeScriptFunction(
+    const char *oneliner, std::string &output, const void *name_token) {
+  StringList input;
+  input.SplitIntoLines(oneliner, strlen(oneliner));
+  return GenerateTypeScriptFunction(input, output, name_token);
 }
 
-bool
-ScriptInterpreterPython::GenerateTypeSynthClass (const char* oneliner, std::string& output, const void* name_token)
-{
-    StringList input;
-    input.SplitIntoLines(oneliner, strlen(oneliner));
-    return GenerateTypeSynthClass(input, output, name_token);
+bool ScriptInterpreterPython::GenerateTypeSynthClass(const char *oneliner,
+                                                     std::string &output,
+                                                     const void *name_token) {
+  StringList input;
+  input.SplitIntoLines(oneliner, strlen(oneliner));
+  return GenerateTypeSynthClass(input, output, name_token);
 }
 
+Error ScriptInterpreterPython::GenerateBreakpointCommandCallbackData(
+    StringList &user_input, std::string &output) {
+  static uint32_t num_created_functions = 0;
+  user_input.RemoveBlankLines();
+  StreamString sstr;
+  Error error;
+  if (user_input.GetSize() == 0) {
+    error.SetErrorString("No input data.");
+    return error;
+  }
 
-Error
-ScriptInterpreterPython::GenerateBreakpointCommandCallbackData (StringList &user_input, std::string& output)
-{
-    static uint32_t num_created_functions = 0;
-    user_input.RemoveBlankLines ();
-    StreamString sstr;
-    Error error;
-    if (user_input.GetSize() == 0)
-    {
-        error.SetErrorString("No input data.");
-        return error;
-    }
+  std::string auto_generated_function_name(GenerateUniqueName(
+      "lldb_autogen_python_bp_callback_func_", num_created_functions));
+  sstr.Printf("def %s (frame, bp_loc, internal_dict):",
+              auto_generated_function_name.c_str());
 
-    std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_bp_callback_func_",num_created_functions));
-    sstr.Printf ("def %s (frame, bp_loc, internal_dict):", auto_generated_function_name.c_str());
-    
-    error = GenerateFunction(sstr.GetData(), user_input);
-    if (!error.Success())
-        return error;
-    
-    // Store the name of the auto-generated function to be called.
-    output.assign(auto_generated_function_name);
+  error = GenerateFunction(sstr.GetData(), user_input);
+  if (!error.Success())
     return error;
+
+  // Store the name of the auto-generated function to be called.
+  output.assign(auto_generated_function_name);
+  return error;
 }
 
-bool
-ScriptInterpreterPython::GenerateWatchpointCommandCallbackData (StringList &user_input, std::string& output)
-{
-    static uint32_t num_created_functions = 0;
-    user_input.RemoveBlankLines ();
-    StreamString sstr;
+bool ScriptInterpreterPython::GenerateWatchpointCommandCallbackData(
+    StringList &user_input, std::string &output) {
+  static uint32_t num_created_functions = 0;
+  user_input.RemoveBlankLines();
+  StreamString sstr;
 
-    if (user_input.GetSize() == 0)
-        return false;
+  if (user_input.GetSize() == 0)
+    return false;
 
-    std::string auto_generated_function_name(GenerateUniqueName("lldb_autogen_python_wp_callback_func_",num_created_functions));
-    sstr.Printf ("def %s (frame, wp, internal_dict):", auto_generated_function_name.c_str());
-    
-    if (!GenerateFunction(sstr.GetData(), user_input).Success())
-        return false;
-    
-    // Store the name of the auto-generated function to be called.
-    output.assign(auto_generated_function_name);
-    return true;
+  std::string auto_generated_function_name(GenerateUniqueName(
+      "lldb_autogen_python_wp_callback_func_", num_created_functions));
+  sstr.Printf("def %s (frame, wp, internal_dict):",
+              auto_generated_function_name.c_str());
+
+  if (!GenerateFunction(sstr.GetData(), user_input).Success())
+    return false;
+
+  // Store the name of the auto-generated function to be called.
+  output.assign(auto_generated_function_name);
+  return true;
 }
 
-bool
-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__);
-    
-    if (!valobj.get())
-    {
-        retval.assign("<no object>");
-        return false;
-    }
+bool ScriptInterpreterPython::GetScriptedSummary(
+    const char *python_function_name, lldb::ValueObjectSP valobj,
+    StructuredData::ObjectSP &callee_wrapper_sp,
+    const TypeSummaryOptions &options, std::string &retval) {
 
-    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)
-    {
-        {
-            Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-            {
-                TypeSummaryOptionsSP options_sp(new TypeSummaryOptions(options));
-                
-                Timer scoped_timer ("g_swig_typescript_callback","g_swig_typescript_callback");
-                ret_val = g_swig_typescript_callback (python_function_name,
-                                                      GetSessionDictionary().get(),
-                                                      valobj,
-                                                      &new_callee,
-                                                      options_sp,
-                                                      retval);
-            }
-        }
-    }
-    else
-    {
-        retval.assign("<no function name>");
-        return false;
-    }
-    
-    if (new_callee && old_callee != new_callee)
-        callee_wrapper_sp.reset(new StructuredPythonObject(new_callee));
+  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
 
-    return ret_val;
+  if (!valobj.get()) {
+    retval.assign("<no object>");
+    return false;
+  }
+
+  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) {
+    {
+      Locker py_lock(this, Locker::AcquireLock | Locker::InitSession |
+                               Locker::NoSTDIN);
+      {
+        TypeSummaryOptionsSP options_sp(new TypeSummaryOptions(options));
+
+        Timer scoped_timer("g_swig_typescript_callback",
+                           "g_swig_typescript_callback");
+        ret_val = g_swig_typescript_callback(
+            python_function_name, GetSessionDictionary().get(), valobj,
+            &new_callee, options_sp, retval);
+      }
+    }
+  } else {
+    retval.assign("<no function name>");
+    return false;
+  }
+
+  if (new_callee && old_callee != new_callee)
+    callee_wrapper_sp.reset(new StructuredPythonObject(new_callee));
+
+  return ret_val;
 }
 
-void
-ScriptInterpreterPython::Clear ()
-{
-    // Release any global variables that might have strong references to
-    // LLDB objects when clearing the python script interpreter.
-    Locker locker(this,
-                  ScriptInterpreterPython::Locker::AcquireLock,
-                  ScriptInterpreterPython::Locker::FreeAcquiredLock);
-
-    // This may be called as part of Py_Finalize.  In that case the modules are destroyed in random
-    // order and we can't guarantee that we can access these.
-    if (Py_IsInitialized())
-        PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process = None; lldb.thread = None; lldb.frame = None");
-}
-
-bool
-ScriptInterpreterPython::BreakpointCallbackFunction 
-(
-    void *baton,
-    StoppointCallbackContext *context,
-    user_id_t break_id,
-    user_id_t break_loc_id
-)
-{
-    BreakpointOptions::CommandData *bp_option_data = (BreakpointOptions::CommandData *) baton;
-    const char *python_function_name = bp_option_data->script_source.c_str();
-
-    if (!context)
-        return true;
-        
-    ExecutionContext exe_ctx (context->exe_ctx_ref);
-    Target *target = exe_ctx.GetTargetPtr();
-    
-    if (!target)
-        return true;
-        
-    Debugger &debugger = target->GetDebugger();
-    ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
-    ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
-    
-    if (!script_interpreter)
-        return true;
-    
-    if (python_function_name && python_function_name[0])
-    {
-        const StackFrameSP stop_frame_sp (exe_ctx.GetFrameSP());
-        BreakpointSP breakpoint_sp = target->GetBreakpointByID (break_id);
-        if (breakpoint_sp)
+void ScriptInterpreterPython::Clear() {
+  // Release any global variables that might have strong references to
+  // LLDB objects when clearing the python script interpreter.
+  Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
+                ScriptInterpreterPython::Locker::FreeAcquiredLock);
+
+  // This may be called as part of Py_Finalize.  In that case the modules are
+  // destroyed in random
+  // order and we can't guarantee that we can access these.
+  if (Py_IsInitialized())
+    PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process "
+                       "= None; lldb.thread = None; lldb.frame = None");
+}
+
+bool ScriptInterpreterPython::BreakpointCallbackFunction(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  CommandDataPython *bp_option_data = (CommandDataPython *)baton;
+  const char *python_function_name = bp_option_data->script_source.c_str();
+
+  if (!context)
+    return true;
+
+  ExecutionContext exe_ctx(context->exe_ctx_ref);
+  Target *target = exe_ctx.GetTargetPtr();
+
+  if (!target)
+    return true;
+
+  Debugger &debugger = target->GetDebugger();
+  ScriptInterpreter *script_interpreter =
+      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreterPython *python_interpreter =
+      (ScriptInterpreterPython *)script_interpreter;
+
+  if (!script_interpreter)
+    return true;
+
+  if (python_function_name && python_function_name[0]) {
+    const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
+    BreakpointSP breakpoint_sp = target->GetBreakpointByID(break_id);
+    if (breakpoint_sp) {
+      const BreakpointLocationSP bp_loc_sp(
+          breakpoint_sp->FindLocationByID(break_loc_id));
+
+      if (stop_frame_sp && bp_loc_sp) {
+        bool ret_val = true;
         {
-            const BreakpointLocationSP bp_loc_sp (breakpoint_sp->FindLocationByID (break_loc_id));
-
-            if (stop_frame_sp && bp_loc_sp)
-            {
-                bool ret_val = true;
-                {
-                    Locker py_lock(python_interpreter, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-                    ret_val = g_swig_breakpoint_callback (python_function_name,
-                                                          python_interpreter->m_dictionary_name.c_str(),
-                                                          stop_frame_sp, 
-                                                          bp_loc_sp);
-                }
-                return ret_val;
-            }
+          Locker py_lock(python_interpreter, Locker::AcquireLock |
+                                                 Locker::InitSession |
+                                                 Locker::NoSTDIN);
+          ret_val = g_swig_breakpoint_callback(
+              python_function_name,
+              python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
+              bp_loc_sp);
         }
+        return ret_val;
+      }
     }
-    // We currently always true so we stop in case anything goes wrong when
-    // trying to call the script function
-    return true;
+  }
+  // We currently always true so we stop in case anything goes wrong when
+  // trying to call the script function
+  return true;
 }
 
-bool
-ScriptInterpreterPython::WatchpointCallbackFunction 
-(
-    void *baton,
-    StoppointCallbackContext *context,
-    user_id_t watch_id
-)
-{
-    WatchpointOptions::CommandData *wp_option_data = (WatchpointOptions::CommandData *) baton;
-    const char *python_function_name = wp_option_data->script_source.c_str();
-
-    if (!context)
-        return true;
-        
-    ExecutionContext exe_ctx (context->exe_ctx_ref);
-    Target *target = exe_ctx.GetTargetPtr();
-    
-    if (!target)
-        return true;
-        
-    Debugger &debugger = target->GetDebugger();
-    ScriptInterpreter *script_interpreter = debugger.GetCommandInterpreter().GetScriptInterpreter();
-    ScriptInterpreterPython *python_interpreter = (ScriptInterpreterPython *) script_interpreter;
-    
-    if (!script_interpreter)
-        return true;
-    
-    if (python_function_name && python_function_name[0])
-    {
-        const StackFrameSP stop_frame_sp (exe_ctx.GetFrameSP());
-        WatchpointSP wp_sp = target->GetWatchpointList().FindByID (watch_id);
-        if (wp_sp)
+bool ScriptInterpreterPython::WatchpointCallbackFunction(
+    void *baton, StoppointCallbackContext *context, user_id_t watch_id) {
+  WatchpointOptions::CommandData *wp_option_data =
+      (WatchpointOptions::CommandData *)baton;
+  const char *python_function_name = wp_option_data->script_source.c_str();
+
+  if (!context)
+    return true;
+
+  ExecutionContext exe_ctx(context->exe_ctx_ref);
+  Target *target = exe_ctx.GetTargetPtr();
+
+  if (!target)
+    return true;
+
+  Debugger &debugger = target->GetDebugger();
+  ScriptInterpreter *script_interpreter =
+      debugger.GetCommandInterpreter().GetScriptInterpreter();
+  ScriptInterpreterPython *python_interpreter =
+      (ScriptInterpreterPython *)script_interpreter;
+
+  if (!script_interpreter)
+    return true;
+
+  if (python_function_name && python_function_name[0]) {
+    const StackFrameSP stop_frame_sp(exe_ctx.GetFrameSP());
+    WatchpointSP wp_sp = target->GetWatchpointList().FindByID(watch_id);
+    if (wp_sp) {
+      if (stop_frame_sp && wp_sp) {
+        bool ret_val = true;
         {
-            if (stop_frame_sp && wp_sp)
-            {
-                bool ret_val = true;
-                {
-                    Locker py_lock(python_interpreter, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-                    ret_val = g_swig_watchpoint_callback (python_function_name,
-                                                          python_interpreter->m_dictionary_name.c_str(),
-                                                          stop_frame_sp, 
-                                                          wp_sp);
-                }
-                return ret_val;
-            }
+          Locker py_lock(python_interpreter, Locker::AcquireLock |
+                                                 Locker::InitSession |
+                                                 Locker::NoSTDIN);
+          ret_val = g_swig_watchpoint_callback(
+              python_function_name,
+              python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
+              wp_sp);
         }
+        return ret_val;
+      }
     }
-    // We currently always true so we stop in case anything goes wrong when
-    // trying to call the script function
-    return true;
+  }
+  // We currently always true so we stop in case anything goes wrong when
+  // trying to call the script function
+  return true;
 }
 
-size_t
-ScriptInterpreterPython::CalculateNumChildren(const StructuredData::ObjectSP &implementor_sp, uint32_t max)
-{
-    if (!implementor_sp)
-        return 0;
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return 0;
-    void *implementor = generic->GetValue();
-    if (!implementor)
-        return 0;
-    
-    if (!g_swig_calc_children)
-        return 0;
-
-    size_t ret_val = 0;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_calc_children (implementor, max);
-    }
-    
-    return ret_val;
+size_t ScriptInterpreterPython::CalculateNumChildren(
+    const StructuredData::ObjectSP &implementor_sp, uint32_t max) {
+  if (!implementor_sp)
+    return 0;
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return 0;
+  void *implementor = generic->GetValue();
+  if (!implementor)
+    return 0;
+
+  if (!g_swig_calc_children)
+    return 0;
+
+  size_t ret_val = 0;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_calc_children(implementor, max);
+  }
+
+  return ret_val;
 }
 
-lldb::ValueObjectSP
-ScriptInterpreterPython::GetChildAtIndex(const StructuredData::ObjectSP &implementor_sp, uint32_t idx)
-{
-    if (!implementor_sp)
-        return lldb::ValueObjectSP();
-
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return lldb::ValueObjectSP();
-    void *implementor = generic->GetValue();
-    if (!implementor)
-        return lldb::ValueObjectSP();
-    
-    if (!g_swig_get_child_index || !g_swig_cast_to_sbvalue)
-        return lldb::ValueObjectSP();
-    
-    lldb::ValueObjectSP ret_val;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        void* child_ptr = g_swig_get_child_index (implementor,idx);
-        if (child_ptr != nullptr && child_ptr != Py_None)
-        {
-            lldb::SBValue* sb_value_ptr = (lldb::SBValue*)g_swig_cast_to_sbvalue(child_ptr);
-            if (sb_value_ptr == nullptr)
-                Py_XDECREF(child_ptr);
-            else
-                ret_val = g_swig_get_valobj_sp_from_sbvalue (sb_value_ptr);
-        }
-        else
-        {
-            Py_XDECREF(child_ptr);
-        }
+lldb::ValueObjectSP ScriptInterpreterPython::GetChildAtIndex(
+    const StructuredData::ObjectSP &implementor_sp, uint32_t idx) {
+  if (!implementor_sp)
+    return lldb::ValueObjectSP();
+
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return lldb::ValueObjectSP();
+  void *implementor = generic->GetValue();
+  if (!implementor)
+    return lldb::ValueObjectSP();
+
+  if (!g_swig_get_child_index || !g_swig_cast_to_sbvalue)
+    return lldb::ValueObjectSP();
+
+  lldb::ValueObjectSP ret_val;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    void *child_ptr = g_swig_get_child_index(implementor, idx);
+    if (child_ptr != nullptr && child_ptr != Py_None) {
+      lldb::SBValue *sb_value_ptr =
+          (lldb::SBValue *)g_swig_cast_to_sbvalue(child_ptr);
+      if (sb_value_ptr == nullptr)
+        Py_XDECREF(child_ptr);
+      else
+        ret_val = g_swig_get_valobj_sp_from_sbvalue(sb_value_ptr);
+    } else {
+      Py_XDECREF(child_ptr);
     }
-    
-    return ret_val;
+  }
+
+  return ret_val;
 }
 
-int
-ScriptInterpreterPython::GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor_sp, const char *child_name)
-{
-    if (!implementor_sp)
-        return UINT32_MAX;
-
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return UINT32_MAX;
-    void *implementor = generic->GetValue();
-    if (!implementor)
-        return UINT32_MAX;
-    
-    if (!g_swig_get_index_child)
-        return UINT32_MAX;
-    
-    int ret_val = UINT32_MAX;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_get_index_child (implementor, child_name);
-    }
-    
-    return ret_val;
+int ScriptInterpreterPython::GetIndexOfChildWithName(
+    const StructuredData::ObjectSP &implementor_sp, const char *child_name) {
+  if (!implementor_sp)
+    return UINT32_MAX;
+
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return UINT32_MAX;
+  void *implementor = generic->GetValue();
+  if (!implementor)
+    return UINT32_MAX;
+
+  if (!g_swig_get_index_child)
+    return UINT32_MAX;
+
+  int ret_val = UINT32_MAX;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_get_index_child(implementor, child_name);
+  }
+
+  return ret_val;
 }
 
-bool
-ScriptInterpreterPython::UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor_sp)
-{
-    bool ret_val = false;
-    
-    if (!implementor_sp)
-        return ret_val;
+bool ScriptInterpreterPython::UpdateSynthProviderInstance(
+    const StructuredData::ObjectSP &implementor_sp) {
+  bool ret_val = false;
 
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return ret_val;
-    void *implementor = generic->GetValue();
-    if (!implementor)
-        return ret_val;
-    
-    if (!g_swig_update_provider)
-        return ret_val;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_update_provider (implementor);
-    }
-    
+  if (!implementor_sp)
     return ret_val;
-}
 
-bool
-ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor_sp)
-{
-    bool ret_val = false;
-    
-    if (!implementor_sp)
-        return ret_val;
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return ret_val;
+  void *implementor = generic->GetValue();
+  if (!implementor)
+    return ret_val;
 
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return ret_val;
-    void *implementor = generic->GetValue();
-    if (!implementor)
-        return ret_val;
-    
-    if (!g_swig_mighthavechildren_provider)
-        return ret_val;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_mighthavechildren_provider (implementor);
-    }
-    
+  if (!g_swig_update_provider)
     return ret_val;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_update_provider(implementor);
+  }
+
+  return ret_val;
 }
 
-lldb::ValueObjectSP
-ScriptInterpreterPython::GetSyntheticValue(const StructuredData::ObjectSP &implementor_sp)
-{
-    lldb::ValueObjectSP ret_val(nullptr);
-    
-    if (!implementor_sp)
-        return ret_val;
+bool ScriptInterpreterPython::MightHaveChildrenSynthProviderInstance(
+    const StructuredData::ObjectSP &implementor_sp) {
+  bool ret_val = false;
 
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return ret_val;
-    void *implementor = generic->GetValue();
-    if (!implementor)
-        return ret_val;
-    
-    if (!g_swig_getvalue_provider || !g_swig_cast_to_sbvalue || !g_swig_get_valobj_sp_from_sbvalue)
-        return ret_val;
-    
-    {
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        void* child_ptr = g_swig_getvalue_provider (implementor);
-        if (child_ptr != nullptr && child_ptr != Py_None)
-        {
-            lldb::SBValue* sb_value_ptr = (lldb::SBValue*)g_swig_cast_to_sbvalue(child_ptr);
-            if (sb_value_ptr == nullptr)
-                Py_XDECREF(child_ptr);
-            else
-                ret_val = g_swig_get_valobj_sp_from_sbvalue (sb_value_ptr);
-        }
-        else
-        {
-            Py_XDECREF(child_ptr);
-        }
-    }
-    
+  if (!implementor_sp)
+    return ret_val;
+
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return ret_val;
+  void *implementor = generic->GetValue();
+  if (!implementor)
     return ret_val;
+
+  if (!g_swig_mighthavechildren_provider)
+    return ret_val;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_mighthavechildren_provider(implementor);
+  }
+
+  return ret_val;
 }
 
-ConstString
-ScriptInterpreterPython::GetSyntheticTypeName (const StructuredData::ObjectSP &implementor_sp)
-{
-    Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+lldb::ValueObjectSP ScriptInterpreterPython::GetSyntheticValue(
+    const StructuredData::ObjectSP &implementor_sp) {
+  lldb::ValueObjectSP ret_val(nullptr);
 
-    static char callee_name[] = "get_type_name";
+  if (!implementor_sp)
+    return ret_val;
 
-    ConstString ret_val;
-    bool got_string = false;
-    std::string buffer;
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return ret_val;
+  void *implementor = generic->GetValue();
+  if (!implementor)
+    return ret_val;
 
-    if (!implementor_sp)
-        return ret_val;
-    
-    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
-    if (!generic)
-        return ret_val;
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)generic->GetValue());
-    if (!implementor.IsAllocated())
-        return ret_val;
-    
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    if (!pmeth.IsAllocated())
-        return ret_val;
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        return ret_val;
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
-    
-    // if it fails, print the error but otherwise go on
-    if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
-    
-    if (py_return.IsAllocated() && PythonString::Check(py_return.get()))
-    {
-        PythonString py_string(PyRefType::Borrowed, py_return.get());
-        llvm::StringRef return_data(py_string.GetString());
-        if (!return_data.empty())
-        {
-            buffer.assign(return_data.data(), return_data.size());
-            got_string = true;
-        }
-    }
-    
-    if (got_string)
-        ret_val.SetCStringWithLength(buffer.c_str(), buffer.size());
-    
+  if (!g_swig_getvalue_provider || !g_swig_cast_to_sbvalue ||
+      !g_swig_get_valobj_sp_from_sbvalue)
     return ret_val;
-}
 
-bool
-ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
-                                                 Process* process,
-                                                 std::string& output,
-                                                 Error& error)
-{
-    bool ret_val;
-    if (!process)
-    {
-        error.SetErrorString("no process");
-        return false;
-    }
-    if (!impl_function || !impl_function[0])
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    if (!g_swig_run_script_keyword_process)
-    {
-        error.SetErrorString("internal helper function missing");
-        return false;
-    }
-    {
-        ProcessSP process_sp(process->shared_from_this());
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_run_script_keyword_process (impl_function, m_dictionary_name.c_str(), process_sp, output);
-        if (!ret_val)
-            error.SetErrorString("python script evaluation failed");
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    void *child_ptr = g_swig_getvalue_provider(implementor);
+    if (child_ptr != nullptr && child_ptr != Py_None) {
+      lldb::SBValue *sb_value_ptr =
+          (lldb::SBValue *)g_swig_cast_to_sbvalue(child_ptr);
+      if (sb_value_ptr == nullptr)
+        Py_XDECREF(child_ptr);
+      else
+        ret_val = g_swig_get_valobj_sp_from_sbvalue(sb_value_ptr);
+    } else {
+      Py_XDECREF(child_ptr);
     }
-    return ret_val;
+  }
+
+  return ret_val;
 }
 
-bool
-ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
-                                                 Thread* thread,
-                                                 std::string& output,
-                                                 Error& error)
-{
-    bool ret_val;
-    if (!thread)
-    {
-        error.SetErrorString("no thread");
-        return false;
-    }
-    if (!impl_function || !impl_function[0])
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    if (!g_swig_run_script_keyword_thread)
-    {
-        error.SetErrorString("internal helper function missing");
-        return false;
-    }
-    {
-        ThreadSP thread_sp(thread->shared_from_this());
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_run_script_keyword_thread (impl_function, m_dictionary_name.c_str(), thread_sp, output);
-        if (!ret_val)
-            error.SetErrorString("python script evaluation failed");
-    }
+ConstString ScriptInterpreterPython::GetSyntheticTypeName(
+    const StructuredData::ObjectSP &implementor_sp) {
+  Locker py_lock(this,
+                 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+
+  static char callee_name[] = "get_type_name";
+
+  ConstString ret_val;
+  bool got_string = false;
+  std::string buffer;
+
+  if (!implementor_sp)
     return ret_val;
-}
 
-bool
-ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
-                                                 Target* target,
-                                                 std::string& output,
-                                                 Error& error)
-{
-    bool ret_val;
-    if (!target)
-    {
-        error.SetErrorString("no thread");
-        return false;
-    }
-    if (!impl_function || !impl_function[0])
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    if (!g_swig_run_script_keyword_target)
-    {
-        error.SetErrorString("internal helper function missing");
-        return false;
-    }
-    {
-        TargetSP target_sp(target->shared_from_this());
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_run_script_keyword_target (impl_function, m_dictionary_name.c_str(), target_sp, output);
-        if (!ret_val)
-            error.SetErrorString("python script evaluation failed");
-    }
+  StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+  if (!generic)
+    return ret_val;
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+  if (!implementor.IsAllocated())
     return ret_val;
-}
 
-bool
-ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
-                                                 StackFrame* frame,
-                                                 std::string& output,
-                                                 Error& error)
-{
-    bool ret_val;
-    if (!frame)
-    {
-        error.SetErrorString("no frame");
-        return false;
-    }
-    if (!impl_function || !impl_function[0])
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    if (!g_swig_run_script_keyword_frame)
-    {
-        error.SetErrorString("internal helper function missing");
-        return false;
-    }
-    {
-        StackFrameSP frame_sp(frame->shared_from_this());
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_run_script_keyword_frame (impl_function, m_dictionary_name.c_str(), frame_sp, output);
-        if (!ret_val)
-            error.SetErrorString("python script evaluation failed");
-    }
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
     return ret_val;
-}
-    
-bool
-ScriptInterpreterPython::RunScriptFormatKeyword (const char* impl_function,
-                                                 ValueObject *value,
-                                                 std::string& output,
-                                                 Error& error)
-{
-    bool ret_val;
-    if (!value)
-    {
-        error.SetErrorString("no value");
-        return false;
-    }
-    if (!impl_function || !impl_function[0])
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    if (!g_swig_run_script_keyword_value)
-    {
-        error.SetErrorString("internal helper function missing");
-        return false;
-    }
-    {
-        ValueObjectSP value_sp(value->GetSP());
-        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
-        ret_val = g_swig_run_script_keyword_value (impl_function, m_dictionary_name.c_str(), value_sp, output);
-        if (!ret_val)
-            error.SetErrorString("python script evaluation failed");
-    }
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
+    if (PyErr_Occurred())
+      PyErr_Clear();
     return ret_val;
-}
+  }
 
-uint64_t replace_all(std::string& str, const std::string& oldStr, const std::string& newStr)
-{
-    size_t pos = 0;
-    uint64_t matches = 0;
-    while((pos = str.find(oldStr, pos)) != std::string::npos)
-    {
-        matches++;
-        str.replace(pos, oldStr.length(), newStr);
-        pos += newStr.length();
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
+    PythonString py_string(PyRefType::Borrowed, py_return.get());
+    llvm::StringRef return_data(py_string.GetString());
+    if (!return_data.empty()) {
+      buffer.assign(return_data.data(), return_data.size());
+      got_string = true;
     }
-    return matches;
+  }
+
+  if (got_string)
+    ret_val.SetCStringWithLength(buffer.c_str(), buffer.size());
+
+  return ret_val;
 }
 
-bool
-ScriptInterpreterPython::LoadScriptingModule(const char *pathname, bool can_reload, bool init_session, lldb_private::Error &error,
-                                             StructuredData::ObjectSP *module_sp)
-{
-    if (!pathname || !pathname[0])
-    {
+bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
+                                                     Process *process,
+                                                     std::string &output,
+                                                     Error &error) {
+  bool ret_val;
+  if (!process) {
+    error.SetErrorString("no process");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+  if (!g_swig_run_script_keyword_process) {
+    error.SetErrorString("internal helper function missing");
+    return false;
+  }
+  {
+    ProcessSP process_sp(process->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_run_script_keyword_process(
+        impl_function, m_dictionary_name.c_str(), process_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
+                                                     Thread *thread,
+                                                     std::string &output,
+                                                     Error &error) {
+  bool ret_val;
+  if (!thread) {
+    error.SetErrorString("no thread");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+  if (!g_swig_run_script_keyword_thread) {
+    error.SetErrorString("internal helper function missing");
+    return false;
+  }
+  {
+    ThreadSP thread_sp(thread->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_run_script_keyword_thread(
+        impl_function, m_dictionary_name.c_str(), thread_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
+                                                     Target *target,
+                                                     std::string &output,
+                                                     Error &error) {
+  bool ret_val;
+  if (!target) {
+    error.SetErrorString("no thread");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+  if (!g_swig_run_script_keyword_target) {
+    error.SetErrorString("internal helper function missing");
+    return false;
+  }
+  {
+    TargetSP target_sp(target->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_run_script_keyword_target(
+        impl_function, m_dictionary_name.c_str(), target_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
+                                                     StackFrame *frame,
+                                                     std::string &output,
+                                                     Error &error) {
+  bool ret_val;
+  if (!frame) {
+    error.SetErrorString("no frame");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+  if (!g_swig_run_script_keyword_frame) {
+    error.SetErrorString("internal helper function missing");
+    return false;
+  }
+  {
+    StackFrameSP frame_sp(frame->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_run_script_keyword_frame(
+        impl_function, m_dictionary_name.c_str(), frame_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPython::RunScriptFormatKeyword(const char *impl_function,
+                                                     ValueObject *value,
+                                                     std::string &output,
+                                                     Error &error) {
+  bool ret_val;
+  if (!value) {
+    error.SetErrorString("no value");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+  if (!g_swig_run_script_keyword_value) {
+    error.SetErrorString("internal helper function missing");
+    return false;
+  }
+  {
+    ValueObjectSP value_sp(value->GetSP());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = g_swig_run_script_keyword_value(
+        impl_function, m_dictionary_name.c_str(), value_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+uint64_t replace_all(std::string &str, const std::string &oldStr,
+                     const std::string &newStr) {
+  size_t pos = 0;
+  uint64_t matches = 0;
+  while ((pos = str.find(oldStr, pos)) != std::string::npos) {
+    matches++;
+    str.replace(pos, oldStr.length(), newStr);
+    pos += newStr.length();
+  }
+  return matches;
+}
+
+bool ScriptInterpreterPython::LoadScriptingModule(
+    const char *pathname, bool can_reload, bool init_session,
+    lldb_private::Error &error, StructuredData::ObjectSP *module_sp) {
+  if (!pathname || !pathname[0]) {
+    error.SetErrorString("invalid pathname");
+    return false;
+  }
+
+  if (!g_swig_call_module_init) {
+    error.SetErrorString("internal helper function missing");
+    return false;
+  }
+
+  lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
+
+  {
+    FileSpec target_file(pathname, true);
+    std::string basename(target_file.GetFilename().GetCString());
+
+    StreamString command_stream;
+
+    // Before executing Python code, lock the GIL.
+    Locker py_lock(this, Locker::AcquireLock |
+                             (init_session ? Locker::InitSession : 0) |
+                             Locker::NoSTDIN,
+                   Locker::FreeAcquiredLock |
+                       (init_session ? Locker::TearDownSession : 0));
+
+    if (target_file.GetFileType() == FileSpec::eFileTypeInvalid ||
+        target_file.GetFileType() == FileSpec::eFileTypeUnknown) {
+      // if not a valid file of any sort, check if it might be a filename still
+      // dot can't be used but / and \ can, and if either is found, reject
+      if (strchr(pathname, '\\') || strchr(pathname, '/')) {
         error.SetErrorString("invalid pathname");
         return false;
-    }
-    
-    if (!g_swig_call_module_init)
-    {
-        error.SetErrorString("internal helper function missing");
+      }
+      basename = pathname; // not a filename, probably a package of some sort,
+                           // let it go through
+    } else if (target_file.GetFileType() == FileSpec::eFileTypeDirectory ||
+               target_file.GetFileType() == FileSpec::eFileTypeRegular ||
+               target_file.GetFileType() == FileSpec::eFileTypeSymbolicLink) {
+      std::string directory = target_file.GetDirectory().GetCString();
+      replace_all(directory, "\\", "\\\\");
+      replace_all(directory, "'", "\\'");
+
+      // now make sure that Python has "directory" in the search path
+      StreamString command_stream;
+      command_stream.Printf("if not (sys.path.__contains__('%s')):\n    "
+                            "sys.path.insert(1,'%s');\n\n",
+                            directory.c_str(), directory.c_str());
+      bool syspath_retval =
+          ExecuteMultipleLines(command_stream.GetData(),
+                               ScriptInterpreter::ExecuteScriptOptions()
+                                   .SetEnableIO(false)
+                                   .SetSetLLDBGlobals(false))
+              .Success();
+      if (!syspath_retval) {
+        error.SetErrorString("Python sys.path handling failed");
         return false;
+      }
+
+      // strip .py or .pyc extension
+      ConstString extension = target_file.GetFileNameExtension();
+      if (extension) {
+        if (::strcmp(extension.GetCString(), "py") == 0)
+          basename.resize(basename.length() - 3);
+        else if (::strcmp(extension.GetCString(), "pyc") == 0)
+          basename.resize(basename.length() - 4);
+      }
+    } else {
+      error.SetErrorString("no known way to import this module specification");
+      return false;
+    }
+
+    // check if the module is already import-ed
+    command_stream.Clear();
+    command_stream.Printf("sys.modules.__contains__('%s')", basename.c_str());
+    bool does_contain = false;
+    // this call will succeed if the module was ever imported in any Debugger in
+    // the lifetime of the process
+    // in which this LLDB framework is living
+    bool was_imported_globally =
+        (ExecuteOneLineWithReturn(
+             command_stream.GetData(),
+             ScriptInterpreterPython::eScriptReturnTypeBool, &does_contain,
+             ScriptInterpreter::ExecuteScriptOptions()
+                 .SetEnableIO(false)
+                 .SetSetLLDBGlobals(false)) &&
+         does_contain);
+    // this call will fail if the module was not imported in this Debugger
+    // before
+    command_stream.Clear();
+    command_stream.Printf("sys.getrefcount(%s)", basename.c_str());
+    bool was_imported_locally = GetSessionDictionary()
+                                    .GetItemForKey(PythonString(basename))
+                                    .IsAllocated();
+
+    bool was_imported = (was_imported_globally || was_imported_locally);
+
+    if (was_imported == true && can_reload == false) {
+      error.SetErrorString("module already imported");
+      return false;
+    }
+
+    // now actually do the import
+    command_stream.Clear();
+
+    if (was_imported) {
+      if (!was_imported_locally)
+        command_stream.Printf("import %s ; reload_module(%s)", basename.c_str(),
+                              basename.c_str());
+      else
+        command_stream.Printf("reload_module(%s)", basename.c_str());
+    } else
+      command_stream.Printf("import %s", basename.c_str());
+
+    error = ExecuteMultipleLines(command_stream.GetData(),
+                                 ScriptInterpreter::ExecuteScriptOptions()
+                                     .SetEnableIO(false)
+                                     .SetSetLLDBGlobals(false));
+    if (error.Fail())
+      return false;
+
+    // if we are here, everything worked
+    // call __lldb_init_module(debugger,dict)
+    if (!g_swig_call_module_init(basename.c_str(), m_dictionary_name.c_str(),
+                                 debugger_sp)) {
+      error.SetErrorString("calling __lldb_init_module failed");
+      return false;
+    }
+
+    if (module_sp) {
+      // everything went just great, now set the module object
+      command_stream.Clear();
+      command_stream.Printf("%s", basename.c_str());
+      void *module_pyobj = nullptr;
+      if (ExecuteOneLineWithReturn(
+              command_stream.GetData(),
+              ScriptInterpreter::eScriptReturnTypeOpaqueObject,
+              &module_pyobj) &&
+          module_pyobj)
+        module_sp->reset(new StructuredPythonObject(module_pyobj));
     }
-    
-    lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
 
-    {
-        FileSpec target_file(pathname, true);
-        std::string basename(target_file.GetFilename().GetCString());
-        
-        StreamString command_stream;
-
-        // Before executing Python code, lock the GIL.
-        Locker py_lock (this,
-                        Locker::AcquireLock      | (init_session ? Locker::InitSession     : 0) | Locker::NoSTDIN,
-                        Locker::FreeAcquiredLock | (init_session ? Locker::TearDownSession : 0));
-        
-        if (target_file.GetFileType() == FileSpec::eFileTypeInvalid ||
-            target_file.GetFileType() == FileSpec::eFileTypeUnknown)
-        {
-            // if not a valid file of any sort, check if it might be a filename still
-            // dot can't be used but / and \ can, and if either is found, reject
-            if (strchr(pathname,'\\') || strchr(pathname,'/'))
-            {
-                error.SetErrorString("invalid pathname");
-                return false;
-            }
-            basename = pathname; // not a filename, probably a package of some sort, let it go through
-        }
-        else if (target_file.GetFileType() == FileSpec::eFileTypeDirectory ||
-                 target_file.GetFileType() == FileSpec::eFileTypeRegular ||
-                 target_file.GetFileType() == FileSpec::eFileTypeSymbolicLink)
-        {
-            std::string directory = target_file.GetDirectory().GetCString();
-            replace_all(directory, "\\", "\\\\");
-            replace_all(directory, "'", "\\'");
-
-            // now make sure that Python has "directory" in the search path
-            StreamString command_stream;
-            command_stream.Printf("if not (sys.path.__contains__('%s')):\n    sys.path.insert(1,'%s');\n\n",
-                                  directory.c_str(),
-                                  directory.c_str());
-            bool syspath_retval = ExecuteMultipleLines(command_stream.GetData(), ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false).SetSetLLDBGlobals(false)).Success();
-            if (!syspath_retval)
-            {
-                error.SetErrorString("Python sys.path handling failed");
-                return false;
-            }
+    return true;
+  }
+}
 
-            // strip .py or .pyc extension
-            ConstString extension = target_file.GetFileNameExtension();
-            if (extension)
-            {
-                if (::strcmp(extension.GetCString(), "py") == 0)
-                    basename.resize(basename.length()-3);
-                else if(::strcmp(extension.GetCString(), "pyc") == 0)
-                    basename.resize(basename.length()-4);
-            }
-        }
-        else
-        {
-            error.SetErrorString("no known way to import this module specification");
-            return false;
-        }
-        
-        // check if the module is already import-ed
-        command_stream.Clear();
-        command_stream.Printf("sys.modules.__contains__('%s')",basename.c_str());
-        bool does_contain = false;
-        // this call will succeed if the module was ever imported in any Debugger in the lifetime of the process
-        // in which this LLDB framework is living
-        bool was_imported_globally = (ExecuteOneLineWithReturn(command_stream.GetData(),
-                                                               ScriptInterpreterPython::eScriptReturnTypeBool,
-                                                               &does_contain,
-                                                               ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false).SetSetLLDBGlobals(false)) && does_contain);
-        // this call will fail if the module was not imported in this Debugger before
-        command_stream.Clear();
-        command_stream.Printf("sys.getrefcount(%s)",basename.c_str());
-        bool was_imported_locally = GetSessionDictionary().GetItemForKey(PythonString(basename)).IsAllocated();
-        
-        bool was_imported = (was_imported_globally || was_imported_locally);
-        
-        if (was_imported == true && can_reload == false)
-        {
-            error.SetErrorString("module already imported");
-            return false;
-        }
+bool ScriptInterpreterPython::IsReservedWord(const char *word) {
+  if (!word || !word[0])
+    return false;
 
-        // now actually do the import
-        command_stream.Clear();
-        
-        if (was_imported)
-        {
-            if (!was_imported_locally)
-                command_stream.Printf("import %s ; reload_module(%s)",basename.c_str(),basename.c_str());
-            else
-                command_stream.Printf("reload_module(%s)",basename.c_str());
-        }
-        else
-            command_stream.Printf("import %s", basename.c_str());
-
-        error = ExecuteMultipleLines(command_stream.GetData(), ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false).SetSetLLDBGlobals(false));
-        if (error.Fail())
-            return false;
-        
-        // if we are here, everything worked
-        // call __lldb_init_module(debugger,dict)
-        if (!g_swig_call_module_init (basename.c_str(),
-                                      m_dictionary_name.c_str(),
-                                      debugger_sp))
-        {
-            error.SetErrorString("calling __lldb_init_module failed");
-            return false;
-        }
-        
-        if (module_sp)
-        {
-            // everything went just great, now set the module object
-            command_stream.Clear();
-            command_stream.Printf("%s",basename.c_str());
-            void* module_pyobj = nullptr;
-            if (ExecuteOneLineWithReturn(command_stream.GetData(),ScriptInterpreter::eScriptReturnTypeOpaqueObject,&module_pyobj) && module_pyobj)
-                module_sp->reset(new StructuredPythonObject(module_pyobj));
-        }
-        
-        return true;
-    }
+  llvm::StringRef word_sr(word);
+
+  // filter out a few characters that would just confuse us
+  // and that are clearly not keyword material anyway
+  if (word_sr.find_first_of("'\"") != llvm::StringRef::npos)
+    return false;
+
+  StreamString command_stream;
+  command_stream.Printf("keyword.iskeyword('%s')", word);
+  bool result;
+  ExecuteScriptOptions options;
+  options.SetEnableIO(false);
+  options.SetMaskoutErrors(true);
+  options.SetSetLLDBGlobals(false);
+  if (ExecuteOneLineWithReturn(command_stream.GetData(),
+                               ScriptInterpreter::eScriptReturnTypeBool,
+                               &result, options))
+    return result;
+  return false;
 }
 
-bool
-ScriptInterpreterPython::IsReservedWord (const char* word)
-{
-    if (!word || !word[0])
-        return false;
-    
-    llvm::StringRef word_sr(word);
+ScriptInterpreterPython::SynchronicityHandler::SynchronicityHandler(
+    lldb::DebuggerSP debugger_sp, ScriptedCommandSynchronicity synchro)
+    : m_debugger_sp(debugger_sp), m_synch_wanted(synchro),
+      m_old_asynch(debugger_sp->GetAsyncExecution()) {
+  if (m_synch_wanted == eScriptedCommandSynchronicitySynchronous)
+    m_debugger_sp->SetAsyncExecution(false);
+  else if (m_synch_wanted == eScriptedCommandSynchronicityAsynchronous)
+    m_debugger_sp->SetAsyncExecution(true);
+}
 
-    // filter out a few characters that would just confuse us
-    // and that are clearly not keyword material anyway
-    if (word_sr.find_first_of("'\"") != llvm::StringRef::npos)
-        return false;
-    
-    StreamString command_stream;
-    command_stream.Printf("keyword.iskeyword('%s')", word);
-    bool result;
-    ExecuteScriptOptions options;
-    options.SetEnableIO(false);
-    options.SetMaskoutErrors(true);
-    options.SetSetLLDBGlobals(false);
-    if (ExecuteOneLineWithReturn(command_stream.GetData(), ScriptInterpreter::eScriptReturnTypeBool, &result, options))
-        return result;
-    return false;
+ScriptInterpreterPython::SynchronicityHandler::~SynchronicityHandler() {
+  if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
+    m_debugger_sp->SetAsyncExecution(m_old_asynch);
 }
 
-ScriptInterpreterPython::SynchronicityHandler::SynchronicityHandler (lldb::DebuggerSP debugger_sp,
-                                                                     ScriptedCommandSynchronicity synchro) :
-    m_debugger_sp(debugger_sp),
-    m_synch_wanted(synchro),
-    m_old_asynch(debugger_sp->GetAsyncExecution())
-{
-    if (m_synch_wanted == eScriptedCommandSynchronicitySynchronous)
-        m_debugger_sp->SetAsyncExecution(false);
-    else if (m_synch_wanted == eScriptedCommandSynchronicityAsynchronous)
-        m_debugger_sp->SetAsyncExecution(true);
-}
-
-ScriptInterpreterPython::SynchronicityHandler::~SynchronicityHandler()
-{
-    if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
-        m_debugger_sp->SetAsyncExecution(m_old_asynch);
-}
-
-bool
-ScriptInterpreterPython::RunScriptBasedCommand(const char* impl_function,
-                                               const char* args,
-                                               ScriptedCommandSynchronicity synchronicity,
-                                               lldb_private::CommandReturnObject& cmd_retobj,
-                                               Error& error,
-                                               const lldb_private::ExecutionContext& exe_ctx)
-{
-    if (!impl_function)
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    
-    if (!g_swig_call_command)
-    {
-        error.SetErrorString("no helper function to run scripted commands");
-        return false;
-    }
-    
-    lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
-    lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
-    
-    if (!debugger_sp.get())
-    {
-        error.SetErrorString("invalid Debugger pointer");
-        return false;
-   }
-    
-    bool ret_val = false;
-    
-    std::string err_msg;
+bool ScriptInterpreterPython::RunScriptBasedCommand(
+    const char *impl_function, const char *args,
+    ScriptedCommandSynchronicity synchronicity,
+    lldb_private::CommandReturnObject &cmd_retobj, Error &error,
+    const lldb_private::ExecutionContext &exe_ctx) {
+  if (!impl_function) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
 
-    {
-        Locker py_lock(this,
-                       Locker::AcquireLock | Locker::InitSession | (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
-                       Locker::FreeLock    | Locker::TearDownSession);
-        
-        SynchronicityHandler synch_handler(debugger_sp,
-                                           synchronicity);
-        
-        ret_val = g_swig_call_command       (impl_function,
-                                             m_dictionary_name.c_str(),
-                                             debugger_sp,
-                                             args,
-                                             cmd_retobj,
-                                             exe_ctx_ref_sp);
-    }
-    
-    if (!ret_val)
-        error.SetErrorString("unable to execute script function");
-    else
-        error.Clear();
-    
-    return ret_val;
+  if (!g_swig_call_command) {
+    error.SetErrorString("no helper function to run scripted commands");
+    return false;
+  }
+
+  lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
+  lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
+
+  if (!debugger_sp.get()) {
+    error.SetErrorString("invalid Debugger pointer");
+    return false;
+  }
+
+  bool ret_val = false;
+
+  std::string err_msg;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession |
+                       (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
+                   Locker::FreeLock | Locker::TearDownSession);
+
+    SynchronicityHandler synch_handler(debugger_sp, synchronicity);
+
+    ret_val =
+        g_swig_call_command(impl_function, m_dictionary_name.c_str(),
+                            debugger_sp, args, cmd_retobj, exe_ctx_ref_sp);
+  }
+
+  if (!ret_val)
+    error.SetErrorString("unable to execute script function");
+  else
+    error.Clear();
+
+  return ret_val;
 }
 
-bool
-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->IsValid())
-    {
-        error.SetErrorString("no function to execute");
-        return false;
-    }
-    
-    if (!g_swig_call_command_object)
-    {
-        error.SetErrorString("no helper function to run scripted commands");
-        return false;
-    }
-    
-    lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
-    lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
-    
-    if (!debugger_sp.get())
-    {
-        error.SetErrorString("invalid Debugger pointer");
-        return false;
-    }
-    
-    bool ret_val = false;
-    
-    std::string err_msg;
-    
-    {
-        Locker py_lock(this,
-                       Locker::AcquireLock | Locker::InitSession | (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
-                       Locker::FreeLock    | Locker::TearDownSession);
-        
-        SynchronicityHandler synch_handler(debugger_sp,
-                                           synchronicity);
-        
-        ret_val = g_swig_call_command_object      (impl_obj_sp->GetValue(),
-                                                   debugger_sp,
-                                                   args,
-                                                   cmd_retobj,
-                                                   exe_ctx_ref_sp);
-    }
-    
-    if (!ret_val)
-        error.SetErrorString("unable to execute script function");
-    else
-        error.Clear();
+bool 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->IsValid()) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
 
-    return ret_val;
+  if (!g_swig_call_command_object) {
+    error.SetErrorString("no helper function to run scripted commands");
+    return false;
+  }
+
+  lldb::DebuggerSP debugger_sp = m_interpreter.GetDebugger().shared_from_this();
+  lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx));
+
+  if (!debugger_sp.get()) {
+    error.SetErrorString("invalid Debugger pointer");
+    return false;
+  }
+
+  bool ret_val = false;
+
+  std::string err_msg;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession |
+                       (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN),
+                   Locker::FreeLock | Locker::TearDownSession);
+
+    SynchronicityHandler synch_handler(debugger_sp, synchronicity);
+
+    ret_val = g_swig_call_command_object(impl_obj_sp->GetValue(), debugger_sp,
+                                         args, cmd_retobj, exe_ctx_ref_sp);
+  }
+
+  if (!ret_val)
+    error.SetErrorString("unable to execute script function");
+  else
+    error.Clear();
+
+  return ret_val;
 }
 
 // in Python, a special attribute __doc__ contains the docstring
 // for an object (function, method, class, ...) if any is defined
 // Otherwise, the attribute's value is None
-bool
-ScriptInterpreterPython::GetDocumentationForItem(const char* item, std::string& dest)
-{
-	dest.clear();
-	if (!item || !*item)
-		return false;
-    std::string command(item);
-    command += ".__doc__";
-    
-    char* result_ptr = nullptr; // Python is going to point this to valid data if ExecuteOneLineWithReturn returns successfully
-    
-    if (ExecuteOneLineWithReturn (command.c_str(),
-                                  ScriptInterpreter::eScriptReturnTypeCharStrOrNone,
-                                  &result_ptr,
-                                  ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false)))
-    {
-        if (result_ptr)
-            dest.assign(result_ptr);
-        return true;
-    }
-    else
-    {
-        StreamString str_stream;
-        str_stream.Printf("Function %s was not found. Containing module might be missing.",item);
-        dest.assign(str_stream.GetData());
-        return false;
-    }
+bool ScriptInterpreterPython::GetDocumentationForItem(const char *item,
+                                                      std::string &dest) {
+  dest.clear();
+  if (!item || !*item)
+    return false;
+  std::string command(item);
+  command += ".__doc__";
+
+  char *result_ptr = nullptr; // Python is going to point this to valid data if
+                              // ExecuteOneLineWithReturn returns successfully
+
+  if (ExecuteOneLineWithReturn(
+          command.c_str(), ScriptInterpreter::eScriptReturnTypeCharStrOrNone,
+          &result_ptr,
+          ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false))) {
+    if (result_ptr)
+      dest.assign(result_ptr);
+    return true;
+  } else {
+    StreamString str_stream;
+    str_stream.Printf(
+        "Function %s was not found. Containing module might be missing.", item);
+    dest = str_stream.GetString();
+    return false;
+  }
 }
 
-bool
-ScriptInterpreterPython::GetShortHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
-                                                       std::string& dest)
-{
-    bool got_string = false;
-    dest.clear();
-    
-    Locker py_lock (this,
-                    Locker::AcquireLock | Locker::NoSTDIN,
-                    Locker::FreeLock);
-    
-    static char callee_name[] = "get_short_help";
-    
-    if (!cmd_obj_sp)
-        return false;
+bool ScriptInterpreterPython::GetShortHelpForCommandObject(
+    StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
+  bool got_string = false;
+  dest.clear();
 
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
-    if (!implementor.IsAllocated())
-        return false;
+  static char callee_name[] = "get_short_help";
 
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+  if (!cmd_obj_sp)
+    return false;
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)cmd_obj_sp->GetValue());
 
-    if (!pmeth.IsAllocated())
-        return false;
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        return false;
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+  if (!implementor.IsAllocated())
+    return false;
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
 
-    // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
+    return false;
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
     if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
+      PyErr_Clear();
+    return false;
+  }
 
-    if (py_return.IsAllocated() && PythonString::Check(py_return.get()))
-    {
-        PythonString py_string(PyRefType::Borrowed, py_return.get());
-        llvm::StringRef return_data(py_string.GetString());
-        dest.assign(return_data.data(), return_data.size());
-        got_string = true;
-    }
-    return got_string;
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
+    PythonString py_string(PyRefType::Borrowed, py_return.get());
+    llvm::StringRef return_data(py_string.GetString());
+    dest.assign(return_data.data(), return_data.size());
+    got_string = true;
+  }
+  return got_string;
 }
 
-uint32_t
-ScriptInterpreterPython::GetFlagsForCommandObject (StructuredData::GenericSP cmd_obj_sp)
-{
-    uint32_t result = 0;
-    
-    Locker py_lock (this,
-                    Locker::AcquireLock | Locker::NoSTDIN,
-                    Locker::FreeLock);
-    
-    static char callee_name[] = "get_flags";
-    
-    if (!cmd_obj_sp)
-        return result;
+uint32_t ScriptInterpreterPython::GetFlagsForCommandObject(
+    StructuredData::GenericSP cmd_obj_sp) {
+  uint32_t result = 0;
 
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
-    if (!implementor.IsAllocated())
-        return result;
+  static char callee_name[] = "get_flags";
 
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+  if (!cmd_obj_sp)
+    return result;
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)cmd_obj_sp->GetValue());
 
-    if (!pmeth.IsAllocated())
-        return result;
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        return result;
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+  if (!implementor.IsAllocated())
+    return result;
 
-    // if it fails, print the error but otherwise go on
-    if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
 
-    if (py_return.IsAllocated() && PythonInteger::Check(py_return.get()))
-    {
-        PythonInteger int_value(PyRefType::Borrowed, py_return.get());
-        result = int_value.GetInteger();
-    }
-    
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
+    return result;
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
+    if (PyErr_Occurred())
+      PyErr_Clear();
     return result;
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.IsAllocated() && PythonInteger::Check(py_return.get())) {
+    PythonInteger int_value(PyRefType::Borrowed, py_return.get());
+    result = int_value.GetInteger();
+  }
+
+  return result;
 }
 
-bool
-ScriptInterpreterPython::GetLongHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
-                                                      std::string& dest)
-{
-    bool got_string = false;
-    dest.clear();
-    
-    Locker py_lock (this,
-                    Locker::AcquireLock | Locker::NoSTDIN,
-                    Locker::FreeLock);
-    
-    static char callee_name[] = "get_long_help";
-    
-    if (!cmd_obj_sp)
-        return false;
+bool ScriptInterpreterPython::GetLongHelpForCommandObject(
+    StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
+  bool got_string = false;
+  dest.clear();
 
-    PythonObject implementor(PyRefType::Borrowed, (PyObject *)cmd_obj_sp->GetValue());
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
 
-    if (!implementor.IsAllocated())
-        return false;
+  static char callee_name[] = "get_long_help";
 
-    PythonObject pmeth(PyRefType::Owned, PyObject_GetAttrString(implementor.get(), callee_name));
+  if (!cmd_obj_sp)
+    return false;
 
-    if (PyErr_Occurred())
-        PyErr_Clear();
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)cmd_obj_sp->GetValue());
 
-    if (!pmeth.IsAllocated())
-        return false;
-    
-    if (PyCallable_Check(pmeth.get()) == 0)
-    {
-        if (PyErr_Occurred())
-            PyErr_Clear();
-        
-        return false;
-    }
-    
-    if (PyErr_Occurred())
-        PyErr_Clear();
-    
-    // right now we know this function exists and is callable..
-    PythonObject py_return(PyRefType::Owned, PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+  if (!implementor.IsAllocated())
+    return false;
 
-    // if it fails, print the error but otherwise go on
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
+    return false;
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
     if (PyErr_Occurred())
-    {
-        PyErr_Print();
-        PyErr_Clear();
-    }
+      PyErr_Clear();
 
-    if (py_return.IsAllocated() && PythonString::Check(py_return.get()))
-    {
-        PythonString str(PyRefType::Borrowed, py_return.get());
-        llvm::StringRef str_data(str.GetString());
-        dest.assign(str_data.data(), str_data.size());
-        got_string = true;
-    }
-    
-    return got_string;
-}
+    return false;
+  }
 
-std::unique_ptr<ScriptInterpreterLocker>
-ScriptInterpreterPython::AcquireInterpreterLock ()
-{
-    std::unique_ptr<ScriptInterpreterLocker> py_lock(new Locker(this,
-                                                                Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN,
-                                                                Locker::FreeLock | Locker::TearDownSession));
-    return py_lock;
-}
-
-void
-ScriptInterpreterPython::InitializeInterpreter (SWIGInitCallback swig_init_callback,
-                                                SWIGBreakpointCallbackFunction swig_breakpoint_callback,
-                                                SWIGWatchpointCallbackFunction swig_watchpoint_callback,
-                                                SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
-                                                SWIGPythonCreateSyntheticProvider swig_synthetic_script,
-                                                SWIGPythonCreateCommandObject swig_create_cmd,
-                                                SWIGPythonCalculateNumChildren swig_calc_children,
-                                                SWIGPythonGetChildAtIndex swig_get_child_index,
-                                                SWIGPythonGetIndexOfChildWithName swig_get_index_child,
-                                                SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue ,
-                                                SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
-                                                SWIGPythonUpdateSynthProviderInstance swig_update_provider,
-                                                SWIGPythonMightHaveChildrenSynthProviderInstance swig_mighthavechildren_provider,
-                                                SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
-                                                SWIGPythonCallCommand swig_call_command,
-                                                SWIGPythonCallCommandObject swig_call_command_object,
-                                                SWIGPythonCallModuleInit swig_call_module_init,
-                                                SWIGPythonCreateOSPlugin swig_create_os_plugin,
-                                                SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
-                                                SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
-                                                SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
-                                                SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
-                                                SWIGPythonScriptKeyword_Value swig_run_script_keyword_value,
-                                                SWIGPython_GetDynamicSetting swig_plugin_get,
-                                                SWIGPythonCreateScriptedThreadPlan swig_thread_plan_script,
-                                                SWIGPythonCallThreadPlan swig_call_thread_plan)
-{
-    g_swig_init_callback = swig_init_callback;
-    g_swig_breakpoint_callback = swig_breakpoint_callback;
-    g_swig_watchpoint_callback = swig_watchpoint_callback;
-    g_swig_typescript_callback = swig_typescript_callback;
-    g_swig_synthetic_script = swig_synthetic_script;
-    g_swig_create_cmd = swig_create_cmd;
-    g_swig_calc_children = swig_calc_children;
-    g_swig_get_child_index = swig_get_child_index;
-    g_swig_get_index_child = swig_get_index_child;
-    g_swig_cast_to_sbvalue = swig_cast_to_sbvalue;
-    g_swig_get_valobj_sp_from_sbvalue = swig_get_valobj_sp_from_sbvalue;
-    g_swig_update_provider = swig_update_provider;
-    g_swig_mighthavechildren_provider = swig_mighthavechildren_provider;
-    g_swig_getvalue_provider = swig_getvalue_provider;
-    g_swig_call_command = swig_call_command;
-    g_swig_call_command_object = swig_call_command_object;
-    g_swig_call_module_init = swig_call_module_init;
-    g_swig_create_os_plugin = swig_create_os_plugin;
-    g_swig_run_script_keyword_process = swig_run_script_keyword_process;
-    g_swig_run_script_keyword_thread = swig_run_script_keyword_thread;
-    g_swig_run_script_keyword_target = swig_run_script_keyword_target;
-    g_swig_run_script_keyword_frame = swig_run_script_keyword_frame;
-    g_swig_run_script_keyword_value = swig_run_script_keyword_value;
-    g_swig_plugin_get = swig_plugin_get;
-    g_swig_thread_plan_script = swig_thread_plan_script;
-    g_swig_call_thread_plan = swig_call_thread_plan;
-}
-
-void
-ScriptInterpreterPython::InitializePrivate ()
-{
-    if (g_initialized)
-        return;
-
-    g_initialized = true;
-
-    Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
-
-    // RAII-based initialization which correctly handles multiple-initialization, version-
-    // specific differences among Python 2 and Python 3, and saving and restoring various
-    // other pieces of state that can get mucked with during initialization.
-    InitializePythonRAII initialize_guard;
-
-    if (g_swig_init_callback)
-        g_swig_init_callback ();
-
-    // Update the path python uses to search for modules to include the current directory.
-
-    PyRun_SimpleString ("import sys");
-    AddToSysPath(AddLocation::End, ".");
-
-    FileSpec file_spec;
-    // Don't denormalize paths when calling file_spec.GetPath().  On platforms that use
-    // a backslash as the path separator, this will result in executing python code containing
-    // paths with unescaped backslashes.  But Python also accepts forward slashes, so to make
-    // life easier we just use that.
-    if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
-        AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
-    if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, file_spec))
-        AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
-
-    PyRun_SimpleString ("sys.dont_write_bytecode = 1; import lldb.embedded_interpreter; from lldb.embedded_interpreter import run_python_interpreter; from lldb.embedded_interpreter import run_one_line");
-}
-
-void
-ScriptInterpreterPython::AddToSysPath(AddLocation location, std::string path)
-{
-    std::string path_copy;
-
-    std::string statement;
-    if (location == AddLocation::Beginning)
-    {
-        statement.assign("sys.path.insert(0,\"");
-        statement.append (path);
-        statement.append ("\")");
-    }
-    else
-    {
-        statement.assign("sys.path.append(\"");
-        statement.append(path);
-        statement.append("\")");
-    }
-    PyRun_SimpleString (statement.c_str());
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.IsAllocated() && PythonString::Check(py_return.get())) {
+    PythonString str(PyRefType::Borrowed, py_return.get());
+    llvm::StringRef str_data(str.GetString());
+    dest.assign(str_data.data(), str_data.size());
+    got_string = true;
+  }
+
+  return got_string;
 }
 
+std::unique_ptr<ScriptInterpreterLocker>
+ScriptInterpreterPython::AcquireInterpreterLock() {
+  std::unique_ptr<ScriptInterpreterLocker> py_lock(new Locker(
+      this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN,
+      Locker::FreeLock | Locker::TearDownSession));
+  return py_lock;
+}
+
+void ScriptInterpreterPython::InitializeInterpreter(
+    SWIGInitCallback swig_init_callback,
+    SWIGBreakpointCallbackFunction swig_breakpoint_callback,
+    SWIGWatchpointCallbackFunction swig_watchpoint_callback,
+    SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
+    SWIGPythonCreateSyntheticProvider swig_synthetic_script,
+    SWIGPythonCreateCommandObject swig_create_cmd,
+    SWIGPythonCalculateNumChildren swig_calc_children,
+    SWIGPythonGetChildAtIndex swig_get_child_index,
+    SWIGPythonGetIndexOfChildWithName swig_get_index_child,
+    SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue,
+    SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
+    SWIGPythonUpdateSynthProviderInstance swig_update_provider,
+    SWIGPythonMightHaveChildrenSynthProviderInstance
+        swig_mighthavechildren_provider,
+    SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
+    SWIGPythonCallCommand swig_call_command,
+    SWIGPythonCallCommandObject swig_call_command_object,
+    SWIGPythonCallModuleInit swig_call_module_init,
+    SWIGPythonCreateOSPlugin swig_create_os_plugin,
+    SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
+    SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
+    SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
+    SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
+    SWIGPythonScriptKeyword_Value swig_run_script_keyword_value,
+    SWIGPython_GetDynamicSetting swig_plugin_get,
+    SWIGPythonCreateScriptedThreadPlan swig_thread_plan_script,
+    SWIGPythonCallThreadPlan swig_call_thread_plan) {
+  g_swig_init_callback = swig_init_callback;
+  g_swig_breakpoint_callback = swig_breakpoint_callback;
+  g_swig_watchpoint_callback = swig_watchpoint_callback;
+  g_swig_typescript_callback = swig_typescript_callback;
+  g_swig_synthetic_script = swig_synthetic_script;
+  g_swig_create_cmd = swig_create_cmd;
+  g_swig_calc_children = swig_calc_children;
+  g_swig_get_child_index = swig_get_child_index;
+  g_swig_get_index_child = swig_get_index_child;
+  g_swig_cast_to_sbvalue = swig_cast_to_sbvalue;
+  g_swig_get_valobj_sp_from_sbvalue = swig_get_valobj_sp_from_sbvalue;
+  g_swig_update_provider = swig_update_provider;
+  g_swig_mighthavechildren_provider = swig_mighthavechildren_provider;
+  g_swig_getvalue_provider = swig_getvalue_provider;
+  g_swig_call_command = swig_call_command;
+  g_swig_call_command_object = swig_call_command_object;
+  g_swig_call_module_init = swig_call_module_init;
+  g_swig_create_os_plugin = swig_create_os_plugin;
+  g_swig_run_script_keyword_process = swig_run_script_keyword_process;
+  g_swig_run_script_keyword_thread = swig_run_script_keyword_thread;
+  g_swig_run_script_keyword_target = swig_run_script_keyword_target;
+  g_swig_run_script_keyword_frame = swig_run_script_keyword_frame;
+  g_swig_run_script_keyword_value = swig_run_script_keyword_value;
+  g_swig_plugin_get = swig_plugin_get;
+  g_swig_thread_plan_script = swig_thread_plan_script;
+  g_swig_call_thread_plan = swig_call_thread_plan;
+}
+
+void ScriptInterpreterPython::InitializePrivate() {
+  if (g_initialized)
+    return;
 
-//void
-//ScriptInterpreterPython::Terminate ()
+  g_initialized = true;
+
+  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+
+  // RAII-based initialization which correctly handles multiple-initialization,
+  // version-
+  // specific differences among Python 2 and Python 3, and saving and restoring
+  // various
+  // other pieces of state that can get mucked with during initialization.
+  InitializePythonRAII initialize_guard;
+
+  if (g_swig_init_callback)
+    g_swig_init_callback();
+
+  // Update the path python uses to search for modules to include the current
+  // directory.
+
+  PyRun_SimpleString("import sys");
+  AddToSysPath(AddLocation::End, ".");
+
+  FileSpec file_spec;
+  // Don't denormalize paths when calling file_spec.GetPath().  On platforms
+  // that use
+  // a backslash as the path separator, this will result in executing python
+  // code containing
+  // paths with unescaped backslashes.  But Python also accepts forward slashes,
+  // so to make
+  // life easier we just use that.
+  if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
+    AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
+  if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, file_spec))
+    AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
+
+  PyRun_SimpleString("sys.dont_write_bytecode = 1; import "
+                     "lldb.embedded_interpreter; from "
+                     "lldb.embedded_interpreter import run_python_interpreter; "
+                     "from lldb.embedded_interpreter import run_one_line");
+}
+
+void ScriptInterpreterPython::AddToSysPath(AddLocation location,
+                                           std::string path) {
+  std::string path_copy;
+
+  std::string statement;
+  if (location == AddLocation::Beginning) {
+    statement.assign("sys.path.insert(0,\"");
+    statement.append(path);
+    statement.append("\")");
+  } else {
+    statement.assign("sys.path.append(\"");
+    statement.append(path);
+    statement.append("\")");
+  }
+  PyRun_SimpleString(statement.c_str());
+}
+
+// void
+// ScriptInterpreterPython::Terminate ()
 //{
-//    // We are intentionally NOT calling Py_Finalize here (this would be the logical place to call it).  Calling
-//    // Py_Finalize here causes test suite runs to seg fault:  The test suite runs in Python.  It registers 
-//    // SBDebugger::Terminate to be called 'at_exit'.  When the test suite Python harness finishes up, it calls 
-//    // Py_Finalize, which calls all the 'at_exit' registered functions.  SBDebugger::Terminate calls Debugger::Terminate,
-//    // which calls lldb::Terminate, which calls ScriptInterpreter::Terminate, which calls 
-//    // ScriptInterpreterPython::Terminate.  So if we call Py_Finalize here, we end up with Py_Finalize being called from
+//    // We are intentionally NOT calling Py_Finalize here (this would be the
+//    logical place to call it).  Calling
+//    // Py_Finalize here causes test suite runs to seg fault:  The test suite
+//    runs in Python.  It registers
+//    // SBDebugger::Terminate to be called 'at_exit'.  When the test suite
+//    Python harness finishes up, it calls
+//    // Py_Finalize, which calls all the 'at_exit' registered functions.
+//    SBDebugger::Terminate calls Debugger::Terminate,
+//    // which calls lldb::Terminate, which calls ScriptInterpreter::Terminate,
+//    which calls
+//    // ScriptInterpreterPython::Terminate.  So if we call Py_Finalize here, we
+//    end up with Py_Finalize being called from
 //    // within Py_Finalize, which results in a seg fault.
 //    //
-//    // Since this function only gets called when lldb is shutting down and going away anyway, the fact that we don't
-//    // actually call Py_Finalize should not cause any problems (everything should shut down/go away anyway when the
+//    // Since this function only gets called when lldb is shutting down and
+//    going away anyway, the fact that we don't
+//    // actually call Py_Finalize should not cause any problems (everything
+//    should shut down/go away anyway when the
 //    // process exits).
 //    //
 ////    Py_Finalize ();
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h
index 263bb52..7b0e1b0 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h
@@ -24,585 +24,543 @@
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/lldb-private.h"
 #include "PythonDataObjects.h"
+#include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/IOHandler.h"
-#include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Host/Terminal.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/lldb-private.h"
 
 class IOHandlerPythonInterpreter;
 
 namespace lldb_private {
-    
-class ScriptInterpreterPython :
-    public ScriptInterpreter,
-    public IOHandlerDelegateMultiline
-{
+
+class ScriptInterpreterPython : public ScriptInterpreter,
+                                public IOHandlerDelegateMultiline {
 public:
+  class CommandDataPython : public BreakpointOptions::CommandData {
+  public:
+    CommandDataPython() : BreakpointOptions::CommandData() {
+      interpreter = lldb::eScriptLanguagePython;
+    }
+  };
+
 #if PY_MAJOR_VERSION >= 3
-    typedef PyObject*(*SWIGInitCallback) (void);
+  typedef PyObject *(*SWIGInitCallback)(void);
 #else
-    typedef void(*SWIGInitCallback) (void);
+  typedef void (*SWIGInitCallback)(void);
 #endif
 
-    typedef bool (*SWIGBreakpointCallbackFunction) (const char *python_function_name,
-                                                    const char *session_dictionary_name,
-                                                    const lldb::StackFrameSP& frame_sp,
-                                                    const lldb::BreakpointLocationSP &bp_loc_sp);
-    
-    typedef bool (*SWIGWatchpointCallbackFunction) (const char *python_function_name,
-                                                    const char *session_dictionary_name,
-                                                    const lldb::StackFrameSP& frame_sp,
-                                                    const lldb::WatchpointSP &wp_sp);
-    
-    typedef bool (*SWIGPythonTypeScriptCallbackFunction) (const char *python_function_name,
-                                                          void *session_dictionary,
-                                                          const lldb::ValueObjectSP& valobj_sp,
-                                                          void** pyfunct_wrapper,
-                                                          const lldb::TypeSummaryOptionsSP& options,
-                                                          std::string& retval);
-    
-    typedef void* (*SWIGPythonCreateSyntheticProvider) (const char *python_class_name,
-                                                        const char *session_dictionary_name,
-                                                        const lldb::ValueObjectSP& valobj_sp);
-
-    typedef void* (*SWIGPythonCreateCommandObject) (const char *python_class_name,
-                                                    const char *session_dictionary_name,
-                                                    const lldb::DebuggerSP debugger_sp);
-    
-    typedef void* (*SWIGPythonCreateScriptedThreadPlan) (const char *python_class_name,
-                                                        const char *session_dictionary_name,
-                                                        const lldb::ThreadPlanSP& thread_plan_sp);
-
-    typedef bool (*SWIGPythonCallThreadPlan) (void *implementor, const char *method_name, Event *event_sp, bool &got_error);
-
-    typedef void* (*SWIGPythonCreateOSPlugin) (const char *python_class_name,
-                                               const char *session_dictionary_name,
-                                               const lldb::ProcessSP& process_sp);
-    
-    typedef size_t          (*SWIGPythonCalculateNumChildren)                   (void *implementor, uint32_t max);
-
-    typedef void*           (*SWIGPythonGetChildAtIndex)                        (void *implementor, uint32_t idx);
-
-    typedef int             (*SWIGPythonGetIndexOfChildWithName)                (void *implementor, const char* child_name);
-
-    typedef void*           (*SWIGPythonCastPyObjectToSBValue)                  (void* data);
-
-    typedef lldb::ValueObjectSP  (*SWIGPythonGetValueObjectSPFromSBValue)       (void* data);
-
-    typedef bool            (*SWIGPythonUpdateSynthProviderInstance)            (void* data);
-
-    typedef bool            (*SWIGPythonMightHaveChildrenSynthProviderInstance) (void* data);
-
-    typedef void*           (*SWIGPythonGetValueSynthProviderInstance)          (void *implementor);
-    
-    typedef bool            (*SWIGPythonCallCommand)            (const char *python_function_name,
-                                                                 const char *session_dictionary_name,
-                                                                 lldb::DebuggerSP& debugger,
-                                                                 const char* args,
-                                                                 lldb_private::CommandReturnObject& cmd_retobj,
-                                                                 lldb::ExecutionContextRefSP exe_ctx_ref_sp);
-
-    typedef bool            (*SWIGPythonCallCommandObject)        (void *implementor,
-                                                                   lldb::DebuggerSP& debugger,
-                                                                   const char* args,
-                                                                   lldb_private::CommandReturnObject& cmd_retobj,
-                                                                   lldb::ExecutionContextRefSP exe_ctx_ref_sp);
-
-    typedef bool            (*SWIGPythonCallModuleInit)         (const char *python_module_name,
-                                                                 const char *session_dictionary_name,
-                                                                 lldb::DebuggerSP& debugger);
-    
-    typedef bool            (*SWIGPythonScriptKeyword_Process)  (const char* python_function_name,
-                                                                 const char* session_dictionary_name,
-                                                                 lldb::ProcessSP& process,
-                                                                 std::string& output);
-
-    typedef bool            (*SWIGPythonScriptKeyword_Thread)   (const char* python_function_name,
-                                                                 const char* session_dictionary_name,
-                                                                 lldb::ThreadSP& thread,
-                                                                 std::string& output);
-    
-    typedef bool            (*SWIGPythonScriptKeyword_Target)   (const char* python_function_name,
-                                                                 const char* session_dictionary_name,
-                                                                 lldb::TargetSP& target,
-                                                                 std::string& output);
+  typedef bool (*SWIGBreakpointCallbackFunction)(
+      const char *python_function_name, const char *session_dictionary_name,
+      const lldb::StackFrameSP &frame_sp,
+      const lldb::BreakpointLocationSP &bp_loc_sp);
 
-    typedef bool            (*SWIGPythonScriptKeyword_Frame)    (const char* python_function_name,
-                                                                 const char* session_dictionary_name,
-                                                                 lldb::StackFrameSP& frame,
-                                                                 std::string& output);
-
-    typedef bool            (*SWIGPythonScriptKeyword_Value)    (const char* python_function_name,
-                                                                 const char* session_dictionary_name,
-                                                                 lldb::ValueObjectSP& value,
-                                                                 std::string& output);
-    
-    typedef void*           (*SWIGPython_GetDynamicSetting)     (void* module,
-                                                                 const char* setting,
-                                                                 const lldb::TargetSP& target_sp);
-
-    friend class ::IOHandlerPythonInterpreter;
-
-    ScriptInterpreterPython (CommandInterpreter &interpreter);
-
-    ~ScriptInterpreterPython() override;
-
-    bool
-    Interrupt() override;
-
-    bool
-    ExecuteOneLine (const char *command,
-                    CommandReturnObject *result,
-                    const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
-
-    void
-    ExecuteInterpreterLoop () override;
-
-    bool
-    ExecuteOneLineWithReturn (const char *in_string, 
-                              ScriptInterpreter::ScriptReturnType return_type,
-                              void *ret_value,
-                              const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
-
-    lldb_private::Error
-    ExecuteMultipleLines (const char *in_string,
-                          const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
-
-    Error
-    ExportFunctionDefinitionToInterpreter (StringList &function_def) override;
-
-    bool
-    GenerateTypeScriptFunction(StringList &input, std::string& output, const void* name_token = nullptr) override;
-    
-    bool
-    GenerateTypeSynthClass(StringList &input, std::string& output, const void* name_token = nullptr) override;
-    
-    bool
-    GenerateTypeSynthClass(const char* oneliner, std::string& output, const void* name_token = nullptr) override;
-    
-    // use this if the function code is just a one-liner script
-    bool
-    GenerateTypeScriptFunction(const char* oneliner, std::string& output, const void* name_token = nullptr) override;
-    
-    bool
-    GenerateScriptAliasFunction (StringList &input, std::string& output) 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, uint32_t max) 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;
-
-    ConstString GetSyntheticTypeName (const StructuredData::ObjectSP &implementor) override;
-    
-    bool
-    RunScriptBasedCommand(const char* impl_function,
-                          const char* args,
-                          ScriptedCommandSynchronicity synchronicity,
-                          lldb_private::CommandReturnObject& cmd_retobj,
-                          Error& error,
-                          const lldb_private::ExecutionContext& exe_ctx) override;
-    
-    bool
-    RunScriptBasedCommand (StructuredData::GenericSP impl_obj_sp,
-                           const char* args,
-                           ScriptedCommandSynchronicity synchronicity,
-                           lldb_private::CommandReturnObject& cmd_retobj,
-                           Error& error,
-                           const lldb_private::ExecutionContext& exe_ctx) override;
-    
-    Error
-    GenerateFunction(const char *signature, const StringList &input) override;
-    
-    Error
-    GenerateBreakpointCommandCallbackData (StringList &input, std::string& output) override;
-
-    bool
-    GenerateWatchpointCommandCallbackData (StringList &input, std::string& output) override;
-
-//    static size_t
-//    GenerateBreakpointOptionsCommandCallback (void *baton, 
-//                                              InputReader &reader, 
-//                                              lldb::InputReaderAction notification,
-//                                              const char *bytes, 
-//                                              size_t bytes_len);
-//    
-//    static size_t
-//    GenerateWatchpointOptionsCommandCallback (void *baton, 
-//                                              InputReader &reader, 
-//                                              lldb::InputReaderAction notification,
-//                                              const char *bytes, 
-//                                              size_t bytes_len);
-    
-    static bool
-    BreakpointCallbackFunction (void *baton, 
-                                StoppointCallbackContext *context, 
-                                lldb::user_id_t break_id,
-                                lldb::user_id_t break_loc_id);
-    
-    static bool
-    WatchpointCallbackFunction (void *baton, 
-                                StoppointCallbackContext *context, 
-                                lldb::user_id_t watch_id);
-
-    bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj, StructuredData::ObjectSP &callee_wrapper_sp,
-                            const TypeSummaryOptions &options, std::string &retval) override;
-
-    void
-    Clear () override;
-
-    bool
-    GetDocumentationForItem (const char* item, std::string& dest) override;
-    
-    bool
-    GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string& dest) override;
-    
-    uint32_t
-    GetFlagsForCommandObject (StructuredData::GenericSP cmd_obj_sp) override;
-    
-    bool
-    GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp, std::string& dest) override;
-    
-    bool
-    CheckObjectExists (const char* name) override
-    {
-        if (!name || !name[0])
-            return false;
-        std::string temp;
-        return GetDocumentationForItem (name,temp);
-    }
-    
-    bool
-    RunScriptFormatKeyword (const char* impl_function,
-                            Process* process,
-                            std::string& output,
-                            Error& error) override;
-
-    bool
-    RunScriptFormatKeyword (const char* impl_function,
-                            Thread* thread,
-                            std::string& output,
-                            Error& error) override;
-    
-    bool
-    RunScriptFormatKeyword (const char* impl_function,
-                            Target* target,
-                            std::string& output,
-                            Error& error) override;
-    
-    bool
-    RunScriptFormatKeyword (const char* impl_function,
-                            StackFrame* frame,
-                            std::string& output,
-                            Error& error) override;
-    
-    bool
-    RunScriptFormatKeyword (const char* impl_function,
-                            ValueObject* value,
-                            std::string& output,
-                            Error& error) 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;
-
-    std::unique_ptr<ScriptInterpreterLocker>
-    AcquireInterpreterLock () override;
-    
-    void
-    CollectDataForBreakpointCommandCallback (std::vector<BreakpointOptions *> &bp_options_vec,
-                                             CommandReturnObject &result) override;
-
-    void 
-    CollectDataForWatchpointCommandCallback (WatchpointOptions *wp_options,
-                                             CommandReturnObject &result) override;
-
-    /// Set the callback body text into the callback for the breakpoint.
-    Error
-    SetBreakpointCommandCallback (BreakpointOptions *bp_options,
-                                  const char *callback_body) override;
-
-    void 
-    SetBreakpointCommandCallbackFunction (BreakpointOptions *bp_options,
-                                          const char *function_name) override;
-
-    /// Set a one-liner as the callback for the watchpoint.
-    void 
-    SetWatchpointCommandCallback (WatchpointOptions *wp_options,
-                                  const char *oneliner) override;
-
-    StringList
-    ReadCommandInputFromUser (FILE *in_file);
-
-    void ResetOutputFileHandle(FILE *new_fh) override;
-
-    static void
-    InitializePrivate ();
-
-    static void
-    InitializeInterpreter (SWIGInitCallback python_swig_init_callback,
-                           SWIGBreakpointCallbackFunction swig_breakpoint_callback,
-                           SWIGWatchpointCallbackFunction swig_watchpoint_callback,
-                           SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
-                           SWIGPythonCreateSyntheticProvider swig_synthetic_script,
-                           SWIGPythonCreateCommandObject swig_create_cmd,
-                           SWIGPythonCalculateNumChildren swig_calc_children,
-                           SWIGPythonGetChildAtIndex swig_get_child_index,
-                           SWIGPythonGetIndexOfChildWithName swig_get_index_child,
-                           SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue ,
-                           SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
-                           SWIGPythonUpdateSynthProviderInstance swig_update_provider,
-                           SWIGPythonMightHaveChildrenSynthProviderInstance swig_mighthavechildren_provider,
-                           SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
-                           SWIGPythonCallCommand swig_call_command,
-                           SWIGPythonCallCommandObject swig_call_command_object,
-                           SWIGPythonCallModuleInit swig_call_module_init,
-                           SWIGPythonCreateOSPlugin swig_create_os_plugin,
-                           SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
-                           SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
-                           SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
-                           SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
-                           SWIGPythonScriptKeyword_Value swig_run_script_keyword_value,
-                           SWIGPython_GetDynamicSetting swig_plugin_get,
-                           SWIGPythonCreateScriptedThreadPlan swig_thread_plan_script,
-                           SWIGPythonCallThreadPlan swig_call_thread_plan);
-
-    const char *
-    GetDictionaryName ()
-    {
-        return m_dictionary_name.c_str();
-    }
+  typedef bool (*SWIGWatchpointCallbackFunction)(
+      const char *python_function_name, const char *session_dictionary_name,
+      const lldb::StackFrameSP &frame_sp, const lldb::WatchpointSP &wp_sp);
 
-    PyThreadState *
-    GetThreadState()
-    {
-        return m_command_thread_state;
-    }
+  typedef bool (*SWIGPythonTypeScriptCallbackFunction)(
+      const char *python_function_name, void *session_dictionary,
+      const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
+      const lldb::TypeSummaryOptionsSP &options, std::string &retval);
 
-    void
-    SetThreadState (PyThreadState *s)
-    {
-        if (s)
-            m_command_thread_state = s;
-    }
+  typedef void *(*SWIGPythonCreateSyntheticProvider)(
+      const char *python_class_name, const char *session_dictionary_name,
+      const lldb::ValueObjectSP &valobj_sp);
 
-    //----------------------------------------------------------------------
-    // IOHandlerDelegate
-    //----------------------------------------------------------------------
-    void
-    IOHandlerActivated (IOHandler &io_handler) override;
-
-    void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override;
-
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
-    
-    static void
-    Terminate();
-    
-    static lldb::ScriptInterpreterSP
-    CreateInstance(CommandInterpreter &interpreter);
-    
-    static lldb_private::ConstString
-    GetPluginNameStatic();
-    
-    static const char *
-    GetPluginDescriptionStatic();
-    
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
-    
-    uint32_t
-    GetPluginVersion() override;
-
-    class Locker : public ScriptInterpreterLocker
-    {
-    public:
-        enum OnEntry
-        {
-            AcquireLock         = 0x0001,
-            InitSession         = 0x0002,
-            InitGlobals         = 0x0004,
-            NoSTDIN             = 0x0008
-        };
-        
-        enum OnLeave
-        {
-            FreeLock            = 0x0001,
-            FreeAcquiredLock    = 0x0002,    // do not free the lock if we already held it when calling constructor
-            TearDownSession     = 0x0004
-        };
-        
-        Locker(ScriptInterpreterPython *py_interpreter = nullptr,
-               uint16_t on_entry = AcquireLock | InitSession,
-               uint16_t on_leave = FreeLock | TearDownSession,
-               FILE *in = nullptr,
-               FILE *out = nullptr,
-               FILE *err = nullptr);
-        
-        ~Locker () override;
-
-    private:
-        bool
-        DoAcquireLock ();
-        
-        bool
-        DoInitSession (uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
-        
-        bool
-        DoFreeLock ();
-        
-        bool
-        DoTearDownSession ();
-
-        static void
-        ReleasePythonLock ();
-        
-    	bool                     m_teardown_session;
-    	ScriptInterpreterPython *m_python_interpreter;
-//    	FILE*                    m_tmp_fh;
-        PyGILState_STATE         m_GILState;
-    };
+  typedef void *(*SWIGPythonCreateCommandObject)(
+      const char *python_class_name, const char *session_dictionary_name,
+      const lldb::DebuggerSP debugger_sp);
 
-protected:
-    class SynchronicityHandler
-    {
-    private:
-        lldb::DebuggerSP             m_debugger_sp;
-        ScriptedCommandSynchronicity m_synch_wanted;
-        bool                         m_old_asynch;
-
-    public:
-        SynchronicityHandler(lldb::DebuggerSP,
-                             ScriptedCommandSynchronicity);
-
-        ~SynchronicityHandler();
+  typedef void *(*SWIGPythonCreateScriptedThreadPlan)(
+      const char *python_class_name, const char *session_dictionary_name,
+      const lldb::ThreadPlanSP &thread_plan_sp);
+
+  typedef bool (*SWIGPythonCallThreadPlan)(void *implementor,
+                                           const char *method_name,
+                                           Event *event_sp, bool &got_error);
+
+  typedef void *(*SWIGPythonCreateOSPlugin)(const char *python_class_name,
+                                            const char *session_dictionary_name,
+                                            const lldb::ProcessSP &process_sp);
+
+  typedef size_t (*SWIGPythonCalculateNumChildren)(void *implementor,
+                                                   uint32_t max);
+
+  typedef void *(*SWIGPythonGetChildAtIndex)(void *implementor, uint32_t idx);
+
+  typedef int (*SWIGPythonGetIndexOfChildWithName)(void *implementor,
+                                                   const char *child_name);
+
+  typedef void *(*SWIGPythonCastPyObjectToSBValue)(void *data);
+
+  typedef lldb::ValueObjectSP (*SWIGPythonGetValueObjectSPFromSBValue)(
+      void *data);
+
+  typedef bool (*SWIGPythonUpdateSynthProviderInstance)(void *data);
+
+  typedef bool (*SWIGPythonMightHaveChildrenSynthProviderInstance)(void *data);
+
+  typedef void *(*SWIGPythonGetValueSynthProviderInstance)(void *implementor);
+
+  typedef bool (*SWIGPythonCallCommand)(
+      const char *python_function_name, const char *session_dictionary_name,
+      lldb::DebuggerSP &debugger, const char *args,
+      lldb_private::CommandReturnObject &cmd_retobj,
+      lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+
+  typedef bool (*SWIGPythonCallCommandObject)(
+      void *implementor, lldb::DebuggerSP &debugger, const char *args,
+      lldb_private::CommandReturnObject &cmd_retobj,
+      lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+
+  typedef bool (*SWIGPythonCallModuleInit)(const char *python_module_name,
+                                           const char *session_dictionary_name,
+                                           lldb::DebuggerSP &debugger);
+
+  typedef bool (*SWIGPythonScriptKeyword_Process)(
+      const char *python_function_name, const char *session_dictionary_name,
+      lldb::ProcessSP &process, std::string &output);
+
+  typedef bool (*SWIGPythonScriptKeyword_Thread)(
+      const char *python_function_name, const char *session_dictionary_name,
+      lldb::ThreadSP &thread, std::string &output);
+
+  typedef bool (*SWIGPythonScriptKeyword_Target)(
+      const char *python_function_name, const char *session_dictionary_name,
+      lldb::TargetSP &target, std::string &output);
+
+  typedef bool (*SWIGPythonScriptKeyword_Frame)(
+      const char *python_function_name, const char *session_dictionary_name,
+      lldb::StackFrameSP &frame, std::string &output);
+
+  typedef bool (*SWIGPythonScriptKeyword_Value)(
+      const char *python_function_name, const char *session_dictionary_name,
+      lldb::ValueObjectSP &value, std::string &output);
+
+  typedef void *(*SWIGPython_GetDynamicSetting)(
+      void *module, const char *setting, const lldb::TargetSP &target_sp);
+
+  friend class ::IOHandlerPythonInterpreter;
+
+  ScriptInterpreterPython(CommandInterpreter &interpreter);
+
+  ~ScriptInterpreterPython() override;
+
+  bool Interrupt() override;
+
+  bool ExecuteOneLine(
+      const char *command, CommandReturnObject *result,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  void ExecuteInterpreterLoop() override;
+
+  bool ExecuteOneLineWithReturn(
+      const char *in_string, ScriptInterpreter::ScriptReturnType return_type,
+      void *ret_value,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  lldb_private::Error ExecuteMultipleLines(
+      const char *in_string,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  Error
+  ExportFunctionDefinitionToInterpreter(StringList &function_def) override;
+
+  bool GenerateTypeScriptFunction(StringList &input, std::string &output,
+                                  const void *name_token = nullptr) override;
+
+  bool GenerateTypeSynthClass(StringList &input, std::string &output,
+                              const void *name_token = nullptr) override;
+
+  bool GenerateTypeSynthClass(const char *oneliner, std::string &output,
+                              const void *name_token = nullptr) override;
+
+  // use this if the function code is just a one-liner script
+  bool GenerateTypeScriptFunction(const char *oneliner, std::string &output,
+                                  const void *name_token = nullptr) override;
+
+  bool GenerateScriptAliasFunction(StringList &input,
+                                   std::string &output) 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;
+
+  bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp,
+                                 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,
+                              uint32_t max) 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;
+
+  ConstString
+  GetSyntheticTypeName(const StructuredData::ObjectSP &implementor) override;
+
+  bool
+  RunScriptBasedCommand(const char *impl_function, const char *args,
+                        ScriptedCommandSynchronicity synchronicity,
+                        lldb_private::CommandReturnObject &cmd_retobj,
+                        Error &error,
+                        const lldb_private::ExecutionContext &exe_ctx) override;
+
+  bool
+  RunScriptBasedCommand(StructuredData::GenericSP impl_obj_sp, const char *args,
+                        ScriptedCommandSynchronicity synchronicity,
+                        lldb_private::CommandReturnObject &cmd_retobj,
+                        Error &error,
+                        const lldb_private::ExecutionContext &exe_ctx) override;
+
+  Error GenerateFunction(const char *signature,
+                         const StringList &input) override;
+
+  Error GenerateBreakpointCommandCallbackData(StringList &input,
+                                              std::string &output) override;
+
+  bool GenerateWatchpointCommandCallbackData(StringList &input,
+                                             std::string &output) override;
+
+  //    static size_t
+  //    GenerateBreakpointOptionsCommandCallback (void *baton,
+  //                                              InputReader &reader,
+  //                                              lldb::InputReaderAction
+  //                                              notification,
+  //                                              const char *bytes,
+  //                                              size_t bytes_len);
+  //
+  //    static size_t
+  //    GenerateWatchpointOptionsCommandCallback (void *baton,
+  //                                              InputReader &reader,
+  //                                              lldb::InputReaderAction
+  //                                              notification,
+  //                                              const char *bytes,
+  //                                              size_t bytes_len);
+
+  static bool BreakpointCallbackFunction(void *baton,
+                                         StoppointCallbackContext *context,
+                                         lldb::user_id_t break_id,
+                                         lldb::user_id_t break_loc_id);
+
+  static bool WatchpointCallbackFunction(void *baton,
+                                         StoppointCallbackContext *context,
+                                         lldb::user_id_t watch_id);
+
+  bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj,
+                          StructuredData::ObjectSP &callee_wrapper_sp,
+                          const TypeSummaryOptions &options,
+                          std::string &retval) override;
+
+  void Clear() override;
+
+  bool GetDocumentationForItem(const char *item, std::string &dest) override;
+
+  bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
+                                    std::string &dest) override;
+
+  uint32_t
+  GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp) override;
+
+  bool GetLongHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
+                                   std::string &dest) override;
+
+  bool CheckObjectExists(const char *name) override {
+    if (!name || !name[0])
+      return false;
+    std::string temp;
+    return GetDocumentationForItem(name, temp);
+  }
+
+  bool RunScriptFormatKeyword(const char *impl_function, Process *process,
+                              std::string &output, Error &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
+                              std::string &output, Error &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, Target *target,
+                              std::string &output, Error &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, StackFrame *frame,
+                              std::string &output, Error &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, ValueObject *value,
+                              std::string &output, Error &error) 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;
+
+  std::unique_ptr<ScriptInterpreterLocker> AcquireInterpreterLock() override;
+
+  void CollectDataForBreakpointCommandCallback(
+      std::vector<BreakpointOptions *> &bp_options_vec,
+      CommandReturnObject &result) override;
+
+  void
+  CollectDataForWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                          CommandReturnObject &result) override;
+
+  /// Set the callback body text into the callback for the breakpoint.
+  Error SetBreakpointCommandCallback(BreakpointOptions *bp_options,
+                                     const char *callback_body) override;
+
+  void SetBreakpointCommandCallbackFunction(BreakpointOptions *bp_options,
+                                            const char *function_name) override;
+
+  /// This one is for deserialization:
+  Error SetBreakpointCommandCallback(
+      BreakpointOptions *bp_options,
+      std::unique_ptr<BreakpointOptions::CommandData> &data_up) override;
+
+  /// Set a one-liner as the callback for the watchpoint.
+  void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                    const char *oneliner) override;
+
+  StringList ReadCommandInputFromUser(FILE *in_file);
+
+  void ResetOutputFileHandle(FILE *new_fh) override;
+
+  static void InitializePrivate();
+
+  static void InitializeInterpreter(
+      SWIGInitCallback python_swig_init_callback,
+      SWIGBreakpointCallbackFunction swig_breakpoint_callback,
+      SWIGWatchpointCallbackFunction swig_watchpoint_callback,
+      SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
+      SWIGPythonCreateSyntheticProvider swig_synthetic_script,
+      SWIGPythonCreateCommandObject swig_create_cmd,
+      SWIGPythonCalculateNumChildren swig_calc_children,
+      SWIGPythonGetChildAtIndex swig_get_child_index,
+      SWIGPythonGetIndexOfChildWithName swig_get_index_child,
+      SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue,
+      SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
+      SWIGPythonUpdateSynthProviderInstance swig_update_provider,
+      SWIGPythonMightHaveChildrenSynthProviderInstance
+          swig_mighthavechildren_provider,
+      SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
+      SWIGPythonCallCommand swig_call_command,
+      SWIGPythonCallCommandObject swig_call_command_object,
+      SWIGPythonCallModuleInit swig_call_module_init,
+      SWIGPythonCreateOSPlugin swig_create_os_plugin,
+      SWIGPythonScriptKeyword_Process swig_run_script_keyword_process,
+      SWIGPythonScriptKeyword_Thread swig_run_script_keyword_thread,
+      SWIGPythonScriptKeyword_Target swig_run_script_keyword_target,
+      SWIGPythonScriptKeyword_Frame swig_run_script_keyword_frame,
+      SWIGPythonScriptKeyword_Value swig_run_script_keyword_value,
+      SWIGPython_GetDynamicSetting swig_plugin_get,
+      SWIGPythonCreateScriptedThreadPlan swig_thread_plan_script,
+      SWIGPythonCallThreadPlan swig_call_thread_plan);
+
+  const char *GetDictionaryName() { return m_dictionary_name.c_str(); }
+
+  PyThreadState *GetThreadState() { return m_command_thread_state; }
+
+  void SetThreadState(PyThreadState *s) {
+    if (s)
+      m_command_thread_state = s;
+  }
+
+  //----------------------------------------------------------------------
+  // IOHandlerDelegate
+  //----------------------------------------------------------------------
+  void IOHandlerActivated(IOHandler &io_handler) override;
+
+  void IOHandlerInputComplete(IOHandler &io_handler,
+                              std::string &data) override;
+
+  //------------------------------------------------------------------
+  // Static Functions
+  //------------------------------------------------------------------
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb::ScriptInterpreterSP
+  CreateInstance(CommandInterpreter &interpreter);
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  static const char *GetPluginDescriptionStatic();
+
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+  class Locker : public ScriptInterpreterLocker {
+  public:
+    enum OnEntry {
+      AcquireLock = 0x0001,
+      InitSession = 0x0002,
+      InitGlobals = 0x0004,
+      NoSTDIN = 0x0008
     };
-    
-    enum class AddLocation
-    {
-        Beginning,
-        End
+
+    enum OnLeave {
+      FreeLock = 0x0001,
+      FreeAcquiredLock = 0x0002, // do not free the lock if we already held it
+                                 // when calling constructor
+      TearDownSession = 0x0004
     };
 
-    static void AddToSysPath(AddLocation location, std::string path);
+    Locker(ScriptInterpreterPython *py_interpreter = nullptr,
+           uint16_t on_entry = AcquireLock | InitSession,
+           uint16_t on_leave = FreeLock | TearDownSession, FILE *in = nullptr,
+           FILE *out = nullptr, FILE *err = nullptr);
 
-    bool
-    EnterSession(uint16_t on_entry_flags,
-                 FILE *in,
-                 FILE *out,
-                 FILE *err);
+    ~Locker() override;
 
-    void
-    LeaveSession();
+  private:
+    bool DoAcquireLock();
 
-    void
-    SaveTerminalState(int fd);
+    bool DoInitSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
 
-    void
-    RestoreTerminalState();
+    bool DoFreeLock();
 
-    uint32_t
-    IsExecutingPython () const
-    {
-        return m_lock_count > 0;
-    }
+    bool DoTearDownSession();
 
-    uint32_t
-    IncrementLockCount()
-    {
-        return ++m_lock_count;
-    }
+    static void ReleasePythonLock();
 
-    uint32_t
-    DecrementLockCount()
-    {
-        if (m_lock_count > 0)
-            --m_lock_count;
-        return m_lock_count;
-    }
+    bool m_teardown_session;
+    ScriptInterpreterPython *m_python_interpreter;
+    //    	FILE*                    m_tmp_fh;
+    PyGILState_STATE m_GILState;
+  };
 
-    enum ActiveIOHandler {
-        eIOHandlerNone,
-        eIOHandlerBreakpoint,
-        eIOHandlerWatchpoint
-    };
+protected:
+  class SynchronicityHandler {
+  private:
+    lldb::DebuggerSP m_debugger_sp;
+    ScriptedCommandSynchronicity m_synch_wanted;
+    bool m_old_asynch;
+
+  public:
+    SynchronicityHandler(lldb::DebuggerSP, ScriptedCommandSynchronicity);
+
+    ~SynchronicityHandler();
+  };
+
+  enum class AddLocation { Beginning, End };
+
+  static void AddToSysPath(AddLocation location, std::string path);
+
+  bool EnterSession(uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
+
+  void LeaveSession();
+
+  void SaveTerminalState(int fd);
+
+  void RestoreTerminalState();
+
+  uint32_t IsExecutingPython() const { return m_lock_count > 0; }
+
+  uint32_t IncrementLockCount() { return ++m_lock_count; }
+
+  uint32_t DecrementLockCount() {
+    if (m_lock_count > 0)
+      --m_lock_count;
+    return m_lock_count;
+  }
+
+  enum ActiveIOHandler {
+    eIOHandlerNone,
+    eIOHandlerBreakpoint,
+    eIOHandlerWatchpoint
+  };
+
+  PythonObject &GetMainModule();
+
+  PythonDictionary &GetSessionDictionary();
+
+  PythonDictionary &GetSysModuleDictionary();
+
+  bool GetEmbeddedInterpreterModuleObjects();
+
+  bool SetStdHandle(File &file, const char *py_name, PythonFile &save_file,
+                    const char *mode);
 
-    PythonObject &GetMainModule();
-
-    PythonDictionary &
-    GetSessionDictionary ();
-    
-    PythonDictionary &
-    GetSysModuleDictionary ();
-
-    bool
-    GetEmbeddedInterpreterModuleObjects ();
-
-    bool
-    SetStdHandle(File &file, const char *py_name, PythonFile &save_file, const char *mode);
-
-    PythonFile m_saved_stdin;
-    PythonFile m_saved_stdout;
-    PythonFile m_saved_stderr;
-    PythonObject m_main_module;
-    PythonObject m_lldb_module;
-    PythonDictionary m_session_dict;
-    PythonDictionary m_sys_module_dict;
-    PythonObject m_run_one_line_function;
-    PythonObject m_run_one_line_str_global;
-    std::string m_dictionary_name;
-    TerminalState m_terminal_state;
-    ActiveIOHandler m_active_io_handler;
-    bool m_session_is_active;
-    bool m_pty_slave_is_open;
-    bool m_valid_session;
-    uint32_t m_lock_count;
-    PyThreadState *m_command_thread_state;
+  PythonFile m_saved_stdin;
+  PythonFile m_saved_stdout;
+  PythonFile m_saved_stderr;
+  PythonObject m_main_module;
+  PythonObject m_lldb_module;
+  PythonDictionary m_session_dict;
+  PythonDictionary m_sys_module_dict;
+  PythonObject m_run_one_line_function;
+  PythonObject m_run_one_line_str_global;
+  std::string m_dictionary_name;
+  TerminalState m_terminal_state;
+  ActiveIOHandler m_active_io_handler;
+  bool m_session_is_active;
+  bool m_pty_slave_is_open;
+  bool m_valid_session;
+  uint32_t m_lock_count;
+  PyThreadState *m_command_thread_state;
 };
 
 } // namespace lldb_private
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h
index 013492c..ee13b7a 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h
@@ -1,4 +1,5 @@
-//===-- lldb-python.h --------------------------------------------*- C++ -*-===//
+//===-- lldb-python.h --------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -10,11 +11,20 @@
 #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H
 #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H
 
-// Python.h needs to be included before any system headers in order to avoid redefinition of macros
+// Python.h needs to be included before any system headers in order to avoid
+// redefinition of macros
 
 #ifdef LLDB_DISABLE_PYTHON
 // Python is disabled in this build
 #else
+#include "llvm/Support/Compiler.h"
+#if defined(LLVM_ON_WIN32)
+// If anyone #includes Host/PosixApi.h later, it will try to typedef pid_t.  We
+// need to ensure this doesn't happen.  At the same time, Python.h will also try
+// to redefine a bunch of stuff that PosixApi.h defines.  So define it all now
+// so that PosixApi.h doesn't redefine it.
+#define NO_PID_T
+#endif
 #if defined(__linux__)
 // features.h will define _POSIX_C_SOURCE if _GNU_SOURCE is defined.  This value
 // may be different from the value that Python defines it to be which results