Import LLVM 10.0.0 release including clang, lld and lldb.

ok hackroom
tested by plenty

9 files changed, 6357 insertions, 0 deletions

diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt
new file mode 100644
index 00000000000..761772f3a37
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt
@@ -0,0 +1,33 @@
+if(NOT LLDB_PYTHON_RELATIVE_PATH)
+  message(FATAL_ERROR "LLDB_PYTHON_RELATIVE_PATH is not set.")
+endif()
+add_definitions(-DLLDB_PYTHON_RELATIVE_LIBDIR="${LLDB_PYTHON_RELATIVE_PATH}")
+
+if (LLDB_ENABLE_LIBEDIT)
+  list(APPEND LLDB_LIBEDIT_LIBS ${LibEdit_LIBRARIES})
+endif()
+
+add_lldb_library(lldbPluginScriptInterpreterPython PLUGIN
+  PythonDataObjects.cpp
+  PythonReadline.cpp
+  ScriptInterpreterPython.cpp
+
+  LINK_LIBS
+    lldbBreakpoint
+    lldbCore
+    lldbDataFormatters
+    lldbHost
+    lldbInterpreter
+    lldbTarget
+    ${PYTHON_LIBRARIES}
+    ${LLDB_LIBEDIT_LIBS}
+
+  LINK_COMPONENTS
+    Support
+  )
+
+if (LLDB_ENABLE_LIBEDIT)
+  target_include_directories(lldbPluginScriptInterpreterPython PUBLIC
+    ${LibEdit_INCLUDE_DIRS}
+  )
+endif()
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
new file mode 100644
index 00000000000..e5a67653e33
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
@@ -0,0 +1,1570 @@
+//===-- PythonDataObjects.cpp -----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+#include "PythonDataObjects.h"
+#include "ScriptInterpreterPython.h"
+
+#include "lldb/Host/File.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Stream.h"
+
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Errno.h"
+
+#include <stdio.h>
+
+using namespace lldb_private;
+using namespace lldb;
+using namespace lldb_private::python;
+using llvm::cantFail;
+using llvm::Error;
+using llvm::Expected;
+using llvm::Twine;
+
+template <> Expected<bool> python::As<bool>(Expected<PythonObject> &&obj) {
+  if (!obj)
+    return obj.takeError();
+  return obj.get().IsTrue();
+}
+
+template <>
+Expected<long long> python::As<long long>(Expected<PythonObject> &&obj) {
+  if (!obj)
+    return obj.takeError();
+  return obj.get().AsLongLong();
+}
+
+template <>
+Expected<std::string> python::As<std::string>(Expected<PythonObject> &&obj) {
+  if (!obj)
+    return obj.takeError();
+  PyObject *str_obj = PyObject_Str(obj.get().get());
+  if (!obj)
+    return llvm::make_error<PythonException>();
+  auto str = Take<PythonString>(str_obj);
+  auto utf8 = str.AsUTF8();
+  if (!utf8)
+    return utf8.takeError();
+  return utf8.get();
+}
+
+void StructuredPythonObject::Serialize(llvm::json::OStream &s) const {
+  s.value(llvm::formatv("Python Obj: {0:X}", GetValue()).str());
+}
+
+// PythonObject
+
+void PythonObject::Dump(Stream &strm) const {
+  if (m_py_obj) {
+    FILE *file = llvm::sys::RetryAfterSignal(nullptr, ::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;
+#if PY_MAJOR_VERSION >= 3
+  if (PythonBytes::Check(m_py_obj))
+    return PyObjectType::Bytes;
+#endif
+  if (PythonByteArray::Check(m_py_obj))
+    return PyObjectType::ByteArray;
+  if (PythonBoolean::Check(m_py_obj))
+    return PyObjectType::Boolean;
+  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('.');
+  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('.');
+  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();
+
+  // Tail recursion.. should be optimized by the compiler
+  return parent.ResolveName(name.substr(dot_pos + 1));
+}
+
+bool PythonObject::HasAttribute(llvm::StringRef attr) const {
+  if (!IsValid())
+    return false;
+  PythonString py_attr(attr);
+  return !!PyObject_HasAttr(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()));
+}
+
+StructuredData::ObjectSP PythonObject::CreateStructuredObject() const {
+  switch (GetObjectType()) {
+  case PyObjectType::Dictionary:
+    return PythonDictionary(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredDictionary();
+  case PyObjectType::Boolean:
+    return PythonBoolean(PyRefType::Borrowed, m_py_obj)
+        .CreateStructuredBoolean();
+  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(llvm::ArrayRef<uint8_t> bytes) { SetBytes(bytes); }
+
+PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) {
+  SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
+}
+
+bool PythonBytes::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyBytes_Check(py_obj);
+}
+
+llvm::ArrayRef<uint8_t> PythonBytes::GetBytes() const {
+  if (!IsValid())
+    return llvm::ArrayRef<uint8_t>();
+
+  Py_ssize_t size;
+  char *c;
+
+  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);
+}
+
+void PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes) {
+  const char *data = reinterpret_cast<const char *>(bytes.data());
+  *this = Take<PythonBytes>(PyBytes_FromStringAndSize(data, bytes.size()));
+}
+
+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(const uint8_t *bytes, size_t length) {
+  const char *str = reinterpret_cast<const char *>(bytes);
+  *this = Take<PythonByteArray>(PyByteArray_FromStringAndSize(str, length));
+}
+
+bool PythonByteArray::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyByteArray_Check(py_obj);
+}
+
+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);
+}
+
+size_t PythonByteArray::GetSize() const {
+  if (!IsValid())
+    return 0;
+
+  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;
+}
+
+// PythonString
+
+Expected<PythonString> PythonString::FromUTF8(llvm::StringRef string) {
+#if PY_MAJOR_VERSION >= 3
+  PyObject *str = PyUnicode_FromStringAndSize(string.data(), string.size());
+#else
+  PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
+#endif
+  if (!str)
+    return llvm::make_error<PythonException>();
+  return Take<PythonString>(str);
+}
+
+PythonString::PythonString(llvm::StringRef string) { SetString(string); }
+
+bool PythonString::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+
+  if (PyUnicode_Check(py_obj))
+    return true;
+#if PY_MAJOR_VERSION < 3
+  if (PyString_Check(py_obj))
+    return true;
+#endif
+  return false;
+}
+
+void PythonString::Convert(PyRefType &type, PyObject *&py_obj) {
+#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)) {
+    PyObject *s = PyUnicode_AsUTF8String(py_obj);
+    if (s == nullptr) {
+      PyErr_Clear();
+      if (type == PyRefType::Owned)
+        Py_DECREF(py_obj);
+      return;
+    }
+    if (type == PyRefType::Owned)
+      Py_DECREF(py_obj);
+    else
+      type = PyRefType::Owned;
+    py_obj = s;
+  }
+#endif
+}
+
+llvm::StringRef PythonString::GetString() const {
+  auto s = AsUTF8();
+  if (!s) {
+    llvm::consumeError(s.takeError());
+    return llvm::StringRef("");
+  }
+  return s.get();
+}
+
+Expected<llvm::StringRef> PythonString::AsUTF8() const {
+  if (!IsValid())
+    return nullDeref();
+
+  Py_ssize_t size;
+  const char *data;
+
+#if PY_MAJOR_VERSION >= 3
+  data = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
+#else
+  char *c = NULL;
+  int r = PyString_AsStringAndSize(m_py_obj, &c, &size);
+  if (r < 0)
+    c = NULL;
+  data = c;
+#endif
+
+  if (!data)
+    return exception();
+
+  return llvm::StringRef(data, size);
+}
+
+size_t PythonString::GetSize() const {
+  if (IsValid()) {
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_GetSize(m_py_obj);
+#else
+    return PyString_Size(m_py_obj);
+#endif
+  }
+  return 0;
+}
+
+void PythonString::SetString(llvm::StringRef string) {
+  auto s = FromUTF8(string);
+  if (!s) {
+    llvm::consumeError(s.takeError());
+    Reset();
+  } else {
+    *this = std::move(s.get());
+  }
+}
+
+StructuredData::StringSP PythonString::CreateStructuredString() const {
+  StructuredData::StringSP result(new StructuredData::String);
+  result->SetValue(GetString());
+  return result;
+}
+
+// PythonInteger
+
+PythonInteger::PythonInteger(int64_t value) { SetInteger(value); }
+
+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);
+#else
+  return PyLong_Check(py_obj) || PyInt_Check(py_obj);
+#endif
+}
+
+void PythonInteger::Convert(PyRefType &type, PyObject *&py_obj) {
+#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.
+    long long value = PyInt_AsLong(py_obj);
+    PyObject *l = nullptr;
+    if (!PyErr_Occurred())
+      l = PyLong_FromLongLong(value);
+    if (l == nullptr) {
+      PyErr_Clear();
+      if (type == PyRefType::Owned)
+        Py_DECREF(py_obj);
+      return;
+    }
+    if (type == PyRefType::Owned)
+      Py_DECREF(py_obj);
+    else
+      type = PyRefType::Owned;
+    py_obj = l;
+  }
+#endif
+}
+
+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 result;
+  }
+  return UINT64_MAX;
+}
+
+void PythonInteger::SetInteger(int64_t value) {
+  *this = Take<PythonInteger>(PyLong_FromLongLong(value));
+}
+
+StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
+  StructuredData::IntegerSP result(new StructuredData::Integer);
+  result->SetValue(GetInteger());
+  return result;
+}
+
+// PythonBoolean
+
+PythonBoolean::PythonBoolean(bool value) {
+  SetValue(value);
+}
+
+bool PythonBoolean::Check(PyObject *py_obj) {
+  return py_obj ? PyBool_Check(py_obj) : false;
+}
+
+bool PythonBoolean::GetValue() const {
+  return m_py_obj ? PyObject_IsTrue(m_py_obj) : false;
+}
+
+void PythonBoolean::SetValue(bool value) {
+  *this = Take<PythonBoolean>(PyBool_FromLong(value));
+}
+
+StructuredData::BooleanSP PythonBoolean::CreateStructuredBoolean() const {
+  StructuredData::BooleanSP result(new StructuredData::Boolean);
+  result->SetValue(GetValue());
+  return result;
+}
+
+// PythonList
+
+PythonList::PythonList(PyInitialValue value) {
+  if (value == PyInitialValue::Empty)
+    *this = Take<PythonList>(PyList_New(0));
+}
+
+PythonList::PythonList(int list_size) {
+  *this = Take<PythonList>(PyList_New(list_size));
+}
+
+bool PythonList::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyList_Check(py_obj);
+}
+
+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();
+}
+
+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());
+  }
+}
+
+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) {
+  if (value == PyInitialValue::Empty)
+    *this = Take<PythonTuple>(PyTuple_New(0));
+}
+
+PythonTuple::PythonTuple(int tuple_size) {
+  *this = Take<PythonTuple>(PyTuple_New(tuple_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++;
+  }
+}
+
+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++;
+  }
+}
+
+bool PythonTuple::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+  return PyTuple_Check(py_obj);
+}
+
+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();
+}
+
+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;
+}
+
+// PythonDictionary
+
+PythonDictionary::PythonDictionary(PyInitialValue value) {
+  if (value == PyInitialValue::Empty)
+    *this = Take<PythonDictionary>(PyDict_New());
+}
+
+bool PythonDictionary::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+
+  return PyDict_Check(py_obj);
+}
+
+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);
+}
+
+PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
+  auto item = GetItem(key);
+  if (!item) {
+    llvm::consumeError(item.takeError());
+    return PythonObject();
+  }
+  return std::move(item.get());
+}
+
+Expected<PythonObject>
+PythonDictionary::GetItem(const PythonObject &key) const {
+  if (!IsValid())
+    return nullDeref();
+#if PY_MAJOR_VERSION >= 3
+  PyObject *o = PyDict_GetItemWithError(m_py_obj, key.get());
+  if (PyErr_Occurred())
+    return exception();
+#else
+  PyObject *o = PyDict_GetItem(m_py_obj, key.get());
+#endif
+  if (!o)
+    return keyError();
+  return Retain<PythonObject>(o);
+}
+
+Expected<PythonObject> PythonDictionary::GetItem(const Twine &key) const {
+  if (!IsValid())
+    return nullDeref();
+  PyObject *o = PyDict_GetItemString(m_py_obj, NullTerminated(key));
+  if (PyErr_Occurred())
+    return exception();
+  if (!o)
+    return keyError();
+  return Retain<PythonObject>(o);
+}
+
+Error PythonDictionary::SetItem(const PythonObject &key,
+                                const PythonObject &value) const {
+  if (!IsValid() || !value.IsValid())
+    return nullDeref();
+  int r = PyDict_SetItem(m_py_obj, key.get(), value.get());
+  if (r < 0)
+    return exception();
+  return Error::success();
+}
+
+Error PythonDictionary::SetItem(const Twine &key,
+                                const PythonObject &value) const {
+  if (!IsValid() || !value.IsValid())
+    return nullDeref();
+  int r = PyDict_SetItemString(m_py_obj, NullTerminated(key), value.get());
+  if (r < 0)
+    return exception();
+  return Error::success();
+}
+
+void PythonDictionary::SetItemForKey(const PythonObject &key,
+                                     const PythonObject &value) {
+  Error error = SetItem(key, value);
+  if (error)
+    llvm::consumeError(std::move(error));
+}
+
+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;
+}
+
+PythonModule PythonModule::BuiltinsModule() {
+#if PY_MAJOR_VERSION >= 3
+  return AddModule("builtins");
+#else
+  return AddModule("__builtin__");
+#endif
+}
+
+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()));
+}
+
+Expected<PythonModule> PythonModule::Import(const Twine &name) {
+  PyObject *mod = PyImport_ImportModule(NullTerminated(name));
+  if (!mod)
+    return exception();
+  return Take<PythonModule>(mod);
+}
+
+Expected<PythonObject> PythonModule::Get(const Twine &name) {
+  if (!IsValid())
+    return nullDeref();
+  PyObject *dict = PyModule_GetDict(m_py_obj);
+  if (!dict)
+    return exception();
+  PyObject *item = PyDict_GetItemString(dict, NullTerminated(name));
+  if (!item)
+    return exception();
+  return Retain<PythonObject>(item);
+}
+
+bool PythonModule::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+
+  return PyModule_Check(py_obj);
+}
+
+PythonDictionary PythonModule::GetDictionary() const {
+  if (!IsValid())
+    return PythonDictionary();
+  return Retain<PythonDictionary>(PyModule_GetDict(m_py_obj));
+}
+
+bool PythonCallable::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+
+  return PyCallable_Check(py_obj);
+}
+
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
+static const char get_arg_info_script[] = R"(
+from inspect import signature, Parameter, ismethod
+from collections import namedtuple
+ArgInfo = namedtuple('ArgInfo', ['count', 'has_varargs'])
+def main(f):
+    count = 0
+    varargs = False
+    for parameter in signature(f).parameters.values():
+        kind = parameter.kind
+        if kind in (Parameter.POSITIONAL_ONLY,
+                    Parameter.POSITIONAL_OR_KEYWORD):
+            count += 1
+        elif kind == Parameter.VAR_POSITIONAL:
+            varargs = True
+        elif kind in (Parameter.KEYWORD_ONLY,
+                      Parameter.VAR_KEYWORD):
+            pass
+        else:
+            raise Exception(f'unknown parameter kind: {kind}')
+    return ArgInfo(count, varargs)
+)";
+#endif
+
+Expected<PythonCallable::ArgInfo> PythonCallable::GetArgInfo() const {
+  ArgInfo result = {};
+  if (!IsValid())
+    return nullDeref();
+
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
+
+  // no need to synchronize access to this global, we already have the GIL
+  static PythonScript get_arg_info(get_arg_info_script);
+  Expected<PythonObject> pyarginfo = get_arg_info(*this);
+  if (!pyarginfo)
+    return pyarginfo.takeError();
+  long long count =
+      cantFail(As<long long>(pyarginfo.get().GetAttribute("count")));
+  bool has_varargs =
+      cantFail(As<bool>(pyarginfo.get().GetAttribute("has_varargs")));
+  result.max_positional_args = has_varargs ? ArgInfo::UNBOUNDED : count;
+
+#else
+  PyObject *py_func_obj;
+  bool is_bound_method = false;
+  bool is_class = false;
+
+  if (PyType_Check(m_py_obj) || PyClass_Check(m_py_obj)) {
+    auto init = GetAttribute("__init__");
+    if (!init)
+      return init.takeError();
+    py_func_obj = init.get().get();
+    is_class = true;
+  } else {
+    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())
+      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 = __callable__.GetAttributeValue("im_self");
+          if (im_self.IsValid() && !im_self.IsNone())
+            is_bound_method = true;
+        }
+      }
+    }
+  }
+
+  if (!py_func_obj)
+    return result;
+
+  PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(py_func_obj);
+  if (!code)
+    return result;
+
+  auto count = code->co_argcount;
+  bool has_varargs = !!(code->co_flags & CO_VARARGS);
+  result.max_positional_args =
+      has_varargs ? ArgInfo::UNBOUNDED
+                  : (count - (int)is_bound_method) - (int)is_class;
+
+#endif
+
+  return result;
+}
+
+constexpr unsigned
+    PythonCallable::ArgInfo::UNBOUNDED; // FIXME delete after c++17
+
+PythonObject PythonCallable::operator()() {
+  return PythonObject(PyRefType::Owned, PyObject_CallObject(m_py_obj, nullptr));
+}
+
+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()(std::initializer_list<PythonObject> args) {
+  PythonTuple arg_tuple(args);
+  return PythonObject(PyRefType::Owned,
+                      PyObject_CallObject(m_py_obj, arg_tuple.get()));
+}
+
+bool PythonFile::Check(PyObject *py_obj) {
+  if (!py_obj)
+    return false;
+#if PY_MAJOR_VERSION < 3
+  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`.
+  auto io_module = PythonModule::Import("io");
+  if (!io_module) {
+    llvm::consumeError(io_module.takeError());
+    return false;
+  }
+  auto iobase = io_module.get().Get("IOBase");
+  if (!iobase) {
+    llvm::consumeError(iobase.takeError());
+    return false;
+  }
+  int r = PyObject_IsInstance(py_obj, iobase.get().get());
+  if (r < 0) {
+    llvm::consumeError(exception()); // clear the exception and log it.
+    return false;
+  }
+  return !!r;
+#endif
+}
+
+namespace {
+class GIL {
+public:
+  GIL() {
+    m_state = PyGILState_Ensure();
+    assert(!PyErr_Occurred());
+  }
+  ~GIL() { PyGILState_Release(m_state); }
+
+protected:
+  PyGILState_STATE m_state;
+};
+} // namespace
+
+const char *PythonException::toCString() const {
+  if (!m_repr_bytes)
+    return "unknown exception";
+  return PyBytes_AS_STRING(m_repr_bytes);
+}
+
+PythonException::PythonException(const char *caller) {
+  assert(PyErr_Occurred());
+  m_exception_type = m_exception = m_traceback = m_repr_bytes = NULL;
+  PyErr_Fetch(&m_exception_type, &m_exception, &m_traceback);
+  PyErr_NormalizeException(&m_exception_type, &m_exception, &m_traceback);
+  PyErr_Clear();
+  if (m_exception) {
+    PyObject *repr = PyObject_Repr(m_exception);
+    if (repr) {
+      m_repr_bytes = PyUnicode_AsEncodedString(repr, "utf-8", nullptr);
+      if (!m_repr_bytes) {
+        PyErr_Clear();
+      }
+      Py_XDECREF(repr);
+    } else {
+      PyErr_Clear();
+    }
+  }
+  Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT);
+  if (caller)
+    LLDB_LOGF(log, "%s failed with exception: %s", caller, toCString());
+  else
+    LLDB_LOGF(log, "python exception: %s", toCString());
+}
+void PythonException::Restore() {
+  if (m_exception_type && m_exception) {
+    PyErr_Restore(m_exception_type, m_exception, m_traceback);
+  } else {
+    PyErr_SetString(PyExc_Exception, toCString());
+  }
+  m_exception_type = m_exception = m_traceback = NULL;
+}
+
+PythonException::~PythonException() {
+  Py_XDECREF(m_exception_type);
+  Py_XDECREF(m_exception);
+  Py_XDECREF(m_traceback);
+  Py_XDECREF(m_repr_bytes);
+}
+
+void PythonException::log(llvm::raw_ostream &OS) const { OS << toCString(); }
+
+std::error_code PythonException::convertToErrorCode() const {
+  return llvm::inconvertibleErrorCode();
+}
+
+bool PythonException::Matches(PyObject *exc) const {
+  return PyErr_GivenExceptionMatches(m_exception_type, exc);
+}
+
+const char read_exception_script[] = R"(
+import sys
+from traceback import print_exception
+if sys.version_info.major < 3:
+  from StringIO import StringIO
+else:
+  from io import StringIO
+def main(exc_type, exc_value, tb):
+  f = StringIO()
+  print_exception(exc_type, exc_value, tb, file=f)
+  return f.getvalue()
+)";
+
+std::string PythonException::ReadBacktrace() const {
+
+  if (!m_traceback)
+    return toCString();
+
+  // no need to synchronize access to this global, we already have the GIL
+  static PythonScript read_exception(read_exception_script);
+
+  Expected<std::string> backtrace = As<std::string>(
+      read_exception(m_exception_type, m_exception, m_traceback));
+
+  if (!backtrace) {
+    std::string message =
+        std::string(toCString()) + "\n" +
+        "Traceback unavailble, an error occurred while reading it:\n";
+    return (message + llvm::toString(backtrace.takeError()));
+  }
+
+  return std::move(backtrace.get());
+}
+
+char PythonException::ID = 0;
+
+llvm::Expected<File::OpenOptions>
+GetOptionsForPyObject(const PythonObject &obj) {
+#if PY_MAJOR_VERSION >= 3
+  auto options = File::OpenOptions(0);
+  auto readable = As<bool>(obj.CallMethod("readable"));
+  if (!readable)
+    return readable.takeError();
+  auto writable = As<bool>(obj.CallMethod("writable"));
+  if (!writable)
+    return writable.takeError();
+  if (readable.get())
+    options |= File::eOpenOptionRead;
+  if (writable.get())
+    options |= File::eOpenOptionWrite;
+  return options;
+#else
+  PythonString py_mode = obj.GetAttributeValue("mode").AsType<PythonString>();
+  return File::GetOptionsFromMode(py_mode.GetString());
+#endif
+}
+
+// Base class template for python files.   All it knows how to do
+// is hold a reference to the python object and close or flush it
+// when the File is closed.
+namespace {
+template <typename Base> class OwnedPythonFile : public Base {
+public:
+  template <typename... Args>
+  OwnedPythonFile(const PythonFile &file, bool borrowed, Args... args)
+      : Base(args...), m_py_obj(file), m_borrowed(borrowed) {
+    assert(m_py_obj);
+  }
+
+  ~OwnedPythonFile() override {
+    assert(m_py_obj);
+    GIL takeGIL;
+    Close();
+    // we need to ensure the python object is released while we still
+    // hold the GIL
+    m_py_obj.Reset();
+  }
+
+  bool IsPythonSideValid() const {
+    GIL takeGIL;
+    auto closed = As<bool>(m_py_obj.GetAttribute("closed"));
+    if (!closed) {
+      llvm::consumeError(closed.takeError());
+      return false;
+    }
+    return !closed.get();
+  }
+
+  bool IsValid() const override {
+    return IsPythonSideValid() && Base::IsValid();
+  }
+
+  Status Close() override {
+    assert(m_py_obj);
+    Status py_error, base_error;
+    GIL takeGIL;
+    if (!m_borrowed) {
+      auto r = m_py_obj.CallMethod("close");
+      if (!r)
+        py_error = Status(r.takeError());
+    }
+    base_error = Base::Close();
+    if (py_error.Fail())
+      return py_error;
+    return base_error;
+  };
+
+  PyObject *GetPythonObject() const {
+    assert(m_py_obj.IsValid());
+    return m_py_obj.get();
+  }
+
+  static bool classof(const File *file) = delete;
+
+protected:
+  PythonFile m_py_obj;
+  bool m_borrowed;
+};
+} // namespace
+
+// A SimplePythonFile is a OwnedPythonFile that just does all I/O as
+// a NativeFile
+namespace {
+class SimplePythonFile : public OwnedPythonFile<NativeFile> {
+public:
+  SimplePythonFile(const PythonFile &file, bool borrowed, int fd,
+                   File::OpenOptions options)
+      : OwnedPythonFile(file, borrowed, fd, options, false) {}
+
+  static char ID;
+  bool isA(const void *classID) const override {
+    return classID == &ID || NativeFile::isA(classID);
+  }
+  static bool classof(const File *file) { return file->isA(&ID); }
+};
+char SimplePythonFile::ID = 0;
+} // namespace
+
+#if PY_MAJOR_VERSION >= 3
+
+namespace {
+class PythonBuffer {
+public:
+  PythonBuffer &operator=(const PythonBuffer &) = delete;
+  PythonBuffer(const PythonBuffer &) = delete;
+
+  static Expected<PythonBuffer> Create(PythonObject &obj,
+                                       int flags = PyBUF_SIMPLE) {
+    Py_buffer py_buffer = {};
+    PyObject_GetBuffer(obj.get(), &py_buffer, flags);
+    if (!py_buffer.obj)
+      return llvm::make_error<PythonException>();
+    return PythonBuffer(py_buffer);
+  }
+
+  PythonBuffer(PythonBuffer &&other) {
+    m_buffer = other.m_buffer;
+    other.m_buffer.obj = nullptr;
+  }
+
+  ~PythonBuffer() {
+    if (m_buffer.obj)
+      PyBuffer_Release(&m_buffer);
+  }
+
+  Py_buffer &get() { return m_buffer; }
+
+private:
+  // takes ownership of the buffer.
+  PythonBuffer(const Py_buffer &py_buffer) : m_buffer(py_buffer) {}
+  Py_buffer m_buffer;
+};
+} // namespace
+
+// Shared methods between TextPythonFile and BinaryPythonFile
+namespace {
+class PythonIOFile : public OwnedPythonFile<File> {
+public:
+  PythonIOFile(const PythonFile &file, bool borrowed)
+      : OwnedPythonFile(file, borrowed) {}
+
+  ~PythonIOFile() override { Close(); }
+
+  bool IsValid() const override { return IsPythonSideValid(); }
+
+  Status Close() override {
+    assert(m_py_obj);
+    GIL takeGIL;
+    if (m_borrowed)
+      return Flush();
+    auto r = m_py_obj.CallMethod("close");
+    if (!r)
+      return Status(r.takeError());
+    return Status();
+  }
+
+  Status Flush() override {
+    GIL takeGIL;
+    auto r = m_py_obj.CallMethod("flush");
+    if (!r)
+      return Status(r.takeError());
+    return Status();
+  }
+
+  Expected<File::OpenOptions> GetOptions() const override {
+    GIL takeGIL;
+    return GetOptionsForPyObject(m_py_obj);
+  }
+
+  static char ID;
+  bool isA(const void *classID) const override {
+    return classID == &ID || File::isA(classID);
+  }
+  static bool classof(const File *file) { return file->isA(&ID); }
+};
+char PythonIOFile::ID = 0;
+} // namespace
+
+namespace {
+class BinaryPythonFile : public PythonIOFile {
+protected:
+  int m_descriptor;
+
+public:
+  BinaryPythonFile(int fd, const PythonFile &file, bool borrowed)
+      : PythonIOFile(file, borrowed),
+        m_descriptor(File::DescriptorIsValid(fd) ? fd
+                                                 : File::kInvalidDescriptor) {}
+
+  int GetDescriptor() const override { return m_descriptor; }
+
+  Status Write(const void *buf, size_t &num_bytes) override {
+    GIL takeGIL;
+    PyObject *pybuffer_p = PyMemoryView_FromMemory(
+        const_cast<char *>((const char *)buf), num_bytes, PyBUF_READ);
+    if (!pybuffer_p)
+      return Status(llvm::make_error<PythonException>());
+    auto pybuffer = Take<PythonObject>(pybuffer_p);
+    num_bytes = 0;
+    auto bytes_written = As<long long>(m_py_obj.CallMethod("write", pybuffer));
+    if (!bytes_written)
+      return Status(bytes_written.takeError());
+    if (bytes_written.get() < 0)
+      return Status(".write() method returned a negative number!");
+    static_assert(sizeof(long long) >= sizeof(size_t), "overflow");
+    num_bytes = bytes_written.get();
+    return Status();
+  }
+
+  Status Read(void *buf, size_t &num_bytes) override {
+    GIL takeGIL;
+    static_assert(sizeof(long long) >= sizeof(size_t), "overflow");
+    auto pybuffer_obj =
+        m_py_obj.CallMethod("read", (unsigned long long)num_bytes);
+    if (!pybuffer_obj)
+      return Status(pybuffer_obj.takeError());
+    num_bytes = 0;
+    if (pybuffer_obj.get().IsNone()) {
+      // EOF
+      num_bytes = 0;
+      return Status();
+    }
+    auto pybuffer = PythonBuffer::Create(pybuffer_obj.get());
+    if (!pybuffer)
+      return Status(pybuffer.takeError());
+    memcpy(buf, pybuffer.get().get().buf, pybuffer.get().get().len);
+    num_bytes = pybuffer.get().get().len;
+    return Status();
+  }
+};
+} // namespace
+
+namespace {
+class TextPythonFile : public PythonIOFile {
+protected:
+  int m_descriptor;
+
+public:
+  TextPythonFile(int fd, const PythonFile &file, bool borrowed)
+      : PythonIOFile(file, borrowed),
+        m_descriptor(File::DescriptorIsValid(fd) ? fd
+                                                 : File::kInvalidDescriptor) {}
+
+  int GetDescriptor() const override { return m_descriptor; }
+
+  Status Write(const void *buf, size_t &num_bytes) override {
+    GIL takeGIL;
+    auto pystring =
+        PythonString::FromUTF8(llvm::StringRef((const char *)buf, num_bytes));
+    if (!pystring)
+      return Status(pystring.takeError());
+    num_bytes = 0;
+    auto bytes_written =
+        As<long long>(m_py_obj.CallMethod("write", pystring.get()));
+    if (!bytes_written)
+      return Status(bytes_written.takeError());
+    if (bytes_written.get() < 0)
+      return Status(".write() method returned a negative number!");
+    static_assert(sizeof(long long) >= sizeof(size_t), "overflow");
+    num_bytes = bytes_written.get();
+    return Status();
+  }
+
+  Status Read(void *buf, size_t &num_bytes) override {
+    GIL takeGIL;
+    size_t num_chars = num_bytes / 6;
+    size_t orig_num_bytes = num_bytes;
+    num_bytes = 0;
+    if (orig_num_bytes < 6) {
+      return Status("can't read less than 6 bytes from a utf8 text stream");
+    }
+    auto pystring = As<PythonString>(
+        m_py_obj.CallMethod("read", (unsigned long long)num_chars));
+    if (!pystring)
+      return Status(pystring.takeError());
+    if (pystring.get().IsNone()) {
+      // EOF
+      return Status();
+    }
+    auto stringref = pystring.get().AsUTF8();
+    if (!stringref)
+      return Status(stringref.takeError());
+    num_bytes = stringref.get().size();
+    memcpy(buf, stringref.get().begin(), num_bytes);
+    return Status();
+  }
+};
+} // namespace
+
+#endif
+
+llvm::Expected<FileSP> PythonFile::ConvertToFile(bool borrowed) {
+  if (!IsValid())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid PythonFile");
+
+  int fd = PyObject_AsFileDescriptor(m_py_obj);
+  if (fd < 0) {
+    PyErr_Clear();
+    return ConvertToFileForcingUseOfScriptingIOMethods(borrowed);
+  }
+  auto options = GetOptionsForPyObject(*this);
+  if (!options)
+    return options.takeError();
+
+  if (options.get() & File::eOpenOptionWrite) {
+    // LLDB and python will not share I/O buffers.  We should probably
+    // flush the python buffers now.
+    auto r = CallMethod("flush");
+    if (!r)
+      return r.takeError();
+  }
+
+  FileSP file_sp;
+  if (borrowed) {
+    // In this case we we don't need to retain the python
+    // object at all.
+    file_sp = std::make_shared<NativeFile>(fd, options.get(), false);
+  } else {
+    file_sp = std::static_pointer_cast<File>(
+        std::make_shared<SimplePythonFile>(*this, borrowed, fd, options.get()));
+  }
+  if (!file_sp->IsValid())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid File");
+
+  return file_sp;
+}
+
+llvm::Expected<FileSP>
+PythonFile::ConvertToFileForcingUseOfScriptingIOMethods(bool borrowed) {
+
+  assert(!PyErr_Occurred());
+
+  if (!IsValid())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid PythonFile");
+
+#if PY_MAJOR_VERSION < 3
+
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "not supported on python 2");
+
+#else
+
+  int fd = PyObject_AsFileDescriptor(m_py_obj);
+  if (fd < 0) {
+    PyErr_Clear();
+    fd = File::kInvalidDescriptor;
+  }
+
+  auto io_module = PythonModule::Import("io");
+  if (!io_module)
+    return io_module.takeError();
+  auto textIOBase = io_module.get().Get("TextIOBase");
+  if (!textIOBase)
+    return textIOBase.takeError();
+  auto rawIOBase = io_module.get().Get("RawIOBase");
+  if (!rawIOBase)
+    return rawIOBase.takeError();
+  auto bufferedIOBase = io_module.get().Get("BufferedIOBase");
+  if (!bufferedIOBase)
+    return bufferedIOBase.takeError();
+
+  FileSP file_sp;
+
+  auto isTextIO = IsInstance(textIOBase.get());
+  if (!isTextIO)
+    return isTextIO.takeError();
+  if (isTextIO.get())
+    file_sp = std::static_pointer_cast<File>(
+        std::make_shared<TextPythonFile>(fd, *this, borrowed));
+
+  auto isRawIO = IsInstance(rawIOBase.get());
+  if (!isRawIO)
+    return isRawIO.takeError();
+  auto isBufferedIO = IsInstance(bufferedIOBase.get());
+  if (!isBufferedIO)
+    return isBufferedIO.takeError();
+
+  if (isRawIO.get() || isBufferedIO.get()) {
+    file_sp = std::static_pointer_cast<File>(
+        std::make_shared<BinaryPythonFile>(fd, *this, borrowed));
+  }
+
+  if (!file_sp)
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "python file is neither text nor binary");
+
+  if (!file_sp->IsValid())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid File");
+
+  return file_sp;
+
+#endif
+}
+
+Expected<PythonFile> PythonFile::FromFile(File &file, const char *mode) {
+  if (!file.IsValid())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid file");
+
+  if (auto *simple = llvm::dyn_cast<SimplePythonFile>(&file))
+    return Retain<PythonFile>(simple->GetPythonObject());
+#if PY_MAJOR_VERSION >= 3
+  if (auto *pythonio = llvm::dyn_cast<PythonIOFile>(&file))
+    return Retain<PythonFile>(pythonio->GetPythonObject());
+#endif
+
+  if (!mode) {
+    auto m = file.GetOpenMode();
+    if (!m)
+      return m.takeError();
+    mode = m.get();
+  }
+
+  PyObject *file_obj;
+#if PY_MAJOR_VERSION >= 3
+  file_obj = PyFile_FromFd(file.GetDescriptor(), nullptr, mode, -1, nullptr,
+                           "ignore", nullptr, /*closefd=*/0);
+#else
+  // I'd like to pass ::fflush here if the file is writable,  so that
+  // when the python side destructs the file object it will be flushed.
+  // However, this would be dangerous.    It can cause fflush to be called
+  // after fclose if the python program keeps a reference to the file after
+  // the original lldb_private::File has been destructed.
+  //
+  // It's all well and good to ask a python program not to use a closed file
+  // but asking a python program to make sure objects get released in a
+  // particular order is not safe.
+  //
+  // The tradeoff here is that if a python 2 program wants to make sure this
+  // file gets flushed, they'll have to do it explicitly or wait untill the
+  // original lldb File itself gets flushed.
+  file_obj = PyFile_FromFile(file.GetStream(), py2_const_cast(""),
+                             py2_const_cast(mode), [](FILE *) { return 0; });
+#endif
+
+  if (!file_obj)
+    return exception();
+
+  return Take<PythonFile>(file_obj);
+}
+
+Error PythonScript::Init() {
+  if (function.IsValid())
+    return Error::success();
+
+  PythonDictionary globals(PyInitialValue::Empty);
+  auto builtins = PythonModule::BuiltinsModule();
+  if (Error error = globals.SetItem("__builtins__", builtins))
+    return error;
+  PyObject *o =
+      PyRun_String(script, Py_file_input, globals.get(), globals.get());
+  if (!o)
+    return exception();
+  Take<PythonObject>(o);
+  auto f = As<PythonCallable>(globals.GetItem("main"));
+  if (!f)
+    return f.takeError();
+  function = std::move(f.get());
+
+  return Error::success();
+}
+
+llvm::Expected<PythonObject>
+python::runStringOneLine(const llvm::Twine &string,
+                         const PythonDictionary &globals,
+                         const PythonDictionary &locals) {
+  if (!globals.IsValid() || !locals.IsValid())
+    return nullDeref();
+
+  PyObject *code =
+      Py_CompileString(NullTerminated(string), "<string>", Py_eval_input);
+  if (!code) {
+    PyErr_Clear();
+    code =
+        Py_CompileString(NullTerminated(string), "<string>", Py_single_input);
+  }
+  if (!code)
+    return exception();
+  auto code_ref = Take<PythonObject>(code);
+
+#if PY_MAJOR_VERSION < 3
+  PyObject *result =
+      PyEval_EvalCode((PyCodeObject *)code, globals.get(), locals.get());
+#else
+  PyObject *result = PyEval_EvalCode(code, globals.get(), locals.get());
+#endif
+
+  if (!result)
+    return exception();
+
+  return Take<PythonObject>(result);
+}
+
+llvm::Expected<PythonObject>
+python::runStringMultiLine(const llvm::Twine &string,
+                           const PythonDictionary &globals,
+                           const PythonDictionary &locals) {
+  if (!globals.IsValid() || !locals.IsValid())
+    return nullDeref();
+  PyObject *result = PyRun_String(NullTerminated(string), Py_file_input,
+                                  globals.get(), locals.get());
+  if (!result)
+    return exception();
+  return Take<PythonObject>(result);
+}
+
+#endif
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h
new file mode 100644
index 00000000000..b75045b239a
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h
@@ -0,0 +1,763 @@
+//===-- PythonDataObjects.h--------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+//
+// !! FIXME FIXME FIXME !!
+//
+// Python APIs nearly all can return an exception.   They do this
+// by returning NULL, or -1, or some such value and setting
+// the exception state with PyErr_Set*().   Exceptions must be
+// handled before further python API functions are called.   Failure
+// to do so will result in asserts on debug builds of python.
+// It will also sometimes, but not usually result in crashes of
+// release builds.
+//
+// Nearly all the code in this header does not handle python exceptions
+// correctly.  It should all be converted to return Expected<> or
+// Error types to capture the exception.
+//
+// Everything in this file except functions that return Error or
+// Expected<> is considered deprecated and should not be
+// used in new code.  If you need to use it, fix it first.
+//
+//
+// TODOs for this file
+//
+// * Make all methods safe for exceptions.
+//
+// * Eliminate method signatures that must translate exceptions into
+//   empty objects or NULLs.   Almost everything here should return
+//   Expected<>.   It should be acceptable for certain operations that
+//   can never fail to assert instead, such as the creation of
+//   PythonString from a string literal.
+//
+// * Elimintate Reset(), and make all non-default constructors private.
+//   Python objects should be created with Retain<> or Take<>, and they
+//   should be assigned with operator=
+//
+// * Eliminate default constructors, make python objects always
+//   nonnull, and use optionals where necessary.
+//
+
+
+#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
+#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+// LLDB Python header must be included first
+#include "lldb-python.h"
+
+#include "lldb/Host/File.h"
+#include "lldb/Utility/StructuredData.h"
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace lldb_private {
+namespace python {
+
+class PythonObject;
+class PythonBytes;
+class PythonString;
+class PythonList;
+class PythonDictionary;
+class PythonInteger;
+class PythonException;
+
+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 Serialize(llvm::json::OStream &s) const override;
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
+};
+
+enum class PyObjectType {
+  Unknown,
+  None,
+  Boolean,
+  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.
+};
+
+
+// Take a reference that you already own, and turn it into
+// a PythonObject.
+//
+// Most python API methods will return a +1 reference
+// if they succeed or NULL if and only if
+// they set an exception.   Use this to collect such return
+// values, after checking for NULL.
+//
+// If T is not just PythonObject, then obj must be already be
+// checked to be of the correct type.
+template <typename T> T Take(PyObject *obj) {
+  assert(obj);
+  assert(!PyErr_Occurred());
+  T thing(PyRefType::Owned, obj);
+  assert(thing.IsValid());
+  return thing;
+}
+
+// Retain a reference you have borrowed, and turn it into
+// a PythonObject.
+//
+// A minority of python APIs return a borrowed reference
+// instead of a +1.   They will also return NULL if and only
+// if they set an exception.   Use this to collect such return
+// values, after checking for NULL.
+//
+// If T is not just PythonObject, then obj must be already be
+// checked to be of the correct type.
+template <typename T> T Retain(PyObject *obj) {
+  assert(obj);
+  assert(!PyErr_Occurred());
+  T thing(PyRefType::Borrowed, obj);
+  assert(thing.IsValid());
+  return thing;
+}
+
+// This class can be used like a utility function to convert from
+// a llvm-friendly Twine into a null-terminated const char *,
+// which is the form python C APIs want their strings in.
+//
+// Example:
+// const llvm::Twine &some_twine;
+// PyFoo_Bar(x, y, z, NullTerminated(some_twine));
+//
+// Why a class instead of a function?  If the twine isn't already null
+// terminated, it will need a temporary buffer to copy the string
+// into.   We need that buffer to stick around for the lifetime of the
+// statement.
+class NullTerminated {
+  const char *str;
+  llvm::SmallString<32> storage;
+
+public:
+  NullTerminated(const llvm::Twine &twine) {
+    llvm::StringRef ref = twine.toNullTerminatedStringRef(storage);
+    str = ref.begin();
+  }
+  operator const char *() { return str; }
+};
+
+inline llvm::Error nullDeref() {
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "A NULL PyObject* was dereferenced");
+}
+
+inline llvm::Error exception(const char *s = nullptr) {
+  return llvm::make_error<PythonException>(s);
+}
+
+inline llvm::Error keyError() {
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "key not in dict");
+}
+
+#if PY_MAJOR_VERSION < 3
+// The python 2 API declares some arguments as char* that should
+// be const char *, but it doesn't actually modify them.
+inline char *py2_const_cast(const char *s) { return const_cast<char *>(s); }
+#else
+inline const char *py2_const_cast(const char *s) { return s; }
+#endif
+
+enum class PyInitialValue { Invalid, Empty };
+
+template <typename T, typename Enable = void> struct PythonFormat;
+
+template <> struct PythonFormat<unsigned long long> {
+  static constexpr char format = 'K';
+  static auto get(unsigned long long value) { return value; }
+};
+
+template <> struct PythonFormat<long long> {
+  static constexpr char format = 'L';
+  static auto get(long long value) { return value; }
+};
+
+template <> struct PythonFormat<PyObject *> {
+  static constexpr char format = 'O';
+  static auto get(PyObject *value) { return value; }
+};
+
+template <typename T>
+struct PythonFormat<
+    T, typename std::enable_if<std::is_base_of<PythonObject, T>::value>::type> {
+  static constexpr char format = 'O';
+  static auto get(const T &value) { return value.get(); }
+};
+
+class PythonObject {
+public:
+  PythonObject() : m_py_obj(nullptr) {}
+
+  PythonObject(PyRefType type, PyObject *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 (m_py_obj && Py_IsInitialized() && type == PyRefType::Borrowed)
+      Py_XINCREF(m_py_obj);
+  }
+
+  PythonObject(const PythonObject &rhs)
+      : PythonObject(PyRefType::Borrowed, rhs.m_py_obj) {}
+
+  PythonObject(PythonObject &&rhs) {
+    m_py_obj = rhs.m_py_obj;
+    rhs.m_py_obj = nullptr;
+  }
+
+  ~PythonObject() { Reset(); }
+
+  void Reset() {
+    if (m_py_obj && Py_IsInitialized())
+      Py_DECREF(m_py_obj);
+    m_py_obj = nullptr;
+  }
+
+  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=(PythonObject other) {
+    Reset();
+    m_py_obj = std::exchange(other.m_py_obj, nullptr);
+    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 IsNone() const { return m_py_obj == Py_None; }
+
+  bool IsValid() const { return m_py_obj != nullptr; }
+
+  bool IsAllocated() const { return IsValid() && !IsNone(); }
+
+  explicit operator bool() const { return IsValid() && !IsNone(); }
+
+  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;
+
+public:
+  template <typename... T>
+  llvm::Expected<PythonObject> CallMethod(const char *name,
+                                          const T &... t) const {
+    const char format[] = {'(', PythonFormat<T>::format..., ')', 0};
+    PyObject *obj =
+        PyObject_CallMethod(m_py_obj, py2_const_cast(name),
+                            py2_const_cast(format), PythonFormat<T>::get(t)...);
+    if (!obj)
+      return exception();
+    return python::Take<PythonObject>(obj);
+  }
+
+  template <typename... T>
+  llvm::Expected<PythonObject> Call(const T &... t) const {
+    const char format[] = {'(', PythonFormat<T>::format..., ')', 0};
+    PyObject *obj = PyObject_CallFunction(m_py_obj, py2_const_cast(format),
+                                          PythonFormat<T>::get(t)...);
+    if (!obj)
+      return exception();
+    return python::Take<PythonObject>(obj);
+  }
+
+  llvm::Expected<PythonObject> GetAttribute(const llvm::Twine &name) const {
+    if (!m_py_obj)
+      return nullDeref();
+    PyObject *obj = PyObject_GetAttrString(m_py_obj, NullTerminated(name));
+    if (!obj)
+      return exception();
+    return python::Take<PythonObject>(obj);
+  }
+
+  llvm::Expected<bool> IsTrue() {
+    if (!m_py_obj)
+      return nullDeref();
+    int r = PyObject_IsTrue(m_py_obj);
+    if (r < 0)
+      return exception();
+    return !!r;
+  }
+
+  llvm::Expected<long long> AsLongLong() {
+    if (!m_py_obj)
+      return nullDeref();
+    assert(!PyErr_Occurred());
+    long long r = PyLong_AsLongLong(m_py_obj);
+    if (PyErr_Occurred())
+      return exception();
+    return r;
+  }
+
+  llvm::Expected<bool> IsInstance(const PythonObject &cls) {
+    if (!m_py_obj || !cls.IsValid())
+      return nullDeref();
+    int r = PyObject_IsInstance(m_py_obj, cls.get());
+    if (r < 0)
+      return exception();
+    return !!r;
+  }
+
+protected:
+  PyObject *m_py_obj;
+};
+
+
+// This is why C++ needs monads.
+template <typename T> llvm::Expected<T> As(llvm::Expected<PythonObject> &&obj) {
+  if (!obj)
+    return obj.takeError();
+  if (!T::Check(obj.get().get()))
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "type error");
+  return T(PyRefType::Borrowed, std::move(obj.get().get()));
+}
+
+template <> llvm::Expected<bool> As<bool>(llvm::Expected<PythonObject> &&obj);
+
+template <>
+llvm::Expected<long long> As<long long>(llvm::Expected<PythonObject> &&obj);
+
+template <>
+llvm::Expected<std::string> As<std::string>(llvm::Expected<PythonObject> &&obj);
+
+
+template <class T> class TypedPythonObject : public PythonObject {
+public:
+  // override to perform implicit type conversions on Reset
+  // This can be eliminated once we drop python 2 support.
+  static void Convert(PyRefType &type, PyObject *&py_obj) {}
+
+  TypedPythonObject(PyRefType type, PyObject *py_obj) {
+    if (!py_obj)
+      return;
+    T::Convert(type, py_obj);
+    if (T::Check(py_obj))
+      PythonObject::operator=(PythonObject(type, py_obj));
+    else if (type == PyRefType::Owned)
+      Py_DECREF(py_obj);
+  }
+
+  TypedPythonObject() {}
+};
+
+class PythonBytes : public TypedPythonObject<PythonBytes> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+  explicit PythonBytes(llvm::ArrayRef<uint8_t> bytes);
+  PythonBytes(const uint8_t *bytes, size_t length);
+
+  static bool Check(PyObject *py_obj);
+
+  llvm::ArrayRef<uint8_t> GetBytes() const;
+
+  size_t GetSize() const;
+
+  void SetBytes(llvm::ArrayRef<uint8_t> stringbytes);
+
+  StructuredData::StringSP CreateStructuredString() const;
+};
+
+class PythonByteArray : public TypedPythonObject<PythonByteArray> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+  explicit PythonByteArray(llvm::ArrayRef<uint8_t> bytes);
+  PythonByteArray(const uint8_t *bytes, size_t length);
+  PythonByteArray(const PythonBytes &object);
+
+  static bool Check(PyObject *py_obj);
+
+  llvm::ArrayRef<uint8_t> GetBytes() const;
+
+  size_t GetSize() const;
+
+  void SetBytes(llvm::ArrayRef<uint8_t> stringbytes);
+
+  StructuredData::StringSP CreateStructuredString() const;
+};
+
+class PythonString : public TypedPythonObject<PythonString> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+  static llvm::Expected<PythonString> FromUTF8(llvm::StringRef string);
+
+  PythonString() : TypedPythonObject() {} // MSVC requires this for some reason
+
+  explicit PythonString(llvm::StringRef string); // safe, null on error
+
+  static bool Check(PyObject *py_obj);
+  static void Convert(PyRefType &type, PyObject *&py_obj);
+
+  llvm::StringRef GetString() const; // safe, empty string on error
+
+  llvm::Expected<llvm::StringRef> AsUTF8() const;
+
+  size_t GetSize() const;
+
+  void SetString(llvm::StringRef string); // safe, null on error
+
+  StructuredData::StringSP CreateStructuredString() const;
+};
+
+class PythonInteger : public TypedPythonObject<PythonInteger> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  PythonInteger() : TypedPythonObject() {} // MSVC requires this for some reason
+
+  explicit PythonInteger(int64_t value);
+
+  static bool Check(PyObject *py_obj);
+  static void Convert(PyRefType &type, PyObject *&py_obj);
+
+  int64_t GetInteger() const;
+
+  void SetInteger(int64_t value);
+
+  StructuredData::IntegerSP CreateStructuredInteger() const;
+};
+
+class PythonBoolean : public TypedPythonObject<PythonBoolean> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  explicit PythonBoolean(bool value);
+
+  static bool Check(PyObject *py_obj);
+
+  bool GetValue() const;
+
+  void SetValue(bool value);
+
+  StructuredData::BooleanSP CreateStructuredBoolean() const;
+};
+
+class PythonList : public TypedPythonObject<PythonList> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  PythonList() : TypedPythonObject() {} // MSVC requires this for some reason
+
+  explicit PythonList(PyInitialValue value);
+  explicit PythonList(int list_size);
+
+  static bool Check(PyObject *py_obj);
+
+  uint32_t GetSize() const;
+
+  PythonObject GetItemAtIndex(uint32_t index) const;
+
+  void SetItemAtIndex(uint32_t index, const PythonObject &object);
+
+  void AppendItem(const PythonObject &object);
+
+  StructuredData::ArraySP CreateStructuredArray() const;
+};
+
+class PythonTuple : public TypedPythonObject<PythonTuple> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  explicit PythonTuple(PyInitialValue value);
+  explicit PythonTuple(int tuple_size);
+  PythonTuple(std::initializer_list<PythonObject> objects);
+  PythonTuple(std::initializer_list<PyObject *> objects);
+
+  static bool Check(PyObject *py_obj);
+
+  uint32_t GetSize() const;
+
+  PythonObject GetItemAtIndex(uint32_t index) const;
+
+  void SetItemAtIndex(uint32_t index, const PythonObject &object);
+
+  StructuredData::ArraySP CreateStructuredArray() const;
+};
+
+class PythonDictionary : public TypedPythonObject<PythonDictionary> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  PythonDictionary() : TypedPythonObject() {} // MSVC requires this for some reason
+
+  explicit PythonDictionary(PyInitialValue value);
+
+  static bool Check(PyObject *py_obj);
+
+  uint32_t GetSize() const;
+
+  PythonList GetKeys() const;
+
+  PythonObject GetItemForKey(const PythonObject &key) const; // DEPRECATED
+  void SetItemForKey(const PythonObject &key,
+                     const PythonObject &value); // DEPRECATED
+
+  llvm::Expected<PythonObject> GetItem(const PythonObject &key) const;
+  llvm::Expected<PythonObject> GetItem(const llvm::Twine &key) const;
+  llvm::Error SetItem(const PythonObject &key, const PythonObject &value) const;
+  llvm::Error SetItem(const llvm::Twine &key, const PythonObject &value) const;
+
+  StructuredData::DictionarySP CreateStructuredDictionary() const;
+};
+
+class PythonModule : public TypedPythonObject<PythonModule> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  static bool Check(PyObject *py_obj);
+
+  static PythonModule BuiltinsModule();
+
+  static PythonModule MainModule();
+
+  static PythonModule AddModule(llvm::StringRef module);
+
+  // safe, returns invalid on error;
+  static PythonModule ImportModule(llvm::StringRef name) {
+    std::string s = name;
+    auto mod = Import(s.c_str());
+    if (!mod) {
+      llvm::consumeError(mod.takeError());
+      return PythonModule();
+    }
+    return std::move(mod.get());
+  }
+
+  static llvm::Expected<PythonModule> Import(const llvm::Twine &name);
+
+  llvm::Expected<PythonObject> Get(const llvm::Twine &name);
+
+  PythonDictionary GetDictionary() const;
+};
+
+class PythonCallable : public TypedPythonObject<PythonCallable> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  struct ArgInfo {
+    /* the largest number of positional arguments this callable
+     * can accept, or UNBOUNDED, ie UINT_MAX if it's a varargs
+     * function and can accept an arbitrary number */
+    unsigned max_positional_args;
+    static constexpr unsigned UNBOUNDED = UINT_MAX; // FIXME c++17 inline
+  };
+
+  static bool Check(PyObject *py_obj);
+
+  llvm::Expected<ArgInfo> GetArgInfo() const;
+
+  PythonObject operator()();
+
+  PythonObject operator()(std::initializer_list<PyObject *> args);
+
+  PythonObject operator()(std::initializer_list<PythonObject> args);
+
+  template <typename Arg, typename... Args>
+  PythonObject operator()(const Arg &arg, Args... args) {
+    return operator()({arg, args...});
+  }
+};
+
+class PythonFile : public TypedPythonObject<PythonFile> {
+public:
+  using TypedPythonObject::TypedPythonObject;
+
+  PythonFile() : TypedPythonObject() {} // MSVC requires this for some reason
+
+  static bool Check(PyObject *py_obj);
+
+  static llvm::Expected<PythonFile> FromFile(File &file,
+                                             const char *mode = nullptr);
+
+  llvm::Expected<lldb::FileSP> ConvertToFile(bool borrowed = false);
+  llvm::Expected<lldb::FileSP>
+  ConvertToFileForcingUseOfScriptingIOMethods(bool borrowed = false);
+};
+
+class PythonException : public llvm::ErrorInfo<PythonException> {
+private:
+  PyObject *m_exception_type, *m_exception, *m_traceback;
+  PyObject *m_repr_bytes;
+
+public:
+  static char ID;
+  const char *toCString() const;
+  PythonException(const char *caller = nullptr);
+  void Restore();
+  ~PythonException();
+  void log(llvm::raw_ostream &OS) const override;
+  std::error_code convertToErrorCode() const override;
+  bool Matches(PyObject *exc) const;
+  std::string ReadBacktrace() const;
+};
+
+// This extracts the underlying T out of an Expected<T> and returns it.
+// If the Expected is an Error instead of a T, that error will be converted
+// into a python exception, and this will return a default-constructed T.
+//
+// This is appropriate for use right at the boundary of python calling into
+// C++, such as in a SWIG typemap.   In such a context you should simply
+// check if the returned T is valid, and if it is, return a NULL back
+// to python.   This will result in the Error being raised as an exception
+// from python code's point of view.
+//
+// For example:
+// ```
+// Expected<Foo *> efoop = some_cpp_function();
+// Foo *foop = unwrapOrSetPythonException(efoop);
+// if (!foop)
+//    return NULL;
+// do_something(*foop);
+//
+// If the Error returned was itself created because a python exception was
+// raised when C++ code called into python, then the original exception
+// will be restored.   Otherwise a simple string exception will be raised.
+template <typename T> T unwrapOrSetPythonException(llvm::Expected<T> expected) {
+  if (expected)
+    return expected.get();
+  llvm::handleAllErrors(
+      expected.takeError(), [](PythonException &E) { E.Restore(); },
+      [](const llvm::ErrorInfoBase &E) {
+        PyErr_SetString(PyExc_Exception, E.message().c_str());
+      });
+  return T();
+}
+
+// This is only here to help incrementally migrate old, exception-unsafe
+// code.
+template <typename T> T unwrapIgnoringErrors(llvm::Expected<T> expected) {
+  if (expected)
+    return std::move(expected.get());
+  llvm::consumeError(expected.takeError());
+  return T();
+}
+
+llvm::Expected<PythonObject> runStringOneLine(const llvm::Twine &string,
+                                              const PythonDictionary &globals,
+                                              const PythonDictionary &locals);
+
+llvm::Expected<PythonObject> runStringMultiLine(const llvm::Twine &string,
+                                                const PythonDictionary &globals,
+                                                const PythonDictionary &locals);
+
+// Sometimes the best way to interact with a python interpreter is
+// to run some python code.   You construct a PythonScript with
+// script string.   The script assigns some function to `_function_`
+// and you get a C++ callable object that calls the python function.
+//
+// Example:
+//
+// const char script[] = R"(
+// def main(x, y):
+//    ....
+// )";
+//
+// Expected<PythonObject> cpp_foo_wrapper(PythonObject x, PythonObject y) {
+//   // no need to synchronize access to this global, we already have the GIL
+//   static PythonScript foo(script)
+//   return  foo(x, y);
+// }
+class PythonScript {
+  const char *script;
+  PythonCallable function;
+
+  llvm::Error Init();
+
+public:
+  PythonScript(const char *script) : script(script), function() {}
+
+  template <typename... Args>
+  llvm::Expected<PythonObject> operator()(Args &&... args) {
+    if (llvm::Error error = Init())
+      return std::move(error);
+    return function.Call(std::forward<Args>(args)...);
+  }
+};
+
+} // namespace python
+} // namespace lldb_private
+
+#endif
+
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.cpp b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.cpp
new file mode 100644
index 00000000000..5f6429f5cd0
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.cpp
@@ -0,0 +1,88 @@
+#include "PythonReadline.h"
+
+#ifdef LLDB_USE_LIBEDIT_READLINE_COMPAT_MODULE
+
+#include <stdio.h>
+
+#include <editline/readline.h>
+
+// Simple implementation of the Python readline module using libedit.
+// In the event that libedit is excluded from the build, this turns
+// back into a null implementation that blocks the module from pulling
+// in the GNU readline shared lib, which causes linkage confusion when
+// both readline and libedit's readline compatibility symbols collide.
+//
+// Currently it only installs a PyOS_ReadlineFunctionPointer, without
+// implementing any of the readline module methods. This is meant to
+// work around LLVM pr18841 to avoid seg faults in the stock Python
+// readline.so linked against GNU readline.
+//
+// Bug on the cpython side: https://bugs.python.org/issue38634
+
+PyDoc_STRVAR(moduleDocumentation,
+             "Simple readline module implementation based on libedit.");
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef readline_module = {
+    PyModuleDef_HEAD_INIT, // m_base
+    "lldb_editline",       // m_name
+    moduleDocumentation,   // m_doc
+    -1,                    // m_size
+    nullptr,               // m_methods
+    nullptr,               // m_reload
+    nullptr,               // m_traverse
+    nullptr,               // m_clear
+    nullptr,               // m_free
+};
+#else
+static struct PyMethodDef moduleMethods[] = {{nullptr, nullptr, 0, nullptr}};
+#endif
+
+static char *
+#if PY_MAJOR_VERSION >= 3
+simple_readline(FILE *stdin, FILE *stdout, const char *prompt)
+#else
+simple_readline(FILE *stdin, FILE *stdout, char *prompt)
+#endif
+{
+  rl_instream = stdin;
+  rl_outstream = stdout;
+  char *line = readline(prompt);
+  if (!line) {
+#if PY_MAJOR_VERSION >= 3
+    char *ret = (char *)PyMem_RawMalloc(1);
+#else
+    char *ret = (char *)PyMem_Malloc(1);
+#endif
+    if (ret != NULL)
+      *ret = '\0';
+    return ret;
+  }
+  if (*line)
+    add_history(line);
+  int n = strlen(line);
+#if PY_MAJOR_VERSION >= 3
+  char *ret = (char *)PyMem_RawMalloc(n + 2);
+#else
+  char *ret = (char *)PyMem_Malloc(n + 2);
+#endif
+  if (ret) {
+    memcpy(ret, line, n);
+    free(line);
+    ret[n] = '\n';
+    ret[n + 1] = '\0';
+  }
+  return ret;
+}
+
+PyMODINIT_FUNC initlldb_readline(void) {
+  PyOS_ReadlineFunctionPointer = simple_readline;
+
+#if PY_MAJOR_VERSION >= 3
+  return PyModule_Create(&readline_module);
+#else
+  Py_InitModule4("readline", moduleMethods, moduleDocumentation,
+                 static_cast<PyObject *>(NULL), PYTHON_API_VERSION);
+#endif
+}
+#endif
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.h b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.h
new file mode 100644
index 00000000000..c75219eb1a4
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/PythonReadline.h
@@ -0,0 +1,28 @@
+//===-- PythonReadline.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONREADLINE_H
+#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONREADLINE_H
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_LIBEDIT && defined(__linux__)
+// NOTE: Since Python may define some pre-processor definitions which affect the
+// standard headers on some systems, you must include Python.h before any
+// standard headers are included.
+#include "Python.h"
+
+// no need to hack into Python's readline module if libedit isn't used.
+//
+#define LLDB_USE_LIBEDIT_READLINE_COMPAT_MODULE 1
+
+PyMODINIT_FUNC initlldb_readline(void);
+
+#endif
+
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONREADLINE_H
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
new file mode 100644
index 00000000000..06e0d5bfa63
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
@@ -0,0 +1,3290 @@
+//===-- ScriptInterpreterPython.cpp -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+// LLDB Python header must be included first
+#include "lldb-python.h"
+
+#include "PythonDataObjects.h"
+#include "PythonReadline.h"
+#include "ScriptInterpreterPythonImpl.h"
+
+#include "lldb/API/SBFrame.h"
+#include "lldb/API/SBValue.h"
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Breakpoint/WatchpointOptions.h"
+#include "lldb/Core/Communication.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/DataFormatters/TypeSummary.h"
+#include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Host/Pipe.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPlan.h"
+#include "lldb/Utility/Timer.h"
+
+#if defined(_WIN32)
+#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
+#endif
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FormatAdapters.h"
+
+#include <memory>
+#include <mutex>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::python;
+using llvm::Expected;
+
+// Defined in the SWIG source file
+#if PY_MAJOR_VERSION >= 3
+extern "C" PyObject *PyInit__lldb(void);
+
+#define LLDBSwigPyInit PyInit__lldb
+
+#else
+extern "C" void init_lldb(void);
+
+#define LLDBSwigPyInit init_lldb
+#endif
+
+// These prototypes are the Pythonic implementations of the required callbacks.
+// Although these are scripting-language specific, their definition depends on
+// the public API.
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+
+// Disable warning C4190: 'LLDBSwigPythonBreakpointCallbackFunction' has
+// C-linkage specified, but returns UDT 'llvm::Expected<bool>' which is
+// incompatible with C
+#if _MSC_VER
+#pragma warning (push)
+#pragma warning (disable : 4190)
+#endif
+
+extern "C" llvm::Expected<bool> LLDBSwigPythonBreakpointCallbackFunction(
+    const char *python_function_name, const char *session_dictionary_name,
+    const lldb::StackFrameSP &sb_frame,
+    const lldb::BreakpointLocationSP &sb_bp_loc, StructuredDataImpl *args_impl);
+
+#if _MSC_VER
+#pragma warning (pop)
+#endif
+
+#pragma clang diagnostic pop
+
+extern "C" bool LLDBSwigPythonWatchpointCallbackFunction(
+    const char *python_function_name, const char *session_dictionary_name,
+    const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp);
+
+extern "C" bool LLDBSwigPythonCallTypeScript(
+    const char *python_function_name, void *session_dictionary,
+    const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
+    const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval);
+
+extern "C" void *
+LLDBSwigPythonCreateSyntheticProvider(const char *python_class_name,
+                                      const char *session_dictionary_name,
+                                      const lldb::ValueObjectSP &valobj_sp);
+
+extern "C" void *
+LLDBSwigPythonCreateCommandObject(const char *python_class_name,
+                                  const char *session_dictionary_name,
+                                  const lldb::DebuggerSP debugger_sp);
+
+extern "C" void *LLDBSwigPythonCreateScriptedThreadPlan(
+    const char *python_class_name, const char *session_dictionary_name,
+    StructuredDataImpl *args_data,
+    std::string &error_string,
+    const lldb::ThreadPlanSP &thread_plan_sp);
+
+extern "C" bool LLDBSWIGPythonCallThreadPlan(void *implementor,
+                                             const char *method_name,
+                                             Event *event_sp, bool &got_error);
+
+extern "C" void *LLDBSwigPythonCreateScriptedBreakpointResolver(
+    const char *python_class_name, const char *session_dictionary_name,
+    lldb_private::StructuredDataImpl *args, lldb::BreakpointSP &bkpt_sp);
+
+extern "C" unsigned int
+LLDBSwigPythonCallBreakpointResolver(void *implementor, const char *method_name,
+                                     lldb_private::SymbolContext *sym_ctx);
+
+extern "C" size_t LLDBSwigPython_CalculateNumChildren(void *implementor,
+                                                      uint32_t max);
+
+extern "C" void *LLDBSwigPython_GetChildAtIndex(void *implementor,
+                                                uint32_t idx);
+
+extern "C" int LLDBSwigPython_GetIndexOfChildWithName(void *implementor,
+                                                      const char *child_name);
+
+extern "C" void *LLDBSWIGPython_CastPyObjectToSBValue(void *data);
+
+extern lldb::ValueObjectSP
+LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data);
+
+extern "C" bool LLDBSwigPython_UpdateSynthProviderInstance(void *implementor);
+
+extern "C" bool
+LLDBSwigPython_MightHaveChildrenSynthProviderInstance(void *implementor);
+
+extern "C" void *
+LLDBSwigPython_GetValueSynthProviderInstance(void *implementor);
+
+extern "C" bool
+LLDBSwigPythonCallCommand(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);
+
+extern "C" bool
+LLDBSwigPythonCallCommandObject(void *implementor, lldb::DebuggerSP &debugger,
+                                const char *args,
+                                lldb_private::CommandReturnObject &cmd_retobj,
+                                lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+
+extern "C" bool
+LLDBSwigPythonCallModuleInit(const char *python_module_name,
+                             const char *session_dictionary_name,
+                             lldb::DebuggerSP &debugger);
+
+extern "C" void *
+LLDBSWIGPythonCreateOSPlugin(const char *python_class_name,
+                             const char *session_dictionary_name,
+                             const lldb::ProcessSP &process_sp);
+
+extern "C" void *
+LLDBSWIGPython_CreateFrameRecognizer(const char *python_class_name,
+                                     const char *session_dictionary_name);
+
+extern "C" void *
+LLDBSwigPython_GetRecognizedArguments(void *implementor,
+                                      const lldb::StackFrameSP &frame_sp);
+
+extern "C" bool LLDBSWIGPythonRunScriptKeywordProcess(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::ProcessSP &process, std::string &output);
+
+extern "C" bool LLDBSWIGPythonRunScriptKeywordThread(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::ThreadSP &thread, std::string &output);
+
+extern "C" bool LLDBSWIGPythonRunScriptKeywordTarget(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::TargetSP &target, std::string &output);
+
+extern "C" bool LLDBSWIGPythonRunScriptKeywordFrame(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::StackFrameSP &frame, std::string &output);
+
+extern "C" bool LLDBSWIGPythonRunScriptKeywordValue(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::ValueObjectSP &value, std::string &output);
+
+extern "C" void *
+LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
+                                 const lldb::TargetSP &target_sp);
+
+static bool g_initialized = false;
+
+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 {
+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);
+
+    InitializePythonHome();
+
+#ifdef LLDB_USE_LIBEDIT_READLINE_COMPAT_MODULE
+    // Python's readline is incompatible with libedit being linked into lldb.
+    // Provide a patched version local to the embedded interpreter.
+    bool ReadlinePatched = false;
+    for (auto *p = PyImport_Inittab; p->name != NULL; p++) {
+      if (strcmp(p->name, "readline") == 0) {
+        p->initfunc = initlldb_readline;
+        break;
+      }
+    }
+    if (!ReadlinePatched) {
+      PyImport_AppendInittab("readline", initlldb_readline);
+      ReadlinePatched = true;
+    }
+#endif
+
+    // Register _lldb as a built-in module.
+    PyImport_AppendInittab("_lldb", LLDBSwigPyInit);
+
+// 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();
+#else
+    InitializeThreadsPrivate();
+    Py_InitializeEx(0);
+#endif
+  }
+
+  ~InitializePythonRAII() {
+    if (m_was_already_initialized) {
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+      LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
+                m_gil_state == 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() {
+#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);
+#else
+    static char g_python_home[] = LLDB_PYTHON_HOME;
+#endif
+    Py_SetPythonHome(g_python_home);
+#else
+#if defined(__APPLE__) && PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION == 7
+    // For Darwin, the only Python version supported is the one shipped in the
+    // OS OS and linked with lldb. Other installation of Python may have higher
+    // priorities in the path, overriding PYTHONHOME and causing
+    // problems/incompatibilities. In order to avoid confusion, always hardcode
+    // the PythonHome to be right, as it's not going to change.
+    static char path[] =
+        "/System/Library/Frameworks/Python.framework/Versions/2.7";
+    Py_SetPythonHome(path);
+#endif
+#endif
+  }
+
+  void InitializeThreadsPrivate() {
+// Since Python 3.7 `Py_Initialize` calls `PyEval_InitThreads` inside itself,
+// so there is no way to determine whether the embedded interpreter
+// was already initialized by some external code. `PyEval_ThreadsInitialized`
+// would always return `true` and `PyGILState_Ensure/Release` flow would be
+// executed instead of unlocking GIL with `PyEval_SaveThread`. When
+// an another thread calls `PyGILState_Ensure` it would get stuck in deadlock.
+#if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 7) || (PY_MAJOR_VERSION > 3)
+    // The only case we should go further and acquire the GIL: it is unlocked.
+    if (PyGILState_Check())
+      return;
+#endif
+
+    if (PyEval_ThreadsInitialized()) {
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+
+      m_was_already_initialized = true;
+      m_gil_state = PyGILState_Ensure();
+      LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked\n",
+                m_gil_state == PyGILState_UNLOCKED ? "un" : "");
+      return;
+    }
+
+    // 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;
+};
+} // namespace
+
+void ScriptInterpreterPython::ComputePythonDirForApple(
+    llvm::SmallVectorImpl<char> &path) {
+  auto style = llvm::sys::path::Style::posix;
+
+  llvm::StringRef path_ref(path.begin(), path.size());
+  auto rbegin = llvm::sys::path::rbegin(path_ref, style);
+  auto rend = llvm::sys::path::rend(path_ref);
+  auto framework = std::find(rbegin, rend, "LLDB.framework");
+  if (framework == rend) {
+    ComputePythonDir(path);
+    return;
+  }
+  path.resize(framework - rend);
+  llvm::sys::path::append(path, style, "LLDB.framework", "Resources", "Python");
+}
+
+void ScriptInterpreterPython::ComputePythonDir(
+    llvm::SmallVectorImpl<char> &path) {
+  // Build the path by backing out of the lib dir, then building with whatever
+  // the real python interpreter uses.  (e.g. lib for most, lib64 on RHEL
+  // x86_64, or bin on Windows).
+  llvm::sys::path::remove_filename(path);
+  llvm::sys::path::append(path, LLDB_PYTHON_RELATIVE_LIBDIR);
+
+#if defined(_WIN32)
+  // This will be injected directly through FileSpec.GetDirectory().SetString(),
+  // so we need to normalize manually.
+  std::replace(path.begin(), path.end(), '\\', '/');
+#endif
+}
+
+FileSpec ScriptInterpreterPython::GetPythonDir() {
+  static FileSpec g_spec = []() {
+    FileSpec spec = HostInfo::GetShlibDir();
+    if (!spec)
+      return FileSpec();
+    llvm::SmallString<64> path;
+    spec.GetPath(path);
+
+#if defined(__APPLE__)
+    ComputePythonDirForApple(path);
+#else
+    ComputePythonDir(path);
+#endif
+    spec.GetDirectory().SetString(path);
+    return spec;
+  }();
+  return g_spec;
+}
+
+lldb_private::ConstString ScriptInterpreterPython::GetPluginNameStatic() {
+  static ConstString g_name("script-python");
+  return g_name;
+}
+
+const char *ScriptInterpreterPython::GetPluginDescriptionStatic() {
+  return "Embedded Python interpreter";
+}
+
+void ScriptInterpreterPython::Initialize() {
+  static llvm::once_flag g_once_flag;
+
+  llvm::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  lldb::eScriptLanguagePython,
+                                  ScriptInterpreterPythonImpl::CreateInstance);
+  });
+}
+
+void ScriptInterpreterPython::Terminate() {}
+
+ScriptInterpreterPythonImpl::Locker::Locker(
+    ScriptInterpreterPythonImpl *py_interpreter, uint16_t on_entry,
+    uint16_t on_leave, FileSP in, FileSP out, FileSP 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)) {
+      // Don't teardown the session if we didn't init it.
+      m_teardown_session = false;
+    }
+  }
+}
+
+bool ScriptInterpreterPythonImpl::Locker::DoAcquireLock() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+  m_GILState = PyGILState_Ensure();
+  LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked",
+            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 ScriptInterpreterPythonImpl::Locker::DoInitSession(uint16_t on_entry_flags,
+                                                        FileSP in, FileSP out,
+                                                        FileSP err) {
+  if (!m_python_interpreter)
+    return false;
+  return m_python_interpreter->EnterSession(on_entry_flags, in, out, err);
+}
+
+bool ScriptInterpreterPythonImpl::Locker::DoFreeLock() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+  LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
+            m_GILState == PyGILState_UNLOCKED ? "un" : "");
+  PyGILState_Release(m_GILState);
+  m_python_interpreter->DecrementLockCount();
+  return true;
+}
+
+bool ScriptInterpreterPythonImpl::Locker::DoTearDownSession() {
+  if (!m_python_interpreter)
+    return false;
+  m_python_interpreter->LeaveSession();
+  return true;
+}
+
+ScriptInterpreterPythonImpl::Locker::~Locker() {
+  if (m_teardown_session)
+    DoTearDownSession();
+  DoFreeLock();
+}
+
+ScriptInterpreterPythonImpl::ScriptInterpreterPythonImpl(Debugger &debugger)
+    : ScriptInterpreterPython(debugger), m_saved_stdin(), m_saved_stdout(),
+      m_saved_stderr(), m_main_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(m_debugger.GetInstanceName().AsCString()),
+      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, Locker::AcquireLock, 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(), m_debugger.GetID());
+  PyRun_SimpleString(run_string.GetData());
+}
+
+ScriptInterpreterPythonImpl::~ScriptInterpreterPythonImpl() {
+  // 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);
+}
+
+lldb_private::ConstString ScriptInterpreterPythonImpl::GetPluginName() {
+  return GetPluginNameStatic();
+}
+
+uint32_t ScriptInterpreterPythonImpl::GetPluginVersion() { return 1; }
+
+void ScriptInterpreterPythonImpl::IOHandlerActivated(IOHandler &io_handler,
+                                                     bool interactive) {
+  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.GetOutputStreamFileSP());
+    if (output_sp && interactive) {
+      output_sp->PutCString(instructions);
+      output_sp->Flush();
+    }
+  }
+}
+
+void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
+                                                         std::string &data) {
+  io_handler.SetIsDone(true);
+  bool batch_mode = m_debugger.GetCommandInterpreter().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_up = std::make_unique<CommandDataPython>();
+      if (!data_up)
+        break;
+      data_up->user_source.SplitIntoLines(data);
+
+      StructuredData::ObjectSP empty_args_sp;
+      if (GenerateBreakpointCommandCallbackData(data_up->user_source,
+                                                data_up->script_source,
+                                                false)
+              .Success()) {
+        auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>(
+            std::move(data_up));
+        bp_options->SetCallback(
+            ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
+      } else if (!batch_mode) {
+        StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
+        if (error_sp) {
+          error_sp->Printf("Warning: No command attached to breakpoint.\n");
+          error_sp->Flush();
+        }
+      }
+    }
+    m_active_io_handler = eIOHandlerNone;
+  } break;
+  case eIOHandlerWatchpoint: {
+    WatchpointOptions *wp_options =
+        (WatchpointOptions *)io_handler.GetUserData();
+    auto data_up = std::make_unique<WatchpointOptions::CommandData>();
+    data_up->user_source.SplitIntoLines(data);
+
+    if (GenerateWatchpointCommandCallbackData(data_up->user_source,
+                                              data_up->script_source)) {
+      auto baton_sp =
+          std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
+      wp_options->SetCallback(
+          ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
+    } else if (!batch_mode) {
+      StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
+      if (error_sp) {
+        error_sp->Printf("Warning: No command attached to breakpoint.\n");
+        error_sp->Flush();
+      }
+    }
+    m_active_io_handler = eIOHandlerNone;
+  } break;
+  }
+}
+
+lldb::ScriptInterpreterSP
+ScriptInterpreterPythonImpl::CreateInstance(Debugger &debugger) {
+  return std::make_shared<ScriptInterpreterPythonImpl>(debugger);
+}
+
+void ScriptInterpreterPythonImpl::LeaveSession() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+  if (log)
+    log->PutCString("ScriptInterpreterPythonImpl::LeaveSession()");
+
+  // Unset the LLDB global variables.
+  PyRun_SimpleString("lldb.debugger = None; lldb.target = None; lldb.process "
+                     "= None; lldb.thread = None; lldb.frame = None");
+
+  // 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 ScriptInterpreterPythonImpl::SetStdHandle(FileSP file_sp,
+                                               const char *py_name,
+                                               PythonObject &save_file,
+                                               const char *mode) {
+  if (!file_sp || !*file_sp) {
+    save_file.Reset();
+    return false;
+  }
+  File &file = *file_sp;
+
+  // Flush the file before giving it to python to avoid interleaved output.
+  file.Flush();
+
+  PythonDictionary &sys_module_dict = GetSysModuleDictionary();
+
+  auto new_file = PythonFile::FromFile(file, mode);
+  if (!new_file) {
+    llvm::consumeError(new_file.takeError());
+    return false;
+  }
+
+  save_file = sys_module_dict.GetItemForKey(PythonString(py_name));
+
+  sys_module_dict.SetItemForKey(PythonString(py_name), new_file.get());
+  return true;
+}
+
+bool ScriptInterpreterPythonImpl::EnterSession(uint16_t on_entry_flags,
+                                               FileSP in_sp, FileSP out_sp,
+                                               FileSP err_sp) {
+  // 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) {
+    LLDB_LOGF(
+        log,
+        "ScriptInterpreterPythonImpl::EnterSession(on_entry_flags=0x%" PRIx16
+        ") session is already active, returning without doing anything",
+        on_entry_flags);
+    return false;
+  }
+
+  LLDB_LOGF(
+      log,
+      "ScriptInterpreterPythonImpl::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(), m_debugger.GetID());
+    run_string.Printf(
+        "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
+        m_debugger.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(), m_debugger.GetID());
+    run_string.Printf(
+        "; lldb.debugger = lldb.SBDebugger.FindDebuggerWithID (%" PRIu64 ")",
+        m_debugger.GetID());
+    run_string.PutCString("')");
+  }
+
+  PyRun_SimpleString(run_string.GetData());
+  run_string.Clear();
+
+  PythonDictionary &sys_module_dict = GetSysModuleDictionary();
+  if (sys_module_dict.IsValid()) {
+    lldb::FileSP top_in_sp;
+    lldb::StreamFileSP top_out_sp, top_err_sp;
+    if (!in_sp || !out_sp || !err_sp || !*in_sp || !*out_sp || !*err_sp)
+      m_debugger.AdoptTopIOHandlerFilesIfInvalid(top_in_sp, top_out_sp,
+                                                 top_err_sp);
+
+    if (on_entry_flags & Locker::NoSTDIN) {
+      m_saved_stdin.Reset();
+    } else {
+      if (!SetStdHandle(in_sp, "stdin", m_saved_stdin, "r")) {
+        if (top_in_sp)
+          SetStdHandle(top_in_sp, "stdin", m_saved_stdin, "r");
+      }
+    }
+
+    if (!SetStdHandle(out_sp, "stdout", m_saved_stdout, "w")) {
+      if (top_out_sp)
+        SetStdHandle(top_out_sp->GetFileSP(), "stdout", m_saved_stdout, "w");
+    }
+
+    if (!SetStdHandle(err_sp, "stderr", m_saved_stderr, "w")) {
+      if (top_err_sp)
+        SetStdHandle(top_err_sp->GetFileSP(), "stderr", m_saved_stderr, "w");
+    }
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  return true;
+}
+
+PythonModule &ScriptInterpreterPythonImpl::GetMainModule() {
+  if (!m_main_module.IsValid())
+    m_main_module = unwrapIgnoringErrors(PythonModule::Import("__main__"));
+  return m_main_module;
+}
+
+PythonDictionary &ScriptInterpreterPythonImpl::GetSessionDictionary() {
+  if (m_session_dict.IsValid())
+    return m_session_dict;
+
+  PythonObject &main_module = GetMainModule();
+  if (!main_module.IsValid())
+    return m_session_dict;
+
+  PythonDictionary main_dict(PyRefType::Borrowed,
+                             PyModule_GetDict(main_module.get()));
+  if (!main_dict.IsValid())
+    return m_session_dict;
+
+  m_session_dict = unwrapIgnoringErrors(
+      As<PythonDictionary>(main_dict.GetItem(m_dictionary_name)));
+  return m_session_dict;
+}
+
+PythonDictionary &ScriptInterpreterPythonImpl::GetSysModuleDictionary() {
+  if (m_sys_module_dict.IsValid())
+    return m_sys_module_dict;
+  PythonModule sys_module = unwrapIgnoringErrors(PythonModule::Import("sys"));
+  m_sys_module_dict = sys_module.GetDictionary();
+  return m_sys_module_dict;
+}
+
+llvm::Expected<unsigned>
+ScriptInterpreterPythonImpl::GetMaxPositionalArgumentsForCallable(
+    const llvm::StringRef &callable_name) {
+  if (callable_name.empty()) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "called with empty callable name.");
+  }
+  Locker py_lock(this, Locker::AcquireLock |
+                 Locker::InitSession |
+                 Locker::NoSTDIN);
+  auto dict = PythonModule::MainModule()
+      .ResolveName<PythonDictionary>(m_dictionary_name);
+  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
+      callable_name, dict);
+  if (!pfunc.IsAllocated()) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "can't find callable: %s", callable_name.str().c_str());
+  }
+  llvm::Expected<PythonCallable::ArgInfo> arg_info = pfunc.GetArgInfo();
+  if (!arg_info)
+    return arg_info.takeError();
+  return arg_info.get().max_positional_args;
+}
+
+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 ScriptInterpreterPythonImpl::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 ScriptInterpreterPythonImpl::ExecuteOneLine(
+    llvm::StringRef command, CommandReturnObject *result,
+    const ExecuteScriptOptions &options) {
+  std::string command_str = command.str();
+
+  if (!m_valid_session)
+    return false;
+
+  if (!command.empty()) {
+    // 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_debugger;
+
+    FileSP input_file_sp;
+    StreamFileSP output_file_sp;
+    StreamFileSP error_file_sp;
+    Communication output_comm(
+        "lldb.ScriptInterpreterPythonImpl.ExecuteOneLine.comm");
+    bool join_read_thread = false;
+    if (options.GetEnableIO()) {
+      if (result) {
+        input_file_sp = debugger.GetInputFileSP();
+        // Set output to a temporary file so we can forward the results on to
+        // the result object
+
+        Pipe pipe;
+        Status 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_up(
+              new ConnectionGenericFile(read_file, true));
+#else
+          std::unique_ptr<ConnectionFileDescriptor> conn_up(
+              new ConnectionFileDescriptor(pipe.ReleaseReadFileDescriptor(),
+                                           true));
+#endif
+          if (conn_up->IsConnected()) {
+            output_comm.SetConnection(conn_up.release());
+            output_comm.SetReadThreadBytesReceivedCallback(
+                ReadThreadBytesReceived, &result->GetOutputStream());
+            output_comm.StartReadThread();
+            join_read_thread = true;
+            FILE *outfile_handle =
+                fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
+            output_file_sp = std::make_shared<StreamFile>(outfile_handle, true);
+            error_file_sp = output_file_sp;
+            if (outfile_handle)
+              ::setbuf(outfile_handle, nullptr);
+
+            result->SetImmediateOutputFile(
+                debugger.GetOutputStream().GetFileSP());
+            result->SetImmediateErrorFile(
+                debugger.GetErrorStream().GetFileSP());
+          }
+        }
+      }
+      if (!input_file_sp || !output_file_sp || !error_file_sp)
+        debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp,
+                                                 error_file_sp);
+    } else {
+      auto nullin = FileSystem::Instance().Open(
+                                  FileSpec(FileSystem::DEV_NULL),
+                                  File::eOpenOptionRead);
+      auto nullout = FileSystem::Instance().Open(
+                                  FileSpec(FileSystem::DEV_NULL),
+                                  File::eOpenOptionWrite);
+      if (!nullin) {
+        result->AppendErrorWithFormatv("failed to open /dev/null: {0}\n",
+                                       llvm::fmt_consume(nullin.takeError()));
+        return false;
+      }
+      if (!nullout) {
+        result->AppendErrorWithFormatv("failed to open /dev/null: {0}\n",
+                                       llvm::fmt_consume(nullout.takeError()));
+        return false;
+      }
+      input_file_sp = std::move(nullin.get());
+      error_file_sp = output_file_sp = std::make_shared<StreamFile>(std::move(nullout.get()));
+    }
+
+    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,
+          Locker::AcquireLock | Locker::InitSession |
+              (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
+              ((result && result->GetInteractive()) ? 0 : Locker::NoSTDIN),
+          Locker::FreeAcquiredLock | Locker::TearDownSession, input_file_sp,
+          output_file_sp->GetFileSP(), error_file_sp->GetFileSP());
+
+      // 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_str.c_str()));
+            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
+      output_file_sp->Flush();
+      error_file_sp->Flush();
+    }
+
+    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_str.c_str());
+    }
+    return false;
+  }
+
+  if (result)
+    result->AppendError("empty command passed to python\n");
+  return false;
+}
+
+void ScriptInterpreterPythonImpl::ExecuteInterpreterLoop() {
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
+
+  Debugger &debugger = m_debugger;
+
+  // 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 (!debugger.GetInputFile().IsValid())
+    return;
+
+  IOHandlerSP io_handler_sp(new IOHandlerPythonInterpreter(debugger, this));
+  if (io_handler_sp) {
+    debugger.PushIOHandler(io_handler_sp);
+  }
+}
+
+bool ScriptInterpreterPythonImpl::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);
+      LLDB_LOGF(log,
+                "ScriptInterpreterPythonImpl::Interrupt() sending "
+                "PyExc_KeyboardInterrupt (tid = %li, num_threads = %i)...",
+                tid, num_threads);
+      return true;
+    }
+  }
+  LLDB_LOGF(log,
+            "ScriptInterpreterPythonImpl::Interrupt() python code not running, "
+            "can't interrupt");
+  return false;
+}
+
+bool ScriptInterpreterPythonImpl::ExecuteOneLineWithReturn(
+    llvm::StringRef in_string, ScriptInterpreter::ScriptReturnType return_type,
+    void *ret_value, const ExecuteScriptOptions &options) {
+
+  Locker locker(this,
+                Locker::AcquireLock | Locker::InitSession |
+                    (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
+                    Locker::NoSTDIN,
+                Locker::FreeAcquiredLock | Locker::TearDownSession);
+
+  PythonModule &main_module = GetMainModule();
+  PythonDictionary globals = main_module.GetDictionary();
+
+  PythonDictionary locals = GetSessionDictionary();
+  if (!locals.IsValid())
+    locals = unwrapIgnoringErrors(
+        As<PythonDictionary>(globals.GetAttribute(m_dictionary_name)));
+  if (!locals.IsValid())
+    locals = globals;
+
+  Expected<PythonObject> maybe_py_return =
+      runStringOneLine(in_string, globals, locals);
+
+  if (!maybe_py_return) {
+    llvm::handleAllErrors(
+        maybe_py_return.takeError(),
+        [&](PythonException &E) {
+          E.Restore();
+          if (options.GetMaskoutErrors()) {
+            if (E.Matches(PyExc_SyntaxError)) {
+              PyErr_Print();
+            }
+            PyErr_Clear();
+          }
+        },
+        [](const llvm::ErrorInfoBase &E) {});
+    return false;
+  }
+
+  PythonObject py_return = std::move(maybe_py_return.get());
+  assert(py_return.IsValid());
+
+  switch (return_type) {
+  case eScriptReturnTypeCharPtr: // "char *"
+  {
+    const char format[3] = "s#";
+    return PyArg_Parse(py_return.get(), format, (char **)ret_value);
+  }
+  case eScriptReturnTypeCharStrOrNone: // char* or NULL if py_return ==
+                                       // Py_None
+  {
+    const char format[3] = "z";
+    return PyArg_Parse(py_return.get(), format, (char **)ret_value);
+  }
+  case eScriptReturnTypeBool: {
+    const char format[2] = "b";
+    return PyArg_Parse(py_return.get(), format, (bool *)ret_value);
+  }
+  case eScriptReturnTypeShortInt: {
+    const char format[2] = "h";
+    return PyArg_Parse(py_return.get(), format, (short *)ret_value);
+  }
+  case eScriptReturnTypeShortIntUnsigned: {
+    const char format[2] = "H";
+    return PyArg_Parse(py_return.get(), format, (unsigned short *)ret_value);
+  }
+  case eScriptReturnTypeInt: {
+    const char format[2] = "i";
+    return PyArg_Parse(py_return.get(), format, (int *)ret_value);
+  }
+  case eScriptReturnTypeIntUnsigned: {
+    const char format[2] = "I";
+    return PyArg_Parse(py_return.get(), format, (unsigned int *)ret_value);
+  }
+  case eScriptReturnTypeLongInt: {
+    const char format[2] = "l";
+    return PyArg_Parse(py_return.get(), format, (long *)ret_value);
+  }
+  case eScriptReturnTypeLongIntUnsigned: {
+    const char format[2] = "k";
+    return PyArg_Parse(py_return.get(), format, (unsigned long *)ret_value);
+  }
+  case eScriptReturnTypeLongLong: {
+    const char format[2] = "L";
+    return PyArg_Parse(py_return.get(), format, (long long *)ret_value);
+  }
+  case eScriptReturnTypeLongLongUnsigned: {
+    const char format[2] = "K";
+    return PyArg_Parse(py_return.get(), format,
+                       (unsigned long long *)ret_value);
+  }
+  case eScriptReturnTypeFloat: {
+    const char format[2] = "f";
+    return PyArg_Parse(py_return.get(), format, (float *)ret_value);
+  }
+  case eScriptReturnTypeDouble: {
+    const char format[2] = "d";
+    return PyArg_Parse(py_return.get(), format, (double *)ret_value);
+  }
+  case eScriptReturnTypeChar: {
+    const char format[2] = "c";
+    return PyArg_Parse(py_return.get(), format, (char *)ret_value);
+  }
+  case eScriptReturnTypeOpaqueObject: {
+    *((PyObject **)ret_value) = py_return.release();
+    return true;
+  }
+  }
+  llvm_unreachable("Fully covered switch!");
+}
+
+Status ScriptInterpreterPythonImpl::ExecuteMultipleLines(
+    const char *in_string, const ExecuteScriptOptions &options) {
+
+  if (in_string == nullptr)
+    return Status();
+
+  Locker locker(this,
+                Locker::AcquireLock | Locker::InitSession |
+                    (options.GetSetLLDBGlobals() ? Locker::InitGlobals : 0) |
+                    Locker::NoSTDIN,
+                Locker::FreeAcquiredLock | Locker::TearDownSession);
+
+  PythonModule &main_module = GetMainModule();
+  PythonDictionary globals = main_module.GetDictionary();
+
+  PythonDictionary locals = GetSessionDictionary();
+  if (!locals.IsValid())
+    locals = unwrapIgnoringErrors(
+        As<PythonDictionary>(globals.GetAttribute(m_dictionary_name)));
+  if (!locals.IsValid())
+    locals = globals;
+
+  Expected<PythonObject> return_value =
+      runStringMultiLine(in_string, globals, locals);
+
+  if (!return_value) {
+    llvm::Error error =
+        llvm::handleErrors(return_value.takeError(), [&](PythonException &E) {
+          llvm::Error error = llvm::createStringError(
+              llvm::inconvertibleErrorCode(), E.ReadBacktrace());
+          if (!options.GetMaskoutErrors())
+            E.Restore();
+          return error;
+        });
+    return Status(std::move(error));
+  }
+
+  return Status();
+}
+
+void ScriptInterpreterPythonImpl::CollectDataForBreakpointCommandCallback(
+    std::vector<BreakpointOptions *> &bp_options_vec,
+    CommandReturnObject &result) {
+  m_active_io_handler = eIOHandlerBreakpoint;
+  m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler(
+      "    ", *this, &bp_options_vec);
+}
+
+void ScriptInterpreterPythonImpl::CollectDataForWatchpointCommandCallback(
+    WatchpointOptions *wp_options, CommandReturnObject &result) {
+  m_active_io_handler = eIOHandlerWatchpoint;
+  m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler(
+      "    ", *this, wp_options);
+}
+
+Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallbackFunction(
+    BreakpointOptions *bp_options, const char *function_name,
+    StructuredData::ObjectSP extra_args_sp) {
+  Status error;
+  // For now just cons up a oneliner that calls the provided function.
+  std::string oneliner("return ");
+  oneliner += function_name;
+
+  llvm::Expected<unsigned> maybe_args =
+      GetMaxPositionalArgumentsForCallable(function_name);
+  if (!maybe_args) {
+    error.SetErrorStringWithFormat(
+        "could not get num args: %s",
+        llvm::toString(maybe_args.takeError()).c_str());
+    return error;
+  }
+  size_t max_args = *maybe_args;
+
+  bool uses_extra_args = false;
+  if (max_args >= 4) {
+    uses_extra_args = true;
+    oneliner += "(frame, bp_loc, extra_args, internal_dict)";
+  } else if (max_args >= 3) {
+    if (extra_args_sp) {
+      error.SetErrorString("cannot pass extra_args to a three argument callback"
+                          );
+      return error;
+    }
+    uses_extra_args = false;
+    oneliner += "(frame, bp_loc, internal_dict)";
+  } else {
+    error.SetErrorStringWithFormat("expected 3 or 4 argument "
+                                   "function, %s can only take %zu",
+                                   function_name, max_args);
+    return error;
+  }
+
+  SetBreakpointCommandCallback(bp_options, oneliner.c_str(), extra_args_sp,
+                               uses_extra_args);
+  return error;
+}
+
+Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
+    BreakpointOptions *bp_options,
+    std::unique_ptr<BreakpointOptions::CommandData> &cmd_data_up) {
+  Status error;
+  error = GenerateBreakpointCommandCallbackData(cmd_data_up->user_source,
+                                                cmd_data_up->script_source,
+                                                false);
+  if (error.Fail()) {
+    return error;
+  }
+  auto baton_sp =
+      std::make_shared<BreakpointOptions::CommandBaton>(std::move(cmd_data_up));
+  bp_options->SetCallback(
+      ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
+  return error;
+}
+
+Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
+    BreakpointOptions *bp_options, const char *command_body_text) {
+  return SetBreakpointCommandCallback(bp_options, command_body_text, {},false);
+}
+
+// Set a Python one-liner as the callback for the breakpoint.
+Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
+    BreakpointOptions *bp_options, const char *command_body_text,
+    StructuredData::ObjectSP extra_args_sp,
+    bool uses_extra_args) {
+  auto data_up = std::make_unique<CommandDataPython>(extra_args_sp);
+  // 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_up->user_source.SplitIntoLines(command_body_text);
+  Status error = GenerateBreakpointCommandCallbackData(data_up->user_source,
+                                                       data_up->script_source,
+                                                       uses_extra_args);
+  if (error.Success()) {
+    auto baton_sp =
+        std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
+    bp_options->SetCallback(
+        ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
+    return error;
+  } else
+    return error;
+}
+
+// Set a Python one-liner as the callback for the watchpoint.
+void ScriptInterpreterPythonImpl::SetWatchpointCommandCallback(
+    WatchpointOptions *wp_options, const char *oneliner) {
+  auto data_up = std::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_up->user_source.AppendString(oneliner);
+  data_up->script_source.assign(oneliner);
+
+  if (GenerateWatchpointCommandCallbackData(data_up->user_source,
+                                            data_up->script_source)) {
+    auto baton_sp =
+        std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
+    wp_options->SetCallback(
+        ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
+  }
+
+  return;
+}
+
+Status ScriptInterpreterPythonImpl::ExportFunctionDefinitionToInterpreter(
+    StringList &function_def) {
+  // Convert StringList to one long, newline delimited, const char *.
+  std::string function_def_string(function_def.CopyList());
+
+  Status error = ExecuteMultipleLines(
+      function_def_string.c_str(),
+      ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false));
+  return error;
+}
+
+Status ScriptInterpreterPythonImpl::GenerateFunction(const char *signature,
+                                                     const StringList &input) {
+  Status 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;
+  }
+
+  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 ScriptInterpreterPythonImpl::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;
+
+  // Store the name of the auto-generated function to be called.
+  output.assign(auto_generated_function_name);
+  return true;
+}
+
+bool ScriptInterpreterPythonImpl::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));
+
+  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;
+}
+
+bool ScriptInterpreterPythonImpl::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.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::GenericSP
+ScriptInterpreterPythonImpl::CreateFrameRecognizer(const char *class_name) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::GenericSP();
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
+                   Locker::FreeLock);
+    ret_val = LLDBSWIGPython_CreateFrameRecognizer(class_name,
+                                                   m_dictionary_name.c_str());
+  }
+
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+}
+
+lldb::ValueObjectListSP ScriptInterpreterPythonImpl::GetRecognizedArguments(
+    const StructuredData::ObjectSP &os_plugin_object_sp,
+    lldb::StackFrameSP frame_sp) {
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
+
+  if (!os_plugin_object_sp)
+    return ValueObjectListSP();
+
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  if (!implementor.IsAllocated())
+    return ValueObjectListSP();
+
+  PythonObject py_return(PyRefType::Owned,
+                         (PyObject *)LLDBSwigPython_GetRecognizedArguments(
+                             implementor.get(), frame_sp));
+
+  // 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());
+    ValueObjectListSP result = ValueObjectListSP(new ValueObjectList());
+    for (size_t i = 0; i < result_list.GetSize(); i++) {
+      PyObject *item = result_list.GetItemAtIndex(i).get();
+      lldb::SBValue *sb_value_ptr =
+          (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(item);
+      auto valobj_sp = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
+      if (valobj_sp)
+        result->Append(valobj_sp);
+    }
+    return result;
+  }
+  return ValueObjectListSP();
+}
+
+StructuredData::GenericSP
+ScriptInterpreterPythonImpl::OSPlugin_CreatePluginObject(
+    const char *class_name, lldb::ProcessSP process_sp) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::GenericSP();
+
+  if (!process_sp)
+    return StructuredData::GenericSP();
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
+                   Locker::FreeLock);
+    ret_val = LLDBSWIGPythonCreateOSPlugin(
+        class_name, m_dictionary_name.c_str(), process_sp);
+  }
+
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+}
+
+StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_RegisterInfo(
+    StructuredData::ObjectSP os_plugin_object_sp) {
+  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();
+
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  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_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 ScriptInterpreterPythonImpl::OSPlugin_ThreadsInfo(
+    StructuredData::ObjectSP os_plugin_object_sp) {
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
+
+  static char callee_name[] = "get_thread_info";
+
+  if (!os_plugin_object_sp)
+    return StructuredData::ArraySP();
+
+  StructuredData::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  if (!implementor.IsAllocated())
+    return StructuredData::ArraySP();
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  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 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
+// convert a variable's type into a python value format. Python value formats
+// are defined in terms of builtin C types and could change from system to as
+// the underlying typedef for uint* types, size_t, off_t and other values
+// change.
+
+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(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
+ScriptInterpreterPythonImpl::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));
+
+  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 ScriptInterpreterPythonImpl::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::Generic *generic = os_plugin_object_sp->GetAsGeneric();
+  if (!generic)
+    return nullptr;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  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_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 ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
+    const char *class_name, StructuredDataImpl *args_data,
+    std::string &error_str, lldb::ThreadPlanSP thread_plan_sp) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::ObjectSP();
+
+  if (!thread_plan_sp.get())
+    return {};
+
+  Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
+  ScriptInterpreterPythonImpl *python_interpreter =
+      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
+
+  if (!script_interpreter)
+    return {};
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSwigPythonCreateScriptedThreadPlan(
+        class_name, python_interpreter->m_dictionary_name.c_str(),
+        args_data, error_str, thread_plan_sp);
+    if (!ret_val)
+      return {};
+  }
+
+  return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
+}
+
+bool ScriptInterpreterPythonImpl::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 = LLDBSWIGPythonCallThreadPlan(
+        generic->GetValue(), "explains_stop", event, script_error);
+    if (script_error)
+      return true;
+  }
+  return explains_stop;
+}
+
+bool ScriptInterpreterPythonImpl::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 = LLDBSWIGPythonCallThreadPlan(
+        generic->GetValue(), "should_stop", event, script_error);
+    if (script_error)
+      return true;
+  }
+  return should_stop;
+}
+
+bool ScriptInterpreterPythonImpl::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 = LLDBSWIGPythonCallThreadPlan(generic->GetValue(), "is_stale",
+                                            nullptr, script_error);
+    if (script_error)
+      return true;
+  }
+  return is_stale;
+}
+
+lldb::StateType ScriptInterpreterPythonImpl::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 = LLDBSWIGPythonCallThreadPlan(
+        generic->GetValue(), "should_step", nullptr, script_error);
+    if (script_error)
+      should_step = true;
+  }
+  if (should_step)
+    return lldb::eStateStepping;
+  else
+    return lldb::eStateRunning;
+}
+
+StructuredData::GenericSP
+ScriptInterpreterPythonImpl::CreateScriptedBreakpointResolver(
+    const char *class_name, StructuredDataImpl *args_data,
+    lldb::BreakpointSP &bkpt_sp) {
+
+  if (class_name == nullptr || class_name[0] == '\0')
+    return StructuredData::GenericSP();
+
+  if (!bkpt_sp.get())
+    return StructuredData::GenericSP();
+
+  Debugger &debugger = bkpt_sp->GetTarget().GetDebugger();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
+  ScriptInterpreterPythonImpl *python_interpreter =
+      static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
+
+  if (!script_interpreter)
+    return StructuredData::GenericSP();
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+
+    ret_val = LLDBSwigPythonCreateScriptedBreakpointResolver(
+        class_name, python_interpreter->m_dictionary_name.c_str(), args_data,
+        bkpt_sp);
+  }
+
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+}
+
+bool ScriptInterpreterPythonImpl::ScriptedBreakpointResolverSearchCallback(
+    StructuredData::GenericSP implementor_sp, SymbolContext *sym_ctx) {
+  bool should_continue = false;
+
+  if (implementor_sp) {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    should_continue = LLDBSwigPythonCallBreakpointResolver(
+        implementor_sp->GetValue(), "__callback__", sym_ctx);
+    if (PyErr_Occurred()) {
+      PyErr_Print();
+      PyErr_Clear();
+    }
+  }
+  return should_continue;
+}
+
+lldb::SearchDepth
+ScriptInterpreterPythonImpl::ScriptedBreakpointResolverSearchDepth(
+    StructuredData::GenericSP implementor_sp) {
+  int depth_as_int = lldb::eSearchDepthModule;
+  if (implementor_sp) {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    depth_as_int = LLDBSwigPythonCallBreakpointResolver(
+        implementor_sp->GetValue(), "__get_depth__", nullptr);
+    if (PyErr_Occurred()) {
+      PyErr_Print();
+      PyErr_Clear();
+    }
+  }
+  if (depth_as_int == lldb::eSearchDepthInvalid)
+    return lldb::eSearchDepthModule;
+
+  if (depth_as_int <= lldb::kLastSearchDepthKind)
+    return (lldb::SearchDepth)depth_as_int;
+  else
+    return lldb::eSearchDepthModule;
+}
+
+StructuredData::ObjectSP
+ScriptInterpreterPythonImpl::LoadPluginModule(const FileSpec &file_spec,
+                                              lldb_private::Status &error) {
+  if (!FileSystem::Instance().Exists(file_spec)) {
+    error.SetErrorString("no such file");
+    return StructuredData::ObjectSP();
+  }
+
+  StructuredData::ObjectSP module_sp;
+
+  if (LoadScriptingModule(file_spec.GetPath().c_str(), true, error, &module_sp))
+    return module_sp;
+
+  return StructuredData::ObjectSP();
+}
+
+StructuredData::DictionarySP ScriptInterpreterPythonImpl::GetDynamicSettings(
+    StructuredData::ObjectSP plugin_module_sp, Target *target,
+    const char *setting_name, lldb_private::Status &error) {
+  if (!plugin_module_sp || !target || !setting_name || !setting_name[0])
+    return StructuredData::DictionarySP();
+  StructuredData::Generic *generic = plugin_module_sp->GetAsGeneric();
+  if (!generic)
+    return StructuredData::DictionarySP();
+
+  Locker py_lock(this,
+                 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+  TargetSP target_sp(target->shared_from_this());
+
+  auto setting = (PyObject *)LLDBSWIGPython_GetDynamicSetting(
+      generic->GetValue(), setting_name, target_sp);
+
+  if (!setting)
+    return StructuredData::DictionarySP();
+
+  PythonDictionary py_dict =
+      unwrapIgnoringErrors(As<PythonDictionary>(Take<PythonObject>(setting)));
+
+  if (!py_dict)
+    return StructuredData::DictionarySP();
+
+  return py_dict.CreateStructuredDictionary();
+}
+
+StructuredData::ObjectSP
+ScriptInterpreterPythonImpl::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();
+
+  ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
+  Target *target = exe_ctx.GetTargetPtr();
+
+  if (!target)
+    return StructuredData::ObjectSP();
+
+  Debugger &debugger = target->GetDebugger();
+  ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
+  ScriptInterpreterPythonImpl *python_interpreter =
+      (ScriptInterpreterPythonImpl *)script_interpreter;
+
+  if (!script_interpreter)
+    return StructuredData::ObjectSP();
+
+  void *ret_val = nullptr;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSwigPythonCreateSyntheticProvider(
+        class_name, python_interpreter->m_dictionary_name.c_str(), valobj);
+  }
+
+  return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
+}
+
+StructuredData::GenericSP
+ScriptInterpreterPythonImpl::CreateScriptCommandObject(const char *class_name) {
+  DebuggerSP debugger_sp(m_debugger.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 = LLDBSwigPythonCreateCommandObject(
+        class_name, m_dictionary_name.c_str(), debugger_sp);
+  }
+
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+}
+
+bool ScriptInterpreterPythonImpl::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 ScriptInterpreterPythonImpl::GenerateTypeSynthClass(
+    const char *oneliner, std::string &output, const void *name_token) {
+  StringList input;
+  input.SplitIntoLines(oneliner, strlen(oneliner));
+  return GenerateTypeSynthClass(input, output, name_token);
+}
+
+Status ScriptInterpreterPythonImpl::GenerateBreakpointCommandCallbackData(
+    StringList &user_input, std::string &output,
+    bool has_extra_args) {
+  static uint32_t num_created_functions = 0;
+  user_input.RemoveBlankLines();
+  StreamString sstr;
+  Status 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));
+  if (has_extra_args)
+    sstr.Printf("def %s (frame, bp_loc, extra_args, internal_dict):",
+                auto_generated_function_name.c_str());
+  else
+    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);
+  return error;
+}
+
+bool ScriptInterpreterPythonImpl::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;
+
+  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 ScriptInterpreterPythonImpl::GetScriptedSummary(
+    const char *python_function_name, lldb::ValueObjectSP valobj,
+    StructuredData::ObjectSP &callee_wrapper_sp,
+    const TypeSummaryOptions &options, std::string &retval) {
+
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
+
+  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));
+
+        static Timer::Category func_cat("LLDBSwigPythonCallTypeScript");
+        Timer scoped_timer(func_cat, "LLDBSwigPythonCallTypeScript");
+        ret_val = LLDBSwigPythonCallTypeScript(
+            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 = std::make_shared<StructuredPythonObject>(new_callee);
+
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::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.GetScriptInterpreter();
+  ScriptInterpreterPythonImpl *python_interpreter =
+      (ScriptInterpreterPythonImpl *)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;
+        {
+          Locker py_lock(python_interpreter, Locker::AcquireLock |
+                                                 Locker::InitSession |
+                                                 Locker::NoSTDIN);
+          Expected<bool> maybe_ret_val =
+              LLDBSwigPythonBreakpointCallbackFunction(
+                  python_function_name,
+                  python_interpreter->m_dictionary_name.c_str(), stop_frame_sp,
+                  bp_loc_sp, bp_option_data->m_extra_args_up.get());
+
+          if (!maybe_ret_val) {
+
+            llvm::handleAllErrors(
+                maybe_ret_val.takeError(),
+                [&](PythonException &E) {
+                  debugger.GetErrorStream() << E.ReadBacktrace();
+                },
+                [&](const llvm::ErrorInfoBase &E) {
+                  debugger.GetErrorStream() << E.message();
+                });
+
+          } else {
+            ret_val = maybe_ret_val.get();
+          }
+        }
+        return ret_val;
+      }
+    }
+  }
+  // We currently always true so we stop in case anything goes wrong when
+  // trying to call the script function
+  return true;
+}
+
+bool ScriptInterpreterPythonImpl::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.GetScriptInterpreter();
+  ScriptInterpreterPythonImpl *python_interpreter =
+      (ScriptInterpreterPythonImpl *)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;
+        {
+          Locker py_lock(python_interpreter, Locker::AcquireLock |
+                                                 Locker::InitSession |
+                                                 Locker::NoSTDIN);
+          ret_val = LLDBSwigPythonWatchpointCallbackFunction(
+              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;
+}
+
+size_t ScriptInterpreterPythonImpl::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;
+
+  size_t ret_val = 0;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSwigPython_CalculateNumChildren(implementor, max);
+  }
+
+  return ret_val;
+}
+
+lldb::ValueObjectSP ScriptInterpreterPythonImpl::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();
+
+  lldb::ValueObjectSP ret_val;
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    void *child_ptr = LLDBSwigPython_GetChildAtIndex(implementor, idx);
+    if (child_ptr != nullptr && child_ptr != Py_None) {
+      lldb::SBValue *sb_value_ptr =
+          (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(child_ptr);
+      if (sb_value_ptr == nullptr)
+        Py_XDECREF(child_ptr);
+      else
+        ret_val = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
+    } else {
+      Py_XDECREF(child_ptr);
+    }
+  }
+
+  return ret_val;
+}
+
+int ScriptInterpreterPythonImpl::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;
+
+  int ret_val = UINT32_MAX;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSwigPython_GetIndexOfChildWithName(implementor, child_name);
+  }
+
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::UpdateSynthProviderInstance(
+    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;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSwigPython_UpdateSynthProviderInstance(implementor);
+  }
+
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::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;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val =
+        LLDBSwigPython_MightHaveChildrenSynthProviderInstance(implementor);
+  }
+
+  return ret_val;
+}
+
+lldb::ValueObjectSP ScriptInterpreterPythonImpl::GetSyntheticValue(
+    const StructuredData::ObjectSP &implementor_sp) {
+  lldb::ValueObjectSP ret_val(nullptr);
+
+  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;
+
+  {
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    void *child_ptr = LLDBSwigPython_GetValueSynthProviderInstance(implementor);
+    if (child_ptr != nullptr && child_ptr != Py_None) {
+      lldb::SBValue *sb_value_ptr =
+          (lldb::SBValue *)LLDBSWIGPython_CastPyObjectToSBValue(child_ptr);
+      if (sb_value_ptr == nullptr)
+        Py_XDECREF(child_ptr);
+      else
+        ret_val = LLDBSWIGPython_GetValueObjectSPFromSBValue(sb_value_ptr);
+    } else {
+      Py_XDECREF(child_ptr);
+    }
+  }
+
+  return ret_val;
+}
+
+ConstString ScriptInterpreterPythonImpl::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;
+
+  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());
+
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, Process *process, std::string &output,
+    Status &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;
+  }
+
+  {
+    ProcessSP process_sp(process->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSWIGPythonRunScriptKeywordProcess(
+        impl_function, m_dictionary_name.c_str(), process_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, Thread *thread, std::string &output,
+    Status &error) {
+  bool ret_val;
+  if (!thread) {
+    error.SetErrorString("no thread");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+
+  {
+    ThreadSP thread_sp(thread->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSWIGPythonRunScriptKeywordThread(
+        impl_function, m_dictionary_name.c_str(), thread_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, Target *target, std::string &output,
+    Status &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;
+  }
+
+  {
+    TargetSP target_sp(target->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSWIGPythonRunScriptKeywordTarget(
+        impl_function, m_dictionary_name.c_str(), target_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, StackFrame *frame, std::string &output,
+    Status &error) {
+  bool ret_val;
+  if (!frame) {
+    error.SetErrorString("no frame");
+    return false;
+  }
+  if (!impl_function || !impl_function[0]) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+
+  {
+    StackFrameSP frame_sp(frame->shared_from_this());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSWIGPythonRunScriptKeywordFrame(
+        impl_function, m_dictionary_name.c_str(), frame_sp, output);
+    if (!ret_val)
+      error.SetErrorString("python script evaluation failed");
+  }
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptFormatKeyword(
+    const char *impl_function, ValueObject *value, std::string &output,
+    Status &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;
+  }
+
+  {
+    ValueObjectSP value_sp(value->GetSP());
+    Locker py_lock(this,
+                   Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+    ret_val = LLDBSWIGPythonRunScriptKeywordValue(
+        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 ScriptInterpreterPythonImpl::LoadScriptingModule(
+    const char *pathname, bool init_session, lldb_private::Status &error,
+    StructuredData::ObjectSP *module_sp) {
+  if (!pathname || !pathname[0]) {
+    error.SetErrorString("invalid pathname");
+    return false;
+  }
+
+  lldb::DebuggerSP debugger_sp = m_debugger.shared_from_this();
+
+  {
+    FileSpec target_file(pathname);
+    FileSystem::Instance().Resolve(target_file);
+    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));
+    namespace fs = llvm::sys::fs;
+    fs::file_status st;
+    std::error_code ec = status(target_file.GetPath(), st);
+
+    if (ec || st.type() == fs::file_type::status_error ||
+        st.type() == fs::file_type::type_unknown ||
+        st.type() == fs::file_type::file_not_found) {
+      // 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 (is_directory(st) || is_regular_file(st)) {
+      if (target_file.GetDirectory().IsEmpty()) {
+        error.SetErrorString("invalid directory name");
+        return false;
+      }
+
+      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 (llvm::StringRef(extension.GetCString()) == ".py")
+          basename.resize(basename.length() - 3);
+        else if (llvm::StringRef(extension.GetCString()) == ".pyc")
+          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(),
+             ScriptInterpreterPythonImpl::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);
+
+    // 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 (!LLDBSwigPythonCallModuleInit(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 = std::make_shared<StructuredPythonObject>(module_pyobj);
+    }
+
+    return true;
+  }
+}
+
+bool ScriptInterpreterPythonImpl::IsReservedWord(const char *word) {
+  if (!word || !word[0])
+    return false;
+
+  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('"') != llvm::StringRef::npos ||
+      word_sr.find('\'') != 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;
+}
+
+ScriptInterpreterPythonImpl::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);
+}
+
+ScriptInterpreterPythonImpl::SynchronicityHandler::~SynchronicityHandler() {
+  if (m_synch_wanted != eScriptedCommandSynchronicityCurrentValue)
+    m_debugger_sp->SetAsyncExecution(m_old_asynch);
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
+    const char *impl_function, llvm::StringRef args,
+    ScriptedCommandSynchronicity synchronicity,
+    lldb_private::CommandReturnObject &cmd_retobj, Status &error,
+    const lldb_private::ExecutionContext &exe_ctx) {
+  if (!impl_function) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+
+  lldb::DebuggerSP debugger_sp = m_debugger.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);
+
+    std::string args_str = args.str();
+    ret_val = LLDBSwigPythonCallCommand(
+        impl_function, m_dictionary_name.c_str(), debugger_sp, args_str.c_str(),
+        cmd_retobj, exe_ctx_ref_sp);
+  }
+
+  if (!ret_val)
+    error.SetErrorString("unable to execute script function");
+  else
+    error.Clear();
+
+  return ret_val;
+}
+
+bool ScriptInterpreterPythonImpl::RunScriptBasedCommand(
+    StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
+    ScriptedCommandSynchronicity synchronicity,
+    lldb_private::CommandReturnObject &cmd_retobj, Status &error,
+    const lldb_private::ExecutionContext &exe_ctx) {
+  if (!impl_obj_sp || !impl_obj_sp->IsValid()) {
+    error.SetErrorString("no function to execute");
+    return false;
+  }
+
+  lldb::DebuggerSP debugger_sp = m_debugger.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);
+
+    std::string args_str = args.str();
+    ret_val = LLDBSwigPythonCallCommandObject(impl_obj_sp->GetValue(),
+                                              debugger_sp, args_str.c_str(),
+                                              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 ScriptInterpreterPythonImpl::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 ScriptInterpreterPythonImpl::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;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)cmd_obj_sp->GetValue());
+
+  if (!implementor.IsAllocated())
+    return false;
+
+  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_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 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 ScriptInterpreterPythonImpl::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;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)cmd_obj_sp->GetValue());
+
+  if (!implementor.IsAllocated())
+    return result;
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  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 ScriptInterpreterPythonImpl::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;
+
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)cmd_obj_sp->GetValue());
+
+  if (!implementor.IsAllocated())
+    return false;
+
+  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_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 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>
+ScriptInterpreterPythonImpl::AcquireInterpreterLock() {
+  std::unique_ptr<ScriptInterpreterLocker> py_lock(new Locker(
+      this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN,
+      Locker::FreeLock | Locker::TearDownSession));
+  return py_lock;
+}
+
+void ScriptInterpreterPythonImpl::InitializePrivate() {
+  if (g_initialized)
+    return;
+
+  g_initialized = true;
+
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, 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;
+
+  LLDBSwigPyInit();
+
+  // Update the path python uses to search for modules to include the current
+  // directory.
+
+  PyRun_SimpleString("import sys");
+  AddToSysPath(AddLocation::End, ".");
+
+  // 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 (FileSpec file_spec = GetPythonDir())
+    AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
+  if (FileSpec file_spec = HostInfo::GetShlibDir())
+    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 ScriptInterpreterPythonImpl::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());
+}
+
+// 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
+// ScriptInterpreterPythonImpl::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 process exits).
+//
+// void ScriptInterpreterPythonImpl::Terminate() { Py_Finalize (); }
+
+#endif
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h
new file mode 100644
index 00000000000..e59fedbd097
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h
@@ -0,0 +1,62 @@
+//===-- ScriptInterpreterPython.h -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
+#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+#include "lldb/Breakpoint/BreakpointOptions.h"
+#include "lldb/Core/IOHandler.h"
+#include "lldb/Core/StructuredDataImpl.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/lldb-private.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace lldb_private {
+/// Abstract interface for the Python script interpreter.
+class ScriptInterpreterPython : public ScriptInterpreter,
+                                public IOHandlerDelegateMultiline {
+public:
+  class CommandDataPython : public BreakpointOptions::CommandData {
+  public:
+    CommandDataPython() : BreakpointOptions::CommandData() {
+      interpreter = lldb::eScriptLanguagePython;
+    }
+    CommandDataPython(StructuredData::ObjectSP extra_args_sp) :
+        BreakpointOptions::CommandData(),
+        m_extra_args_up(new StructuredDataImpl()) {
+        interpreter = lldb::eScriptLanguagePython;
+        m_extra_args_up->SetObjectSP(extra_args_sp);
+    }
+    lldb::StructuredDataImplUP m_extra_args_up;
+  };
+
+  ScriptInterpreterPython(Debugger &debugger)
+      : ScriptInterpreter(debugger, lldb::eScriptLanguagePython),
+        IOHandlerDelegateMultiline("DONE") {}
+
+  static void Initialize();
+  static void Terminate();
+  static lldb_private::ConstString GetPluginNameStatic();
+  static const char *GetPluginDescriptionStatic();
+  static FileSpec GetPythonDir();
+
+protected:
+  static void ComputePythonDirForApple(llvm::SmallVectorImpl<char> &path);
+  static void ComputePythonDir(llvm::SmallVectorImpl<char> &path);
+};
+} // namespace lldb_private
+
+#endif // LLDB_ENABLE_PYTHON
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h
new file mode 100644
index 00000000000..1fa198b07e5
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h
@@ -0,0 +1,478 @@
+//===-- ScriptInterpreterPythonImpl.h ---------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+#include "lldb-python.h"
+
+#include "PythonDataObjects.h"
+#include "ScriptInterpreterPython.h"
+
+#include "lldb/Host/Terminal.h"
+#include "lldb/Utility/StreamString.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace lldb_private {
+class IOHandlerPythonInterpreter;
+class ScriptInterpreterPythonImpl : public ScriptInterpreterPython {
+public:
+  friend class IOHandlerPythonInterpreter;
+
+  ScriptInterpreterPythonImpl(Debugger &debugger);
+
+  ~ScriptInterpreterPythonImpl() override;
+
+  bool Interrupt() override;
+
+  bool ExecuteOneLine(
+      llvm::StringRef command, CommandReturnObject *result,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  void ExecuteInterpreterLoop() override;
+
+  bool ExecuteOneLineWithReturn(
+      llvm::StringRef in_string,
+      ScriptInterpreter::ScriptReturnType return_type, void *ret_value,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  lldb_private::Status ExecuteMultipleLines(
+      const char *in_string,
+      const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
+
+  Status
+  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,
+                           StructuredDataImpl *args_data,
+                           std::string &error_str,
+                           lldb::ThreadPlanSP thread_plan) override;
+
+  bool ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
+                                      Event *event,
+                                      bool &script_error) override;
+
+  bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp,
+                                    Event *event, bool &script_error) override;
+
+  bool ScriptedThreadPlanIsStale(StructuredData::ObjectSP implementor_sp,
+                                 bool &script_error) override;
+
+  lldb::StateType
+  ScriptedThreadPlanGetRunState(StructuredData::ObjectSP implementor_sp,
+                                bool &script_error) override;
+
+  StructuredData::GenericSP
+  CreateScriptedBreakpointResolver(const char *class_name,
+                                   StructuredDataImpl *args_data,
+                                   lldb::BreakpointSP &bkpt_sp) override;
+  bool ScriptedBreakpointResolverSearchCallback(
+      StructuredData::GenericSP implementor_sp,
+      SymbolContext *sym_ctx) override;
+
+  lldb::SearchDepth ScriptedBreakpointResolverSearchDepth(
+      StructuredData::GenericSP implementor_sp) override;
+
+  StructuredData::GenericSP
+  CreateFrameRecognizer(const char *class_name) override;
+
+  lldb::ValueObjectListSP
+  GetRecognizedArguments(const StructuredData::ObjectSP &implementor,
+                         lldb::StackFrameSP frame_sp) 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::Status &error) override;
+
+  StructuredData::DictionarySP
+  GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target,
+                     const char *setting_name,
+                     lldb_private::Status &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, llvm::StringRef args,
+                        ScriptedCommandSynchronicity synchronicity,
+                        lldb_private::CommandReturnObject &cmd_retobj,
+                        Status &error,
+                        const lldb_private::ExecutionContext &exe_ctx) override;
+
+  bool RunScriptBasedCommand(
+      StructuredData::GenericSP impl_obj_sp, llvm::StringRef args,
+      ScriptedCommandSynchronicity synchronicity,
+      lldb_private::CommandReturnObject &cmd_retobj, Status &error,
+      const lldb_private::ExecutionContext &exe_ctx) override;
+
+  Status GenerateFunction(const char *signature,
+                          const StringList &input) override;
+
+  Status GenerateBreakpointCommandCallbackData(
+      StringList &input,
+      std::string &output,
+      bool has_extra_args) override;
+
+  bool GenerateWatchpointCommandCallbackData(StringList &input,
+                                             std::string &output) override;
+
+  bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj,
+                          StructuredData::ObjectSP &callee_wrapper_sp,
+                          const TypeSummaryOptions &options,
+                          std::string &retval) 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, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, Thread *thread,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, Target *target,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, StackFrame *frame,
+                              std::string &output, Status &error) override;
+
+  bool RunScriptFormatKeyword(const char *impl_function, ValueObject *value,
+                              std::string &output, Status &error) override;
+
+  bool
+  LoadScriptingModule(const char *filename, bool init_session,
+                      lldb_private::Status &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.
+  Status SetBreakpointCommandCallback(BreakpointOptions *bp_options,
+                                      const char *callback_body) override;
+
+  Status SetBreakpointCommandCallbackFunction(
+      BreakpointOptions *bp_options,
+      const char *function_name,
+      StructuredData::ObjectSP extra_args_sp) override;
+
+  /// This one is for deserialization:
+  Status SetBreakpointCommandCallback(
+      BreakpointOptions *bp_options,
+      std::unique_ptr<BreakpointOptions::CommandData> &data_up) override;
+
+  Status SetBreakpointCommandCallback(BreakpointOptions *bp_options,
+                                      const char *command_body_text,
+                                      StructuredData::ObjectSP extra_args_sp,
+                                      bool uses_extra_args);
+
+  /// Set a one-liner as the callback for the watchpoint.
+  void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
+                                    const char *oneliner) override;
+
+  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, bool interactive) override;
+
+  void IOHandlerInputComplete(IOHandler &io_handler,
+                              std::string &data) override;
+
+  static lldb::ScriptInterpreterSP CreateInstance(Debugger &debugger);
+
+  // 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(ScriptInterpreterPythonImpl *py_interpreter,
+           uint16_t on_entry = AcquireLock | InitSession,
+           uint16_t on_leave = FreeLock | TearDownSession,
+           lldb::FileSP in = nullptr, lldb::FileSP out = nullptr,
+           lldb::FileSP err = nullptr);
+
+    ~Locker() override;
+
+  private:
+    bool DoAcquireLock();
+
+    bool DoInitSession(uint16_t on_entry_flags, lldb::FileSP in,
+                       lldb::FileSP out, lldb::FileSP err);
+
+    bool DoFreeLock();
+
+    bool DoTearDownSession();
+
+    bool m_teardown_session;
+    ScriptInterpreterPythonImpl *m_python_interpreter;
+    PyGILState_STATE m_GILState;
+  };
+
+  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);
+  static void InitializePrivate();
+
+  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, lldb::FileSP in, lldb::FileSP out,
+                    lldb::FileSP err);
+
+  void LeaveSession();
+
+  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
+  };
+
+  python::PythonModule &GetMainModule();
+
+  python::PythonDictionary &GetSessionDictionary();
+
+  python::PythonDictionary &GetSysModuleDictionary();
+
+  llvm::Expected<unsigned> GetMaxPositionalArgumentsForCallable(
+      const llvm::StringRef &callable_name) override;
+
+  bool GetEmbeddedInterpreterModuleObjects();
+
+  bool SetStdHandle(lldb::FileSP file, const char *py_name,
+                    python::PythonObject &save_file, const char *mode);
+
+  python::PythonObject m_saved_stdin;
+  python::PythonObject m_saved_stdout;
+  python::PythonObject m_saved_stderr;
+  python::PythonModule m_main_module;
+  python::PythonDictionary m_session_dict;
+  python::PythonDictionary m_sys_module_dict;
+  python::PythonObject m_run_one_line_function;
+  python::PythonObject m_run_one_line_str_global;
+  std::string m_dictionary_name;
+  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;
+};
+
+class IOHandlerPythonInterpreter : public IOHandler {
+public:
+  IOHandlerPythonInterpreter(Debugger &debugger,
+                             ScriptInterpreterPythonImpl *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);
+        }
+
+        ScriptInterpreterPythonImpl::Locker locker(
+            m_python,
+            ScriptInterpreterPythonImpl::Locker::AcquireLock |
+                ScriptInterpreterPythonImpl::Locker::InitSession |
+                ScriptInterpreterPythonImpl::Locker::InitGlobals,
+            ScriptInterpreterPythonImpl::Locker::FreeAcquiredLock |
+                ScriptInterpreterPythonImpl::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();
+      }
+    }
+    SetIsDone(true);
+  }
+
+  void Cancel() override {}
+
+  bool Interrupt() override { return m_python->Interrupt(); }
+
+  void GotEOF() override {}
+
+protected:
+  ScriptInterpreterPythonImpl *m_python;
+};
+
+} // namespace lldb_private
+
+#endif
diff --git a/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h
new file mode 100644
index 00000000000..48f27b09b95
--- /dev/null
+++ b/gnu/llvm/lldb/source/Plugins/ScriptInterpreter/Python/lldb-python.h
@@ -0,0 +1,45 @@
+//===-- lldb-python.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H
+#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H
+
+#include "lldb/Host/Config.h"
+
+// Python.h needs to be included before any system headers in order to avoid
+// redefinition of macros
+
+#if LLDB_ENABLE_PYTHON
+#include "llvm/Support/Compiler.h"
+#if defined(_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
+// in a warning.  Undefine _POSIX_C_SOURCE before including Python.h  The same
+// holds for _XOPEN_SOURCE.
+#undef _POSIX_C_SOURCE
+#undef _XOPEN_SOURCE
+#endif
+
+// Include locale before Python so _PY_PORT_CTYPE_UTF8_ISSUE doesn't cause
+// macro redefinitions.
+#if defined(__APPLE__)
+#include <locale>
+#endif
+
+// Include python for non windows machines
+#include <Python.h>
+#endif
+
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H