From 7e01924e4e5634a6fa7d500574aeca58c8f36873 Mon Sep 17 00:00:00 2001 From: Med Ismail Bennani Date: Fri, 18 Nov 2022 13:53:57 -0800 Subject: [lldb/Plugins] Improve error reporting with reading memory in Scripted Process This patch improves the ScriptedPythonInterface::Dispatch method to support passing lldb_private types to the python implementation. This will allow, for instance, the Scripted Process python implementation to report errors when reading memory back to lldb. To do so, the Dispatch method will transform the private types in the parameter pack into `PythonObject`s to be able to pass them down to the python methods. Then, if the call succeeded, the transformed arguments will be converted back to their original type and re-assigned in the parameter pack, to ensure pointers and references behaviours are preserved. This patch also updates various scripted process python class and tests to reflect this change. rdar://100030995 Differential Revision: https://reviews.llvm.org/D134033 Signed-off-by: Med Ismail Bennani --- .../Python/ScriptedPythonInterface.h | 149 +++++++++++++++------ 1 file changed, 105 insertions(+), 44 deletions(-) (limited to 'lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h') diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h index 7c2fadc..ac1fe09 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h @@ -9,10 +9,14 @@ #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H -#include "lldb/Host/Config.h" - #if LLDB_ENABLE_PYTHON +#include +#include +#include +#include + +#include "lldb/Host/Config.h" #include "lldb/Interpreter/ScriptedInterface.h" #include "lldb/Utility/DataBufferHeap.h" @@ -34,7 +38,7 @@ protected: } template - T Dispatch(llvm::StringRef method_name, Status &error, Args... args) { + T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) { using namespace python; using Locker = ScriptInterpreterPythonImpl::Locker; @@ -56,59 +60,116 @@ protected: return ErrorWithMessage(caller_signature, "Python implementor not allocated.", error); - PythonObject pmeth( - PyRefType::Owned, - PyObject_GetAttrString(implementor.get(), method_name.str().c_str())); + std::tuple original_args = std::forward_as_tuple(args...); + auto transformed_args = TransformArgs(original_args); + + llvm::Expected expected_return_object = + llvm::make_error("Not initialized.", + llvm::inconvertibleErrorCode()); + std::apply( + [&implementor, &method_name, &expected_return_object](auto &&...args) { + llvm::consumeError(expected_return_object.takeError()); + expected_return_object = + implementor.CallMethod(method_name.data(), args...); + }, + transformed_args); + + if (llvm::Error e = expected_return_object.takeError()) { + error.SetErrorString(llvm::toString(std::move(e)).c_str()); + return ErrorWithMessage(caller_signature, + "Python method could not be called.", error); + } - if (PyErr_Occurred()) - PyErr_Clear(); + PythonObject py_return = std::move(expected_return_object.get()); - if (!pmeth.IsAllocated()) - return ErrorWithMessage(caller_signature, - "Python method not allocated.", error); + if (!py_return.IsAllocated()) + return ErrorWithMessage(caller_signature, "Returned object is null.", + error); - if (PyCallable_Check(pmeth.get()) == 0) { - if (PyErr_Occurred()) - PyErr_Clear(); - return ErrorWithMessage(caller_signature, - "Python method not callable.", error); - } + // Now that we called the python method with the transformed arguments, + // we need to interate again over both the original and transformed + // parameter pack, and transform back the parameter that were passed in + // the original parameter pack as references or pointers. + if (sizeof...(Args) > 0) + if (!ReassignPtrsOrRefsArgs(original_args, transformed_args)) + return ErrorWithMessage( + caller_signature, + "Couldn't re-assign reference and pointer arguments.", error); - if (PyErr_Occurred()) - PyErr_Clear(); + return ExtractValueFromPythonObject(py_return, error); + } - // TODO: make `const char *` when removing support for Python 2. - char *format = nullptr; - std::string format_buffer; + Status GetStatusFromMethod(llvm::StringRef method_name); - if (sizeof...(Args) > 0) { - FormatArgs(format_buffer, args...); - // TODO: make `const char *` when removing support for Python 2. - format = const_cast(format_buffer.c_str()); + template struct transformation { using type = T; }; + template struct reverse_transformation { + static void Apply(ScriptedPythonInterface &obj, T &original_arg, + U transformed_arg, Status &error) { + // If U is not a PythonObject, don't touch it! + return; + } + }; + + template <> struct transformation { + using type = python::PythonObject; + }; + template struct reverse_transformation { + static void Apply(ScriptedPythonInterface &obj, T &original_arg, + python::PythonObject transformed_arg, Status &error) { + original_arg = + obj.ExtractValueFromPythonObject(transformed_arg, error); } + }; - // TODO: make `const char *` when removing support for Python 2. - PythonObject py_return( - PyRefType::Owned, - PyObject_CallMethod(implementor.get(), - const_cast(method_name.data()), format, - args...)); + template typename transformation::type Transform(T object) { + // No Transformation for generic usage + return {object}; + } - if (PyErr_Occurred()) { - PyErr_Print(); - PyErr_Clear(); - return ErrorWithMessage(caller_signature, - "Python method could not be called.", error); - } + template <> typename transformation::type Transform(Status arg) { + // Call SWIG Wrapper function + return python::ToSWIGWrapper(arg); + } - if (!py_return.IsAllocated()) - return ErrorWithMessage(caller_signature, "Returned object is null.", - error); + template + auto TransformTuple(const std::tuple &args, + std::index_sequence) { + return std::make_tuple(Transform(std::get(args))...); + } - return ExtractValueFromPythonObject(py_return, error); + // This will iterate over the Dispatch parameter pack and replace in-place + // every `lldb_private` argument that has a SB counterpart. + template + auto TransformArgs(const std::tuple &args) { + return TransformTuple(args, std::make_index_sequence()); } - Status GetStatusFromMethod(llvm::StringRef method_name); + template + void TransformBack(T &original_arg, U transformed_arg, Status &error) { + reverse_transformation::Apply(*this, original_arg, transformed_arg, + error); + } + + template + bool ReassignPtrsOrRefsArgs(std::tuple &original_args, + std::tuple &transformed_args, + std::index_sequence) { + Status error; + (TransformBack(std::get(original_args), std::get(transformed_args), + error), + ...); + return error.Success(); + } + + template + bool ReassignPtrsOrRefsArgs(std::tuple &original_args, + std::tuple &transformed_args) { + if (sizeof...(Ts) != sizeof...(Us)) + return false; + + return ReassignPtrsOrRefsArgs(original_args, transformed_args, + std::make_index_sequence()); + } template void FormatArgs(std::string &fmt, T arg, Args... args) const { @@ -117,7 +178,7 @@ protected: } template void FormatArgs(std::string &fmt, T arg) const { - fmt += GetPythonValueFormatString(arg); + fmt += python::PythonFormat::format; } void FormatArgs(std::string &fmt) const {} -- cgit v1.1