diff options
Diffstat (limited to 'source/Plugins/ScriptInterpreter/Python')
6 files changed, 0 insertions, 6106 deletions
diff --git a/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp deleted file mode 100644 index 70d93424fdec..000000000000 --- a/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp +++ /dev/null @@ -1,1582 +0,0 @@ -//===-- 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 -// -//===----------------------------------------------------------------------===// - -#ifdef LLDB_DISABLE_PYTHON - -// Python is disabled in this build - -#else - -#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); -} - -PythonCallable::ArgInfo PythonCallable::GetNumInitArguments() const { - auto arginfo = GetInitArgInfo(); - if (!arginfo) { - llvm::consumeError(arginfo.takeError()); - return ArgInfo{}; - } - return arginfo.get(); -} - -Expected<PythonCallable::ArgInfo> PythonCallable::GetInitArgInfo() const { - if (!IsValid()) - return nullDeref(); - auto init = As<PythonCallable>(GetAttribute("__init__")); - if (!init) - return init.takeError(); - return init.get().GetArgInfo(); -} - -#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', 'is_bound_method']) -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, ismethod(f)) -)"; -#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(); - result.count = cantFail(As<long long>(pyarginfo.get().GetAttribute("count"))); - result.has_varargs = - cantFail(As<bool>(pyarginfo.get().GetAttribute("has_varargs"))); - bool is_method = - cantFail(As<bool>(pyarginfo.get().GetAttribute("is_bound_method"))); - result.max_positional_args = - result.has_varargs ? ArgInfo::UNBOUNDED : result.count; - - // FIXME emulate old broken behavior - if (is_method) - result.count++; - -#else - bool is_bound_method = false; - PyObject *py_func_obj = m_py_obj; - if (PyMethod_Check(py_func_obj)) { - py_func_obj = PyMethod_GET_FUNCTION(py_func_obj); - PythonObject im_self = GetAttributeValue("im_self"); - if (im_self.IsValid() && !im_self.IsNone()) - 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; - - result.count = code->co_argcount; - result.has_varargs = !!(code->co_flags & CO_VARARGS); - result.max_positional_args = result.has_varargs - ? ArgInfo::UNBOUNDED - : (result.count - (int)is_bound_method); - -#endif - - return result; -} - -constexpr unsigned - PythonCallable::ArgInfo::UNBOUNDED; // FIXME delete after c++17 - -PythonCallable::ArgInfo PythonCallable::GetNumArguments() const { - auto arginfo = GetArgInfo(); - if (!arginfo) { - llvm::consumeError(arginfo.takeError()); - return ArgInfo{}; - } - return arginfo.get(); -} - -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(); - - // 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, 0); -#else - // Read through the Python source, doesn't seem to modify these strings - char *cmode = const_cast<char *>(mode); - // We pass ::flush instead of ::fclose here so we borrow the FILE* -- - // the lldb_private::File still owns it. - file_obj = - PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode, ::fflush); -#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/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h b/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h deleted file mode 100644 index 373d3212697d..000000000000 --- a/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h +++ /dev/null @@ -1,781 +0,0 @@ -//===-- 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 - -#ifndef LLDB_DISABLE_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 std::move(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 std::move(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"); -} - -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; - -protected: - -#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. - static char *py2_const_cast(const char *s) { return const_cast<char *>(s); } -#else - static const char *py2_const_cast(const char *s) { return s; } -#endif - -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 - /* the number of positional arguments, including optional ones, - * and excluding varargs. If this is a bound method, then the - * count will still include a +1 for self. - * - * FIXME. That's crazy. This should be replaced with - * an accurate min and max for positional args. - */ - int count; - /* does the callable have positional varargs? */ - bool has_varargs : 1; // FIXME delete this - }; - - static bool Check(PyObject *py_obj); - - llvm::Expected<ArgInfo> GetArgInfo() const; - - llvm::Expected<ArgInfo> GetInitArgInfo() const; - - ArgInfo GetNumArguments() const; // DEPRECATED - - // If the callable is a Py_Class, then find the number of arguments - // of the __init__ method. - ArgInfo GetNumInitArguments() const; // DEPRECATED - - 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/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp deleted file mode 100644 index 3eee52184142..000000000000 --- a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp +++ /dev/null @@ -1,3174 +0,0 @@ -//===-- 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 -// -//===----------------------------------------------------------------------===// - -#ifdef LLDB_DISABLE_PYTHON - -// Python is disabled in this build - -#else - -// LLDB Python header must be included first -#include "lldb-python.h" - -#include "PythonDataObjects.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. -extern "C" bool LLDBSwigPythonBreakpointCallbackFunction( - const char *python_function_name, const char *session_dictionary_name, - const lldb::StackFrameSP &sb_frame, - const lldb::BreakpointLocationSP &sb_bp_loc); - -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(); - - // 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); - - if (GenerateBreakpointCommandCallbackData(data_up->user_source, - data_up->script_source) - .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; -} - -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; - } - } -} - -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, true, &bp_options_vec); -} - -void ScriptInterpreterPythonImpl::CollectDataForWatchpointCommandCallback( - WatchpointOptions *wp_options, CommandReturnObject &result) { - m_active_io_handler = eIOHandlerWatchpoint; - m_debugger.GetCommandInterpreter().GetPythonCommandsFromIOHandler( - " ", *this, true, wp_options); -} - -void ScriptInterpreterPythonImpl::SetBreakpointCommandCallbackFunction( - BreakpointOptions *bp_options, const char *function_name) { - // For now just cons up a oneliner that calls the provided function. - std::string oneliner("return "); - oneliner += function_name; - oneliner += "(frame, bp_loc, internal_dict)"; - m_debugger.GetScriptInterpreter()->SetBreakpointCommandCallback( - bp_options, oneliner.c_str()); -} - -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); - 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; -} - -// Set a Python one-liner as the callback for the breakpoint. -Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback( - BreakpointOptions *bp_options, const char *command_body_text) { - auto data_up = std::make_unique<CommandDataPython>(); - - // Split the command_body_text into lines, and pass that to - // GenerateBreakpointCommandCallbackData. That will wrap the body in an - // auto-generated function, and return the function name in script_source. - // That is what the callback will actually invoke. - - data_up->user_source.SplitIntoLines(command_body_text); - Status error = GenerateBreakpointCommandCallbackData(data_up->user_source, - data_up->script_source); - 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, - ¶m_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, 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) { - 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)); - 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); - ret_val = LLDBSwigPythonBreakpointCallbackFunction( - python_function_name, - python_interpreter->m_dictionary_name.c_str(), stop_frame_sp, - bp_loc_sp); - } - return ret_val; - } - } - } - // We currently always true so we stop in case anything goes wrong when - // trying to call the script function - return true; -} - -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 can_reload, 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); - - if (was_imported && !can_reload) { - error.SetErrorString("module already imported"); - return false; - } - - // now actually do the import - command_stream.Clear(); - - if (was_imported) { - if (!was_imported_locally) - command_stream.Printf("import %s ; reload_module(%s)", basename.c_str(), - basename.c_str()); - else - command_stream.Printf("reload_module(%s)", basename.c_str()); - } else - command_stream.Printf("import %s", basename.c_str()); - - error = ExecuteMultipleLines(command_stream.GetData(), - ScriptInterpreter::ExecuteScriptOptions() - .SetEnableIO(false) - .SetSetLLDBGlobals(false)); - if (error.Fail()) - return false; - - // if we are here, everything worked - // call __lldb_init_module(debugger,dict) - if (!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 // LLDB_DISABLE_PYTHON diff --git a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h b/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h deleted file mode 100644 index 33ae308041b2..000000000000 --- a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h +++ /dev/null @@ -1,56 +0,0 @@ -//===-- 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 - -#ifdef LLDB_DISABLE_PYTHON - -// Python is disabled in this build - -#else - -#include "lldb/Breakpoint/BreakpointOptions.h" -#include "lldb/Core/IOHandler.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; - } - }; - - 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_DISABLE_PYTHON -#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H diff --git a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h b/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h deleted file mode 100644 index 929567e579d8..000000000000 --- a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h +++ /dev/null @@ -1,468 +0,0 @@ -//===-- 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 -// -//===----------------------------------------------------------------------===// - -#ifdef LLDB_DISABLE_PYTHON - -// Python is disabled in this build - -#else - -#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) 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 can_reload, 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; - - void SetBreakpointCommandCallbackFunction(BreakpointOptions *bp_options, - const char *function_name) override; - - /// This one is for deserialization: - Status SetBreakpointCommandCallback( - BreakpointOptions *bp_options, - std::unique_ptr<BreakpointOptions::CommandData> &data_up) override; - - /// Set a one-liner as the callback for the watchpoint. - void SetWatchpointCommandCallback(WatchpointOptions *wp_options, - const char *oneliner) override; - - 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(); - - 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/source/Plugins/ScriptInterpreter/Python/lldb-python.h b/source/Plugins/ScriptInterpreter/Python/lldb-python.h deleted file mode 100644 index 884514da9924..000000000000 --- a/source/Plugins/ScriptInterpreter/Python/lldb-python.h +++ /dev/null @@ -1,45 +0,0 @@ -//===-- 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 - -// Python.h needs to be included before any system headers in order to avoid -// redefinition of macros - -#ifdef LLDB_DISABLE_PYTHON -// Python is disabled in this build -#else -#include "llvm/Support/Compiler.h" -#if defined(_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 // LLDB_DISABLE_PYTHON - -#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H |