gdb/python/py-registers.c

   1 /* Python interface to register, and register group information.
   2
   3    Copyright (C) 2020 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 "defs.h"
  21 #include "gdbarch.h"
  22 #include "arch-utils.h"
  23 #include "disasm.h"
  24 #include "reggroups.h"
  25 #include "python-internal.h"
  26
  27 /* Structure for iterator over register descriptors.  */
  28 typedef struct {
  29   PyObject_HEAD
  30
  31   /* The register group that the user is iterating over.  This will never
  32      be NULL.  */
  33   struct reggroup *reggroup;
  34
  35   /* The next register number to lookup.  Starts at 0 and counts up.  */
  36   int regnum;
  37
  38   /* Pointer back to the architecture we're finding registers for.  */
  39   struct gdbarch *gdbarch;
  40 } register_descriptor_iterator_object;
  41
  42 extern PyTypeObject register_descriptor_iterator_object_type
  43     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_iterator_object");
  44
  45 /* A register descriptor.  */
  46 typedef struct {
  47   PyObject_HEAD
  48
  49   /* The register this is a descriptor for.  */
  50   int regnum;
  51
  52   /* The architecture this is a register for.  */
  53   struct gdbarch *gdbarch;
  54 } register_descriptor_object;
  55
  56 extern PyTypeObject register_descriptor_object_type
  57     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_object");
  58
  59 /* Structure for iterator over register groups.  */
  60 typedef struct {
  61   PyObject_HEAD
  62
  63   /* The last register group returned.  Initially this will be NULL.  */
  64   struct reggroup *reggroup;
  65
  66   /* Pointer back to the architecture we're finding registers for.  */
  67   struct gdbarch *gdbarch;
  68 } reggroup_iterator_object;
  69
  70 extern PyTypeObject reggroup_iterator_object_type
  71     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_iterator_object");
  72
  73 /* A register group object.  */
  74 typedef struct {
  75   PyObject_HEAD
  76
  77   /* The register group being described.  */
  78   struct reggroup *reggroup;
  79 } reggroup_object;
  80
  81 extern PyTypeObject reggroup_object_type
  82     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_object");
  83
  84 /* Create a new gdb.RegisterGroup object wrapping REGGROUP.  */
  85
  86 static PyObject *
  87 gdbpy_new_reggroup (struct reggroup *reggroup)
  88 {
  89   /* Create a new object and fill in its details.  */
  90   reggroup_object *group
  91     = PyObject_New (reggroup_object, &reggroup_object_type);
  92   if (group == NULL)
  93     return NULL;
  94   group->reggroup = reggroup;
  95   return (PyObject *) group;
  96 }
  97
  98 /* Convert a gdb.RegisterGroup to a string, it just returns the name of
  99    the register group.  */
 100
 101 static PyObject *
 102 gdbpy_reggroup_to_string (PyObject *self)
 103 {
 104   reggroup_object *group = (reggroup_object *) self;
 105   struct reggroup *reggroup = group->reggroup;
 106
 107   const char *name = reggroup_name (reggroup);
 108   return PyString_FromString (name);
 109 }
 110
 111 /* Implement gdb.RegisterGroup.name (self) -> String.
 112    Return a string that is the name of this register group.  */
 113
 114 static PyObject *
 115 gdbpy_reggroup_name (PyObject *self, void *closure)
 116 {
 117   return gdbpy_reggroup_to_string (self);
 118 }
 119
 120 /* Create an return a new gdb.RegisterDescriptor object.  */
 121 static PyObject *
 122 gdbpy_new_register_descriptor (struct gdbarch *gdbarch,
 123                                int regnum)
 124 {
 125   /* Create a new object and fill in its details.  */
 126   register_descriptor_object *reg
 127     = PyObject_New (register_descriptor_object,
 128                     &register_descriptor_object_type);
 129   if (reg == NULL)
 130     return NULL;
 131   reg->regnum = regnum;
 132   reg->gdbarch = gdbarch;
 133   return (PyObject *) reg;
 134 }
 135
 136 /* Convert the register descriptor to a string.  */
 137
 138 static PyObject *
 139 gdbpy_register_descriptor_to_string (PyObject *self)
 140 {
 141   register_descriptor_object *reg
 142     = (register_descriptor_object *) self;
 143   struct gdbarch *gdbarch = reg->gdbarch;
 144   int regnum = reg->regnum;
 145
 146   const char *name = gdbarch_register_name (gdbarch, regnum);
 147   return PyString_FromString (name);
 148 }
 149
 150 /* Implement gdb.RegisterDescriptor.name attribute get function.  Return a
 151    string that is the name of this register.  Due to checking when register
 152    descriptors are created the name will never by the empty string.  */
 153
 154 static PyObject *
 155 gdbpy_register_descriptor_name (PyObject *self, void *closure)
 156 {
 157   return gdbpy_register_descriptor_to_string (self);
 158 }
 159
 160 /* Return a reference to the gdb.RegisterGroupsIterator object.  */
 161
 162 static PyObject *
 163 gdbpy_reggroup_iter (PyObject *self)
 164 {
 165   Py_INCREF (self);
 166   return self;
 167 }
 168
 169 /* Return the next gdb.RegisterGroup object from the iterator.  */
 170
 171 static PyObject *
 172 gdbpy_reggroup_iter_next (PyObject *self)
 173 {
 174   reggroup_iterator_object *iter_obj
 175     = (reggroup_iterator_object *) self;
 176   struct gdbarch *gdbarch = iter_obj->gdbarch;
 177
 178   struct reggroup *next_group = reggroup_next (gdbarch, iter_obj->reggroup);
 179   if (next_group == NULL)
 180     {
 181       PyErr_SetString (PyExc_StopIteration, _("No more groups"));
 182       return NULL;
 183     }
 184
 185   iter_obj->reggroup = next_group;
 186   return gdbpy_new_reggroup (iter_obj->reggroup);
 187 }
 188
 189 /* Return a new gdb.RegisterGroupsIterator over all the register groups in
 190    GDBARCH.  */
 191
 192 PyObject *
 193 gdbpy_new_reggroup_iterator (struct gdbarch *gdbarch)
 194 {
 195   gdb_assert (gdbarch != nullptr);
 196
 197   /* Create a new object and fill in its internal state.  */
 198   reggroup_iterator_object *iter
 199     = PyObject_New (reggroup_iterator_object,
 200                     &reggroup_iterator_object_type);
 201   if (iter == NULL)
 202     return NULL;
 203   iter->reggroup = NULL;
 204   iter->gdbarch = gdbarch;
 205   return (PyObject *) iter;
 206 }
 207
 208 /* Create and return a new gdb.RegisterDescriptorIterator object which
 209    will iterate over all registers in GROUP_NAME for GDBARCH.  If
 210    GROUP_NAME is either NULL or the empty string then the ALL_REGGROUP is
 211    used, otherwise lookup the register group matching GROUP_NAME and use
 212    that.
 213
 214    This function can return NULL if GROUP_NAME isn't found.  */
 215
 216 PyObject *
 217 gdbpy_new_register_descriptor_iterator (struct gdbarch *gdbarch,
 218                                         const char *group_name)
 219 {
 220   struct reggroup *grp = NULL;
 221
 222   /* Lookup the requested register group, or find the default.  */
 223   if (group_name == NULL || *group_name == '\0')
 224     grp = all_reggroup;
 225   else
 226     {
 227       grp = reggroup_find (gdbarch, group_name);
 228       if (grp == NULL)
 229         {
 230           PyErr_SetString (PyExc_ValueError,
 231                            _("Unknown register group name."));
 232           return NULL;
 233         }
 234     }
 235   /* Create a new iterator object initialised for this architecture and
 236      fill in all of the details.  */
 237   register_descriptor_iterator_object *iter
 238     = PyObject_New (register_descriptor_iterator_object,
 239                     &register_descriptor_iterator_object_type);
 240   if (iter == NULL)
 241     return NULL;
 242   iter->regnum = 0;
 243   iter->gdbarch = gdbarch;
 244   gdb_assert (grp != NULL);
 245   iter->reggroup = grp;
 246
 247   return (PyObject *) iter;
 248 }
 249
 250 /* Return a reference to the gdb.RegisterDescriptorIterator object.  */
 251
 252 static PyObject *
 253 gdbpy_register_descriptor_iter (PyObject *self)
 254 {
 255   Py_INCREF (self);
 256   return self;
 257 }
 258
 259 /* Return the next register name.  */
 260
 261 static PyObject *
 262 gdbpy_register_descriptor_iter_next (PyObject *self)
 263 {
 264   register_descriptor_iterator_object *iter_obj
 265     = (register_descriptor_iterator_object *) self;
 266   struct gdbarch *gdbarch = iter_obj->gdbarch;
 267
 268   do
 269     {
 270       if (iter_obj->regnum >= gdbarch_num_cooked_regs (gdbarch))
 271         {
 272           PyErr_SetString (PyExc_StopIteration, _("No more registers"));
 273           return NULL;
 274         }
 275
 276       const char *name = nullptr;
 277       int regnum = iter_obj->regnum;
 278       if (gdbarch_register_reggroup_p (gdbarch, regnum,
 279                                        iter_obj->reggroup))
 280         name = gdbarch_register_name (gdbarch, regnum);
 281       iter_obj->regnum++;
 282
 283       if (name != nullptr && *name != '\0')
 284         return gdbpy_new_register_descriptor (gdbarch, regnum);
 285     }
 286   while (true);
 287 }
 288
 289 /* Initializes the new Python classes from this file in the gdb module.  */
 290
 291 int
 292 gdbpy_initialize_registers ()
 293 {
 294   register_descriptor_object_type.tp_new = PyType_GenericNew;
 295   if (PyType_Ready (&register_descriptor_object_type) < 0)
 296     return -1;
 297   if (gdb_pymodule_addobject
 298       (gdb_module, "RegisterDescriptor",
 299        (PyObject *) &register_descriptor_object_type) < 0)
 300     return -1;
 301
 302   reggroup_iterator_object_type.tp_new = PyType_GenericNew;
 303   if (PyType_Ready (&reggroup_iterator_object_type) < 0)
 304     return -1;
 305   if (gdb_pymodule_addobject
 306       (gdb_module, "RegisterGroupsIterator",
 307        (PyObject *) &reggroup_iterator_object_type) < 0)
 308     return -1;
 309
 310   reggroup_object_type.tp_new = PyType_GenericNew;
 311   if (PyType_Ready (&reggroup_object_type) < 0)
 312     return -1;
 313   if (gdb_pymodule_addobject
 314       (gdb_module, "RegisterGroup",
 315        (PyObject *) &reggroup_object_type) < 0)
 316     return -1;
 317
 318   register_descriptor_iterator_object_type.tp_new = PyType_GenericNew;
 319   if (PyType_Ready (&register_descriptor_iterator_object_type) < 0)
 320     return -1;
 321   return (gdb_pymodule_addobject
 322           (gdb_module, "RegisterDescriptorIterator",
 323            (PyObject *) &register_descriptor_iterator_object_type));
 324 }
 325
 326 PyTypeObject register_descriptor_iterator_object_type = {
 327   PyVarObject_HEAD_INIT (NULL, 0)
 328   "gdb.RegisterDescriptorIterator",             /*tp_name*/
 329   sizeof (register_descriptor_iterator_object), /*tp_basicsize*/
 330   0,                              /*tp_itemsize*/
 331   0,                              /*tp_dealloc*/
 332   0,                              /*tp_print*/
 333   0,                              /*tp_getattr*/
 334   0,                              /*tp_setattr*/
 335   0,                              /*tp_compare*/
 336   0,                              /*tp_repr*/
 337   0,                              /*tp_as_number*/
 338   0,                              /*tp_as_sequence*/
 339   0,                              /*tp_as_mapping*/
 340   0,                              /*tp_hash */
 341   0,                              /*tp_call*/
 342   0,                              /*tp_str*/
 343   0,                              /*tp_getattro*/
 344   0,                              /*tp_setattro*/
 345   0,                              /*tp_as_buffer*/
 346   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,                    /*tp_flags*/
 347   "GDB architecture register descriptor iterator object",       /*tp_doc */
 348   0,                              /*tp_traverse */
 349   0,                              /*tp_clear */
 350   0,                              /*tp_richcompare */
 351   0,                              /*tp_weaklistoffset */
 352   gdbpy_register_descriptor_iter,         /*tp_iter */
 353   gdbpy_register_descriptor_iter_next,  /*tp_iternext */
 354   0                               /*tp_methods */
 355 };
 356
 357 static gdb_PyGetSetDef gdbpy_register_descriptor_getset[] = {
 358   { "name", gdbpy_register_descriptor_name, NULL,
 359     "The name of this register.", NULL },
 360   { NULL }  /* Sentinel */
 361 };
 362
 363 PyTypeObject register_descriptor_object_type = {
 364   PyVarObject_HEAD_INIT (NULL, 0)
 365   "gdb.RegisterDescriptor",       /*tp_name*/
 366   sizeof (register_descriptor_object),  /*tp_basicsize*/
 367   0,                              /*tp_itemsize*/
 368   0,                              /*tp_dealloc*/
 369   0,                              /*tp_print*/
 370   0,                              /*tp_getattr*/
 371   0,                              /*tp_setattr*/
 372   0,                              /*tp_compare*/
 373   0,                              /*tp_repr*/
 374   0,                              /*tp_as_number*/
 375   0,                              /*tp_as_sequence*/
 376   0,                              /*tp_as_mapping*/
 377   0,                              /*tp_hash */
 378   0,                              /*tp_call*/
 379   gdbpy_register_descriptor_to_string,                  /*tp_str*/
 380   0,                              /*tp_getattro*/
 381   0,                              /*tp_setattro*/
 382   0,                              /*tp_as_buffer*/
 383   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 384   "GDB architecture register descriptor object",        /*tp_doc */
 385   0,                              /*tp_traverse */
 386   0,                              /*tp_clear */
 387   0,                              /*tp_richcompare */
 388   0,                              /*tp_weaklistoffset */
 389   0,                              /*tp_iter */
 390   0,                              /*tp_iternext */
 391   0,                              /*tp_methods */
 392   0,                              /*tp_members */
 393   gdbpy_register_descriptor_getset                      /*tp_getset */
 394 };
 395
 396 PyTypeObject reggroup_iterator_object_type = {
 397   PyVarObject_HEAD_INIT (NULL, 0)
 398   "gdb.RegisterGroupsIterator",   /*tp_name*/
 399   sizeof (reggroup_iterator_object),            /*tp_basicsize*/
 400   0,                              /*tp_itemsize*/
 401   0,                              /*tp_dealloc*/
 402   0,                              /*tp_print*/
 403   0,                              /*tp_getattr*/
 404   0,                              /*tp_setattr*/
 405   0,                              /*tp_compare*/
 406   0,                              /*tp_repr*/
 407   0,                              /*tp_as_number*/
 408   0,                              /*tp_as_sequence*/
 409   0,                              /*tp_as_mapping*/
 410   0,                              /*tp_hash */
 411   0,                              /*tp_call*/
 412   0,                              /*tp_str*/
 413   0,                              /*tp_getattro*/
 414   0,                              /*tp_setattro*/
 415   0,                              /*tp_as_buffer*/
 416   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,    /*tp_flags*/
 417   "GDB register groups iterator object",        /*tp_doc */
 418   0,                              /*tp_traverse */
 419   0,                              /*tp_clear */
 420   0,                              /*tp_richcompare */
 421   0,                              /*tp_weaklistoffset */
 422   gdbpy_reggroup_iter,            /*tp_iter */
 423   gdbpy_reggroup_iter_next,       /*tp_iternext */
 424   0                               /*tp_methods */
 425 };
 426
 427 static gdb_PyGetSetDef gdbpy_reggroup_getset[] = {
 428   { "name", gdbpy_reggroup_name, NULL,
 429     "The name of this register group.", NULL },
 430   { NULL }  /* Sentinel */
 431 };
 432
 433 PyTypeObject reggroup_object_type = {
 434   PyVarObject_HEAD_INIT (NULL, 0)
 435   "gdb.RegisterGroup",            /*tp_name*/
 436   sizeof (reggroup_object),       /*tp_basicsize*/
 437   0,                              /*tp_itemsize*/
 438   0,                              /*tp_dealloc*/
 439   0,                              /*tp_print*/
 440   0,                              /*tp_getattr*/
 441   0,                              /*tp_setattr*/
 442   0,                              /*tp_compare*/
 443   0,                              /*tp_repr*/
 444   0,                              /*tp_as_number*/
 445   0,                              /*tp_as_sequence*/
 446   0,                              /*tp_as_mapping*/
 447   0,                              /*tp_hash */
 448   0,                              /*tp_call*/
 449   gdbpy_reggroup_to_string,       /*tp_str*/
 450   0,                              /*tp_getattro*/
 451   0,                              /*tp_setattro*/
 452   0,                              /*tp_as_buffer*/
 453   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 454   "GDB register group object",    /*tp_doc */
 455   0,                              /*tp_traverse */
 456   0,                              /*tp_clear */
 457   0,                              /*tp_richcompare */
 458   0,                              /*tp_weaklistoffset */
 459   0,                              /*tp_iter */
 460   0,                              /*tp_iternext */
 461   0,                              /*tp_methods */
 462   0,                              /*tp_members */
 463   gdbpy_reggroup_getset           /*tp_getset */
 464 };