cc9ad72713
This patch enforces that every scripted object implements all the necessary abstract methods. Every scripted affordance language interface can implement a list of abstract methods name that checked when the object is instanciated. Since some scripting affordances implementations can be derived from template base classes, we can't check the object dictionary since it will contain the definition of the base class, so instead, this checks the scripting class dictionary. Previously, for the various python interfaces, we used `ABC.abstractmethod` decorators but this is too language specific and doesn't work for scripting affordances that are not derived from template base classes (i.e OperatingSystem, ScriptedThreadPlan, ...), so this patch provides generic/language-agnostic checks for every scripted affordance. Signed-off-by: Med Ismail Bennani <ismail@bennani.ma>
457 lines
17 KiB
C++
457 lines
17 KiB
C++
//===-- ScriptedPythonInterface.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_INTERFACES_SCRIPTEDPYTHONINTERFACE_H
|
|
#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_INTERFACES_SCRIPTEDPYTHONINTERFACE_H
|
|
|
|
#if LLDB_ENABLE_PYTHON
|
|
|
|
#include <optional>
|
|
#include <sstream>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include "lldb/Host/Config.h"
|
|
#include "lldb/Interpreter/Interfaces/ScriptedInterface.h"
|
|
#include "lldb/Utility/DataBufferHeap.h"
|
|
|
|
#include "../PythonDataObjects.h"
|
|
#include "../SWIGPythonBridge.h"
|
|
#include "../ScriptInterpreterPythonImpl.h"
|
|
|
|
namespace lldb_private {
|
|
class ScriptInterpreterPythonImpl;
|
|
class ScriptedPythonInterface : virtual public ScriptedInterface {
|
|
public:
|
|
ScriptedPythonInterface(ScriptInterpreterPythonImpl &interpreter);
|
|
~ScriptedPythonInterface() override = default;
|
|
|
|
enum class AbstractMethodCheckerCases {
|
|
eNotImplemented,
|
|
eNotAllocated,
|
|
eNotCallable,
|
|
eValid
|
|
};
|
|
|
|
llvm::Expected<std::map<llvm::StringLiteral, AbstractMethodCheckerCases>>
|
|
CheckAbstractMethodImplementation(
|
|
const python::PythonDictionary &class_dict) const {
|
|
|
|
using namespace python;
|
|
|
|
std::map<llvm::StringLiteral, AbstractMethodCheckerCases> checker;
|
|
#define SET_ERROR_AND_CONTINUE(method_name, error) \
|
|
{ \
|
|
checker[method_name] = error; \
|
|
continue; \
|
|
}
|
|
|
|
for (const llvm::StringLiteral &method_name : GetAbstractMethods()) {
|
|
if (!class_dict.HasKey(method_name))
|
|
SET_ERROR_AND_CONTINUE(method_name,
|
|
AbstractMethodCheckerCases::eNotImplemented)
|
|
auto callable_or_err = class_dict.GetItem(method_name);
|
|
if (!callable_or_err)
|
|
SET_ERROR_AND_CONTINUE(method_name,
|
|
AbstractMethodCheckerCases::eNotAllocated)
|
|
if (!PythonCallable::Check(callable_or_err.get().get()))
|
|
SET_ERROR_AND_CONTINUE(method_name,
|
|
AbstractMethodCheckerCases::eNotCallable)
|
|
checker[method_name] = AbstractMethodCheckerCases::eValid;
|
|
}
|
|
|
|
#undef HANDLE_ERROR
|
|
|
|
return checker;
|
|
}
|
|
|
|
template <typename... Args>
|
|
llvm::Expected<StructuredData::GenericSP>
|
|
CreatePluginObject(llvm::StringRef class_name,
|
|
StructuredData::Generic *script_obj, Args... args) {
|
|
using namespace python;
|
|
using Locker = ScriptInterpreterPythonImpl::Locker;
|
|
|
|
auto create_error = [](std::string message) {
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(), message);
|
|
};
|
|
|
|
bool has_class_name = !class_name.empty();
|
|
bool has_interpreter_dict =
|
|
!(llvm::StringRef(m_interpreter.GetDictionaryName()).empty());
|
|
if (!has_class_name && !has_interpreter_dict && !script_obj) {
|
|
if (!has_class_name)
|
|
return create_error("Missing script class name.");
|
|
else if (!has_interpreter_dict)
|
|
return create_error("Invalid script interpreter dictionary.");
|
|
else
|
|
return create_error("Missing scripting object.");
|
|
}
|
|
|
|
Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
|
|
Locker::FreeLock);
|
|
|
|
PythonObject result = {};
|
|
|
|
if (script_obj) {
|
|
result = PythonObject(PyRefType::Borrowed,
|
|
static_cast<PyObject *>(script_obj->GetValue()));
|
|
} else {
|
|
auto dict =
|
|
PythonModule::MainModule().ResolveName<python::PythonDictionary>(
|
|
m_interpreter.GetDictionaryName());
|
|
if (!dict.IsAllocated())
|
|
return create_error(
|
|
llvm::formatv("Could not find interpreter dictionary: %s",
|
|
m_interpreter.GetDictionaryName()));
|
|
|
|
auto init =
|
|
PythonObject::ResolveNameWithDictionary<python::PythonCallable>(
|
|
class_name, dict);
|
|
if (!init.IsAllocated())
|
|
return create_error(llvm::formatv("Could not find script class: %s",
|
|
class_name.data()));
|
|
|
|
std::tuple<Args...> original_args = std::forward_as_tuple(args...);
|
|
auto transformed_args = TransformArgs(original_args);
|
|
|
|
std::string error_string;
|
|
llvm::Expected<PythonCallable::ArgInfo> arg_info = init.GetArgInfo();
|
|
if (!arg_info) {
|
|
llvm::handleAllErrors(
|
|
arg_info.takeError(),
|
|
[&](PythonException &E) { error_string.append(E.ReadBacktrace()); },
|
|
[&](const llvm::ErrorInfoBase &E) {
|
|
error_string.append(E.message());
|
|
});
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
error_string);
|
|
}
|
|
|
|
llvm::Expected<PythonObject> expected_return_object =
|
|
create_error("Resulting object is not initialized.");
|
|
|
|
std::apply(
|
|
[&init, &expected_return_object](auto &&...args) {
|
|
llvm::consumeError(expected_return_object.takeError());
|
|
expected_return_object = init(args...);
|
|
},
|
|
transformed_args);
|
|
|
|
if (!expected_return_object)
|
|
return expected_return_object.takeError();
|
|
result = expected_return_object.get();
|
|
}
|
|
|
|
if (!result.IsValid())
|
|
return create_error("Resulting object is not a valid Python Object.");
|
|
if (!result.HasAttribute("__class__"))
|
|
return create_error("Resulting object doesn't have '__class__' member.");
|
|
|
|
PythonObject obj_class = result.GetAttributeValue("__class__");
|
|
if (!obj_class.IsValid())
|
|
return create_error("Resulting class object is not a valid.");
|
|
if (!obj_class.HasAttribute("__name__"))
|
|
return create_error(
|
|
"Resulting object class doesn't have '__name__' member.");
|
|
PythonString obj_class_name =
|
|
obj_class.GetAttributeValue("__name__").AsType<PythonString>();
|
|
|
|
PythonObject object_class_mapping_proxy =
|
|
obj_class.GetAttributeValue("__dict__");
|
|
if (!obj_class.HasAttribute("__dict__"))
|
|
return create_error(
|
|
"Resulting object class doesn't have '__dict__' member.");
|
|
|
|
PythonCallable dict_converter = PythonModule::BuiltinsModule()
|
|
.ResolveName("dict")
|
|
.AsType<PythonCallable>();
|
|
if (!dict_converter.IsAllocated())
|
|
return create_error(
|
|
"Python 'builtins' module doesn't have 'dict' class.");
|
|
|
|
PythonDictionary object_class_dict =
|
|
dict_converter(object_class_mapping_proxy).AsType<PythonDictionary>();
|
|
if (!object_class_dict.IsAllocated())
|
|
return create_error("Coudn't create dictionary from resulting object "
|
|
"class mapping proxy object.");
|
|
|
|
auto checker_or_err = CheckAbstractMethodImplementation(object_class_dict);
|
|
if (!checker_or_err)
|
|
return checker_or_err.takeError();
|
|
|
|
for (const auto &method_checker : *checker_or_err)
|
|
switch (method_checker.second) {
|
|
case AbstractMethodCheckerCases::eNotImplemented:
|
|
LLDB_LOG(GetLog(LLDBLog::Script),
|
|
"Abstract method {0}.{1} not implemented.",
|
|
obj_class_name.GetString(), method_checker.first);
|
|
break;
|
|
case AbstractMethodCheckerCases::eNotAllocated:
|
|
LLDB_LOG(GetLog(LLDBLog::Script),
|
|
"Abstract method {0}.{1} not allocated.",
|
|
obj_class_name.GetString(), method_checker.first);
|
|
break;
|
|
case AbstractMethodCheckerCases::eNotCallable:
|
|
LLDB_LOG(GetLog(LLDBLog::Script),
|
|
"Abstract method {0}.{1} not callable.",
|
|
obj_class_name.GetString(), method_checker.first);
|
|
break;
|
|
case AbstractMethodCheckerCases::eValid:
|
|
LLDB_LOG(GetLog(LLDBLog::Script),
|
|
"Abstract method {0}.{1} implemented & valid.",
|
|
obj_class_name.GetString(), method_checker.first);
|
|
break;
|
|
}
|
|
|
|
for (const auto &method_checker : *checker_or_err)
|
|
if (method_checker.second != AbstractMethodCheckerCases::eValid)
|
|
return create_error(
|
|
llvm::formatv("Abstract method {0}.{1} missing. Enable lldb "
|
|
"script log for more details.",
|
|
obj_class_name.GetString(), method_checker.first));
|
|
|
|
m_object_instance_sp = StructuredData::GenericSP(
|
|
new StructuredPythonObject(std::move(result)));
|
|
return m_object_instance_sp;
|
|
}
|
|
|
|
protected:
|
|
template <typename T = StructuredData::ObjectSP>
|
|
T ExtractValueFromPythonObject(python::PythonObject &p, Status &error) {
|
|
return p.CreateStructuredObject();
|
|
}
|
|
|
|
template <typename T = StructuredData::ObjectSP, typename... Args>
|
|
T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
|
|
using namespace python;
|
|
using Locker = ScriptInterpreterPythonImpl::Locker;
|
|
|
|
std::string caller_signature =
|
|
llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
|
|
llvm::Twine(method_name) + llvm::Twine(")"))
|
|
.str();
|
|
if (!m_object_instance_sp)
|
|
return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
|
|
error);
|
|
|
|
Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
|
|
Locker::FreeLock);
|
|
|
|
PythonObject implementor(PyRefType::Borrowed,
|
|
(PyObject *)m_object_instance_sp->GetValue());
|
|
|
|
if (!implementor.IsAllocated())
|
|
return ErrorWithMessage<T>(caller_signature,
|
|
"Python implementor not allocated.", error);
|
|
|
|
std::tuple<Args...> original_args = std::forward_as_tuple(args...);
|
|
auto transformed_args = TransformArgs(original_args);
|
|
|
|
llvm::Expected<PythonObject> expected_return_object =
|
|
llvm::make_error<llvm::StringError>("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<T>(caller_signature,
|
|
"Python method could not be called.", error);
|
|
}
|
|
|
|
PythonObject py_return = std::move(expected_return_object.get());
|
|
|
|
// 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<T>(
|
|
caller_signature,
|
|
"Couldn't re-assign reference and pointer arguments.", error);
|
|
|
|
if (!py_return.IsAllocated())
|
|
return {};
|
|
return ExtractValueFromPythonObject<T>(py_return, error);
|
|
}
|
|
|
|
template <typename... Args>
|
|
Status GetStatusFromMethod(llvm::StringRef method_name, Args &&...args) {
|
|
Status error;
|
|
Dispatch<Status>(method_name, error, std::forward<Args>(args)...);
|
|
|
|
return error;
|
|
}
|
|
|
|
template <typename T> T Transform(T object) {
|
|
// No Transformation for generic usage
|
|
return {object};
|
|
}
|
|
|
|
python::PythonObject Transform(bool arg) {
|
|
// Boolean arguments need to be turned into python objects.
|
|
return python::PythonBoolean(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(Status arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(const StructuredDataImpl &arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(lldb::ExecutionContextRefSP arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(lldb::ProcessSP arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(lldb::ProcessAttachInfoSP arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(lldb::ProcessLaunchInfoSP arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
python::PythonObject Transform(lldb::DataExtractorSP arg) {
|
|
return python::SWIGBridge::ToSWIGWrapper(arg);
|
|
}
|
|
|
|
template <typename T, typename U>
|
|
void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
|
|
// If U is not a PythonObject, don't touch it!
|
|
return;
|
|
}
|
|
|
|
template <typename T>
|
|
void ReverseTransform(T &original_arg, python::PythonObject transformed_arg,
|
|
Status &error) {
|
|
original_arg = ExtractValueFromPythonObject<T>(transformed_arg, error);
|
|
}
|
|
|
|
void ReverseTransform(bool &original_arg,
|
|
python::PythonObject transformed_arg, Status &error) {
|
|
python::PythonBoolean boolean_arg = python::PythonBoolean(
|
|
python::PyRefType::Borrowed, transformed_arg.get());
|
|
if (boolean_arg.IsValid())
|
|
original_arg = boolean_arg.GetValue();
|
|
else
|
|
error.SetErrorString(
|
|
llvm::formatv("{}: Invalid boolean argument.", LLVM_PRETTY_FUNCTION)
|
|
.str());
|
|
}
|
|
|
|
template <std::size_t... I, typename... Args>
|
|
auto TransformTuple(const std::tuple<Args...> &args,
|
|
std::index_sequence<I...>) {
|
|
return std::make_tuple(Transform(std::get<I>(args))...);
|
|
}
|
|
|
|
// This will iterate over the Dispatch parameter pack and replace in-place
|
|
// every `lldb_private` argument that has a SB counterpart.
|
|
template <typename... Args>
|
|
auto TransformArgs(const std::tuple<Args...> &args) {
|
|
return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
|
|
}
|
|
|
|
template <typename T, typename U>
|
|
void TransformBack(T &original_arg, U transformed_arg, Status &error) {
|
|
ReverseTransform(original_arg, transformed_arg, error);
|
|
}
|
|
|
|
template <std::size_t... I, typename... Ts, typename... Us>
|
|
bool ReassignPtrsOrRefsArgs(std::tuple<Ts...> &original_args,
|
|
std::tuple<Us...> &transformed_args,
|
|
std::index_sequence<I...>) {
|
|
Status error;
|
|
(TransformBack(std::get<I>(original_args), std::get<I>(transformed_args),
|
|
error),
|
|
...);
|
|
return error.Success();
|
|
}
|
|
|
|
template <typename... Ts, typename... Us>
|
|
bool ReassignPtrsOrRefsArgs(std::tuple<Ts...> &original_args,
|
|
std::tuple<Us...> &transformed_args) {
|
|
if (sizeof...(Ts) != sizeof...(Us))
|
|
return false;
|
|
|
|
return ReassignPtrsOrRefsArgs(original_args, transformed_args,
|
|
std::make_index_sequence<sizeof...(Ts)>());
|
|
}
|
|
|
|
template <typename T, typename... Args>
|
|
void FormatArgs(std::string &fmt, T arg, Args... args) const {
|
|
FormatArgs(fmt, arg);
|
|
FormatArgs(fmt, args...);
|
|
}
|
|
|
|
template <typename T> void FormatArgs(std::string &fmt, T arg) const {
|
|
fmt += python::PythonFormat<T>::format;
|
|
}
|
|
|
|
void FormatArgs(std::string &fmt) const {}
|
|
|
|
// The lifetime is managed by the ScriptInterpreter
|
|
ScriptInterpreterPythonImpl &m_interpreter;
|
|
};
|
|
|
|
template <>
|
|
StructuredData::ArraySP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<StructuredData::ArraySP>(
|
|
python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
StructuredData::DictionarySP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
StructuredData::DictionarySP>(python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
Status ScriptedPythonInterface::ExtractValueFromPythonObject<Status>(
|
|
python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
lldb::BreakpointSP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::BreakpointSP>(
|
|
python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
lldb::ProcessAttachInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
lldb::ProcessAttachInfoSP>(python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
lldb::ProcessLaunchInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
lldb::ProcessLaunchInfoSP>(python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
lldb::DataExtractorSP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
|
|
python::PythonObject &p, Status &error);
|
|
|
|
template <>
|
|
std::optional<MemoryRegionInfo>
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error);
|
|
|
|
} // namespace lldb_private
|
|
|
|
#endif // LLDB_ENABLE_PYTHON
|
|
#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_INTERFACES_SCRIPTEDPYTHONINTERFACE_H
|