148 struct disassemble_info *info)
noexcept;
150 struct disassemble_info *info)
noexcept;
153 struct disassemble_info *info)
noexcept;
157 static int fprintf_func (
void *dis_info,
const char *format, ...) noexcept
163 enum disassembler_style style,
164 const
char *format, ...) noexcept
172 enum disassembler_style style,
173 const
char *format, va_list args) noexcept
200 gdb_assert (!PyErr_Occurred ());
281 static const char *keywords[] = {
"info", NULL };
313 Py_TYPE (self)->tp_free (self);
323 const char *arch_name
325 return PyUnicode_FromFormat (
"<%s address=%s architecture=%s>",
326 Py_TYPE (obj)->tp_name,
327 core_addr_to_string_nz (obj->
address),
365 text_part->
string =
new std::string (str);
366 text_part->
style = style;
389#define DISASMPY_DISASM_INFO_REQUIRE_VALID(Info) \
391 if (!disasm_info_object_is_valid (Info)) \
393 PyErr_SetString (PyExc_RuntimeError, \
394 _("DisassembleInfo is no longer valid.")); \
409 static const char *keywords[] = {
"style",
"string", NULL };
413 &style_num, &
string))
416 if (style_num < 0 || style_num > ((
int) dis_style_comment_start))
418 PyErr_SetString (PyExc_ValueError,
419 _(
"Invalid disassembler style."));
423 if (strlen (
string) == 0)
425 PyErr_SetString (PyExc_ValueError,
426 _(
"String must not be empty."));
432 (
enum disassembler_style) style_num);
433 return text_part.release ();
446 static const char *keywords[] = {
"address", NULL };
465 gdb_assert (text_part->
string !=
nullptr);
466 return *(text_part->
string);
521 if (obj->
parts ==
nullptr)
522 obj->
parts =
new std::vector<gdbpy_ref<>>;
524 obj->
parts->clear ();
527 *(obj->
parts) = std::move (parts);
543 PyObject *info_obj, *memory_source_obj =
nullptr;
544 static const char *keywords[] = {
"info",
"memory_source",
nullptr };
561 disassembler.disasm_info ());
567 if (disassembler.restore_exception ())
583 if (disassembler.memory_error_address ().has_value ())
585 CORE_ADDR addr = *disassembler.memory_error_address ();
590 auto content = disassembler.release ();
597 catch (
const gdb_exception &except)
605 _(
"Unknown disassembly error."));
612 gdb_assert (length > 0);
615 gdb_assert (!disassembler.memory_error_address ().has_value ());
621 auto content = disassembler.release ();
623 return reinterpret_cast<PyObject *
> (res.release ());
642 static const char *keywords[] = {
"state",
nullptr };
647 if (!PyBool_Check (newstate))
649 PyErr_SetString (PyExc_TypeError,
650 _(
"The value passed to `_set_enabled' must be a boolean."));
671 LONGEST length, offset = 0;
672 gdb::unique_xmalloc_ptr<gdb_byte> buffer;
673 static const char *keywords[] = {
"length",
"offset",
nullptr };
684 CORE_ADDR address = obj->
address + offset;
687 buffer.reset ((gdb_byte *)
xmalloc (length));
692 disassemble_info *info = obj->
gdb_info;
693 if (info->read_memory_func ((bfd_vma) address, buffer.get (),
694 (
unsigned int) length, info) != 0)
751 enum disassembler_style style,
753 va_list args)
noexcept
757 = gdb::checked_static_cast<gdbpy_disassembler *> (di);
766 string_vappendf (*
string, format, args);
770 std::string str = string_vprintf (format, args);
775 dis->
m_parts.emplace_back (std::move (text_part));
789 const char *format, ...) noexcept
792 va_start (args, format);
805 enum disassembler_style style,
806 const char *format, ...) noexcept
809 va_start (args, format);
836 struct disassemble_info *info)
noexcept
853 LONGEST offset = (LONGEST) memaddr - (LONGEST) obj->
address;
862 if (result_obj ==
nullptr)
886 if (!PyObject_CheckBuffer (result_obj.get ())
887 || PyObject_GetBuffer (result_obj.get(), &py_buff, PyBUF_CONTIG_RO) < 0)
889 PyErr_Format (PyExc_TypeError,
890 _(
"Result from read_memory is not a buffer"));
900 if (py_buff.len != len)
902 PyErr_Format (PyExc_ValueError,
903 _(
"Buffer returned from read_memory is sized %d instead of the expected %d"),
910 const gdb_byte *buffer = (
const gdb_byte *) py_buff.buf;
911 memcpy (buff, buffer, len);
924 gdb_assert (obj->
parts !=
nullptr);
925 gdb_assert (obj->
parts->size () > 0);
926 gdb_assert (obj->
length > 0);
934 catch (
const gdb_exception &except)
939 return PyUnicode_Decode (str.c_str (), str.size (),
973 gdb_assert (obj->
parts !=
nullptr);
974 gdb_assert (obj->
parts->size () > 0);
975 gdb_assert (obj->
length > 0);
978 if (result_list ==
nullptr)
981 for (
auto p : *obj->
parts)
984 PyList_SET_ITEM (result_list.get (), idx, item.release ());
990 gdb_assert (PyList_Size (result_list.get()) > 0);
992 return result_list.release ();
1002 static const char *keywords[] = {
"length",
"string",
"parts", NULL };
1004 const char *
string =
nullptr;
1007 &length, &
string, &parts_list))
1012 PyErr_SetString (PyExc_ValueError,
1013 _(
"Length must be greater than 0."));
1017 if (parts_list == Py_None)
1018 parts_list =
nullptr;
1020 if (
string !=
nullptr && parts_list !=
nullptr)
1022 PyErr_Format (PyExc_ValueError,
1023 _(
"Cannot use 'string' and 'parts' when creating %s."),
1024 Py_TYPE (self)->tp_name);
1028 if (
string !=
nullptr)
1030 if (strlen (
string) == 0)
1032 PyErr_SetString (PyExc_ValueError,
1033 _(
"String must not be empty."));
1038 std::vector<gdbpy_ref<>> content;
1041 content.emplace_back (text_part.release ());
1046 if (!PySequence_Check (parts_list))
1048 PyErr_SetString (PyExc_TypeError,
1049 _(
"'parts' argument is not a sequence"));
1053 Py_ssize_t parts_count = PySequence_Size (parts_list);
1054 if (parts_count <= 0)
1056 PyErr_SetString (PyExc_ValueError,
1057 _(
"'parts' list must not be empty."));
1062 std::vector<gdbpy_ref<>> content (parts_count);
1065 for (Py_ssize_t i = 0; i < parts_count; ++i)
1067 gdbpy_ref<> part (PySequence_GetItem (parts_list, i));
1069 if (part ==
nullptr)
1076 gdb_assert (addr_part->
gdbarch !=
nullptr);
1081 PyErr_SetString (PyExc_ValueError,
1082 _(
"Inconsistent gdb.Architectures used "
1083 "in 'parts' sequence."));
1088 content[i] = std::move (part);
1105 gdb_assert (obj->
parts !=
nullptr);
1107 return PyUnicode_FromFormat (
"<%s length=%d string=\"%U\">",
1108 Py_TYPE (obj)->tp_name,
1119 struct disassemble_info *
info)
noexcept
1130 struct disassemble_info *
info)
noexcept
1137 dis->
m_parts.emplace_back (std::move (addr_part));
1149 fprintf_styled_func),
1150 m_disasm_info_object (obj),
1151 m_memory_source (memory_source)
1171 disassemble_info *info)
1175 memaddr, info,
nullptr);
1186 obj->gdb_info =
nullptr;
1220 disassemble_info *info)
1235 (PyImport_ImportModule (
"gdb.disassembler"));
1236 if (gdb_python_disassembler_module ==
nullptr)
1245 (PyObject_GetAttrString (gdb_python_disassembler_module.get (),
1247 if (hook ==
nullptr)
1261 gdbpy_ref<> result (PyObject_CallFunctionObjArgs (hook.get (),
1265 if (result ==
nullptr)
1285 if (
err.value () !=
nullptr
1286 && PyObject_HasAttrString (
err.value ().get (),
"address"))
1289 = PyObject_GetAttrString (
err.value ().get (),
"address");
1296 info->memory_error_func (-1, addr, info);
1297 return gdb::optional<int> (-1);
1304 info->fprintf_func (info->stream,
"%s", msg.get ());
1305 return gdb::optional<int> (-1);
1310 return gdb::optional<int> (-1);
1314 else if (result == Py_None)
1323 if (!PyObject_IsInstance (result.get (),
1326 PyErr_SetString (PyExc_TypeError,
1327 _(
"Result is not a DisassemblerResult."));
1329 return gdb::optional<int> (-1);
1346 _(
"Invalid length attribute: length must be greater than 0."));
1348 return gdb::optional<int> (-1);
1350 if (
length > max_insn_length)
1354 _(
"Invalid length attribute: length %d greater than architecture maximum of %d"),
1355 length, max_insn_length);
1357 return gdb::optional<int> (-1);
1364 gdb_assert (result_obj->
parts->size () > 0);
1367 for (
auto &p : *result_obj->
parts)
1373 gdb_assert (text_part->
string !=
nullptr);
1374 info->fprintf_styled_func (info->stream, text_part->
style,
1375 "%s", text_part->
string->c_str ());
1389 info->print_address_func (addr_part->
address, info);
1393 return gdb::optional<int> (
length);
1404 Py_TYPE (self)->tp_free (self);
1414 PyErr_SetString (PyExc_RuntimeError,
1415 _(
"Cannot create instances of DisassemblerPart."));
1427 case dis_style_text:
return "STYLE_TEXT";
1428 case dis_style_mnemonic:
return "STYLE_MNEMONIC";
1429 case dis_style_sub_mnemonic:
return "STYLE_SUB_MNEMONIC";
1430 case dis_style_assembler_directive:
return "STYLE_ASSEMBLER_DIRECTIVE";
1431 case dis_style_register:
return "STYLE_REGISTER";
1432 case dis_style_immediate:
return "STYLE_IMMEDIATE";
1433 case dis_style_address:
return "STYLE_ADDRESS";
1434 case dis_style_address_offset:
return "STYLE_ADDRESS_OFFSET";
1435 case dis_style_symbol:
return "STYLE_SYMBOL";
1436 case dis_style_comment_start:
return "STYLE_COMMENT_START";
1439 gdb_assert_not_reached (
"unknown disassembler style");
1449 gdb_assert (obj->
string !=
nullptr);
1451 return PyUnicode_FromFormat (
"<%s string='%s', style='%s'>",
1452 Py_TYPE (obj)->tp_name,
1464 return PyUnicode_Decode (obj->
string->c_str (), obj->
string->size (),
1483 LONGEST style_val = (LONGEST) obj->
style;
1494 return PyUnicode_FromFormat (
"<%s address='%s'>",
1495 Py_TYPE (obj)->tp_name,
1496 core_addr_to_string_nz (obj->
address));
1513 catch (
const gdb_exception &except)
1518 return PyUnicode_Decode (str.c_str (), str.size (),
1544 "Start address of the instruction to disassemble.",
nullptr },
1546 "Architecture to disassemble in",
nullptr },
1548 "Program space to disassemble in",
nullptr },
1556 METH_VARARGS | METH_KEYWORDS,
1557 "read_memory (LEN, OFFSET = 0) -> Octets[]\n\
1558Read LEN octets for the instruction to disassemble." },
1560 "is_valid () -> Boolean.\n\
1561Return true if this DisassembleInfo is valid, false if not." },
1563 METH_VARARGS | METH_KEYWORDS,
1564 "text_part (STRING, STYLE) -> DisassemblerTextPart\n\
1565Create a new text part, with contents STRING styled with STYLE." },
1567 METH_VARARGS | METH_KEYWORDS,
1568 "address_part (ADDRESS) -> DisassemblerAddressPart\n\
1569Create a new address part representing ADDRESS." },
1577 "Length of the disassembled instruction.",
nullptr },
1579 "String representing the disassembled instruction.",
nullptr },
1581 "List of all the separate disassembly parts",
nullptr },
1589 "String representing a text part.",
nullptr },
1591 "The style of this text part.",
nullptr },
1599 "String representing an address part.",
nullptr },
1601 "The address of this address part.",
nullptr },
1612 METH_VARARGS | METH_KEYWORDS,
1613 "builtin_disassemble (INFO, MEMORY_SOURCE = None) -> None\n\
1614Disassemble using GDB's builtin disassembler. INFO is an instance of\n\
1615gdb.disassembler.DisassembleInfo. The MEMORY_SOURCE, if not None, should\n\
1616be an object with the read_memory method." },
1618 METH_VARARGS | METH_KEYWORDS,
1619 "_set_enabled (STATE) -> None\n\
1620Set whether GDB should call into the Python _print_insn code or not." },
1621 {
nullptr,
nullptr, 0,
nullptr}
1628 PyModuleDef_HEAD_INIT,
1629 "_gdb.disassembler",
1648 if (gdb_disassembler_module ==
nullptr)
1651 gdb_disassembler_module) < 0)
1655 PyObject *dict = PyImport_GetModuleDict ();
1656 if (PyDict_SetItemString (dict,
"_gdb.disassembler",
1657 gdb_disassembler_module) < 0)
1660 for (
int i = 0; i <= (int) dis_style_comment_start; ++i)
1662 const char *style_name =
get_style_name ((
enum disassembler_style) i);
1663 if (PyModule_AddIntConstant (gdb_disassembler_module, style_name, i) < 0)
1696 "DisassemblerAddressPart",
1705 "DisassemblerTextPart",
1719 PyVarObject_HEAD_INIT (
nullptr, 0)
1720 "gdb.disassembler.DisassembleInfo",
1738 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1739 "GDB instruction disassembler object",
1761 PyVarObject_HEAD_INIT (
nullptr, 0)
1762 "gdb.disassembler.DisassemblerResult",
1781 "GDB object, representing a disassembler result",
1806 PyVarObject_HEAD_INIT (
nullptr, 0)
1807 "gdb.disassembler.DisassemblerPart",
1826 "GDB object, representing part of a disassembled instruction",
1848 PyVarObject_HEAD_INIT (
nullptr, 0)
1849 "gdb.disassembler.DisassemblerTextPart",
1868 "GDB object, representing a text part of an instruction",
1890 PyVarObject_HEAD_INIT (
nullptr, 0)
1891 "gdb.disassembler.DisassemblerAddressPart",
1910 "GDB object, representing an address part of an instruction",
struct gdbarch * get_current_arch(void)
const char * host_charset(void)
gdb::unique_xmalloc_ptr< char > to_string() const
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
static void ATTRIBUTE_PRINTF(1, 0)
bool gdbarch_max_insn_length_p(struct gdbarch *gdbarch)
int gdbarch_print_insn(struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
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 PyObject * disasmpy_info_make_text_part(PyObject *self, PyObject *args, PyObject *kwargs)
static gdbpy_ref make_disasm_text_part(std::string &&str, enum disassembler_style style)
static PyObject * disasmpy_addr_part_string(PyObject *self, void *closure)
static PyMethodDef disasm_info_object_methods[]
static void disasmpy_init_disassembler_result(disasm_result_object *obj, int length, std::vector< gdbpy_ref<> > &&parts)
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)
static int disasmpy_part_init(PyObject *self, PyObject *args, PyObject *kwargs)
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
static PyObject * disasmpy_addr_part_repr(PyObject *self)
static gdbpy_ref make_disasm_addr_part(struct gdbarch *gdbarch, CORE_ADDR address)
static PyObject * disasmpy_info_repr(PyObject *self)
PyTypeObject disasm_info_object_type
static PyObject * disasmpy_set_enabled(PyObject *self, PyObject *args, PyObject *kw)
static PyObject * disasmpy_addr_part_str(PyObject *self)
static PyObject * disasmpy_result_str(PyObject *self)
static PyObject * disasmpy_builtin_disassemble(PyObject *self, PyObject *args, PyObject *kw)
static std::string disasmpy_part_to_string(const disasm_text_part_object *text_part)
static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION gdbpy_initialize_disasm()
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 const char * get_style_name(enum disassembler_style style)
static PyObject * disasmpy_result_parts(PyObject *self, void *closure)
static PyObject * disasmpy_text_part_str(PyObject *self)
static PyObject * disasmpy_info_make_address_part(PyObject *self, PyObject *args, PyObject *kwargs)
static gdb_PyGetSetDef disasm_info_object_getset[]
PyTypeObject disasm_text_part_object_type
PyTypeObject disasm_part_object_type
static bool python_print_insn_enabled
static PyObject * disasmpy_result_repr(PyObject *self)
static PyObject * disasmpy_addr_part_address(PyObject *self, void *closure)
static gdb_PyGetSetDef disasmpy_addr_part_getset[]
#define DISASMPY_DISASM_INFO_REQUIRE_VALID(Info)
static bool disasm_info_object_is_valid(disasm_info_object *obj)
static PyObject * disasmpy_text_part_repr(PyObject *self)
static gdb_PyGetSetDef disasmpy_text_part_getset[]
static PyObject * disasmpy_text_part_string(PyObject *self, void *closure)
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)
PyTypeObject disasm_addr_part_object_type
static PyObject * disasmpy_text_part_style(PyObject *self, void *closure)
static std::string disasmpy_parts_list_to_string(const std::vector< gdbpy_ref<> > &parts)
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_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
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)
#define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
#define GDBPY_INITIALIZE_FILE(INIT,...)
PyObject * gdbpy_gdb_memory_error
PyObject * gdbpy_gdberror_exc
#define GDB_PY_HANDLE_EXCEPTION(Exception)
static int gdb_PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, const char **keywords,...)
PyObject_HEAD bfd_vma address
struct program_space * program_space
struct disasm_info_object * next
PyObject_HEAD struct gdbarch * gdbarch
disassemble_info * gdb_info
std::vector< gdbpy_ref<> > * parts
PyObject_HEAD std::string * string
enum disassembler_style style
PyObject * m_memory_source
void store_exception(gdbpy_err_fetch &&ex)
gdb::optional< CORE_ADDR > m_memory_error_address
disasm_info_object * py_disasm_info() const
static int static int fprintf_styled_func(void *dis_info, enum disassembler_style style, const char *format,...) noexcept ATTRIBUTE_PRINTF(3
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 static int static int const gdb::optional< CORE_ADDR > & memory_error_address() const
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
std::vector< gdbpy_ref<> > m_parts
static int fprintf_func(void *dis_info, const char *format,...) noexcept ATTRIBUTE_PRINTF(2
static int static int static int vfprintf_styled_func(void *dis_info, enum disassembler_style style, const char *format, va_list args) noexcept ATTRIBUTE_PRINTF(3
static void print_address_func(bfd_vma addr, struct disassemble_info *info) noexcept
std::vector< gdbpy_ref<> > release()
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()