104 struct disassemble_info *info)
noexcept;
106 struct disassemble_info *info)
noexcept;
109 struct disassemble_info *info)
noexcept;
135 gdb_assert (!PyErr_Occurred ());
214 static const char *keywords[] = {
"info", NULL };
229 Py_INCREF ((PyObject *) info);
243 Py_XDECREF ((PyObject *) obj->
next);
246 Py_TYPE (self)->tp_free (self);
275#define DISASMPY_DISASM_INFO_REQUIRE_VALID(Info) \
277 if (!disasm_info_object_is_valid (Info)) \
279 PyErr_SetString (PyExc_RuntimeError, \
280 _("DisassembleInfo is no longer valid.")); \
299 *(obj->
content) = std::move (content);
315 PyObject *info_obj, *memory_source_obj =
nullptr;
316 static const char *keywords[] = {
"info",
"memory_source",
nullptr };
362 std::string content = disassembler.
release ();
363 if (!content.empty ())
367 _(
"Unknown disassembly error."));
374 gdb_assert (length > 0);
380 std::string content = disassembler.
release ();
385 return reinterpret_cast<PyObject *
> (res.release ());
404 static const char *keywords[] = {
"state",
nullptr };
409 if (!PyBool_Check (newstate))
411 PyErr_SetString (PyExc_TypeError,
412 _(
"The value passed to `_set_enabled' must be a boolean."));
433 LONGEST length, offset = 0;
434 gdb::unique_xmalloc_ptr<gdb_byte> buffer;
435 static const char *keywords[] = {
"length",
"offset",
nullptr };
446 CORE_ADDR address = obj->
address + offset;
449 buffer.reset ((gdb_byte *)
xmalloc (length));
454 disassemble_info *info = obj->
gdb_info;
455 if (info->read_memory_func ((bfd_vma) address, buffer.get (),
456 (
unsigned int) length, info) != 0)
516 struct disassemble_info *info)
noexcept
533 LONGEST offset = (LONGEST) memaddr - (LONGEST) obj->
address;
542 if (result_obj ==
nullptr)
566 if (!PyObject_CheckBuffer (result_obj.get ())
567 || PyObject_GetBuffer (result_obj.get(), &py_buff, PyBUF_CONTIG_RO) < 0)
569 PyErr_Format (PyExc_TypeError,
570 _(
"Result from read_memory is not a buffer"));
580 if (py_buff.len != len)
582 PyErr_Format (PyExc_ValueError,
583 _(
"Buffer returned from read_memory is sized %d instead of the expected %d"),
590 const gdb_byte *buffer = (
const gdb_byte *) py_buff.buf;
591 memcpy (buff, buffer, len);
613 gdb_assert (obj->
content !=
nullptr);
615 gdb_assert (obj->
length > 0);
628 static const char *keywords[] = {
"length",
"string", NULL };
637 PyErr_SetString (PyExc_ValueError,
638 _(
"Length must be greater than 0."));
642 if (strlen (
string) == 0)
644 PyErr_SetString (PyExc_ValueError,
645 _(
"String must not be empty."));
661 struct disassemble_info *info)
noexcept
672 struct disassemble_info *info)
noexcept
682 PyObject *memory_source)
684 read_memory_func, memory_error_func,
686 m_disasm_info_object (obj),
687 m_memory_source (memory_source)
707 disassemble_info *info)
711 memaddr, info,
nullptr);
722 obj->gdb_info =
nullptr;
756 disassemble_info *info)
771 (PyImport_ImportModule (
"gdb.disassembler"));
772 if (gdb_python_disassembler_module ==
nullptr)
781 (PyObject_GetAttrString (gdb_python_disassembler_module.get (),
796 PyObject *insn_disas_obj = (PyObject *) disasm_info;
797 gdbpy_ref<> result (PyObject_CallFunctionObjArgs (hook.get (),
801 if (result ==
nullptr)
821 if (
err.value () !=
nullptr
822 && PyObject_HasAttrString (
err.value ().get (),
"address"))
825 = PyObject_GetAttrString (
err.value ().get (),
"address");
832 info->memory_error_func (-1, addr, info);
833 return gdb::optional<int> (-1);
838 gdb::unique_xmalloc_ptr<char> msg =
err.to_string ();
840 info->fprintf_func (info->stream,
"%s", msg.get ());
841 return gdb::optional<int> (-1);
846 return gdb::optional<int> (-1);
850 else if (result == Py_None)
859 if (!PyObject_IsInstance (result.get (),
862 PyErr_SetString (PyExc_TypeError,
863 _(
"Result is not a DisassemblerResult."));
865 return gdb::optional<int> (-1);
870 gdbpy_ref<> length_obj (PyObject_GetAttrString (result.get (),
"length"));
871 if (length_obj ==
nullptr)
874 return gdb::optional<int> (-1);
877 gdbpy_ref<> string_obj (PyObject_GetAttrString (result.get (),
"string"));
878 if (string_obj ==
nullptr)
881 return gdb::optional<int> (-1);
885 PyErr_SetString (PyExc_TypeError, _(
"String attribute is not a string."));
887 return gdb::optional<int> (-1);
890 gdb::unique_xmalloc_ptr<char>
string
892 if (
string ==
nullptr)
895 return gdb::optional<int> (-1);
902 return gdb::optional<int> (-1);
911 _(
"Invalid length attribute: length must be greater than 0."));
913 return gdb::optional<int> (-1);
915 if (length > max_insn_length)
919 _(
"Invalid length attribute: length %d greater than architecture maximum of %d"),
920 length, max_insn_length);
922 return gdb::optional<int> (-1);
925 if (strlen (
string.
get ()) == 0)
927 PyErr_SetString (PyExc_ValueError,
928 _(
"String attribute must not be empty."));
930 return gdb::optional<int> (-1);
935 info->fprintf_func (info->stream,
"%s",
string.get ());
936 return gdb::optional<int> (length);
947 Py_TYPE (self)->tp_free (self);
954 "Start address of the instruction to disassemble.",
nullptr },
956 "Architecture to disassemble in",
nullptr },
958 "Program space to disassemble in",
nullptr },
966 METH_VARARGS | METH_KEYWORDS,
967 "read_memory (LEN, OFFSET = 0) -> Octets[]\n\
968Read LEN octets for the instruction to disassemble." },
970 "is_valid () -> Boolean.\n\
971Return true if this DisassembleInfo is valid, false if not." },
979 "Length of the disassembled instruction.",
nullptr },
981 "String representing the disassembled instruction.",
nullptr },
992 METH_VARARGS | METH_KEYWORDS,
993 "builtin_disassemble (INFO, MEMORY_SOURCE = None) -> None\n\
994Disassemble using GDB's builtin disassembler. INFO is an instance of\n\
995gdb.disassembler.DisassembleInfo. The MEMORY_SOURCE, if not None, should\n\
996be an object with the read_memory method." },
998 METH_VARARGS | METH_KEYWORDS,
999 "_set_enabled (STATE) -> None\n\
1000Set whether GDB should call into the Python _print_insn code or not." },
1001 {
nullptr,
nullptr, 0,
nullptr}
1008 PyModuleDef_HEAD_INIT,
1009 "_gdb.disassembler",
1026 PyObject *gdb_disassembler_module;
1028 if (gdb_disassembler_module ==
nullptr)
1030 PyModule_AddObject(
gdb_module,
"disassembler", gdb_disassembler_module);
1033 PyObject *dict = PyImport_GetModuleDict ();
1034 PyDict_SetItemString (dict,
"_gdb.disassembler", gdb_disassembler_module);
1058 PyVarObject_HEAD_INIT (
nullptr, 0)
1059 "gdb.disassembler.DisassembleInfo",
1077 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1078 "GDB instruction disassembler object",
1100 PyVarObject_HEAD_INIT (
nullptr, 0)
1101 "gdb.disassembler.DisassemblerResult",
1119 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1120 "GDB object, representing a disassembler result",
constexpr string_view get()
struct gdbarch * get_current_arch(void)
const char * host_charset(void)
const char * c_str() const
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
bool gdbarch_max_insn_length_p(struct gdbarch *gdbarch)
int gdbarch_print_insn(struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
const struct language_defn * current_language
struct program_space * current_program_space
PyObject * gdbarch_to_arch_object(struct gdbarch *gdbarch)
static void disasmpy_set_memory_error_for_address(CORE_ADDR address)
static PyMethodDef disasm_info_object_methods[]
static int disasmpy_result_init(PyObject *self, PyObject *args, PyObject *kwargs)
static void disasm_info_dealloc(PyObject *self)
gdb::optional< int > gdbpy_print_insn(struct gdbarch *gdbarch, CORE_ADDR memaddr, disassemble_info *info)
PyMethodDef python_disassembler_methods[]
static PyObject * disasmpy_result_length(PyObject *self, void *closure)
static PyObject * disasmpy_info_architecture(PyObject *self, void *closure)
static struct PyModuleDef python_disassembler_module_def
PyTypeObject disasm_info_object_type
static PyObject * disasmpy_set_enabled(PyObject *self, PyObject *args, PyObject *kw)
static void disasmpy_init_disassembler_result(disasm_result_object *obj, int length, std::string content)
static PyObject * disasmpy_builtin_disassemble(PyObject *self, PyObject *args, PyObject *kw)
static gdb_PyGetSetDef disasm_result_object_getset[]
static PyObject * disasmpy_info_address(PyObject *self, void *closure)
static PyObject * disasmpy_info_read_memory(PyObject *self, PyObject *args, PyObject *kw)
static int disasm_info_init(PyObject *self, PyObject *args, PyObject *kwargs)
static PyObject * disasmpy_info_is_valid(PyObject *self, PyObject *args)
static gdb_PyGetSetDef disasm_info_object_getset[]
static bool python_print_insn_enabled
#define DISASMPY_DISASM_INFO_REQUIRE_VALID(Info)
static bool disasm_info_object_is_valid(disasm_info_object *obj)
static void disasm_info_fill(disasm_info_object *obj, struct gdbarch *gdbarch, program_space *progspace, bfd_vma address, disassemble_info *di, disasm_info_object *next)
PyTypeObject disasm_result_object_type
static PyObject * disasmpy_result_string(PyObject *self, void *closure)
static void disasmpy_dealloc_result(PyObject *self)
static PyObject * disasmpy_info_progspace(PyObject *self, void *closure)
int gdbpy_initialize_disasm()
PyObject * gdbpy_buffer_to_membuf(gdb::unique_xmalloc_ptr< gdb_byte > buffer, CORE_ADDR address, ULONGEST length)
gdbpy_ref pspace_to_pspace_object(struct program_space *pspace)
gdb::ref_ptr< T, gdbpy_ref_policy< T > > gdbpy_ref
gdbpy_ref gdb_py_object_from_longest(LONGEST l)
int get_addr_from_python(PyObject *obj, CORE_ADDR *addr)
int gdb_py_int_as_long(PyObject *obj, long *result)
gdb::unique_xmalloc_ptr< char > gdbpy_obj_to_string(PyObject *obj)
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
int gdbpy_is_string(PyObject *obj)
void gdbpy_print_stack(void)
#define PyObject_CallMethod
std::unique_ptr< Py_buffer, Py_buffer_deleter > Py_buffer_up
int gdb_python_initialized
#define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
PyObject * gdbpy_gdb_memory_error
PyObject * gdbpy_gdberror_exc
static int gdb_PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, const char **keywords,...)
struct program_space * program_space
struct disasm_info_object * next
PyObject_HEAD struct gdbarch * gdbarch
disassemble_info * gdb_info
struct disassemble_info * disasm_info()
struct ui_file * stream()
PyObject * m_memory_source
void store_exception(gdbpy_err_fetch &&ex)
const gdb::optional< CORE_ADDR > & memory_error_address() const
gdb::optional< CORE_ADDR > m_memory_error_address
disasm_info_object * py_disasm_info() const
gdbpy_disassembler(disasm_info_object *obj, PyObject *memory_source)
static void memory_error_func(int status, bfd_vma memaddr, struct disassemble_info *info) noexcept
gdb::optional< gdbpy_err_fetch > m_stored_exception
static int read_memory_func(bfd_vma memaddr, gdb_byte *buff, unsigned int len, struct disassemble_info *info) noexcept
bool has_stored_exception() const
disasm_info_object * m_disasm_info_object
static void print_address_func(bfd_vma addr, struct disassemble_info *info) noexcept
string_file m_string_file
scoped_disasm_info_object(struct gdbarch *gdbarch, CORE_ADDR memaddr, disassemble_info *info)
gdbpy_ref< disasm_info_object > m_disasm_info
disasm_info_object * get() const
~scoped_disasm_info_object()
static disasm_info_object * allocate_disasm_info_object()