https://github.com/bzcheeseman updated https://github.com/llvm/llvm-project/pull/178574
>From 509aa8a2e2ccda69169d6626f1ece57522e92a31 Mon Sep 17 00:00:00 2001 From: bzcheeseman <[email protected]> Date: Wed, 28 Jan 2026 15:40:02 -0800 Subject: [PATCH 1/2] [lldb] Move ValueImpl and ValueLocker to ValueObject, NFC. This patch moves ValueImpl and ValueLocker to ValueObject.{h,cpp}. This follows the example set in TypeImpl/SBType, where we have something that SBType uses internally that needs to be exposed in the layer below. In this case, SBValue uses ValueImpl, which wraps ValueObject. The wrapper helps avoid bugs, so we want to keep it, but the script interpreter needs to use it and said interpreter is conceptually *below* the SB layer...which means we can't use methods on SBValue. This patch is purely the code motion part of that, future patches will actually make use of this moved code. stack-info: PR: https://github.com/llvm/llvm-project/pull/178573, branch: users/bzcheeseman/stack/4 --- lldb/include/lldb/API/SBValue.h | 10 +- lldb/include/lldb/ValueObject/ValueObject.h | 78 +++++++++ lldb/source/API/SBValue.cpp | 166 -------------------- lldb/source/ValueObject/ValueObject.cpp | 91 +++++++++++ 4 files changed, 175 insertions(+), 170 deletions(-) diff --git a/lldb/include/lldb/API/SBValue.h b/lldb/include/lldb/API/SBValue.h index dead11fba19fe..d4cc2f05c39e3 100644 --- a/lldb/include/lldb/API/SBValue.h +++ b/lldb/include/lldb/API/SBValue.h @@ -13,10 +13,9 @@ #include "lldb/API/SBDefines.h" #include "lldb/API/SBType.h" +namespace lldb_private { class ValueImpl; class ValueLocker; - -namespace lldb_private { namespace python { class SWIGBridge; } @@ -490,7 +489,7 @@ class LLDB_API SBValue { /// \return /// A ValueObjectSP of the best kind (static, dynamic or synthetic) we /// can cons up, in accordance with the SBValue's settings. - lldb::ValueObjectSP GetSP(ValueLocker &value_locker) const; + lldb::ValueObjectSP GetSP(lldb_private::ValueLocker &value_locker) const; // these calls do the right thing WRT adjusting their settings according to // the target's preferences @@ -506,8 +505,11 @@ class LLDB_API SBValue { void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name); +protected: + friend class lldb_private::ScriptInterpreter; + private: - typedef std::shared_ptr<ValueImpl> ValueImplSP; + typedef std::shared_ptr<lldb_private::ValueImpl> ValueImplSP; ValueImplSP m_opaque_sp; void SetSP(ValueImplSP impl_sp); diff --git a/lldb/include/lldb/ValueObject/ValueObject.h b/lldb/include/lldb/ValueObject/ValueObject.h index 3f9f2b5de8dbe..8a528bad15f94 100644 --- a/lldb/include/lldb/ValueObject/ValueObject.h +++ b/lldb/include/lldb/ValueObject/ValueObject.h @@ -1121,6 +1121,84 @@ class ValueObject { const ValueObject &operator=(const ValueObject &) = delete; }; +// The two classes below are used by the public SBValue API implementation. This +// is useful here because we need them in order to access the underlying +// ValueObject from SBValue without introducing a back-dependency from the API +// library to the more core libs. + +class ValueImpl { +public: + ValueImpl() = default; + + ValueImpl(lldb::ValueObjectSP in_valobj_sp, + lldb::DynamicValueType use_dynamic, bool use_synthetic, + const char *name = nullptr); + + ValueImpl(const ValueImpl &rhs) = default; + + ValueImpl &operator=(const ValueImpl &rhs); + + bool IsValid(); + + lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; } + + lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker, + std::unique_lock<std::recursive_mutex> &lock, + Status &error); + + void SetUseDynamic(lldb::DynamicValueType use_dynamic) { + m_use_dynamic = use_dynamic; + } + + void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; } + + lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; } + + bool GetUseSynthetic() { return m_use_synthetic; } + + // All the derived values that we would make from the m_valobj_sp will share + // the ExecutionContext with m_valobj_sp, so we don't need to do the + // calculations in GetSP to return the Target, Process, Thread or Frame. It + // is convenient to provide simple accessors for these, which I do here. + lldb::TargetSP GetTargetSP() { + return m_valobj_sp ? m_valobj_sp->GetTargetSP() : lldb::TargetSP{}; + } + + lldb::ProcessSP GetProcessSP() { + return m_valobj_sp ? m_valobj_sp->GetProcessSP() : lldb::ProcessSP{}; + } + + lldb::ThreadSP GetThreadSP() { + return m_valobj_sp ? m_valobj_sp->GetThreadSP() : lldb::ThreadSP{}; + } + + lldb::StackFrameSP GetFrameSP() { + return m_valobj_sp ? m_valobj_sp->GetFrameSP() : lldb::StackFrameSP{}; + } + +private: + lldb::ValueObjectSP m_valobj_sp; + lldb::DynamicValueType m_use_dynamic; + bool m_use_synthetic; + ConstString m_name; +}; + +class ValueLocker { +public: + ValueLocker() = default; + + lldb::ValueObjectSP GetLockedSP(ValueImpl &in_value) { + return in_value.GetSP(m_stop_locker, m_lock, m_lock_error); + } + + Status &GetError() { return m_lock_error; } + +private: + Process::StopLocker m_stop_locker; + std::unique_lock<std::recursive_mutex> m_lock; + Status m_lock_error; +}; + } // namespace lldb_private #endif // LLDB_VALUEOBJECT_VALUEOBJECT_H diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp index 5b67270859da2..adc03785602e1 100644 --- a/lldb/source/API/SBValue.cpp +++ b/lldb/source/API/SBValue.cpp @@ -52,172 +52,6 @@ using namespace lldb; using namespace lldb_private; -class ValueImpl { -public: - ValueImpl() = default; - - ValueImpl(lldb::ValueObjectSP in_valobj_sp, - lldb::DynamicValueType use_dynamic, bool use_synthetic, - const char *name = nullptr) - : m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic), - m_name(name) { - if (in_valobj_sp) { - if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable( - lldb::eNoDynamicValues, false))) { - if (!m_name.IsEmpty()) - m_valobj_sp->SetName(m_name); - } - } - } - - ValueImpl(const ValueImpl &rhs) = default; - - ValueImpl &operator=(const ValueImpl &rhs) { - if (this != &rhs) { - m_valobj_sp = rhs.m_valobj_sp; - m_use_dynamic = rhs.m_use_dynamic; - m_use_synthetic = rhs.m_use_synthetic; - m_name = rhs.m_name; - } - return *this; - } - - bool IsValid() { - if (m_valobj_sp.get() == nullptr) - return false; - else { - // FIXME: This check is necessary but not sufficient. We for sure don't - // want to touch SBValues whose owning - // targets have gone away. This check is a little weak in that it - // enforces that restriction when you call IsValid, but since IsValid - // doesn't lock the target, you have no guarantee that the SBValue won't - // go invalid after you call this... Also, an SBValue could depend on - // data from one of the modules in the target, and those could go away - // independently of the target, for instance if a module is unloaded. - // But right now, neither SBValues nor ValueObjects know which modules - // they depend on. So I have no good way to make that check without - // tracking that in all the ValueObject subclasses. - TargetSP target_sp = m_valobj_sp->GetTargetSP(); - return target_sp && target_sp->IsValid(); - } - } - - lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; } - - lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker, - std::unique_lock<std::recursive_mutex> &lock, - Status &error) { - if (!m_valobj_sp) { - error = Status::FromErrorString("invalid value object"); - return m_valobj_sp; - } - - lldb::ValueObjectSP value_sp = m_valobj_sp; - - Target *target = value_sp->GetTargetSP().get(); - // If this ValueObject holds an error, then it is valuable for that. - if (value_sp->GetError().Fail()) - return value_sp; - - if (!target) - return ValueObjectSP(); - - lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex()); - - ProcessSP process_sp(value_sp->GetProcessSP()); - if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) { - // We don't allow people to play around with ValueObject if the process - // is running. If you want to look at values, pause the process, then - // look. - error = Status::FromErrorString("process must be stopped."); - return ValueObjectSP(); - } - - if (m_use_dynamic != eNoDynamicValues) { - ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic); - if (dynamic_sp) - value_sp = dynamic_sp; - } - - if (m_use_synthetic) { - ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(); - if (synthetic_sp) - value_sp = synthetic_sp; - } - - if (!value_sp) - error = Status::FromErrorString("invalid value object"); - if (!m_name.IsEmpty()) - value_sp->SetName(m_name); - - return value_sp; - } - - void SetUseDynamic(lldb::DynamicValueType use_dynamic) { - m_use_dynamic = use_dynamic; - } - - void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; } - - lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; } - - bool GetUseSynthetic() { return m_use_synthetic; } - - // All the derived values that we would make from the m_valobj_sp will share - // the ExecutionContext with m_valobj_sp, so we don't need to do the - // calculations in GetSP to return the Target, Process, Thread or Frame. It - // is convenient to provide simple accessors for these, which I do here. - TargetSP GetTargetSP() { - if (m_valobj_sp) - return m_valobj_sp->GetTargetSP(); - else - return TargetSP(); - } - - ProcessSP GetProcessSP() { - if (m_valobj_sp) - return m_valobj_sp->GetProcessSP(); - else - return ProcessSP(); - } - - ThreadSP GetThreadSP() { - if (m_valobj_sp) - return m_valobj_sp->GetThreadSP(); - else - return ThreadSP(); - } - - StackFrameSP GetFrameSP() { - if (m_valobj_sp) - return m_valobj_sp->GetFrameSP(); - else - return StackFrameSP(); - } - -private: - lldb::ValueObjectSP m_valobj_sp; - lldb::DynamicValueType m_use_dynamic; - bool m_use_synthetic; - ConstString m_name; -}; - -class ValueLocker { -public: - ValueLocker() = default; - - ValueObjectSP GetLockedSP(ValueImpl &in_value) { - return in_value.GetSP(m_stop_locker, m_lock, m_lock_error); - } - - Status &GetError() { return m_lock_error; } - -private: - Process::StopLocker m_stop_locker; - std::unique_lock<std::recursive_mutex> m_lock; - Status m_lock_error; -}; - SBValue::SBValue() { LLDB_INSTRUMENT_VA(this); } SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { diff --git a/lldb/source/ValueObject/ValueObject.cpp b/lldb/source/ValueObject/ValueObject.cpp index 121054e3e92ed..5b7c65a102e5d 100644 --- a/lldb/source/ValueObject/ValueObject.cpp +++ b/lldb/source/ValueObject/ValueObject.cpp @@ -3768,3 +3768,94 @@ ValueObjectSP ValueObject::Persist() { lldb::ValueObjectSP ValueObject::GetVTable() { return ValueObjectVTable::Create(*this); } + +ValueImpl::ValueImpl(lldb::ValueObjectSP in_valobj_sp, + lldb::DynamicValueType use_dynamic, bool use_synthetic, + const char *name) + : m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic), m_name(name) { + if (in_valobj_sp) { + if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable( + lldb::eNoDynamicValues, false))) { + if (!m_name.IsEmpty()) + m_valobj_sp->SetName(m_name); + } + } +} + +ValueImpl &ValueImpl::operator=(const ValueImpl &rhs) { + if (this != &rhs) { + m_valobj_sp = rhs.m_valobj_sp; + m_use_dynamic = rhs.m_use_dynamic; + m_use_synthetic = rhs.m_use_synthetic; + m_name = rhs.m_name; + } + return *this; +} + +bool ValueImpl::IsValid() { + if (m_valobj_sp.get() == nullptr) + return false; + + // FIXME: This check is necessary but not sufficient. We for sure don't + // want to touch SBValues whose owning + // targets have gone away. This check is a little weak in that it + // enforces that restriction when you call IsValid, but since IsValid + // doesn't lock the target, you have no guarantee that the SBValue won't + // go invalid after you call this... Also, an SBValue could depend on + // data from one of the modules in the target, and those could go away + // independently of the target, for instance if a module is unloaded. + // But right now, neither SBValues nor ValueObjects know which modules + // they depend on. So I have no good way to make that check without + // tracking that in all the ValueObject subclasses. + TargetSP target_sp = m_valobj_sp->GetTargetSP(); + return target_sp && target_sp->IsValid(); +} + +lldb::ValueObjectSP +ValueImpl::GetSP(Process::StopLocker &stop_locker, + std::unique_lock<std::recursive_mutex> &lock, Status &error) { + if (!m_valobj_sp) { + error = Status::FromErrorString("invalid value object"); + return m_valobj_sp; + } + + lldb::ValueObjectSP value_sp = m_valobj_sp; + + Target *target = value_sp->GetTargetSP().get(); + // If this ValueObject holds an error, then it is valuable for that. + if (value_sp->GetError().Fail()) + return value_sp; + + if (!target) + return ValueObjectSP(); + + lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex()); + + ProcessSP process_sp(value_sp->GetProcessSP()); + if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) { + // We don't allow people to play around with ValueObject if the process + // is running. If you want to look at values, pause the process, then + // look. + error = Status::FromErrorString("process must be stopped."); + return ValueObjectSP(); + } + + if (m_use_dynamic != eNoDynamicValues) { + ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic); + if (dynamic_sp) + value_sp = dynamic_sp; + } + + if (m_use_synthetic) { + ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(); + if (synthetic_sp) + value_sp = synthetic_sp; + } + + if (!value_sp) + error = Status::FromErrorString("invalid value object"); + if (!m_name.IsEmpty()) + value_sp->SetName(m_name); + + return value_sp; +} >From f4b81874b0a84e8449e0435392929a5165a2a62a Mon Sep 17 00:00:00 2001 From: bzcheeseman <[email protected]> Date: Wed, 28 Jan 2026 16:03:57 -0800 Subject: [PATCH 2/2] [lldb] Add conversions for SBValueList and SBValue to the python bridge. This patch adds support for: - PyObject -> SBValueList (which was surprisingly not there before!) - PyObject -> SBValue - SBValue -> ValueObjectSP using the ScriptInterpreter These three are the main remaining plumbing changes necessary before we can get to the meat of actually using ScriptedFrame to provide values to the printer/etc. Future patches build off this change in order to allow ScriptedFrames to provide variables and get values for variable expressions. stack-info: PR: https://github.com/llvm/llvm-project/pull/178574, branch: users/bzcheeseman/stack/5 --- lldb/bindings/python/python-wrapper.swig | 12 ++++++ .../lldb/Interpreter/ScriptInterpreter.h | 3 ++ lldb/source/Interpreter/ScriptInterpreter.cpp | 10 +++++ .../Interfaces/ScriptedPythonInterface.cpp | 38 +++++++++++++++++++ .../Interfaces/ScriptedPythonInterface.h | 14 +++++++ .../Python/SWIGPythonBridge.h | 1 + 6 files changed, 78 insertions(+) diff --git a/lldb/bindings/python/python-wrapper.swig b/lldb/bindings/python/python-wrapper.swig index 0ba152166522b..bf59569920470 100644 --- a/lldb/bindings/python/python-wrapper.swig +++ b/lldb/bindings/python/python-wrapper.swig @@ -545,6 +545,18 @@ void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBValue(PyObject * data return sb_ptr; } +void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBValueList(PyObject * data) { + lldb::SBValueList *sb_ptr = NULL; + + int valid_cast = + SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBValueList, 0); + + if (valid_cast == -1) + return NULL; + + return sb_ptr; +} + void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject * data) { lldb::SBMemoryRegionInfo *sb_ptr = NULL; diff --git a/lldb/include/lldb/Interpreter/ScriptInterpreter.h b/lldb/include/lldb/Interpreter/ScriptInterpreter.h index 0b91d6756552d..557d73a415452 100644 --- a/lldb/include/lldb/Interpreter/ScriptInterpreter.h +++ b/lldb/include/lldb/Interpreter/ScriptInterpreter.h @@ -609,6 +609,9 @@ class ScriptInterpreter : public PluginInterface { lldb::StackFrameListSP GetOpaqueTypeFromSBFrameList(const lldb::SBFrameList &exe_ctx) const; + lldb::ValueObjectSP + GetOpaqueTypeFromSBValue(const lldb::SBValue &value) const; + protected: Debugger &m_debugger; lldb::ScriptLanguage m_script_lang; diff --git a/lldb/source/Interpreter/ScriptInterpreter.cpp b/lldb/source/Interpreter/ScriptInterpreter.cpp index 7bad10ff3ea61..5e8478c2670bb 100644 --- a/lldb/source/Interpreter/ScriptInterpreter.cpp +++ b/lldb/source/Interpreter/ScriptInterpreter.cpp @@ -15,6 +15,7 @@ #include "lldb/Utility/Status.h" #include "lldb/Utility/Stream.h" #include "lldb/Utility/StringList.h" +#include "lldb/ValueObject/ValueObject.h" #if defined(_WIN32) #include "lldb/Host/windows/ConnectionGenericFileWindows.h" #endif @@ -162,6 +163,15 @@ lldb::StackFrameListSP ScriptInterpreter::GetOpaqueTypeFromSBFrameList( return frame_list.m_opaque_sp; } +lldb::ValueObjectSP +ScriptInterpreter::GetOpaqueTypeFromSBValue(const lldb::SBValue &value) const { + if (!value.m_opaque_sp) + return lldb::ValueObjectSP(); + + lldb_private::ValueLocker locker; + return locker.GetLockedSP(*value.m_opaque_sp); +} + lldb::ScriptLanguage ScriptInterpreter::StringToLanguage(const llvm::StringRef &language) { if (language.equals_insensitive(LanguageToString(eScriptLanguageNone))) diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp index ba4473cf9ec4d..f5fd8b2d2d802 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.cpp @@ -18,6 +18,7 @@ #include "../ScriptInterpreterPythonImpl.h" #include "ScriptedPythonInterface.h" #include "lldb/Symbol/SymbolContext.h" +#include "lldb/ValueObject/ValueObjectList.h" #include <optional> using namespace lldb; @@ -273,4 +274,41 @@ ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::StackFrameListSP>( return m_interpreter.GetOpaqueTypeFromSBFrameList(*sb_frame_list); } +template <> +lldb::ValueObjectSP +ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectSP>( + python::PythonObject &p, Status &error) { + lldb::SBValue *sb_value = reinterpret_cast<lldb::SBValue *>( + python::LLDBSWIGPython_CastPyObjectToSBValue(p.get())); + if (!sb_value) { + error = Status::FromErrorStringWithFormat( + "couldn't cast lldb::SBValue to lldb::ValueObjectSP"); + return {}; + } + + return m_interpreter.GetOpaqueTypeFromSBValue(*sb_value); +} + +template <> +lldb::ValueObjectListSP +ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectListSP>( + python::PythonObject &p, Status &error) { + lldb::SBValueList *sb_value_list = reinterpret_cast<lldb::SBValueList *>( + python::LLDBSWIGPython_CastPyObjectToSBValueList(p.get())); + + if (!sb_value_list) { + error = Status::FromErrorStringWithFormat( + "couldn't cast lldb::SBValueList to lldb::ValueObjectListSP"); + return {}; + } + + lldb::ValueObjectListSP out = std::make_shared<ValueObjectList>(); + for (uint32_t i = 0, e = sb_value_list->GetSize(); i < e; ++i) { + SBValue value = sb_value_list->GetValueAtIndex(i); + out->Append(m_interpreter.GetOpaqueTypeFromSBValue(value)); + } + + return out; +} + #endif diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h index b737f945845f6..5e3df8f18c2be 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/Interfaces/ScriptedPythonInterface.h @@ -656,6 +656,10 @@ class ScriptedPythonInterface : virtual public ScriptedInterface { return python::SWIGBridge::ToSWIGWrapper(arg); } + python::PythonObject Transform(lldb::ValueObjectSP 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! @@ -814,6 +818,16 @@ lldb::StackFrameListSP ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::StackFrameListSP>( python::PythonObject &p, Status &error); +template <> +lldb::ValueObjectSP +ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectSP>( + python::PythonObject &p, Status &error); + +template <> +lldb::ValueObjectListSP +ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::ValueObjectListSP>( + python::PythonObject &p, Status &error); + } // namespace lldb_private #endif // LLDB_ENABLE_PYTHON diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h index 32948ffd30023..9f68445d0d72b 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h @@ -269,6 +269,7 @@ void *LLDBSWIGPython_CastPyObjectToSBThread(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBFrame(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBSymbolContext(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data); +void *LLDBSWIGPython_CastPyObjectToSBValueList(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyObject *data); void *LLDBSWIGPython_CastPyObjectToSBFrameList(PyObject *data); _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
