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 #include "user-regs.h"
  27 #include <unordered_map>
  28
  29 /* Token to access per-gdbarch data related to register descriptors.  */
  30 static struct gdbarch_data *gdbpy_register_object_data = NULL;
  31
  32 /* Structure for iterator over register descriptors.  */
  33 typedef struct {
  34   PyObject_HEAD
  35
  36   /* The register group that the user is iterating over.  This will never
  37      be NULL.  */
  38   struct reggroup *reggroup;
  39
  40   /* The next register number to lookup.  Starts at 0 and counts up.  */
  41   int regnum;
  42
  43   /* Pointer back to the architecture we're finding registers for.  */
  44   struct gdbarch *gdbarch;
  45 } register_descriptor_iterator_object;
  46
  47 extern PyTypeObject register_descriptor_iterator_object_type
  48     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_iterator_object");
  49
  50 /* A register descriptor.  */
  51 typedef struct {
  52   PyObject_HEAD
  53
  54   /* The register this is a descriptor for.  */
  55   int regnum;
  56
  57   /* The architecture this is a register for.  */
  58   struct gdbarch *gdbarch;
  59 } register_descriptor_object;
  60
  61 extern PyTypeObject register_descriptor_object_type
  62     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_object");
  63
  64 /* Structure for iterator over register groups.  */
  65 typedef struct {
  66   PyObject_HEAD
  67
  68   /* The last register group returned.  Initially this will be NULL.  */
  69   struct reggroup *reggroup;
  70
  71   /* Pointer back to the architecture we're finding registers for.  */
  72   struct gdbarch *gdbarch;
  73 } reggroup_iterator_object;
  74
  75 extern PyTypeObject reggroup_iterator_object_type
  76     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_iterator_object");
  77
  78 /* A register group object.  */
  79 typedef struct {
  80   PyObject_HEAD
  81
  82   /* The register group being described.  */
  83   struct reggroup *reggroup;
  84 } reggroup_object;
  85
  86 extern PyTypeObject reggroup_object_type
  87     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_object");
  88
  89 /* Associates a vector of gdb.RegisterDescriptor objects with GDBARCH as
  90    gdbarch_data via the gdbarch post init registration mechanism
  91    (gdbarch_data_register_post_init).  */
  92
  93 static void *
  94 gdbpy_register_object_data_init (struct gdbarch *gdbarch)
  95 {
  96   return new std::vector<gdbpy_ref<>>;
  97 }
  98
  99 /* Return a gdb.RegisterGroup object wrapping REGGROUP.  The register
 100    group objects are cached, and the same Python object will always be
 101    returned for the same REGGROUP pointer.  */
 102
 103 static gdbpy_ref<>
 104 gdbpy_get_reggroup (struct reggroup *reggroup)
 105 {
 106   /* Map from GDB's internal reggroup objects to the Python representation.
 107      GDB's reggroups are global, and are never deleted, so using a map like
 108      this is safe.  */
 109   static std::unordered_map<struct reggroup *,gdbpy_ref<>>
 110     gdbpy_reggroup_object_map;
 111
 112   /* If there is not already a suitable Python object in the map then
 113      create a new one, and add it to the map.  */
 114   if (gdbpy_reggroup_object_map[reggroup] == nullptr)
 115     {
 116       /* Create a new object and fill in its details.  */
 117       gdbpy_ref<reggroup_object> group
 118         (PyObject_New (reggroup_object, &reggroup_object_type));
 119       if (group == NULL)
 120         return NULL;
 121       group->reggroup = reggroup;
 122       gdbpy_reggroup_object_map[reggroup]
 123         = gdbpy_ref<> ((PyObject *) group.release ());
 124     }
 125
 126   /* Fetch the Python object wrapping REGGROUP from the map, increasing
 127      the reference count is handled by the gdbpy_ref class.  */
 128   return gdbpy_reggroup_object_map[reggroup];
 129 }
 130
 131 /* Convert a gdb.RegisterGroup to a string, it just returns the name of
 132    the register group.  */
 133
 134 static PyObject *
 135 gdbpy_reggroup_to_string (PyObject *self)
 136 {
 137   reggroup_object *group = (reggroup_object *) self;
 138   struct reggroup *reggroup = group->reggroup;
 139
 140   const char *name = reggroup_name (reggroup);
 141   return PyString_FromString (name);
 142 }
 143
 144 /* Implement gdb.RegisterGroup.name (self) -> String.
 145    Return a string that is the name of this register group.  */
 146
 147 static PyObject *
 148 gdbpy_reggroup_name (PyObject *self, void *closure)
 149 {
 150   return gdbpy_reggroup_to_string (self);
 151 }
 152
 153 /* Return a gdb.RegisterDescriptor object for REGNUM from GDBARCH.  For
 154    each REGNUM (in GDBARCH) only one descriptor is ever created, which is
 155    then cached on the GDBARCH.  */
 156
 157 static gdbpy_ref<>
 158 gdbpy_get_register_descriptor (struct gdbarch *gdbarch,
 159                                int regnum)
 160 {
 161   auto &vec
 162     = *(std::vector<gdbpy_ref<>> *) gdbarch_data (gdbarch,
 163                                                   gdbpy_register_object_data);
 164
 165   /* Ensure that we have enough entries in the vector.  */
 166   if (vec.size () <= regnum)
 167     vec.resize ((regnum + 1), nullptr);
 168
 169   /* If we don't already have a descriptor for REGNUM in GDBARCH then
 170      create one now.  */
 171   if (vec[regnum] == nullptr)
 172     {
 173       gdbpy_ref <register_descriptor_object> reg
 174         (PyObject_New (register_descriptor_object,
 175                        &register_descriptor_object_type));
 176       if (reg == NULL)
 177         return NULL;
 178       reg->regnum = regnum;
 179       reg->gdbarch = gdbarch;
 180       vec[regnum] = gdbpy_ref<> ((PyObject *) reg.release ());
 181     }
 182
 183   /* Grab the register descriptor from the vector, the reference count is
 184      automatically incremented thanks to gdbpy_ref.  */
 185   return vec[regnum];
 186 }
 187
 188 /* Convert the register descriptor to a string.  */
 189
 190 static PyObject *
 191 gdbpy_register_descriptor_to_string (PyObject *self)
 192 {
 193   register_descriptor_object *reg
 194     = (register_descriptor_object *) self;
 195   struct gdbarch *gdbarch = reg->gdbarch;
 196   int regnum = reg->regnum;
 197
 198   const char *name = gdbarch_register_name (gdbarch, regnum);
 199   return PyString_FromString (name);
 200 }
 201
 202 /* Implement gdb.RegisterDescriptor.name attribute get function.  Return a
 203    string that is the name of this register.  Due to checking when register
 204    descriptors are created the name will never by the empty string.  */
 205
 206 static PyObject *
 207 gdbpy_register_descriptor_name (PyObject *self, void *closure)
 208 {
 209   return gdbpy_register_descriptor_to_string (self);
 210 }
 211
 212 /* Return a reference to the gdb.RegisterGroupsIterator object.  */
 213
 214 static PyObject *
 215 gdbpy_reggroup_iter (PyObject *self)
 216 {
 217   Py_INCREF (self);
 218   return self;
 219 }
 220
 221 /* Return the next gdb.RegisterGroup object from the iterator.  */
 222
 223 static PyObject *
 224 gdbpy_reggroup_iter_next (PyObject *self)
 225 {
 226   reggroup_iterator_object *iter_obj
 227     = (reggroup_iterator_object *) self;
 228   struct gdbarch *gdbarch = iter_obj->gdbarch;
 229
 230   struct reggroup *next_group = reggroup_next (gdbarch, iter_obj->reggroup);
 231   if (next_group == NULL)
 232     {
 233       PyErr_SetString (PyExc_StopIteration, _("No more groups"));
 234       return NULL;
 235     }
 236
 237   iter_obj->reggroup = next_group;
 238   return gdbpy_get_reggroup (iter_obj->reggroup).release ();
 239 }
 240
 241 /* Return a new gdb.RegisterGroupsIterator over all the register groups in
 242    GDBARCH.  */
 243
 244 PyObject *
 245 gdbpy_new_reggroup_iterator (struct gdbarch *gdbarch)
 246 {
 247   gdb_assert (gdbarch != nullptr);
 248
 249   /* Create a new object and fill in its internal state.  */
 250   reggroup_iterator_object *iter
 251     = PyObject_New (reggroup_iterator_object,
 252                     &reggroup_iterator_object_type);
 253   if (iter == NULL)
 254     return NULL;
 255   iter->reggroup = NULL;
 256   iter->gdbarch = gdbarch;
 257   return (PyObject *) iter;
 258 }
 259
 260 /* Create and return a new gdb.RegisterDescriptorIterator object which
 261    will iterate over all registers in GROUP_NAME for GDBARCH.  If
 262    GROUP_NAME is either NULL or the empty string then the ALL_REGGROUP is
 263    used, otherwise lookup the register group matching GROUP_NAME and use
 264    that.
 265
 266    This function can return NULL if GROUP_NAME isn't found.  */
 267
 268 PyObject *
 269 gdbpy_new_register_descriptor_iterator (struct gdbarch *gdbarch,
 270                                         const char *group_name)
 271 {
 272   struct reggroup *grp = NULL;
 273
 274   /* Lookup the requested register group, or find the default.  */
 275   if (group_name == NULL || *group_name == '\0')
 276     grp = all_reggroup;
 277   else
 278     {
 279       grp = reggroup_find (gdbarch, group_name);
 280       if (grp == NULL)
 281         {
 282           PyErr_SetString (PyExc_ValueError,
 283                            _("Unknown register group name."));
 284           return NULL;
 285         }
 286     }
 287   /* Create a new iterator object initialised for this architecture and
 288      fill in all of the details.  */
 289   register_descriptor_iterator_object *iter
 290     = PyObject_New (register_descriptor_iterator_object,
 291                     &register_descriptor_iterator_object_type);
 292   if (iter == NULL)
 293     return NULL;
 294   iter->regnum = 0;
 295   iter->gdbarch = gdbarch;
 296   gdb_assert (grp != NULL);
 297   iter->reggroup = grp;
 298
 299   return (PyObject *) iter;
 300 }
 301
 302 /* Return a reference to the gdb.RegisterDescriptorIterator object.  */
 303
 304 static PyObject *
 305 gdbpy_register_descriptor_iter (PyObject *self)
 306 {
 307   Py_INCREF (self);
 308   return self;
 309 }
 310
 311 /* Return the next register name.  */
 312
 313 static PyObject *
 314 gdbpy_register_descriptor_iter_next (PyObject *self)
 315 {
 316   register_descriptor_iterator_object *iter_obj
 317     = (register_descriptor_iterator_object *) self;
 318   struct gdbarch *gdbarch = iter_obj->gdbarch;
 319
 320   do
 321     {
 322       if (iter_obj->regnum >= gdbarch_num_cooked_regs (gdbarch))
 323         {
 324           PyErr_SetString (PyExc_StopIteration, _("No more registers"));
 325           return NULL;
 326         }
 327
 328       const char *name = nullptr;
 329       int regnum = iter_obj->regnum;
 330       if (gdbarch_register_reggroup_p (gdbarch, regnum,
 331                                        iter_obj->reggroup))
 332         name = gdbarch_register_name (gdbarch, regnum);
 333       iter_obj->regnum++;
 334
 335       if (name != nullptr && *name != '\0')
 336         return gdbpy_get_register_descriptor (gdbarch, regnum).release ();
 337     }
 338   while (true);
 339 }
 340
 341 /* Implement:
 342
 343    gdb.RegisterDescriptorIterator.find (self, name) -> gdb.RegisterDescriptor
 344
 345    Look up a descriptor for register with NAME.  If no matching register is
 346    found then return None.  */
 347
 348 static PyObject *
 349 register_descriptor_iter_find (PyObject *self, PyObject *args, PyObject *kw)
 350 {
 351   static const char *keywords[] = { "name", NULL };
 352   const char *register_name = NULL;
 353
 354   register_descriptor_iterator_object *iter_obj
 355     = (register_descriptor_iterator_object *) self;
 356   struct gdbarch *gdbarch = iter_obj->gdbarch;
 357
 358   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s", keywords,
 359                                         &register_name))
 360     return NULL;
 361
 362   if (register_name != NULL && *register_name != '\0')
 363     {
 364       int regnum = user_reg_map_name_to_regnum (gdbarch, register_name,
 365                                                 strlen (register_name));
 366       if (regnum >= 0)
 367         return gdbpy_get_register_descriptor (gdbarch, regnum).release ();
 368     }
 369
 370   Py_RETURN_NONE;
 371 }
 372
 373 /* Initializes the new Python classes from this file in the gdb module.  */
 374
 375 int
 376 gdbpy_initialize_registers ()
 377 {
 378   gdbpy_register_object_data
 379     = gdbarch_data_register_post_init (gdbpy_register_object_data_init);
 380
 381   register_descriptor_object_type.tp_new = PyType_GenericNew;
 382   if (PyType_Ready (&register_descriptor_object_type) < 0)
 383     return -1;
 384   if (gdb_pymodule_addobject
 385       (gdb_module, "RegisterDescriptor",
 386        (PyObject *) &register_descriptor_object_type) < 0)
 387     return -1;
 388
 389   reggroup_iterator_object_type.tp_new = PyType_GenericNew;
 390   if (PyType_Ready (&reggroup_iterator_object_type) < 0)
 391     return -1;
 392   if (gdb_pymodule_addobject
 393       (gdb_module, "RegisterGroupsIterator",
 394        (PyObject *) &reggroup_iterator_object_type) < 0)
 395     return -1;
 396
 397   reggroup_object_type.tp_new = PyType_GenericNew;
 398   if (PyType_Ready (&reggroup_object_type) < 0)
 399     return -1;
 400   if (gdb_pymodule_addobject
 401       (gdb_module, "RegisterGroup",
 402        (PyObject *) &reggroup_object_type) < 0)
 403     return -1;
 404
 405   register_descriptor_iterator_object_type.tp_new = PyType_GenericNew;
 406   if (PyType_Ready (&register_descriptor_iterator_object_type) < 0)
 407     return -1;
 408   return (gdb_pymodule_addobject
 409           (gdb_module, "RegisterDescriptorIterator",
 410            (PyObject *) &register_descriptor_iterator_object_type));
 411 }
 412
 413 static PyMethodDef register_descriptor_iterator_object_methods [] = {
 414   { "find", (PyCFunction) register_descriptor_iter_find,
 415     METH_VARARGS | METH_KEYWORDS,
 416     "registers (name) -> gdb.RegisterDescriptor.\n\
 417 Return a register descriptor for the register NAME, or None if no register\n\
 418 with that name exists in this iterator." },
 419   {NULL}  /* Sentinel */
 420 };
 421
 422 PyTypeObject register_descriptor_iterator_object_type = {
 423   PyVarObject_HEAD_INIT (NULL, 0)
 424   "gdb.RegisterDescriptorIterator",             /*tp_name*/
 425   sizeof (register_descriptor_iterator_object), /*tp_basicsize*/
 426   0,                              /*tp_itemsize*/
 427   0,                              /*tp_dealloc*/
 428   0,                              /*tp_print*/
 429   0,                              /*tp_getattr*/
 430   0,                              /*tp_setattr*/
 431   0,                              /*tp_compare*/
 432   0,                              /*tp_repr*/
 433   0,                              /*tp_as_number*/
 434   0,                              /*tp_as_sequence*/
 435   0,                              /*tp_as_mapping*/
 436   0,                              /*tp_hash */
 437   0,                              /*tp_call*/
 438   0,                              /*tp_str*/
 439   0,                              /*tp_getattro*/
 440   0,                              /*tp_setattro*/
 441   0,                              /*tp_as_buffer*/
 442   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,                    /*tp_flags*/
 443   "GDB architecture register descriptor iterator object",       /*tp_doc */
 444   0,                              /*tp_traverse */
 445   0,                              /*tp_clear */
 446   0,                              /*tp_richcompare */
 447   0,                              /*tp_weaklistoffset */
 448   gdbpy_register_descriptor_iter,         /*tp_iter */
 449   gdbpy_register_descriptor_iter_next,  /*tp_iternext */
 450   register_descriptor_iterator_object_methods           /*tp_methods */
 451 };
 452
 453 static gdb_PyGetSetDef gdbpy_register_descriptor_getset[] = {
 454   { "name", gdbpy_register_descriptor_name, NULL,
 455     "The name of this register.", NULL },
 456   { NULL }  /* Sentinel */
 457 };
 458
 459 PyTypeObject register_descriptor_object_type = {
 460   PyVarObject_HEAD_INIT (NULL, 0)
 461   "gdb.RegisterDescriptor",       /*tp_name*/
 462   sizeof (register_descriptor_object),  /*tp_basicsize*/
 463   0,                              /*tp_itemsize*/
 464   0,                              /*tp_dealloc*/
 465   0,                              /*tp_print*/
 466   0,                              /*tp_getattr*/
 467   0,                              /*tp_setattr*/
 468   0,                              /*tp_compare*/
 469   0,                              /*tp_repr*/
 470   0,                              /*tp_as_number*/
 471   0,                              /*tp_as_sequence*/
 472   0,                              /*tp_as_mapping*/
 473   0,                              /*tp_hash */
 474   0,                              /*tp_call*/
 475   gdbpy_register_descriptor_to_string,                  /*tp_str*/
 476   0,                              /*tp_getattro*/
 477   0,                              /*tp_setattro*/
 478   0,                              /*tp_as_buffer*/
 479   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 480   "GDB architecture register descriptor object",        /*tp_doc */
 481   0,                              /*tp_traverse */
 482   0,                              /*tp_clear */
 483   0,                              /*tp_richcompare */
 484   0,                              /*tp_weaklistoffset */
 485   0,                              /*tp_iter */
 486   0,                              /*tp_iternext */
 487   0,                              /*tp_methods */
 488   0,                              /*tp_members */
 489   gdbpy_register_descriptor_getset                      /*tp_getset */
 490 };
 491
 492 PyTypeObject reggroup_iterator_object_type = {
 493   PyVarObject_HEAD_INIT (NULL, 0)
 494   "gdb.RegisterGroupsIterator",   /*tp_name*/
 495   sizeof (reggroup_iterator_object),            /*tp_basicsize*/
 496   0,                              /*tp_itemsize*/
 497   0,                              /*tp_dealloc*/
 498   0,                              /*tp_print*/
 499   0,                              /*tp_getattr*/
 500   0,                              /*tp_setattr*/
 501   0,                              /*tp_compare*/
 502   0,                              /*tp_repr*/
 503   0,                              /*tp_as_number*/
 504   0,                              /*tp_as_sequence*/
 505   0,                              /*tp_as_mapping*/
 506   0,                              /*tp_hash */
 507   0,                              /*tp_call*/
 508   0,                              /*tp_str*/
 509   0,                              /*tp_getattro*/
 510   0,                              /*tp_setattro*/
 511   0,                              /*tp_as_buffer*/
 512   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,    /*tp_flags*/
 513   "GDB register groups iterator object",        /*tp_doc */
 514   0,                              /*tp_traverse */
 515   0,                              /*tp_clear */
 516   0,                              /*tp_richcompare */
 517   0,                              /*tp_weaklistoffset */
 518   gdbpy_reggroup_iter,            /*tp_iter */
 519   gdbpy_reggroup_iter_next,       /*tp_iternext */
 520   0                               /*tp_methods */
 521 };
 522
 523 static gdb_PyGetSetDef gdbpy_reggroup_getset[] = {
 524   { "name", gdbpy_reggroup_name, NULL,
 525     "The name of this register group.", NULL },
 526   { NULL }  /* Sentinel */
 527 };
 528
 529 PyTypeObject reggroup_object_type = {
 530   PyVarObject_HEAD_INIT (NULL, 0)
 531   "gdb.RegisterGroup",            /*tp_name*/
 532   sizeof (reggroup_object),       /*tp_basicsize*/
 533   0,                              /*tp_itemsize*/
 534   0,                              /*tp_dealloc*/
 535   0,                              /*tp_print*/
 536   0,                              /*tp_getattr*/
 537   0,                              /*tp_setattr*/
 538   0,                              /*tp_compare*/
 539   0,                              /*tp_repr*/
 540   0,                              /*tp_as_number*/
 541   0,                              /*tp_as_sequence*/
 542   0,                              /*tp_as_mapping*/
 543   0,                              /*tp_hash */
 544   0,                              /*tp_call*/
 545   gdbpy_reggroup_to_string,       /*tp_str*/
 546   0,                              /*tp_getattro*/
 547   0,                              /*tp_setattro*/
 548   0,                              /*tp_as_buffer*/
 549   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 550   "GDB register group object",    /*tp_doc */
 551   0,                              /*tp_traverse */
 552   0,                              /*tp_clear */
 553   0,                              /*tp_richcompare */
 554   0,                              /*tp_weaklistoffset */
 555   0,                              /*tp_iter */
 556   0,                              /*tp_iternext */
 557   0,                              /*tp_methods */
 558   0,                              /*tp_members */
 559   gdbpy_reggroup_getset           /*tp_getset */
 560 };