gdb/python/py-arch.c

   1 /* Python interface to architecture
   2
   3    Copyright (C) 2013-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "gdbarch.h"
  21 #include "arch-utils.h"
  22 #include "disasm.h"
  23 #include "python-internal.h"
  24
  25 struct arch_object {
  26   PyObject_HEAD
  27   struct gdbarch *gdbarch;
  28 };
  29
  30 static const registry<gdbarch>::key<PyObject, gdb::noop_deleter<PyObject>>
  31      arch_object_data;
  32
  33 /* Require a valid Architecture.  */
  34 #define ARCHPY_REQUIRE_VALID(arch_obj, arch)                    \
  35   do {                                                          \
  36     arch = arch_object_to_gdbarch (arch_obj);                   \
  37     if (arch == NULL)                                           \
  38       {                                                         \
  39         PyErr_SetString (PyExc_RuntimeError,                    \
  40                          _("Architecture is invalid."));        \
  41         return NULL;                                            \
  42       }                                                         \
  43   } while (0)
  44
  45 extern PyTypeObject arch_object_type
  46     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("arch_object");
  47
  48 /* Associates an arch_object with GDBARCH as gdbarch_data via the gdbarch
  49    post init registration mechanism (gdbarch_data_register_post_init).  */
  50
  51 static PyObject *
  52 arch_object_data_init (struct gdbarch *gdbarch)
  53 {
  54   arch_object *arch_obj = PyObject_New (arch_object, &arch_object_type);
  55
  56   if (arch_obj == NULL)
  57     return NULL;
  58
  59   arch_obj->gdbarch = gdbarch;
  60
  61   return (PyObject *) arch_obj;
  62 }
  63
  64 /* Returns the struct gdbarch value corresponding to the given Python
  65    architecture object OBJ, which must be a gdb.Architecture object.  */
  66
  67 struct gdbarch *
  68 arch_object_to_gdbarch (PyObject *obj)
  69 {
  70   gdb_assert (gdbpy_is_architecture (obj));
  71
  72   arch_object *py_arch = (arch_object *) obj;
  73   return py_arch->gdbarch;
  74 }
  75
  76 /* See python-internal.h.  */
  77
  78 bool
  79 gdbpy_is_architecture (PyObject *obj)
  80 {
  81   return PyObject_TypeCheck (obj, &arch_object_type);
  82 }
  83
  84 /* Returns the Python architecture object corresponding to GDBARCH.
  85    Returns a new reference to the arch_object associated as data with
  86    GDBARCH.  */
  87
  88 PyObject *
  89 gdbarch_to_arch_object (struct gdbarch *gdbarch)
  90 {
  91   PyObject *new_ref = arch_object_data.get (gdbarch);
  92   if (new_ref == nullptr)
  93     {
  94       new_ref = arch_object_data_init (gdbarch);
  95       arch_object_data.set (gdbarch, new_ref);
  96     }
  97
  98   /* new_ref could be NULL if creation failed.  */
  99   Py_XINCREF (new_ref);
 100
 101   return new_ref;
 102 }
 103
 104 /* Implementation of gdb.Architecture.name (self) -> String.
 105    Returns the name of the architecture as a string value.  */
 106
 107 static PyObject *
 108 archpy_name (PyObject *self, PyObject *args)
 109 {
 110   struct gdbarch *gdbarch = NULL;
 111   const char *name;
 112
 113   ARCHPY_REQUIRE_VALID (self, gdbarch);
 114
 115   name = (gdbarch_bfd_arch_info (gdbarch))->printable_name;
 116   return PyUnicode_FromString (name);
 117 }
 118
 119 /* Implementation of
 120    gdb.Architecture.disassemble (self, start_pc [, end_pc [,count]]) -> List.
 121    Returns a list of instructions in a memory address range.  Each instruction
 122    in the list is a Python dict object.
 123 */
 124
 125 static PyObject *
 126 archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw)
 127 {
 128   static const char *keywords[] = { "start_pc", "end_pc", "count", NULL };
 129   CORE_ADDR start = 0, end = 0;
 130   CORE_ADDR pc;
 131   long count = 0, i;
 132   PyObject *start_obj = nullptr, *end_obj = nullptr, *count_obj = nullptr;
 133   struct gdbarch *gdbarch = NULL;
 134
 135   ARCHPY_REQUIRE_VALID (self, gdbarch);
 136
 137   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "O|OO",
 138                                         keywords, &start_obj, &end_obj,
 139                                         &count_obj))
 140     return NULL;
 141
 142   if (get_addr_from_python (start_obj, &start) < 0)
 143     return nullptr;
 144
 145   if (end_obj != nullptr)
 146     {
 147       if (get_addr_from_python (end_obj, &end) < 0)
 148         return nullptr;
 149
 150       if (end < start)
 151         {
 152           PyErr_SetString (PyExc_ValueError,
 153                            _("Argument 'end_pc' should be greater than or "
 154                              "equal to the argument 'start_pc'."));
 155
 156           return NULL;
 157         }
 158     }
 159   if (count_obj)
 160     {
 161       count = PyLong_AsLong (count_obj);
 162       if (PyErr_Occurred () || count < 0)
 163         {
 164           PyErr_SetString (PyExc_TypeError,
 165                            _("Argument 'count' should be an non-negative "
 166                              "integer."));
 167
 168           return NULL;
 169         }
 170     }
 171
 172   gdbpy_ref<> result_list (PyList_New (0));
 173   if (result_list == NULL)
 174     return NULL;
 175
 176   for (pc = start, i = 0;
 177        /* All args are specified.  */
 178        (end_obj && count_obj && pc <= end && i < count)
 179        /* end_pc is specified, but no count.  */
 180        || (end_obj && count_obj == NULL && pc <= end)
 181        /* end_pc is not specified, but a count is.  */
 182        || (end_obj == NULL && count_obj && i < count)
 183        /* Both end_pc and count are not specified.  */
 184        || (end_obj == NULL && count_obj == NULL && pc == start);)
 185     {
 186       int insn_len = 0;
 187       gdbpy_ref<> insn_dict (PyDict_New ());
 188
 189       if (insn_dict == NULL)
 190         return NULL;
 191       if (PyList_Append (result_list.get (), insn_dict.get ()))
 192         return NULL;  /* PyList_Append Sets the exception.  */
 193
 194       string_file stb;
 195
 196       try
 197         {
 198           insn_len = gdb_print_insn (gdbarch, pc, &stb, NULL);
 199         }
 200       catch (const gdb_exception &except)
 201         {
 202           return gdbpy_handle_gdb_exception (nullptr, except);
 203         }
 204
 205       gdbpy_ref<> pc_obj = gdb_py_object_from_ulongest (pc);
 206       if (pc_obj == nullptr)
 207         return nullptr;
 208
 209       gdbpy_ref<> asm_obj
 210         (PyUnicode_FromString (!stb.empty () ? stb.c_str () : "<unknown>"));
 211       if (asm_obj == nullptr)
 212         return nullptr;
 213
 214       gdbpy_ref<> len_obj = gdb_py_object_from_longest (insn_len);
 215       if (len_obj == nullptr)
 216         return nullptr;
 217
 218       if (PyDict_SetItemString (insn_dict.get (), "addr", pc_obj.get ())
 219           || PyDict_SetItemString (insn_dict.get (), "asm", asm_obj.get ())
 220           || PyDict_SetItemString (insn_dict.get (), "length", len_obj.get ()))
 221         return NULL;
 222
 223       pc += insn_len;
 224       i++;
 225     }
 226
 227   return result_list.release ();
 228 }
 229
 230 /* Implementation of gdb.Architecture.registers (self, reggroup) -> Iterator.
 231    Returns an iterator over register descriptors for registers in GROUP
 232    within the architecture SELF.  */
 233
 234 static PyObject *
 235 archpy_registers (PyObject *self, PyObject *args, PyObject *kw)
 236 {
 237   static const char *keywords[] = { "reggroup", NULL };
 238   struct gdbarch *gdbarch = NULL;
 239   const char *group_name = NULL;
 240
 241   /* Parse method arguments.  */
 242   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|s", keywords,
 243                                         &group_name))
 244     return NULL;
 245
 246   /* Extract the gdbarch from the self object.  */
 247   ARCHPY_REQUIRE_VALID (self, gdbarch);
 248
 249   return gdbpy_new_register_descriptor_iterator (gdbarch, group_name);
 250 }
 251
 252 /* Implementation of gdb.Architecture.register_groups (self) -> Iterator.
 253    Returns an iterator that will give up all valid register groups in the
 254    architecture SELF.  */
 255
 256 static PyObject *
 257 archpy_register_groups (PyObject *self, PyObject *args)
 258 {
 259   struct gdbarch *gdbarch = NULL;
 260
 261   /* Extract the gdbarch from the self object.  */
 262   ARCHPY_REQUIRE_VALID (self, gdbarch);
 263   return gdbpy_new_reggroup_iterator (gdbarch);
 264 }
 265
 266 /* Implementation of gdb.integer_type.  */
 267 static PyObject *
 268 archpy_integer_type (PyObject *self, PyObject *args, PyObject *kw)
 269 {
 270   static const char *keywords[] = { "size", "signed", NULL };
 271   int size;
 272   PyObject *is_signed_obj = nullptr;
 273
 274   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "i|O", keywords,
 275                                         &size, &is_signed_obj))
 276     return nullptr;
 277
 278   /* Assume signed by default.  */
 279   bool is_signed = (is_signed_obj == nullptr
 280                     || PyObject_IsTrue (is_signed_obj));
 281
 282   struct gdbarch *gdbarch;
 283   ARCHPY_REQUIRE_VALID (self, gdbarch);
 284
 285   const struct builtin_type *builtins = builtin_type (gdbarch);
 286   struct type *type = nullptr;
 287   switch (size)
 288     {
 289     case 0:
 290       type = builtins->builtin_int0;
 291       break;
 292     case 8:
 293       type = is_signed ? builtins->builtin_int8 : builtins->builtin_uint8;
 294       break;
 295     case 16:
 296       type = is_signed ? builtins->builtin_int16 : builtins->builtin_uint16;
 297       break;
 298     case 24:
 299       type = is_signed ? builtins->builtin_int24 : builtins->builtin_uint24;
 300       break;
 301     case 32:
 302       type = is_signed ? builtins->builtin_int32 : builtins->builtin_uint32;
 303       break;
 304     case 64:
 305       type = is_signed ? builtins->builtin_int64 : builtins->builtin_uint64;
 306       break;
 307     case 128:
 308       type = is_signed ? builtins->builtin_int128 : builtins->builtin_uint128;
 309       break;
 310
 311     default:
 312       PyErr_SetString (PyExc_ValueError,
 313                        _("no integer type of that size is available"));
 314       return nullptr;
 315     }
 316
 317   return type_to_type_object (type);
 318 }
 319
 320 /* __repr__ implementation for gdb.Architecture.  */
 321
 322 static PyObject *
 323 archpy_repr (PyObject *self)
 324 {
 325   const auto gdbarch = arch_object_to_gdbarch (self);
 326   if (gdbarch == nullptr)
 327     return gdb_py_invalid_object_repr (self);
 328
 329   auto arch_info = gdbarch_bfd_arch_info (gdbarch);
 330   return PyUnicode_FromFormat ("<%s arch_name=%s printable_name=%s>",
 331                                Py_TYPE (self)->tp_name, arch_info->arch_name,
 332                                arch_info->printable_name);
 333 }
 334
 335 /* Implementation of gdb.architecture_names().  Return a list of all the
 336    BFD architecture names that GDB understands.  */
 337
 338 PyObject *
 339 gdbpy_all_architecture_names (PyObject *self, PyObject *args)
 340 {
 341   gdbpy_ref<> list (PyList_New (0));
 342   if (list == nullptr)
 343     return nullptr;
 344
 345   std::vector<const char *> name_list = gdbarch_printable_names ();
 346   for (const char *name : name_list)
 347     {
 348       gdbpy_ref <> py_name (PyUnicode_FromString (name));
 349       if (py_name == nullptr)
 350         return nullptr;
 351       if (PyList_Append (list.get (), py_name.get ()) < 0)
 352         return nullptr;
 353     }
 354
 355  return list.release ();
 356 }
 357
 358 /* Initializes the Architecture class in the gdb module.  */
 359
 360 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
 361 gdbpy_initialize_arch (void)
 362 {
 363   arch_object_type.tp_new = PyType_GenericNew;
 364   return gdbpy_type_ready (&arch_object_type);
 365 }
 366
 367 GDBPY_INITIALIZE_FILE (gdbpy_initialize_arch);
 368
 369 \f
 370
 371 static PyMethodDef arch_object_methods [] = {
 372   { "name", archpy_name, METH_NOARGS,
 373     "name () -> String.\n\
 374 Return the name of the architecture as a string value." },
 375   { "disassemble", (PyCFunction) archpy_disassemble,
 376     METH_VARARGS | METH_KEYWORDS,
 377     "disassemble (start_pc [, end_pc [, count]]) -> List.\n\
 378 Return a list of at most COUNT disassembled instructions from START_PC to\n\
 379 END_PC." },
 380   { "integer_type", (PyCFunction) archpy_integer_type,
 381     METH_VARARGS | METH_KEYWORDS,
 382     "integer_type (size [, signed]) -> type\n\
 383 Return an integer Type corresponding to the given bitsize and signed-ness.\n\
 384 If not specified, the type defaults to signed." },
 385   { "registers", (PyCFunction) archpy_registers,
 386     METH_VARARGS | METH_KEYWORDS,
 387     "registers ([ group-name ]) -> Iterator.\n\
 388 Return an iterator of register descriptors for the registers in register\n\
 389 group GROUP-NAME." },
 390   { "register_groups", archpy_register_groups,
 391     METH_NOARGS,
 392     "register_groups () -> Iterator.\n\
 393 Return an iterator over all of the register groups in this architecture." },
 394   {NULL}  /* Sentinel */
 395 };
 396
 397 PyTypeObject arch_object_type = {
 398   PyVarObject_HEAD_INIT (NULL, 0)
 399   "gdb.Architecture",                 /* tp_name */
 400   sizeof (arch_object),               /* tp_basicsize */
 401   0,                                  /* tp_itemsize */
 402   0,                                  /* tp_dealloc */
 403   0,                                  /* tp_print */
 404   0,                                  /* tp_getattr */
 405   0,                                  /* tp_setattr */
 406   0,                                  /* tp_compare */
 407   archpy_repr,                        /* tp_repr */
 408   0,                                  /* tp_as_number */
 409   0,                                  /* tp_as_sequence */
 410   0,                                  /* tp_as_mapping */
 411   0,                                  /* tp_hash  */
 412   0,                                  /* tp_call */
 413   0,                                  /* tp_str */
 414   0,                                  /* tp_getattro */
 415   0,                                  /* tp_setattro */
 416   0,                                  /* tp_as_buffer */
 417   Py_TPFLAGS_DEFAULT,                 /* tp_flags */
 418   "GDB architecture object",          /* tp_doc */
 419   0,                                  /* tp_traverse */
 420   0,                                  /* tp_clear */
 421   0,                                  /* tp_richcompare */
 422   0,                                  /* tp_weaklistoffset */
 423   0,                                  /* tp_iter */
 424   0,                                  /* tp_iternext */
 425   arch_object_methods,                /* tp_methods */
 426   0,                                  /* tp_members */
 427   0,                                  /* tp_getset */
 428   0,                                  /* tp_base */
 429   0,                                  /* tp_dict */
 430   0,                                  /* tp_descr_get */
 431   0,                                  /* tp_descr_set */
 432   0,                                  /* tp_dictoffset */
 433   0,                                  /* tp_init */
 434   0,                                  /* tp_alloc */
 435 };