Coverage Report

Created: 2023-09-30 09:22

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h
Line
Count
Source (jump to first uncovered line)
1
//===-- ScriptedPythonInterface.h -------------------------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H
10
#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H
11
12
#if LLDB_ENABLE_PYTHON
13
14
#include <optional>
15
#include <sstream>
16
#include <tuple>
17
#include <type_traits>
18
#include <utility>
19
20
#include "lldb/Host/Config.h"
21
#include "lldb/Interpreter/ScriptedInterface.h"
22
#include "lldb/Utility/DataBufferHeap.h"
23
24
#include "PythonDataObjects.h"
25
#include "SWIGPythonBridge.h"
26
#include "ScriptInterpreterPythonImpl.h"
27
28
namespace lldb_private {
29
class ScriptInterpreterPythonImpl;
30
class ScriptedPythonInterface : virtual public ScriptedInterface {
31
public:
32
  ScriptedPythonInterface(ScriptInterpreterPythonImpl &interpreter);
33
2.01k
  ~ScriptedPythonInterface() override = default;
34
35
protected:
36
  template <typename T = StructuredData::ObjectSP>
37
35
  T ExtractValueFromPythonObject(python::PythonObject &p, Status &error) {
38
35
    return p.CreateStructuredObject();
39
35
  }
40
41
  template <typename T = StructuredData::ObjectSP, typename... Args>
42
282
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
282
    using namespace python;
44
282
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
282
    std::string caller_signature =
47
282
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
282
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
282
            .str();
50
282
    if (!m_object_instance_sp)
51
195
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
195
                                 error);
53
54
87
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
87
                   Locker::FreeLock);
56
57
87
    PythonObject implementor(PyRefType::Borrowed,
58
87
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
87
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
87
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
87
    auto transformed_args = TransformArgs(original_args);
66
67
87
    llvm::Expected<PythonObject> expected_return_object =
68
87
        llvm::make_error<llvm::StringError>("Not initialized.",
69
87
                                            llvm::inconvertibleErrorCode());
70
87
    std::apply(
71
87
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
87
          llvm::consumeError(expected_return_object.takeError());
73
87
          expected_return_object =
74
87
              implementor.CallMethod(method_name.data(), args...);
75
87
        },
auto std::__1::shared_ptr<lldb_private::StructuredData::Dictionary> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Dictionary> >(llvm::StringRef, lldb_private::Status&)::'lambda'(auto&&...)::operator()<>(auto&&...) const
Line
Count
Source
71
21
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
21
          llvm::consumeError(expected_return_object.takeError());
73
21
          expected_return_object =
74
21
              implementor.CallMethod(method_name.data(), args...);
75
21
        },
auto lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>(llvm::StringRef, lldb_private::Status&, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&)::'lambda'(auto&&...)::operator()<lldb_private::python::PythonObject&>(auto&&...) const
Line
Count
Source
71
1
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
1
          llvm::consumeError(expected_return_object.takeError());
73
1
          expected_return_object =
74
1
              implementor.CallMethod(method_name.data(), args...);
75
1
        },
auto lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status>(llvm::StringRef, lldb_private::Status&)::'lambda'(auto&&...)::operator()<>(auto&&...) const
Line
Count
Source
71
2
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
2
          llvm::consumeError(expected_return_object.takeError());
73
2
          expected_return_object =
74
2
              implementor.CallMethod(method_name.data(), args...);
75
2
        },
auto lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status, bool>(llvm::StringRef, lldb_private::Status&, bool&&)::'lambda'(auto&&...)::operator()<lldb_private::python::PythonObject&>(auto&&...) const
Line
Count
Source
71
2
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
2
          llvm::consumeError(expected_return_object.takeError());
73
2
          expected_return_object =
74
2
              implementor.CallMethod(method_name.data(), args...);
75
2
        },
auto std::__1::optional<lldb_private::MemoryRegionInfo> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::optional<lldb_private::MemoryRegionInfo>, unsigned long long&>(llvm::StringRef, lldb_private::Status&, unsigned long long&)::'lambda'(auto&&...)::operator()<unsigned long long&>(auto&&...) const
Line
Count
Source
71
1
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
1
          llvm::consumeError(expected_return_object.takeError());
73
1
          expected_return_object =
74
1
              implementor.CallMethod(method_name.data(), args...);
75
1
        },
Unexecuted instantiation: auto std::__1::shared_ptr<lldb_private::StructuredData::Object> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Object>, unsigned long long&, lldb_private::Status&>(llvm::StringRef, lldb_private::Status&, unsigned long long&, lldb_private::Status&)::'lambda'(auto&&...)::operator()<unsigned long long&, lldb_private::python::PythonObject&>(auto&&...) const
auto std::__1::shared_ptr<lldb_private::DataExtractor> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::DataExtractor>, unsigned long long&, unsigned long&, lldb_private::Status&>(llvm::StringRef, lldb_private::Status&, unsigned long long&, unsigned long&, lldb_private::Status&)::'lambda'(auto&&...)::operator()<unsigned long long&, unsigned long&, lldb_private::python::PythonObject&>(auto&&...) const
Line
Count
Source
71
9
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
9
          llvm::consumeError(expected_return_object.takeError());
73
9
          expected_return_object =
74
9
              implementor.CallMethod(method_name.data(), args...);
75
9
        },
auto std::__1::shared_ptr<lldb_private::StructuredData::Object> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Object>, unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&>(llvm::StringRef, lldb_private::Status&, unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&)::'lambda'(auto&&...)::operator()<unsigned long long&, lldb_private::python::PythonObject&, lldb_private::python::PythonObject&>(auto&&...) const
Line
Count
Source
71
1
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
1
          llvm::consumeError(expected_return_object.takeError());
73
1
          expected_return_object =
74
1
              implementor.CallMethod(method_name.data(), args...);
75
1
        },
auto std::__1::shared_ptr<lldb_private::StructuredData::Array> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Array> >(llvm::StringRef, lldb_private::Status&)::'lambda'(auto&&...)::operator()<>(auto&&...) const
Line
Count
Source
71
4
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
4
          llvm::consumeError(expected_return_object.takeError());
73
4
          expected_return_object =
74
4
              implementor.CallMethod(method_name.data(), args...);
75
4
        },
auto std::__1::shared_ptr<lldb_private::StructuredData::Object> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Object> >(llvm::StringRef, lldb_private::Status&)::'lambda'(auto&&...)::operator()<>(auto&&...) const
Line
Count
Source
71
46
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
46
          llvm::consumeError(expected_return_object.takeError());
73
46
          expected_return_object =
74
46
              implementor.CallMethod(method_name.data(), args...);
75
46
        },
Unexecuted instantiation: auto std::__1::shared_ptr<lldb_private::StructuredData::Dictionary> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Dictionary>, unsigned long long&>(llvm::StringRef, lldb_private::Status&, unsigned long long&)::'lambda'(auto&&...)::operator()<unsigned long long&>(auto&&...) const
Unexecuted instantiation: auto lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status, unsigned long long&>(llvm::StringRef, lldb_private::Status&, unsigned long long&)::'lambda'(auto&&...)::operator()<unsigned long long&>(auto&&...) const
76
87
        transformed_args);
77
78
87
    if (llvm::Error e = expected_return_object.takeError()) {
79
5
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
5
      return ErrorWithMessage<T>(caller_signature,
81
5
                                 "Python method could not be called.", error);
82
5
    }
83
84
82
    PythonObject py_return = std::move(expected_return_object.get());
85
86
82
    if (!py_return.IsAllocated())
87
13
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
13
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
69
    if (sizeof...(Args) > 0)
95
8
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
69
    return ExtractValueFromPythonObject<T>(py_return, error);
101
69
  }
std::__1::shared_ptr<lldb_private::StructuredData::Dictionary> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Dictionary> >(llvm::StringRef, lldb_private::Status&)
Line
Count
Source
42
21
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
21
    using namespace python;
44
21
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
21
    std::string caller_signature =
47
21
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
21
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
21
            .str();
50
21
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
21
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
21
                   Locker::FreeLock);
56
57
21
    PythonObject implementor(PyRefType::Borrowed,
58
21
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
21
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
21
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
21
    auto transformed_args = TransformArgs(original_args);
66
67
21
    llvm::Expected<PythonObject> expected_return_object =
68
21
        llvm::make_error<llvm::StringError>("Not initialized.",
69
21
                                            llvm::inconvertibleErrorCode());
70
21
    std::apply(
71
21
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
21
          llvm::consumeError(expected_return_object.takeError());
73
21
          expected_return_object =
74
21
              implementor.CallMethod(method_name.data(), args...);
75
21
        },
76
21
        transformed_args);
77
78
21
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
21
    PythonObject py_return = std::move(expected_return_object.get());
85
86
21
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
21
    if (sizeof...(Args) > 0)
95
0
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
21
    return ExtractValueFromPythonObject<T>(py_return, error);
101
21
  }
lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>(llvm::StringRef, lldb_private::Status&, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&)
Line
Count
Source
42
1
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
1
    using namespace python;
44
1
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
1
    std::string caller_signature =
47
1
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
1
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
1
            .str();
50
1
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
1
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
1
                   Locker::FreeLock);
56
57
1
    PythonObject implementor(PyRefType::Borrowed,
58
1
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
1
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
1
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
1
    auto transformed_args = TransformArgs(original_args);
66
67
1
    llvm::Expected<PythonObject> expected_return_object =
68
1
        llvm::make_error<llvm::StringError>("Not initialized.",
69
1
                                            llvm::inconvertibleErrorCode());
70
1
    std::apply(
71
1
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
1
          llvm::consumeError(expected_return_object.takeError());
73
1
          expected_return_object =
74
1
              implementor.CallMethod(method_name.data(), args...);
75
1
        },
76
1
        transformed_args);
77
78
1
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
1
    PythonObject py_return = std::move(expected_return_object.get());
85
86
1
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
1
    if (sizeof...(Args) > 0)
95
1
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
1
    return ExtractValueFromPythonObject<T>(py_return, error);
101
1
  }
lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status>(llvm::StringRef, lldb_private::Status&)
Line
Count
Source
42
2
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
2
    using namespace python;
44
2
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
2
    std::string caller_signature =
47
2
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
2
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
2
            .str();
50
2
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
2
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
2
                   Locker::FreeLock);
56
57
2
    PythonObject implementor(PyRefType::Borrowed,
58
2
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
2
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
2
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
2
    auto transformed_args = TransformArgs(original_args);
66
67
2
    llvm::Expected<PythonObject> expected_return_object =
68
2
        llvm::make_error<llvm::StringError>("Not initialized.",
69
2
                                            llvm::inconvertibleErrorCode());
70
2
    std::apply(
71
2
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
2
          llvm::consumeError(expected_return_object.takeError());
73
2
          expected_return_object =
74
2
              implementor.CallMethod(method_name.data(), args...);
75
2
        },
76
2
        transformed_args);
77
78
2
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
2
    PythonObject py_return = std::move(expected_return_object.get());
85
86
2
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
2
    if (sizeof...(Args) > 0)
95
0
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
2
    return ExtractValueFromPythonObject<T>(py_return, error);
101
2
  }
lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status, bool>(llvm::StringRef, lldb_private::Status&, bool&&)
Line
Count
Source
42
2
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
2
    using namespace python;
44
2
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
2
    std::string caller_signature =
47
2
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
2
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
2
            .str();
50
2
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
2
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
2
                   Locker::FreeLock);
56
57
2
    PythonObject implementor(PyRefType::Borrowed,
58
2
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
2
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
2
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
2
    auto transformed_args = TransformArgs(original_args);
66
67
2
    llvm::Expected<PythonObject> expected_return_object =
68
2
        llvm::make_error<llvm::StringError>("Not initialized.",
69
2
                                            llvm::inconvertibleErrorCode());
70
2
    std::apply(
71
2
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
2
          llvm::consumeError(expected_return_object.takeError());
73
2
          expected_return_object =
74
2
              implementor.CallMethod(method_name.data(), args...);
75
2
        },
76
2
        transformed_args);
77
78
2
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
2
    PythonObject py_return = std::move(expected_return_object.get());
85
86
2
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
2
    if (sizeof...(Args) > 0)
95
2
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
2
    return ExtractValueFromPythonObject<T>(py_return, error);
101
2
  }
std::__1::optional<lldb_private::MemoryRegionInfo> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::optional<lldb_private::MemoryRegionInfo>, unsigned long long&>(llvm::StringRef, lldb_private::Status&, unsigned long long&)
Line
Count
Source
42
1
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
1
    using namespace python;
44
1
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
1
    std::string caller_signature =
47
1
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
1
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
1
            .str();
50
1
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
1
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
1
                   Locker::FreeLock);
56
57
1
    PythonObject implementor(PyRefType::Borrowed,
58
1
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
1
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
1
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
1
    auto transformed_args = TransformArgs(original_args);
66
67
1
    llvm::Expected<PythonObject> expected_return_object =
68
1
        llvm::make_error<llvm::StringError>("Not initialized.",
69
1
                                            llvm::inconvertibleErrorCode());
70
1
    std::apply(
71
1
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
1
          llvm::consumeError(expected_return_object.takeError());
73
1
          expected_return_object =
74
1
              implementor.CallMethod(method_name.data(), args...);
75
1
        },
76
1
        transformed_args);
77
78
1
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
1
    PythonObject py_return = std::move(expected_return_object.get());
85
86
1
    if (!py_return.IsAllocated())
87
1
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
1
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
0
    if (sizeof...(Args) > 0)
95
0
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
0
    return ExtractValueFromPythonObject<T>(py_return, error);
101
0
  }
Unexecuted instantiation: std::__1::shared_ptr<lldb_private::StructuredData::Object> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Object>, unsigned long long&, lldb_private::Status&>(llvm::StringRef, lldb_private::Status&, unsigned long long&, lldb_private::Status&)
std::__1::shared_ptr<lldb_private::DataExtractor> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::DataExtractor>, unsigned long long&, unsigned long&, lldb_private::Status&>(llvm::StringRef, lldb_private::Status&, unsigned long long&, unsigned long&, lldb_private::Status&)
Line
Count
Source
42
9
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
9
    using namespace python;
44
9
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
9
    std::string caller_signature =
47
9
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
9
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
9
            .str();
50
9
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
9
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
9
                   Locker::FreeLock);
56
57
9
    PythonObject implementor(PyRefType::Borrowed,
58
9
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
9
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
9
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
9
    auto transformed_args = TransformArgs(original_args);
66
67
9
    llvm::Expected<PythonObject> expected_return_object =
68
9
        llvm::make_error<llvm::StringError>("Not initialized.",
69
9
                                            llvm::inconvertibleErrorCode());
70
9
    std::apply(
71
9
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
9
          llvm::consumeError(expected_return_object.takeError());
73
9
          expected_return_object =
74
9
              implementor.CallMethod(method_name.data(), args...);
75
9
        },
76
9
        transformed_args);
77
78
9
    if (llvm::Error e = expected_return_object.takeError()) {
79
5
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
5
      return ErrorWithMessage<T>(caller_signature,
81
5
                                 "Python method could not be called.", error);
82
5
    }
83
84
4
    PythonObject py_return = std::move(expected_return_object.get());
85
86
4
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
4
    if (sizeof...(Args) > 0)
95
4
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
4
    return ExtractValueFromPythonObject<T>(py_return, error);
101
4
  }
std::__1::shared_ptr<lldb_private::StructuredData::Object> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Object>, unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&>(llvm::StringRef, lldb_private::Status&, unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&)
Line
Count
Source
42
1
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
1
    using namespace python;
44
1
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
1
    std::string caller_signature =
47
1
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
1
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
1
            .str();
50
1
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
1
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
1
                   Locker::FreeLock);
56
57
1
    PythonObject implementor(PyRefType::Borrowed,
58
1
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
1
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
1
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
1
    auto transformed_args = TransformArgs(original_args);
66
67
1
    llvm::Expected<PythonObject> expected_return_object =
68
1
        llvm::make_error<llvm::StringError>("Not initialized.",
69
1
                                            llvm::inconvertibleErrorCode());
70
1
    std::apply(
71
1
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
1
          llvm::consumeError(expected_return_object.takeError());
73
1
          expected_return_object =
74
1
              implementor.CallMethod(method_name.data(), args...);
75
1
        },
76
1
        transformed_args);
77
78
1
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
1
    PythonObject py_return = std::move(expected_return_object.get());
85
86
1
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
1
    if (sizeof...(Args) > 0)
95
1
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
1
    return ExtractValueFromPythonObject<T>(py_return, error);
101
1
  }
std::__1::shared_ptr<lldb_private::StructuredData::Array> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Array> >(llvm::StringRef, lldb_private::Status&)
Line
Count
Source
42
4
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
4
    using namespace python;
44
4
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
4
    std::string caller_signature =
47
4
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
4
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
4
            .str();
50
4
    if (!m_object_instance_sp)
51
0
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
0
                                 error);
53
54
4
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
4
                   Locker::FreeLock);
56
57
4
    PythonObject implementor(PyRefType::Borrowed,
58
4
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
4
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
4
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
4
    auto transformed_args = TransformArgs(original_args);
66
67
4
    llvm::Expected<PythonObject> expected_return_object =
68
4
        llvm::make_error<llvm::StringError>("Not initialized.",
69
4
                                            llvm::inconvertibleErrorCode());
70
4
    std::apply(
71
4
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
4
          llvm::consumeError(expected_return_object.takeError());
73
4
          expected_return_object =
74
4
              implementor.CallMethod(method_name.data(), args...);
75
4
        },
76
4
        transformed_args);
77
78
4
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
4
    PythonObject py_return = std::move(expected_return_object.get());
85
86
4
    if (!py_return.IsAllocated())
87
0
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
0
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
4
    if (sizeof...(Args) > 0)
95
0
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
4
    return ExtractValueFromPythonObject<T>(py_return, error);
101
4
  }
std::__1::shared_ptr<lldb_private::StructuredData::Object> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Object> >(llvm::StringRef, lldb_private::Status&)
Line
Count
Source
42
241
  T Dispatch(llvm::StringRef method_name, Status &error, Args &&...args) {
43
241
    using namespace python;
44
241
    using Locker = ScriptInterpreterPythonImpl::Locker;
45
46
241
    std::string caller_signature =
47
241
        llvm::Twine(LLVM_PRETTY_FUNCTION + llvm::Twine(" (") +
48
241
                    llvm::Twine(method_name) + llvm::Twine(")"))
49
241
            .str();
50
241
    if (!m_object_instance_sp)
51
195
      return ErrorWithMessage<T>(caller_signature, "Python object ill-formed",
52
195
                                 error);
53
54
46
    Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
55
46
                   Locker::FreeLock);
56
57
46
    PythonObject implementor(PyRefType::Borrowed,
58
46
                             (PyObject *)m_object_instance_sp->GetValue());
59
60
46
    if (!implementor.IsAllocated())
61
0
      return ErrorWithMessage<T>(caller_signature,
62
0
                                 "Python implementor not allocated.", error);
63
64
46
    std::tuple<Args...> original_args = std::forward_as_tuple(args...);
65
46
    auto transformed_args = TransformArgs(original_args);
66
67
46
    llvm::Expected<PythonObject> expected_return_object =
68
46
        llvm::make_error<llvm::StringError>("Not initialized.",
69
46
                                            llvm::inconvertibleErrorCode());
70
46
    std::apply(
71
46
        [&implementor, &method_name, &expected_return_object](auto &&...args) {
72
46
          llvm::consumeError(expected_return_object.takeError());
73
46
          expected_return_object =
74
46
              implementor.CallMethod(method_name.data(), args...);
75
46
        },
76
46
        transformed_args);
77
78
46
    if (llvm::Error e = expected_return_object.takeError()) {
79
0
      error.SetErrorString(llvm::toString(std::move(e)).c_str());
80
0
      return ErrorWithMessage<T>(caller_signature,
81
0
                                 "Python method could not be called.", error);
82
0
    }
83
84
46
    PythonObject py_return = std::move(expected_return_object.get());
85
86
46
    if (!py_return.IsAllocated())
87
12
      return ErrorWithMessage<T>(caller_signature, "Returned object is null.",
88
12
                                 error);
89
90
    // Now that we called the python method with the transformed arguments,
91
    // we need to interate again over both the original and transformed
92
    // parameter pack, and transform back the parameter that were passed in
93
    // the original parameter pack as references or pointers.
94
34
    if (sizeof...(Args) > 0)
95
0
      if (!ReassignPtrsOrRefsArgs(original_args, transformed_args))
96
0
        return ErrorWithMessage<T>(
97
0
            caller_signature,
98
0
            "Couldn't re-assign reference and pointer arguments.", error);
99
100
34
    return ExtractValueFromPythonObject<T>(py_return, error);
101
34
  }
Unexecuted instantiation: std::__1::shared_ptr<lldb_private::StructuredData::Dictionary> lldb_private::ScriptedPythonInterface::Dispatch<std::__1::shared_ptr<lldb_private::StructuredData::Dictionary>, unsigned long long&>(llvm::StringRef, lldb_private::Status&, unsigned long long&)
Unexecuted instantiation: lldb_private::Status lldb_private::ScriptedPythonInterface::Dispatch<lldb_private::Status, unsigned long long&>(llvm::StringRef, lldb_private::Status&, unsigned long long&)
102
103
  template <typename... Args>
104
5
  Status GetStatusFromMethod(llvm::StringRef method_name, Args &&...args) {
105
5
    Status error;
106
5
    Dispatch<Status>(method_name, error, std::forward<Args>(args)...);
107
108
5
    return error;
109
5
  }
lldb_private::Status lldb_private::ScriptedPythonInterface::GetStatusFromMethod<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>(llvm::StringRef, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&)
Line
Count
Source
104
1
  Status GetStatusFromMethod(llvm::StringRef method_name, Args &&...args) {
105
1
    Status error;
106
1
    Dispatch<Status>(method_name, error, std::forward<Args>(args)...);
107
108
1
    return error;
109
1
  }
lldb_private::Status lldb_private::ScriptedPythonInterface::GetStatusFromMethod<>(llvm::StringRef)
Line
Count
Source
104
2
  Status GetStatusFromMethod(llvm::StringRef method_name, Args &&...args) {
105
2
    Status error;
106
2
    Dispatch<Status>(method_name, error, std::forward<Args>(args)...);
107
108
2
    return error;
109
2
  }
lldb_private::Status lldb_private::ScriptedPythonInterface::GetStatusFromMethod<bool>(llvm::StringRef, bool&&)
Line
Count
Source
104
2
  Status GetStatusFromMethod(llvm::StringRef method_name, Args &&...args) {
105
2
    Status error;
106
2
    Dispatch<Status>(method_name, error, std::forward<Args>(args)...);
107
108
2
    return error;
109
2
  }
Unexecuted instantiation: lldb_private::Status lldb_private::ScriptedPythonInterface::GetStatusFromMethod<unsigned long long&>(llvm::StringRef, unsigned long long&)
110
111
20
  template <typename T> T Transform(T object) {
112
    // No Transformation for generic usage
113
20
    return {object};
114
20
  }
unsigned long long lldb_private::ScriptedPythonInterface::Transform<unsigned long long>(unsigned long long)
Line
Count
Source
111
11
  template <typename T> T Transform(T object) {
112
    // No Transformation for generic usage
113
11
    return {object};
114
11
  }
unsigned long lldb_private::ScriptedPythonInterface::Transform<unsigned long>(unsigned long)
Line
Count
Source
111
9
  template <typename T> T Transform(T object) {
112
    // No Transformation for generic usage
113
9
    return {object};
114
9
  }
115
116
2
  python::PythonObject Transform(bool arg) {
117
    // Boolean arguments need to be turned into python objects.
118
2
    return python::PythonBoolean(arg);
119
2
  }
120
121
10
  python::PythonObject Transform(Status arg) {
122
10
    return python::SWIGBridge::ToSWIGWrapper(arg);
123
10
  }
124
125
1
  python::PythonObject Transform(lldb::ProcessAttachInfoSP arg) {
126
1
    return python::SWIGBridge::ToSWIGWrapper(arg);
127
1
  }
128
129
0
  python::PythonObject Transform(lldb::ProcessLaunchInfoSP arg) {
130
0
    return python::SWIGBridge::ToSWIGWrapper(arg);
131
0
  }
132
133
1
  python::PythonObject Transform(lldb::DataExtractorSP arg) {
134
1
    return python::SWIGBridge::ToSWIGWrapper(arg);
135
1
  }
136
137
  template <typename T, typename U>
138
9
  void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
139
    // If U is not a PythonObject, don't touch it!
140
9
    return;
141
9
  }
void lldb_private::ScriptedPythonInterface::ReverseTransform<unsigned long long, unsigned long long>(unsigned long long&, unsigned long long, lldb_private::Status&)
Line
Count
Source
138
5
  void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
139
    // If U is not a PythonObject, don't touch it!
140
5
    return;
141
5
  }
void lldb_private::ScriptedPythonInterface::ReverseTransform<unsigned long, unsigned long>(unsigned long&, unsigned long, lldb_private::Status&)
Line
Count
Source
138
4
  void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
139
    // If U is not a PythonObject, don't touch it!
140
4
    return;
141
4
  }
142
143
  template <typename T>
144
  void ReverseTransform(T &original_arg, python::PythonObject transformed_arg,
145
7
                        Status &error) {
146
7
    original_arg = ExtractValueFromPythonObject<T>(transformed_arg, error);
147
7
  }
void lldb_private::ScriptedPythonInterface::ReverseTransform<std::__1::shared_ptr<lldb_private::ProcessAttachInfo> >(std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
145
1
                        Status &error) {
146
1
    original_arg = ExtractValueFromPythonObject<T>(transformed_arg, error);
147
1
  }
void lldb_private::ScriptedPythonInterface::ReverseTransform<lldb_private::Status>(lldb_private::Status&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
145
5
                        Status &error) {
146
5
    original_arg = ExtractValueFromPythonObject<T>(transformed_arg, error);
147
5
  }
void lldb_private::ScriptedPythonInterface::ReverseTransform<std::__1::shared_ptr<lldb_private::DataExtractor> >(std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
145
1
                        Status &error) {
146
1
    original_arg = ExtractValueFromPythonObject<T>(transformed_arg, error);
147
1
  }
148
149
150
  void ReverseTransform(bool &original_arg,
151
2
                        python::PythonObject transformed_arg, Status &error) {
152
2
    python::PythonBoolean boolean_arg = python::PythonBoolean(
153
2
        python::PyRefType::Borrowed, transformed_arg.get());
154
2
    if (boolean_arg.IsValid())
155
2
      original_arg = boolean_arg.GetValue();
156
0
    else
157
0
      error.SetErrorString(
158
0
          llvm::formatv("{}: Invalid boolean argument.", LLVM_PRETTY_FUNCTION)
159
0
              .str());
160
2
  }
161
162
  template <std::size_t... I, typename... Args>
163
  auto TransformTuple(const std::tuple<Args...> &args,
164
87
                      std::index_sequence<I...>) {
165
87
    return std::make_tuple(Transform(std::get<I>(args))...);
166
87
  }
_ZN12lldb_private23ScriptedPythonInterface14TransformTupleITpTnmJEJEEEDaRKNSt3__15tupleIJDpT0_EEENS2_16integer_sequenceImJXspT_EEEE
Line
Count
Source
164
73
                      std::index_sequence<I...>) {
165
73
    return std::make_tuple(Transform(std::get<I>(args))...);
166
73
  }
auto lldb_private::ScriptedPythonInterface::TransformTuple<0ul, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>(std::__1::tuple<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&> const&, std::__1::integer_sequence<unsigned long, 0ul>)
Line
Count
Source
164
1
                      std::index_sequence<I...>) {
165
1
    return std::make_tuple(Transform(std::get<I>(args))...);
166
1
  }
auto lldb_private::ScriptedPythonInterface::TransformTuple<0ul, bool>(std::__1::tuple<bool> const&, std::__1::integer_sequence<unsigned long, 0ul>)
Line
Count
Source
164
2
                      std::index_sequence<I...>) {
165
2
    return std::make_tuple(Transform(std::get<I>(args))...);
166
2
  }
auto lldb_private::ScriptedPythonInterface::TransformTuple<0ul, unsigned long long&>(std::__1::tuple<unsigned long long&> const&, std::__1::integer_sequence<unsigned long, 0ul>)
Line
Count
Source
164
1
                      std::index_sequence<I...>) {
165
1
    return std::make_tuple(Transform(std::get<I>(args))...);
166
1
  }
Unexecuted instantiation: auto lldb_private::ScriptedPythonInterface::TransformTuple<0ul, 1ul, unsigned long long&, lldb_private::Status&>(std::__1::tuple<unsigned long long&, lldb_private::Status&> const&, std::__1::integer_sequence<unsigned long, 0ul, 1ul>)
auto lldb_private::ScriptedPythonInterface::TransformTuple<0ul, 1ul, 2ul, unsigned long long&, unsigned long&, lldb_private::Status&>(std::__1::tuple<unsigned long long&, unsigned long&, lldb_private::Status&> const&, std::__1::integer_sequence<unsigned long, 0ul, 1ul, 2ul>)
Line
Count
Source
164
9
                      std::index_sequence<I...>) {
165
9
    return std::make_tuple(Transform(std::get<I>(args))...);
166
9
  }
auto lldb_private::ScriptedPythonInterface::TransformTuple<0ul, 1ul, 2ul, unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&>(std::__1::tuple<unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&> const&, std::__1::integer_sequence<unsigned long, 0ul, 1ul, 2ul>)
Line
Count
Source
164
1
                      std::index_sequence<I...>) {
165
1
    return std::make_tuple(Transform(std::get<I>(args))...);
166
1
  }
167
168
  // This will iterate over the Dispatch parameter pack and replace in-place
169
  // every `lldb_private` argument that has a SB counterpart.
170
  template <typename... Args>
171
87
  auto TransformArgs(const std::tuple<Args...> &args) {
172
87
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
87
  }
auto lldb_private::ScriptedPythonInterface::TransformArgs<>(std::__1::tuple<> const&)
Line
Count
Source
171
73
  auto TransformArgs(const std::tuple<Args...> &args) {
172
73
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
73
  }
auto lldb_private::ScriptedPythonInterface::TransformArgs<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>(std::__1::tuple<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&> const&)
Line
Count
Source
171
1
  auto TransformArgs(const std::tuple<Args...> &args) {
172
1
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
1
  }
auto lldb_private::ScriptedPythonInterface::TransformArgs<bool>(std::__1::tuple<bool> const&)
Line
Count
Source
171
2
  auto TransformArgs(const std::tuple<Args...> &args) {
172
2
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
2
  }
auto lldb_private::ScriptedPythonInterface::TransformArgs<unsigned long long&>(std::__1::tuple<unsigned long long&> const&)
Line
Count
Source
171
1
  auto TransformArgs(const std::tuple<Args...> &args) {
172
1
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
1
  }
Unexecuted instantiation: auto lldb_private::ScriptedPythonInterface::TransformArgs<unsigned long long&, lldb_private::Status&>(std::__1::tuple<unsigned long long&, lldb_private::Status&> const&)
auto lldb_private::ScriptedPythonInterface::TransformArgs<unsigned long long&, unsigned long&, lldb_private::Status&>(std::__1::tuple<unsigned long long&, unsigned long&, lldb_private::Status&> const&)
Line
Count
Source
171
9
  auto TransformArgs(const std::tuple<Args...> &args) {
172
9
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
9
  }
auto lldb_private::ScriptedPythonInterface::TransformArgs<unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&>(std::__1::tuple<unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&> const&)
Line
Count
Source
171
1
  auto TransformArgs(const std::tuple<Args...> &args) {
172
1
    return TransformTuple(args, std::make_index_sequence<sizeof...(Args)>());
173
1
  }
174
175
  template <typename T, typename U>
176
18
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
18
    ReverseTransform(original_arg, transformed_arg, error);
178
18
  }
void lldb_private::ScriptedPythonInterface::TransformBack<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>, lldb_private::python::PythonObject>(std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
176
1
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
1
    ReverseTransform(original_arg, transformed_arg, error);
178
1
  }
void lldb_private::ScriptedPythonInterface::TransformBack<bool, lldb_private::python::PythonObject>(bool&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
176
2
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
2
    ReverseTransform(original_arg, transformed_arg, error);
178
2
  }
void lldb_private::ScriptedPythonInterface::TransformBack<unsigned long long, unsigned long long>(unsigned long long&, unsigned long long, lldb_private::Status&)
Line
Count
Source
176
5
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
5
    ReverseTransform(original_arg, transformed_arg, error);
178
5
  }
void lldb_private::ScriptedPythonInterface::TransformBack<lldb_private::Status, lldb_private::python::PythonObject>(lldb_private::Status&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
176
5
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
5
    ReverseTransform(original_arg, transformed_arg, error);
178
5
  }
void lldb_private::ScriptedPythonInterface::TransformBack<unsigned long, unsigned long>(unsigned long&, unsigned long, lldb_private::Status&)
Line
Count
Source
176
4
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
4
    ReverseTransform(original_arg, transformed_arg, error);
178
4
  }
void lldb_private::ScriptedPythonInterface::TransformBack<std::__1::shared_ptr<lldb_private::DataExtractor>, lldb_private::python::PythonObject>(std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::python::PythonObject, lldb_private::Status&)
Line
Count
Source
176
1
  void TransformBack(T &original_arg, U transformed_arg, Status &error) {
177
1
    ReverseTransform(original_arg, transformed_arg, error);
178
1
  }
179
180
  template <std::size_t... I, typename... Ts, typename... Us>
181
  bool ReassignPtrsOrRefsArgs(std::tuple<Ts...> &original_args,
182
                              std::tuple<Us...> &transformed_args,
183
8
                              std::index_sequence<I...>) {
184
8
    Status error;
185
8
    (TransformBack(std::get<I>(original_args), std::get<I>(transformed_args),
186
8
                   error),
187
8
     ...);
188
8
    return error.Success();
189
8
  }
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<0ul, std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&, lldb_private::python::PythonObject>(std::__1::tuple<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>&, std::__1::tuple<lldb_private::python::PythonObject>&, std::__1::integer_sequence<unsigned long, 0ul>)
Line
Count
Source
183
1
                              std::index_sequence<I...>) {
184
1
    Status error;
185
1
    (TransformBack(std::get<I>(original_args), std::get<I>(transformed_args),
186
1
                   error),
187
1
     ...);
188
1
    return error.Success();
189
1
  }
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<0ul, bool, lldb_private::python::PythonObject>(std::__1::tuple<bool>&, std::__1::tuple<lldb_private::python::PythonObject>&, std::__1::integer_sequence<unsigned long, 0ul>)
Line
Count
Source
183
2
                              std::index_sequence<I...>) {
184
2
    Status error;
185
2
    (TransformBack(std::get<I>(original_args), std::get<I>(transformed_args),
186
2
                   error),
187
2
     ...);
188
2
    return error.Success();
189
2
  }
Unexecuted instantiation: bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<0ul, unsigned long long&, unsigned long long>(std::__1::tuple<unsigned long long&>&, std::__1::tuple<unsigned long long>&, std::__1::integer_sequence<unsigned long, 0ul>)
Unexecuted instantiation: bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<0ul, 1ul, unsigned long long&, lldb_private::Status&, unsigned long long, lldb_private::python::PythonObject>(std::__1::tuple<unsigned long long&, lldb_private::Status&>&, std::__1::tuple<unsigned long long, lldb_private::python::PythonObject>&, std::__1::integer_sequence<unsigned long, 0ul, 1ul>)
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<0ul, 1ul, 2ul, unsigned long long&, unsigned long&, lldb_private::Status&, unsigned long long, unsigned long, lldb_private::python::PythonObject>(std::__1::tuple<unsigned long long&, unsigned long&, lldb_private::Status&>&, std::__1::tuple<unsigned long long, unsigned long, lldb_private::python::PythonObject>&, std::__1::integer_sequence<unsigned long, 0ul, 1ul, 2ul>)
Line
Count
Source
183
4
                              std::index_sequence<I...>) {
184
4
    Status error;
185
4
    (TransformBack(std::get<I>(original_args), std::get<I>(transformed_args),
186
4
                   error),
187
4
     ...);
188
4
    return error.Success();
189
4
  }
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<0ul, 1ul, 2ul, unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&, unsigned long long, lldb_private::python::PythonObject, lldb_private::python::PythonObject>(std::__1::tuple<unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&>&, std::__1::tuple<unsigned long long, lldb_private::python::PythonObject, lldb_private::python::PythonObject>&, std::__1::integer_sequence<unsigned long, 0ul, 1ul, 2ul>)
Line
Count
Source
183
1
                              std::index_sequence<I...>) {
184
1
    Status error;
185
1
    (TransformBack(std::get<I>(original_args), std::get<I>(transformed_args),
186
1
                   error),
187
1
     ...);
188
1
    return error.Success();
189
1
  }
Unexecuted instantiation: _ZN12lldb_private23ScriptedPythonInterface22ReassignPtrsOrRefsArgsITpTnmJEJEJEEEbRNSt3__15tupleIJDpT0_EEERNS3_IJDpT1_EEENS2_16integer_sequenceImJXspT_EEEE
190
191
  template <typename... Ts, typename... Us>
192
  bool ReassignPtrsOrRefsArgs(std::tuple<Ts...> &original_args,
193
8
                              std::tuple<Us...> &transformed_args) {
194
8
    if (sizeof...(Ts) != sizeof...(Us))
195
0
      return false;
196
197
8
    return ReassignPtrsOrRefsArgs(original_args, transformed_args,
198
8
                                  std::make_index_sequence<sizeof...(Ts)>());
199
8
  }
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&, lldb_private::python::PythonObject>(std::__1::tuple<std::__1::shared_ptr<lldb_private::ProcessAttachInfo>&>&, std::__1::tuple<lldb_private::python::PythonObject>&)
Line
Count
Source
193
1
                              std::tuple<Us...> &transformed_args) {
194
1
    if (sizeof...(Ts) != sizeof...(Us))
195
0
      return false;
196
197
1
    return ReassignPtrsOrRefsArgs(original_args, transformed_args,
198
1
                                  std::make_index_sequence<sizeof...(Ts)>());
199
1
  }
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<bool, lldb_private::python::PythonObject>(std::__1::tuple<bool>&, std::__1::tuple<lldb_private::python::PythonObject>&)
Line
Count
Source
193
2
                              std::tuple<Us...> &transformed_args) {
194
2
    if (sizeof...(Ts) != sizeof...(Us))
195
0
      return false;
196
197
2
    return ReassignPtrsOrRefsArgs(original_args, transformed_args,
198
2
                                  std::make_index_sequence<sizeof...(Ts)>());
199
2
  }
Unexecuted instantiation: bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<unsigned long long&, unsigned long long>(std::__1::tuple<unsigned long long&>&, std::__1::tuple<unsigned long long>&)
Unexecuted instantiation: bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<unsigned long long&, lldb_private::Status&, unsigned long long, lldb_private::python::PythonObject>(std::__1::tuple<unsigned long long&, lldb_private::Status&>&, std::__1::tuple<unsigned long long, lldb_private::python::PythonObject>&)
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<unsigned long long&, unsigned long&, lldb_private::Status&, unsigned long long, unsigned long, lldb_private::python::PythonObject>(std::__1::tuple<unsigned long long&, unsigned long&, lldb_private::Status&>&, std::__1::tuple<unsigned long long, unsigned long, lldb_private::python::PythonObject>&)
Line
Count
Source
193
4
                              std::tuple<Us...> &transformed_args) {
194
4
    if (sizeof...(Ts) != sizeof...(Us))
195
0
      return false;
196
197
4
    return ReassignPtrsOrRefsArgs(original_args, transformed_args,
198
4
                                  std::make_index_sequence<sizeof...(Ts)>());
199
4
  }
bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&, unsigned long long, lldb_private::python::PythonObject, lldb_private::python::PythonObject>(std::__1::tuple<unsigned long long&, std::__1::shared_ptr<lldb_private::DataExtractor>&, lldb_private::Status&>&, std::__1::tuple<unsigned long long, lldb_private::python::PythonObject, lldb_private::python::PythonObject>&)
Line
Count
Source
193
1
                              std::tuple<Us...> &transformed_args) {
194
1
    if (sizeof...(Ts) != sizeof...(Us))
195
0
      return false;
196
197
1
    return ReassignPtrsOrRefsArgs(original_args, transformed_args,
198
1
                                  std::make_index_sequence<sizeof...(Ts)>());
199
1
  }
Unexecuted instantiation: bool lldb_private::ScriptedPythonInterface::ReassignPtrsOrRefsArgs<>(std::__1::tuple<>&, std::__1::tuple<>&)
200
201
  template <typename T, typename... Args>
202
  void FormatArgs(std::string &fmt, T arg, Args... args) const {
203
    FormatArgs(fmt, arg);
204
    FormatArgs(fmt, args...);
205
  }
206
207
  template <typename T> void FormatArgs(std::string &fmt, T arg) const {
208
    fmt += python::PythonFormat<T>::format;
209
  }
210
211
0
  void FormatArgs(std::string &fmt) const {}
212
213
  // The lifetime is managed by the ScriptInterpreter
214
  ScriptInterpreterPythonImpl &m_interpreter;
215
};
216
217
template <>
218
StructuredData::ArraySP
219
ScriptedPythonInterface::ExtractValueFromPythonObject<StructuredData::ArraySP>(
220
    python::PythonObject &p, Status &error);
221
222
template <>
223
StructuredData::DictionarySP
224
ScriptedPythonInterface::ExtractValueFromPythonObject<
225
    StructuredData::DictionarySP>(python::PythonObject &p, Status &error);
226
227
template <>
228
Status ScriptedPythonInterface::ExtractValueFromPythonObject<Status>(
229
    python::PythonObject &p, Status &error);
230
231
template <>
232
lldb::BreakpointSP
233
ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::BreakpointSP>(
234
    python::PythonObject &p, Status &error);
235
236
template <>
237
lldb::ProcessAttachInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
238
    lldb::ProcessAttachInfoSP>(python::PythonObject &p, Status &error);
239
240
template <>
241
lldb::ProcessLaunchInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
242
    lldb::ProcessLaunchInfoSP>(python::PythonObject &p, Status &error);
243
244
template <>
245
lldb::DataExtractorSP
246
ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
247
    python::PythonObject &p, Status &error);
248
249
template <>
250
std::optional<MemoryRegionInfo>
251
ScriptedPythonInterface::ExtractValueFromPythonObject<
252
    std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error);
253
254
} // namespace lldb_private
255
256
#endif // LLDB_ENABLE_PYTHON
257
#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H