04b443e778
If your arguments or option values are of a type that naturally uses one of our common completion mechanisms, you will get completion for free. But if you have your own custom values or if you want to do fancy things like have `break set -s foo.dylib -n ba<TAB>` only complete on symbols in foo.dylib, you can use this new mechanism to achieve that.
1099 lines
34 KiB
Plaintext
1099 lines
34 KiB
Plaintext
%header %{
|
|
|
|
class PyErr_Cleaner {
|
|
public:
|
|
PyErr_Cleaner(bool print = false) : m_print(print) {}
|
|
|
|
~PyErr_Cleaner() {
|
|
if (PyErr_Occurred()) {
|
|
if (m_print && !PyErr_ExceptionMatches(PyExc_SystemExit))
|
|
PyErr_Print();
|
|
PyErr_Clear();
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_print;
|
|
};
|
|
|
|
llvm::Expected<bool> lldb_private::python::SWIGBridge::LLDBSwigPythonBreakpointCallbackFunction(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
const lldb::StackFrameSP &frame_sp,
|
|
const lldb::BreakpointLocationSP &bp_loc_sp,
|
|
const lldb_private::StructuredDataImpl &args_impl) {
|
|
using namespace llvm;
|
|
|
|
lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
unsigned max_positional_args;
|
|
if (auto arg_info = pfunc.GetArgInfo())
|
|
max_positional_args = arg_info.get().max_positional_args;
|
|
else
|
|
return arg_info.takeError();
|
|
|
|
PythonObject frame_arg = SWIGBridge::ToSWIGWrapper(frame_sp);
|
|
PythonObject bp_loc_arg = SWIGBridge::ToSWIGWrapper(bp_loc_sp);
|
|
|
|
auto result =
|
|
max_positional_args < 4
|
|
? pfunc.Call(frame_arg, bp_loc_arg, dict)
|
|
: pfunc.Call(frame_arg, bp_loc_arg, SWIGBridge::ToSWIGWrapper(args_impl), dict);
|
|
|
|
if (!result)
|
|
return result.takeError();
|
|
|
|
// Only False counts as false!
|
|
return result.get().get() != Py_False;
|
|
}
|
|
|
|
// resolve a dotted Python name in the form
|
|
// foo.bar.baz.Foobar to an actual Python object
|
|
// if pmodule is NULL, the __main__ module will be used
|
|
// as the starting point for the search
|
|
|
|
// This function is called by
|
|
// lldb_private::ScriptInterpreterPython::BreakpointCallbackFunction(...) and is
|
|
// used when a script command is attached to a breakpoint for execution.
|
|
|
|
// This function is called by
|
|
// lldb_private::ScriptInterpreterPython::WatchpointCallbackFunction(...) and is
|
|
// used when a script command is attached to a watchpoint for execution.
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonWatchpointCallbackFunction(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
const lldb::StackFrameSP &frame_sp, const lldb::WatchpointSP &wp_sp) {
|
|
|
|
bool stop_at_watchpoint = true;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return stop_at_watchpoint;
|
|
|
|
PythonObject result =
|
|
pfunc(SWIGBridge::ToSWIGWrapper(frame_sp), SWIGBridge::ToSWIGWrapper(wp_sp), dict);
|
|
|
|
if (result.get() == Py_False)
|
|
stop_at_watchpoint = false;
|
|
|
|
return stop_at_watchpoint;
|
|
}
|
|
|
|
// This function is called by
|
|
// ScriptInterpreterPython::FormatterMatchingCallbackFunction and it's used when
|
|
// a data formatter provides the name of a callback to inspect a candidate type
|
|
// before considering a match.
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonFormatterCallbackFunction(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
lldb::TypeImplSP type_impl_sp) {
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
PythonObject result =
|
|
pfunc(SWIGBridge::ToSWIGWrapper(type_impl_sp), dict);
|
|
|
|
// Only if everything goes okay and the function returns True we'll consider
|
|
// it a match.
|
|
return result.get() == Py_True;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallTypeScript(
|
|
const char *python_function_name, const void *session_dictionary,
|
|
const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
|
|
const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval) {
|
|
|
|
retval.clear();
|
|
|
|
if (!python_function_name || !session_dictionary)
|
|
return false;
|
|
|
|
PyObject *pfunc_impl = nullptr;
|
|
|
|
if (pyfunct_wrapper && *pyfunct_wrapper &&
|
|
PyFunction_Check(*pyfunct_wrapper)) {
|
|
pfunc_impl = (PyObject *)(*pyfunct_wrapper);
|
|
if (pfunc_impl->ob_refcnt == 1) {
|
|
Py_XDECREF(pfunc_impl);
|
|
pfunc_impl = NULL;
|
|
}
|
|
}
|
|
|
|
PyObject *py_dict = (PyObject *)session_dictionary;
|
|
if (!PythonDictionary::Check(py_dict))
|
|
return true;
|
|
|
|
PythonDictionary dict(PyRefType::Borrowed, py_dict);
|
|
|
|
PyErr_Cleaner pyerr_cleanup(true); // show Python errors
|
|
|
|
PythonCallable pfunc(PyRefType::Borrowed, pfunc_impl);
|
|
|
|
if (!pfunc.IsAllocated()) {
|
|
pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
if (pyfunct_wrapper) {
|
|
*pyfunct_wrapper = pfunc.get();
|
|
Py_XINCREF(pfunc.get());
|
|
}
|
|
}
|
|
|
|
PythonObject result;
|
|
auto argc = pfunc.GetArgInfo();
|
|
if (!argc) {
|
|
llvm::consumeError(argc.takeError());
|
|
return false;
|
|
}
|
|
|
|
PythonObject value_arg = SWIGBridge::ToSWIGWrapper(valobj_sp);
|
|
|
|
if (argc.get().max_positional_args < 3)
|
|
result = pfunc(value_arg, dict);
|
|
else
|
|
result = pfunc(value_arg, dict, SWIGBridge::ToSWIGWrapper(*options_sp));
|
|
|
|
retval = result.Str().GetString().str();
|
|
|
|
return true;
|
|
}
|
|
|
|
PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateSyntheticProvider(
|
|
const char *python_class_name, const char *session_dictionary_name,
|
|
const lldb::ValueObjectSP &valobj_sp) {
|
|
if (python_class_name == NULL || python_class_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return PythonObject();
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_class_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return PythonObject();
|
|
|
|
auto sb_value = std::unique_ptr<lldb::SBValue>(new lldb::SBValue(valobj_sp));
|
|
sb_value->SetPreferSyntheticValue(false);
|
|
|
|
PythonObject val_arg = SWIGBridge::ToSWIGWrapper(std::move(sb_value));
|
|
if (!val_arg.IsAllocated())
|
|
return PythonObject();
|
|
|
|
PythonObject result = pfunc(val_arg, dict);
|
|
|
|
if (result.IsAllocated())
|
|
return result;
|
|
|
|
return PythonObject();
|
|
}
|
|
|
|
PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateCommandObject(
|
|
const char *python_class_name, const char *session_dictionary_name,
|
|
lldb::DebuggerSP debugger_sp) {
|
|
if (python_class_name == NULL || python_class_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return PythonObject();
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_class_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return PythonObject();
|
|
|
|
return pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger_sp)), dict);
|
|
}
|
|
|
|
PythonObject lldb_private::python::SWIGBridge::LLDBSwigPythonCreateScriptedBreakpointResolver(
|
|
const char *python_class_name, const char *session_dictionary_name,
|
|
const StructuredDataImpl &args_impl,
|
|
const lldb::BreakpointSP &breakpoint_sp) {
|
|
|
|
if (python_class_name == NULL || python_class_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return PythonObject();
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_class_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return PythonObject();
|
|
|
|
PythonObject result =
|
|
pfunc(SWIGBridge::ToSWIGWrapper(breakpoint_sp), SWIGBridge::ToSWIGWrapper(args_impl), dict);
|
|
// FIXME: At this point we should check that the class we found supports all
|
|
// the methods that we need.
|
|
|
|
if (result.IsAllocated()) {
|
|
// Check that __callback__ is defined:
|
|
auto callback_func = result.ResolveName<PythonCallable>("__callback__");
|
|
if (callback_func.IsAllocated())
|
|
return result;
|
|
}
|
|
return PythonObject();
|
|
}
|
|
|
|
unsigned int lldb_private::python::SWIGBridge::LLDBSwigPythonCallBreakpointResolver(
|
|
void *implementor, const char *method_name,
|
|
lldb_private::SymbolContext *sym_ctx) {
|
|
PyErr_Cleaner py_err_cleaner(false);
|
|
PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
|
|
auto pfunc = self.ResolveName<PythonCallable>(method_name);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return 0;
|
|
|
|
PythonObject result = sym_ctx ? pfunc(SWIGBridge::ToSWIGWrapper(*sym_ctx)) : pfunc();
|
|
|
|
if (PyErr_Occurred()) {
|
|
PyErr_Print();
|
|
PyErr_Clear();
|
|
return 0;
|
|
}
|
|
|
|
// The callback will return a bool, but we're need to also return ints
|
|
// so we're squirrelling the bool through as an int... And if you return
|
|
// nothing, we'll continue.
|
|
if (strcmp(method_name, "__callback__") == 0) {
|
|
if (result.get() == Py_False)
|
|
return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
long long ret_val = unwrapOrSetPythonException(As<long long>(result));
|
|
|
|
if (PyErr_Occurred()) {
|
|
PyErr_Print();
|
|
PyErr_Clear();
|
|
return 0;
|
|
}
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
// wrapper that calls an optional instance member of an object taking no
|
|
// arguments
|
|
static PyObject *LLDBSwigPython_CallOptionalMember(
|
|
PyObject * implementor, char *callee_name,
|
|
PyObject *ret_if_not_found = Py_None, bool *was_found = NULL) {
|
|
PyErr_Cleaner py_err_cleaner(false);
|
|
|
|
PythonObject self(PyRefType::Borrowed, static_cast<PyObject *>(implementor));
|
|
auto pfunc = self.ResolveName<PythonCallable>(callee_name);
|
|
|
|
if (!pfunc.IsAllocated()) {
|
|
if (was_found)
|
|
*was_found = false;
|
|
Py_XINCREF(ret_if_not_found);
|
|
return ret_if_not_found;
|
|
}
|
|
|
|
if (was_found)
|
|
*was_found = true;
|
|
|
|
PythonObject result = pfunc();
|
|
return result.release();
|
|
}
|
|
|
|
size_t lldb_private::python::SWIGBridge::LLDBSwigPython_CalculateNumChildren(PyObject * implementor,
|
|
uint32_t max) {
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("num_children");
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return 0;
|
|
|
|
auto arg_info = pfunc.GetArgInfo();
|
|
if (!arg_info) {
|
|
llvm::consumeError(arg_info.takeError());
|
|
return 0;
|
|
}
|
|
|
|
size_t ret_val;
|
|
if (arg_info.get().max_positional_args < 1)
|
|
ret_val = unwrapOrSetPythonException(As<long long>(pfunc.Call()));
|
|
else
|
|
ret_val = unwrapOrSetPythonException(
|
|
As<long long>(pfunc.Call(PythonInteger(max))));
|
|
|
|
if (PyErr_Occurred()) {
|
|
PyErr_Print();
|
|
PyErr_Clear();
|
|
return 0;
|
|
}
|
|
|
|
if (arg_info.get().max_positional_args < 1)
|
|
ret_val = std::min(ret_val, static_cast<size_t>(max));
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetChildAtIndex(PyObject * implementor,
|
|
uint32_t idx) {
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("get_child_at_index");
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return nullptr;
|
|
|
|
PythonObject result = pfunc(PythonInteger(idx));
|
|
|
|
if (!result.IsAllocated())
|
|
return nullptr;
|
|
|
|
lldb::SBValue *sbvalue_ptr = nullptr;
|
|
if (SWIG_ConvertPtr(result.get(), (void **)&sbvalue_ptr,
|
|
SWIGTYPE_p_lldb__SBValue, 0) == -1)
|
|
return nullptr;
|
|
|
|
if (sbvalue_ptr == nullptr)
|
|
return nullptr;
|
|
|
|
return result.release();
|
|
}
|
|
|
|
int lldb_private::python::SWIGBridge::LLDBSwigPython_GetIndexOfChildWithName(
|
|
PyObject * implementor, const char *child_name) {
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("get_child_index");
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return UINT32_MAX;
|
|
|
|
llvm::Expected<PythonObject> result = pfunc.Call(PythonString(child_name));
|
|
|
|
long long retval =
|
|
unwrapOrSetPythonException(As<long long>(std::move(result)));
|
|
|
|
if (PyErr_Occurred()) {
|
|
PyErr_Clear(); // FIXME print this? do something else
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
if (retval >= 0)
|
|
return (uint32_t)retval;
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPython_UpdateSynthProviderInstance(PyObject *
|
|
implementor) {
|
|
bool ret_val = false;
|
|
|
|
static char callee_name[] = "update";
|
|
|
|
PyObject *py_return =
|
|
LLDBSwigPython_CallOptionalMember(implementor, callee_name);
|
|
|
|
if (py_return == Py_True)
|
|
ret_val = true;
|
|
|
|
Py_XDECREF(py_return);
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPython_MightHaveChildrenSynthProviderInstance(
|
|
PyObject * implementor) {
|
|
bool ret_val = false;
|
|
|
|
static char callee_name[] = "has_children";
|
|
|
|
PyObject *py_return =
|
|
LLDBSwigPython_CallOptionalMember(implementor, callee_name, Py_True);
|
|
|
|
if (py_return == Py_True)
|
|
ret_val = true;
|
|
|
|
Py_XDECREF(py_return);
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetValueSynthProviderInstance(
|
|
PyObject * implementor) {
|
|
PyObject *ret_val = nullptr;
|
|
|
|
static char callee_name[] = "get_value";
|
|
|
|
PyObject *py_return =
|
|
LLDBSwigPython_CallOptionalMember(implementor, callee_name, Py_None);
|
|
|
|
if (py_return == Py_None || py_return == nullptr)
|
|
ret_val = nullptr;
|
|
|
|
lldb::SBValue *sbvalue_ptr = NULL;
|
|
|
|
if (SWIG_ConvertPtr(py_return, (void **)&sbvalue_ptr,
|
|
SWIGTYPE_p_lldb__SBValue, 0) == -1)
|
|
ret_val = nullptr;
|
|
else if (sbvalue_ptr == NULL)
|
|
ret_val = nullptr;
|
|
else
|
|
ret_val = py_return;
|
|
|
|
Py_XDECREF(py_return);
|
|
return ret_val;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBData(PyObject * data) {
|
|
lldb::SBData *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBData, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject * data) {
|
|
lldb::SBBreakpoint *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject * data) {
|
|
lldb::SBAttachInfo *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject * data) {
|
|
lldb::SBLaunchInfo *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBLaunchInfo, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBError(PyObject * data) {
|
|
lldb::SBError *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBError, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBEvent(PyObject * data) {
|
|
lldb::SBEvent *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBEvent, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBStream(PyObject * data) {
|
|
lldb::SBStream *sb_ptr = nullptr;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBStream, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBValue(PyObject * data) {
|
|
lldb::SBValue *sb_ptr = NULL;
|
|
|
|
int valid_cast =
|
|
SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBValue, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *
|
|
data) {
|
|
lldb::SBMemoryRegionInfo *sb_ptr = NULL;
|
|
|
|
int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr,
|
|
SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
void *lldb_private::python::LLDBSWIGPython_CastPyObjectToSBExecutionContext(PyObject *
|
|
data) {
|
|
lldb::SBExecutionContext *sb_ptr = NULL;
|
|
|
|
int valid_cast = SWIG_ConvertPtr(data, (void **)&sb_ptr,
|
|
SWIGTYPE_p_lldb__SBExecutionContext, 0);
|
|
|
|
if (valid_cast == -1)
|
|
return NULL;
|
|
|
|
return sb_ptr;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommand(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
lldb::DebuggerSP debugger, const char *args,
|
|
lldb_private::CommandReturnObject &cmd_retobj,
|
|
lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
auto argc = pfunc.GetArgInfo();
|
|
if (!argc) {
|
|
llvm::consumeError(argc.takeError());
|
|
return false;
|
|
}
|
|
PythonObject debugger_arg = SWIGBridge::ToSWIGWrapper(std::move(debugger));
|
|
auto cmd_retobj_arg = SWIGBridge::ToSWIGWrapper(cmd_retobj);
|
|
|
|
if (argc.get().max_positional_args < 5u)
|
|
pfunc(debugger_arg, PythonString(args), cmd_retobj_arg.obj(), dict);
|
|
else
|
|
pfunc(debugger_arg, PythonString(args),
|
|
SWIGBridge::ToSWIGWrapper(std::move(exe_ctx_ref_sp)), cmd_retobj_arg.obj(), dict);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallCommandObject(
|
|
PyObject *implementor, lldb::DebuggerSP debugger, const char *args,
|
|
lldb_private::CommandReturnObject &cmd_retobj,
|
|
lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("__call__");
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
auto cmd_retobj_arg = SWIGBridge::ToSWIGWrapper(cmd_retobj);
|
|
|
|
pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), PythonString(args),
|
|
SWIGBridge::ToSWIGWrapper(exe_ctx_ref_sp), cmd_retobj_arg.obj());
|
|
|
|
return true;
|
|
}
|
|
|
|
std::optional<std::string>
|
|
lldb_private::python::SWIGBridge::LLDBSwigPythonGetRepeatCommandForScriptedCommand(PyObject *implementor,
|
|
std::string &command) {
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("get_repeat_command");
|
|
// If not implemented, repeat the exact command.
|
|
if (!pfunc.IsAllocated())
|
|
return std::nullopt;
|
|
|
|
PythonString command_str(command);
|
|
PythonObject result = pfunc(command_str);
|
|
|
|
// A return of None is the equivalent of nullopt - means repeat
|
|
// the command as is:
|
|
if (result.IsNone())
|
|
return std::nullopt;
|
|
|
|
return result.Str().GetString().str();
|
|
}
|
|
|
|
StructuredData::DictionarySP
|
|
lldb_private::python::SWIGBridge::LLDBSwigPythonHandleArgumentCompletionForScriptedCommand(PyObject *implementor,
|
|
std::vector<llvm::StringRef> &args_vec, size_t args_pos, size_t pos_in_arg) {
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("handle_argument_completion");
|
|
// If this isn't implemented, return an empty dict to signal falling back to default completion:
|
|
if (!pfunc.IsAllocated())
|
|
return {};
|
|
|
|
PythonList args_list(PyInitialValue::Empty);
|
|
for (auto elem : args_vec)
|
|
args_list.AppendItem(PythonString(elem));
|
|
|
|
PythonObject result = pfunc(args_list, PythonInteger(args_pos), PythonInteger(pos_in_arg));
|
|
// Returning None means do the ordinary completion
|
|
if (result.IsNone())
|
|
return {};
|
|
|
|
// Convert the return dictionary to a DictionarySP.
|
|
StructuredData::ObjectSP result_obj_sp = result.CreateStructuredObject();
|
|
if (!result_obj_sp)
|
|
return {};
|
|
|
|
StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary(result_obj_sp));
|
|
if (dict_sp->GetType() == lldb::eStructuredDataTypeInvalid)
|
|
return {};
|
|
return dict_sp;
|
|
}
|
|
|
|
StructuredData::DictionarySP
|
|
lldb_private::python::SWIGBridge::LLDBSwigPythonHandleOptionArgumentCompletionForScriptedCommand(PyObject *implementor,
|
|
llvm::StringRef &long_option, size_t pos_in_arg) {
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("handle_option_argument_completion");
|
|
// If this isn't implemented, return an empty dict to signal falling back to default completion:
|
|
if (!pfunc.IsAllocated())
|
|
return {};
|
|
|
|
PythonObject result = pfunc(PythonString(long_option), PythonInteger(pos_in_arg));
|
|
// Returning None means do the ordinary completion
|
|
if (result.IsNone())
|
|
return {};
|
|
|
|
// Returning a boolean:
|
|
// True means the completion was handled, but there were no completions
|
|
// False means that the completion was not handled, again, do the ordinary completion:
|
|
if (result.GetObjectType() == PyObjectType::Boolean) {
|
|
if (!result.IsTrue())
|
|
return {};
|
|
// Make up a completion dictionary with the right element:
|
|
StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary());
|
|
dict_sp->AddBooleanItem("no-completion", true);
|
|
return dict_sp;
|
|
}
|
|
|
|
|
|
// Convert the return dictionary to a DictionarySP.
|
|
StructuredData::ObjectSP result_obj_sp = result.CreateStructuredObject();
|
|
if (!result_obj_sp)
|
|
return {};
|
|
|
|
StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary(result_obj_sp));
|
|
if (dict_sp->GetType() == lldb::eStructuredDataTypeInvalid)
|
|
return {};
|
|
return dict_sp;
|
|
}
|
|
|
|
#include "lldb/Interpreter/CommandReturnObject.h"
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallParsedCommandObject(
|
|
PyObject *implementor, lldb::DebuggerSP debugger, lldb_private::StructuredDataImpl &args_impl,
|
|
lldb_private::CommandReturnObject &cmd_retobj,
|
|
lldb::ExecutionContextRefSP exe_ctx_ref_sp) {
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
PythonObject self(PyRefType::Borrowed, implementor);
|
|
auto pfunc = self.ResolveName<PythonCallable>("__call__");
|
|
|
|
if (!pfunc.IsAllocated()) {
|
|
cmd_retobj.AppendError("Could not find '__call__' method in implementation class");
|
|
return false;
|
|
}
|
|
|
|
pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), SWIGBridge::ToSWIGWrapper(args_impl),
|
|
SWIGBridge::ToSWIGWrapper(exe_ctx_ref_sp), SWIGBridge::ToSWIGWrapper(cmd_retobj).obj());
|
|
|
|
return true;
|
|
}
|
|
|
|
PythonObject lldb_private::python::SWIGBridge::LLDBSWIGPythonCreateOSPlugin(
|
|
const char *python_class_name, const char *session_dictionary_name,
|
|
const lldb::ProcessSP &process_sp) {
|
|
if (python_class_name == NULL || python_class_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return PythonObject();
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_class_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return PythonObject();
|
|
|
|
return pfunc(SWIGBridge::ToSWIGWrapper(process_sp));
|
|
}
|
|
|
|
PythonObject lldb_private::python::SWIGBridge::LLDBSWIGPython_CreateFrameRecognizer(
|
|
const char *python_class_name, const char *session_dictionary_name) {
|
|
if (python_class_name == NULL || python_class_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return PythonObject();
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_class_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return PythonObject();
|
|
|
|
return pfunc();
|
|
}
|
|
|
|
PyObject *lldb_private::python::SWIGBridge::LLDBSwigPython_GetRecognizedArguments(
|
|
PyObject *implementor, const lldb::StackFrameSP &frame_sp) {
|
|
static char callee_name[] = "get_recognized_arguments";
|
|
|
|
PythonObject arg = SWIGBridge::ToSWIGWrapper(frame_sp);
|
|
|
|
PythonString str(callee_name);
|
|
PyObject *result =
|
|
PyObject_CallMethodObjArgs(implementor, str.get(), arg.get(), NULL);
|
|
return result;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPython_ShouldHide(
|
|
PyObject *implementor, const lldb::StackFrameSP &frame_sp) {
|
|
static char callee_name[] = "should_hide";
|
|
|
|
PythonObject arg = SWIGBridge::ToSWIGWrapper(frame_sp);
|
|
|
|
PythonString str(callee_name);
|
|
|
|
PyObject *result =
|
|
PyObject_CallMethodObjArgs(implementor, str.get(), arg.get(), NULL);
|
|
bool ret_val = result ? PyObject_IsTrue(result) : false;
|
|
Py_XDECREF(result);
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
void *lldb_private::python::SWIGBridge::LLDBSWIGPython_GetDynamicSetting(
|
|
void *module, const char *setting, const lldb::TargetSP &target_sp) {
|
|
if (!module || !setting)
|
|
Py_RETURN_NONE;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
PythonObject py_module(PyRefType::Borrowed, (PyObject *)module);
|
|
auto pfunc = py_module.ResolveName<PythonCallable>("get_dynamic_setting");
|
|
|
|
if (!pfunc.IsAllocated())
|
|
Py_RETURN_NONE;
|
|
|
|
auto result = pfunc(SWIGBridge::ToSWIGWrapper(target_sp), PythonString(setting));
|
|
|
|
return result.release();
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordProcess(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
const lldb::ProcessSP &process, std::string &output) {
|
|
|
|
if (python_function_name == NULL || python_function_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return false;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
auto result = pfunc(SWIGBridge::ToSWIGWrapper(process), dict);
|
|
|
|
output = result.Str().GetString().str();
|
|
|
|
return true;
|
|
}
|
|
|
|
std::optional<std::string> lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordThread(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
lldb::ThreadSP thread) {
|
|
if (python_function_name == NULL || python_function_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return std::nullopt;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return std::nullopt;
|
|
|
|
auto result = pfunc(SWIGBridge::ToSWIGWrapper(std::move(thread)), dict);
|
|
|
|
return result.Str().GetString().str();
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordTarget(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
const lldb::TargetSP &target, std::string &output) {
|
|
|
|
if (python_function_name == NULL || python_function_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return false;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
auto result = pfunc(SWIGBridge::ToSWIGWrapper(target), dict);
|
|
|
|
output = result.Str().GetString().str();
|
|
|
|
return true;
|
|
}
|
|
|
|
std::optional<std::string> lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordFrame(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
lldb::StackFrameSP frame) {
|
|
if (python_function_name == NULL || python_function_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return std::nullopt;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return std::nullopt;
|
|
|
|
auto result = pfunc(SWIGBridge::ToSWIGWrapper(std::move(frame)), dict);
|
|
|
|
return result.Str().GetString().str();
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSWIGPythonRunScriptKeywordValue(
|
|
const char *python_function_name, const char *session_dictionary_name,
|
|
const lldb::ValueObjectSP &value, std::string &output) {
|
|
|
|
if (python_function_name == NULL || python_function_name[0] == '\0' ||
|
|
!session_dictionary_name)
|
|
return false;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
if (!pfunc.IsAllocated())
|
|
return false;
|
|
|
|
auto result = pfunc(SWIGBridge::ToSWIGWrapper(value), dict);
|
|
|
|
output = result.Str().GetString().str();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool lldb_private::python::SWIGBridge::LLDBSwigPythonCallModuleInit(
|
|
const char *python_module_name, const char *session_dictionary_name,
|
|
lldb::DebuggerSP debugger) {
|
|
std::string python_function_name_string = python_module_name;
|
|
python_function_name_string += ".__lldb_init_module";
|
|
const char *python_function_name = python_function_name_string.c_str();
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
|
|
auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
|
|
session_dictionary_name);
|
|
auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
|
|
python_function_name, dict);
|
|
|
|
// This method is optional and need not exist. So if we don't find it,
|
|
// it's actually a success, not a failure.
|
|
if (!pfunc.IsAllocated())
|
|
return true;
|
|
|
|
pfunc(SWIGBridge::ToSWIGWrapper(std::move(debugger)), dict);
|
|
|
|
return true;
|
|
}
|
|
|
|
lldb::ValueObjectSP lldb_private::python::SWIGBridge::LLDBSWIGPython_GetValueObjectSPFromSBValue(
|
|
void *data) {
|
|
lldb::ValueObjectSP valobj_sp;
|
|
if (data) {
|
|
lldb::SBValue *sb_ptr = (lldb::SBValue *)data;
|
|
valobj_sp = sb_ptr->GetSP();
|
|
}
|
|
return valobj_sp;
|
|
}
|
|
|
|
// For the LogOutputCallback functions
|
|
static void LLDBSwigPythonCallPythonLogOutputCallback(const char *str,
|
|
void *baton) {
|
|
if (baton != Py_None) {
|
|
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
|
PyObject *result = PyObject_CallFunction(
|
|
reinterpret_cast<PyObject *>(baton), const_cast<char *>("s"), str);
|
|
Py_XDECREF(result);
|
|
SWIG_PYTHON_THREAD_END_BLOCK;
|
|
}
|
|
}
|
|
|
|
// For DebuggerTerminateCallback functions
|
|
static void LLDBSwigPythonCallPythonSBDebuggerTerminateCallback(lldb::user_id_t debugger_id,
|
|
void *baton) {
|
|
if (baton != Py_None) {
|
|
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
|
PyObject *result = PyObject_CallFunction(
|
|
reinterpret_cast<PyObject *>(baton), const_cast<char *>("l"), debugger_id);
|
|
Py_XDECREF(result);
|
|
SWIG_PYTHON_THREAD_END_BLOCK;
|
|
}
|
|
}
|
|
|
|
static bool LLDBSwigPythonCallPythonSBCommandInterpreterSetCommandOverrideCallback(void *baton, const char **argv) {
|
|
bool ret_val = false;
|
|
if (baton != Py_None) {
|
|
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
|
// Create a PyList of items since we're going to pass it to the callback as a tuple
|
|
// of arguments.
|
|
PyObject *py_argv = PyList_New(0);
|
|
for (const char **arg = argv; arg && *arg; arg++) {
|
|
std::string arg_string = *arg;
|
|
PyObject *py_string = PyUnicode_FromStringAndSize(arg_string.c_str(), arg_string.size());
|
|
PyList_Append(py_argv, py_string);
|
|
}
|
|
|
|
PyObject *result = PyObject_CallObject(
|
|
reinterpret_cast<PyObject *>(baton), PyList_AsTuple(py_argv));
|
|
ret_val = result ? PyObject_IsTrue(result) : false;
|
|
Py_XDECREF(result);
|
|
SWIG_PYTHON_THREAD_END_BLOCK;
|
|
}
|
|
return ret_val;
|
|
}
|
|
|
|
static SBError LLDBSwigPythonCallLocateModuleCallback(
|
|
void *callback_baton, const SBModuleSpec &module_spec_sb,
|
|
SBFileSpec &module_file_spec_sb, SBFileSpec &symbol_file_spec_sb) {
|
|
SWIG_Python_Thread_Block swig_thread_block;
|
|
|
|
PyErr_Cleaner py_err_cleaner(true);
|
|
PythonObject module_spec_arg = SWIGBridge::ToSWIGWrapper(
|
|
std::make_unique<SBModuleSpec>(module_spec_sb));
|
|
PythonObject module_file_spec_arg = SWIGBridge::ToSWIGWrapper(
|
|
std::make_unique<SBFileSpec>(module_file_spec_sb));
|
|
PythonObject symbol_file_spec_arg = SWIGBridge::ToSWIGWrapper(
|
|
std::make_unique<SBFileSpec>(symbol_file_spec_sb));
|
|
|
|
PythonCallable callable =
|
|
Retain<PythonCallable>(reinterpret_cast<PyObject *>(callback_baton));
|
|
if (!callable.IsValid()) {
|
|
return SBError("The callback callable is not valid.");
|
|
}
|
|
|
|
PythonObject result = callable(module_spec_arg, module_file_spec_arg,
|
|
symbol_file_spec_arg);
|
|
|
|
if (!result.IsAllocated())
|
|
return SBError("No result.");
|
|
lldb::SBError *sb_error_ptr = nullptr;
|
|
if (SWIG_ConvertPtr(result.get(), (void **)&sb_error_ptr,
|
|
SWIGTYPE_p_lldb__SBError, 0) == -1) {
|
|
return SBError("Result is not SBError.");
|
|
}
|
|
|
|
if (sb_error_ptr->Success()) {
|
|
lldb::SBFileSpec *sb_module_file_spec_ptr = nullptr;
|
|
if (SWIG_ConvertPtr(module_file_spec_arg.get(),
|
|
(void **)&sb_module_file_spec_ptr,
|
|
SWIGTYPE_p_lldb__SBFileSpec, 0) == -1)
|
|
return SBError("module_file_spec is not SBFileSpec.");
|
|
|
|
lldb::SBFileSpec *sb_symbol_file_spec_ptr = nullptr;
|
|
if (SWIG_ConvertPtr(symbol_file_spec_arg.get(),
|
|
(void **)&sb_symbol_file_spec_ptr,
|
|
SWIGTYPE_p_lldb__SBFileSpec, 0) == -1)
|
|
return SBError("symbol_file_spec is not SBFileSpec.");
|
|
|
|
module_file_spec_sb = *sb_module_file_spec_ptr;
|
|
symbol_file_spec_sb = *sb_symbol_file_spec_ptr;
|
|
}
|
|
|
|
return *sb_error_ptr;
|
|
}
|
|
%}
|