/* Python interface to architecture
- Copyright (C) 2013-2016 Free Software Foundation, Inc.
+ Copyright (C) 2013-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "disasm.h"
#include "python-internal.h"
-typedef struct arch_object_type_object {
+struct arch_object {
PyObject_HEAD
struct gdbarch *gdbarch;
-} arch_object;
+};
static struct gdbarch_data *arch_object_data = NULL;
{
struct gdbarch *gdbarch = NULL;
const char *name;
- PyObject *py_name;
ARCHPY_REQUIRE_VALID (self, gdbarch);
name = (gdbarch_bfd_arch_info (gdbarch))->printable_name;
- py_name = PyString_FromString (name);
-
- return py_name;
+ return PyString_FromString (name);
}
/* Implementation of
static PyObject *
archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw)
{
- static char *keywords[] = { "start_pc", "end_pc", "count", NULL };
+ static const char *keywords[] = { "start_pc", "end_pc", "count", NULL };
CORE_ADDR start, end = 0;
CORE_ADDR pc;
gdb_py_ulongest start_temp;
long count = 0, i;
- PyObject *result_list, *end_obj = NULL, *count_obj = NULL;
+ PyObject *end_obj = NULL, *count_obj = NULL;
struct gdbarch *gdbarch = NULL;
ARCHPY_REQUIRE_VALID (self, gdbarch);
- if (!PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO", keywords,
- &start_temp, &end_obj, &count_obj))
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO",
+ keywords, &start_temp, &end_obj,
+ &count_obj))
return NULL;
start = start_temp;
to be done first to ensure we do not lose information in the
conversion process. */
if (PyLong_Check (end_obj))
- end = PyLong_AsUnsignedLongLong (end_obj);
+ end = PyLong_AsUnsignedLongLong (end_obj);
#if PY_MAJOR_VERSION == 2
else if (PyInt_Check (end_obj))
- /* If the end_pc value is specified without a trailing 'L', end_obj will
- be an integer and not a long integer. */
- end = PyInt_AsLong (end_obj);
+ /* If the end_pc value is specified without a trailing 'L', end_obj will
+ be an integer and not a long integer. */
+ end = PyInt_AsLong (end_obj);
#endif
else
- {
- Py_DECREF (end_obj);
- Py_XDECREF (count_obj);
- PyErr_SetString (PyExc_TypeError,
- _("Argument 'end_pc' should be a (long) integer."));
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Argument 'end_pc' should be a (long) integer."));
- return NULL;
- }
+ return NULL;
+ }
if (end < start)
- {
- Py_DECREF (end_obj);
- Py_XDECREF (count_obj);
- PyErr_SetString (PyExc_ValueError,
- _("Argument 'end_pc' should be greater than or "
- "equal to the argument 'start_pc'."));
-
- return NULL;
- }
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("Argument 'end_pc' should be greater than or "
+ "equal to the argument 'start_pc'."));
+
+ return NULL;
+ }
}
if (count_obj)
{
count = PyInt_AsLong (count_obj);
if (PyErr_Occurred () || count < 0)
- {
- Py_DECREF (count_obj);
- Py_XDECREF (end_obj);
- PyErr_SetString (PyExc_TypeError,
- _("Argument 'count' should be an non-negative "
- "integer."));
-
- return NULL;
- }
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Argument 'count' should be an non-negative "
+ "integer."));
+
+ return NULL;
+ }
}
- result_list = PyList_New (0);
+ gdbpy_ref<> result_list (PyList_New (0));
if (result_list == NULL)
return NULL;
|| (end_obj == NULL && count_obj == NULL && pc == start);)
{
int insn_len = 0;
- char *as = NULL;
- struct ui_file *memfile = mem_fileopen ();
- PyObject *insn_dict = PyDict_New ();
+ gdbpy_ref<> insn_dict (PyDict_New ());
if (insn_dict == NULL)
- {
- Py_DECREF (result_list);
- ui_file_delete (memfile);
-
- return NULL;
- }
- if (PyList_Append (result_list, insn_dict))
- {
- Py_DECREF (result_list);
- Py_DECREF (insn_dict);
- ui_file_delete (memfile);
-
- return NULL; /* PyList_Append Sets the exception. */
- }
-
- TRY
- {
- insn_len = gdb_print_insn (gdbarch, pc, memfile, NULL);
- }
- CATCH (except, RETURN_MASK_ALL)
- {
- Py_DECREF (result_list);
- ui_file_delete (memfile);
-
+ return NULL;
+ if (PyList_Append (result_list.get (), insn_dict.get ()))
+ return NULL; /* PyList_Append Sets the exception. */
+
+ string_file stb;
+
+ try
+ {
+ insn_len = gdb_print_insn (gdbarch, pc, &stb, NULL);
+ }
+ catch (const gdb_exception &except)
+ {
gdbpy_convert_exception (except);
return NULL;
- }
- END_CATCH
+ }
- as = ui_file_xstrdup (memfile, NULL);
- if (PyDict_SetItemString (insn_dict, "addr",
- gdb_py_long_from_ulongest (pc))
- || PyDict_SetItemString (insn_dict, "asm",
- PyString_FromString (*as ? as : "<unknown>"))
- || PyDict_SetItemString (insn_dict, "length",
- PyInt_FromLong (insn_len)))
- {
- Py_DECREF (result_list);
+ gdbpy_ref<> pc_obj = gdb_py_object_from_ulongest (pc);
+ if (pc_obj == nullptr)
+ return nullptr;
- ui_file_delete (memfile);
- xfree (as);
+ gdbpy_ref<> asm_obj (PyString_FromString (!stb.empty ()
+ ? stb.c_str ()
+ : "<unknown>"));
+ if (asm_obj == nullptr)
+ return nullptr;
- return NULL;
- }
+ gdbpy_ref<> len_obj = gdb_py_object_from_longest (insn_len);
+ if (len_obj == nullptr)
+ return nullptr;
+
+ if (PyDict_SetItemString (insn_dict.get (), "addr", pc_obj.get ())
+ || PyDict_SetItemString (insn_dict.get (), "asm", asm_obj.get ())
+ || PyDict_SetItemString (insn_dict.get (), "length", len_obj.get ()))
+ return NULL;
pc += insn_len;
i++;
- ui_file_delete (memfile);
- xfree (as);
}
- return result_list;
+ return result_list.release ();
+}
+
+/* Implementation of gdb.Architecture.registers (self, reggroup) -> Iterator.
+ Returns an iterator over register descriptors for registers in GROUP
+ within the architecture SELF. */
+
+static PyObject *
+archpy_registers (PyObject *self, PyObject *args, PyObject *kw)
+{
+ static const char *keywords[] = { "reggroup", NULL };
+ struct gdbarch *gdbarch = NULL;
+ const char *group_name = NULL;
+
+ /* Parse method arguments. */
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|s", keywords,
+ &group_name))
+ return NULL;
+
+ /* Extract the gdbarch from the self object. */
+ ARCHPY_REQUIRE_VALID (self, gdbarch);
+
+ return gdbpy_new_register_descriptor_iterator (gdbarch, group_name);
+}
+
+/* Implementation of gdb.Architecture.register_groups (self) -> Iterator.
+ Returns an iterator that will give up all valid register groups in the
+ architecture SELF. */
+
+static PyObject *
+archpy_register_groups (PyObject *self, PyObject *args)
+{
+ struct gdbarch *gdbarch = NULL;
+
+ /* Extract the gdbarch from the self object. */
+ ARCHPY_REQUIRE_VALID (self, gdbarch);
+ return gdbpy_new_reggroup_iterator (gdbarch);
+}
+
+/* Implementation of gdb.integer_type. */
+static PyObject *
+archpy_integer_type (PyObject *self, PyObject *args, PyObject *kw)
+{
+ static const char *keywords[] = { "size", "signed", NULL };
+ int size;
+ PyObject *is_signed_obj = nullptr;
+
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "i|O", keywords,
+ &size, &is_signed_obj))
+ return nullptr;
+
+ /* Assume signed by default. */
+ bool is_signed = (is_signed_obj == nullptr
+ || PyObject_IsTrue (is_signed_obj));
+
+ struct gdbarch *gdbarch;
+ ARCHPY_REQUIRE_VALID (self, gdbarch);
+
+ const struct builtin_type *builtins = builtin_type (gdbarch);
+ struct type *type = nullptr;
+ switch (size)
+ {
+ case 0:
+ type = builtins->builtin_int0;
+ break;
+ case 8:
+ type = is_signed ? builtins->builtin_int8 : builtins->builtin_uint8;
+ break;
+ case 16:
+ type = is_signed ? builtins->builtin_int16 : builtins->builtin_uint16;
+ break;
+ case 24:
+ type = is_signed ? builtins->builtin_int24 : builtins->builtin_uint24;
+ break;
+ case 32:
+ type = is_signed ? builtins->builtin_int32 : builtins->builtin_uint32;
+ break;
+ case 64:
+ type = is_signed ? builtins->builtin_int64 : builtins->builtin_uint64;
+ break;
+ case 128:
+ type = is_signed ? builtins->builtin_int128 : builtins->builtin_uint128;
+ break;
+
+ default:
+ PyErr_SetString (PyExc_ValueError,
+ _("no integer type of that size is available"));
+ return nullptr;
+ }
+
+ return type_to_type_object (type);
+}
+
+/* Implementation of gdb.architecture_names(). Return a list of all the
+ BFD architecture names that GDB understands. */
+
+PyObject *
+gdbpy_all_architecture_names (PyObject *self, PyObject *args)
+{
+ gdbpy_ref<> list (PyList_New (0));
+ if (list == nullptr)
+ return nullptr;
+
+ std::vector<const char *> name_list = gdbarch_printable_names ();
+ for (const char *name : name_list)
+ {
+ gdbpy_ref <> py_name (PyString_FromString (name));
+ if (py_name == nullptr)
+ return nullptr;
+ if (PyList_Append (list.get (), py_name.get ()) < 0)
+ return nullptr;
+ }
+
+ return list.release ();
+}
+
+void _initialize_py_arch ();
+void
+_initialize_py_arch ()
+{
+ arch_object_data = gdbarch_data_register_post_init (arch_object_data_init);
}
/* Initializes the Architecture class in the gdb module. */
int
gdbpy_initialize_arch (void)
{
- arch_object_data = gdbarch_data_register_post_init (arch_object_data_init);
arch_object_type.tp_new = PyType_GenericNew;
if (PyType_Ready (&arch_object_type) < 0)
return -1;
"disassemble (start_pc [, end_pc [, count]]) -> List.\n\
Return a list of at most COUNT disassembled instructions from START_PC to\n\
END_PC." },
+ { "integer_type", (PyCFunction) archpy_integer_type,
+ METH_VARARGS | METH_KEYWORDS,
+ "integer_type (size [, signed]) -> type\n\
+Return an integer Type corresponding to the given bitsize and signed-ness.\n\
+If not specified, the type defaults to signed." },
+ { "registers", (PyCFunction) archpy_registers,
+ METH_VARARGS | METH_KEYWORDS,
+ "registers ([ group-name ]) -> Iterator.\n\
+Return an iterator of register descriptors for the registers in register\n\
+group GROUP-NAME." },
+ { "register_groups", archpy_register_groups,
+ METH_NOARGS,
+ "register_groups () -> Iterator.\n\
+Return an iterator over all of the register groups in this architecture." },
{NULL} /* Sentinel */
};
projects / binutils.git / blobdiff