gdb/python/py-registers.c

   1 /* Python interface to register, and register group information.
   2
   3    Copyright (C) 2020-2021 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 struct register_descriptor_iterator_object {
  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 };
  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 struct register_descriptor_object {
  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 };
  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 struct reggroup_iterator_object {
  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 };
  74
  75 extern PyTypeObject reggroup_iterator_object_type
  76     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_iterator_object");
  77
  78 /* A register group object.  */
  79 struct reggroup_object {
  80   PyObject_HEAD
  81
  82   /* The register group being described.  */
  83   struct reggroup *reggroup;
  84 };
  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 /* See python-internal.h.  */
 374
 375 bool
 376 gdbpy_parse_register_id (struct gdbarch *gdbarch, PyObject *pyo_reg_id,
 377                          int *reg_num)
 378 {
 379   gdb_assert (pyo_reg_id != NULL);
 380
 381   /* The register could be a string, its name.  */
 382   if (gdbpy_is_string (pyo_reg_id))
 383     {
 384       gdb::unique_xmalloc_ptr<char> reg_name (gdbpy_obj_to_string (pyo_reg_id));
 385
 386       if (reg_name != NULL)
 387         {
 388           *reg_num = user_reg_map_name_to_regnum (gdbarch, reg_name.get (),
 389                                                   strlen (reg_name.get ()));
 390           return *reg_num >= 0;
 391         }
 392     }
 393   /* The register could be its internal GDB register number.  */
 394   else if (PyInt_Check (pyo_reg_id))
 395     {
 396       long value;
 397       if (gdb_py_int_as_long (pyo_reg_id, &value) && (int) value == value)
 398         {
 399           if (user_reg_map_regnum_to_name (gdbarch, value) != NULL)
 400             {
 401               *reg_num = (int) value;
 402               return true;
 403             }
 404         }
 405     }
 406   /* The register could be a gdb.RegisterDescriptor object.  */
 407   else if (PyObject_IsInstance (pyo_reg_id,
 408                            (PyObject *) &register_descriptor_object_type))
 409     {
 410       register_descriptor_object *reg
 411         = (register_descriptor_object *) pyo_reg_id;
 412       if (reg->gdbarch == gdbarch)
 413         {
 414           *reg_num = reg->regnum;
 415           return true;
 416         }
 417       else
 418         PyErr_SetString (PyExc_ValueError,
 419                          _("Invalid Architecture in RegisterDescriptor"));
 420     }
 421
 422   gdb_assert (PyErr_Occurred ());
 423   return false;
 424 }
 425
 426 void _initialize_py_registers ();
 427 void
 428 _initialize_py_registers ()
 429 {
 430   gdbpy_register_object_data
 431     = gdbarch_data_register_post_init (gdbpy_register_object_data_init);
 432 }
 433
 434 /* Initializes the new Python classes from this file in the gdb module.  */
 435
 436 int
 437 gdbpy_initialize_registers ()
 438 {
 439   register_descriptor_object_type.tp_new = PyType_GenericNew;
 440   if (PyType_Ready (&register_descriptor_object_type) < 0)
 441     return -1;
 442   if (gdb_pymodule_addobject
 443       (gdb_module, "RegisterDescriptor",
 444        (PyObject *) &register_descriptor_object_type) < 0)
 445     return -1;
 446
 447   reggroup_iterator_object_type.tp_new = PyType_GenericNew;
 448   if (PyType_Ready (&reggroup_iterator_object_type) < 0)
 449     return -1;
 450   if (gdb_pymodule_addobject
 451       (gdb_module, "RegisterGroupsIterator",
 452        (PyObject *) &reggroup_iterator_object_type) < 0)
 453     return -1;
 454
 455   reggroup_object_type.tp_new = PyType_GenericNew;
 456   if (PyType_Ready (&reggroup_object_type) < 0)
 457     return -1;
 458   if (gdb_pymodule_addobject
 459       (gdb_module, "RegisterGroup",
 460        (PyObject *) &reggroup_object_type) < 0)
 461     return -1;
 462
 463   register_descriptor_iterator_object_type.tp_new = PyType_GenericNew;
 464   if (PyType_Ready (&register_descriptor_iterator_object_type) < 0)
 465     return -1;
 466   return (gdb_pymodule_addobject
 467           (gdb_module, "RegisterDescriptorIterator",
 468            (PyObject *) &register_descriptor_iterator_object_type));
 469 }
 470
 471 static PyMethodDef register_descriptor_iterator_object_methods [] = {
 472   { "find", (PyCFunction) register_descriptor_iter_find,
 473     METH_VARARGS | METH_KEYWORDS,
 474     "registers (name) -> gdb.RegisterDescriptor.\n\
 475 Return a register descriptor for the register NAME, or None if no register\n\
 476 with that name exists in this iterator." },
 477   {NULL}  /* Sentinel */
 478 };
 479
 480 PyTypeObject register_descriptor_iterator_object_type = {
 481   PyVarObject_HEAD_INIT (NULL, 0)
 482   "gdb.RegisterDescriptorIterator",             /*tp_name*/
 483   sizeof (register_descriptor_iterator_object), /*tp_basicsize*/
 484   0,                              /*tp_itemsize*/
 485   0,                              /*tp_dealloc*/
 486   0,                              /*tp_print*/
 487   0,                              /*tp_getattr*/
 488   0,                              /*tp_setattr*/
 489   0,                              /*tp_compare*/
 490   0,                              /*tp_repr*/
 491   0,                              /*tp_as_number*/
 492   0,                              /*tp_as_sequence*/
 493   0,                              /*tp_as_mapping*/
 494   0,                              /*tp_hash */
 495   0,                              /*tp_call*/
 496   0,                              /*tp_str*/
 497   0,                              /*tp_getattro*/
 498   0,                              /*tp_setattro*/
 499   0,                              /*tp_as_buffer*/
 500   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,                    /*tp_flags*/
 501   "GDB architecture register descriptor iterator object",       /*tp_doc */
 502   0,                              /*tp_traverse */
 503   0,                              /*tp_clear */
 504   0,                              /*tp_richcompare */
 505   0,                              /*tp_weaklistoffset */
 506   gdbpy_register_descriptor_iter,         /*tp_iter */
 507   gdbpy_register_descriptor_iter_next,  /*tp_iternext */
 508   register_descriptor_iterator_object_methods           /*tp_methods */
 509 };
 510
 511 static gdb_PyGetSetDef gdbpy_register_descriptor_getset[] = {
 512   { "name", gdbpy_register_descriptor_name, NULL,
 513     "The name of this register.", NULL },
 514   { NULL }  /* Sentinel */
 515 };
 516
 517 PyTypeObject register_descriptor_object_type = {
 518   PyVarObject_HEAD_INIT (NULL, 0)
 519   "gdb.RegisterDescriptor",       /*tp_name*/
 520   sizeof (register_descriptor_object),  /*tp_basicsize*/
 521   0,                              /*tp_itemsize*/
 522   0,                              /*tp_dealloc*/
 523   0,                              /*tp_print*/
 524   0,                              /*tp_getattr*/
 525   0,                              /*tp_setattr*/
 526   0,                              /*tp_compare*/
 527   0,                              /*tp_repr*/
 528   0,                              /*tp_as_number*/
 529   0,                              /*tp_as_sequence*/
 530   0,                              /*tp_as_mapping*/
 531   0,                              /*tp_hash */
 532   0,                              /*tp_call*/
 533   gdbpy_register_descriptor_to_string,                  /*tp_str*/
 534   0,                              /*tp_getattro*/
 535   0,                              /*tp_setattro*/
 536   0,                              /*tp_as_buffer*/
 537   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 538   "GDB architecture register descriptor object",        /*tp_doc */
 539   0,                              /*tp_traverse */
 540   0,                              /*tp_clear */
 541   0,                              /*tp_richcompare */
 542   0,                              /*tp_weaklistoffset */
 543   0,                              /*tp_iter */
 544   0,                              /*tp_iternext */
 545   0,                              /*tp_methods */
 546   0,                              /*tp_members */
 547   gdbpy_register_descriptor_getset                      /*tp_getset */
 548 };
 549
 550 PyTypeObject reggroup_iterator_object_type = {
 551   PyVarObject_HEAD_INIT (NULL, 0)
 552   "gdb.RegisterGroupsIterator",   /*tp_name*/
 553   sizeof (reggroup_iterator_object),            /*tp_basicsize*/
 554   0,                              /*tp_itemsize*/
 555   0,                              /*tp_dealloc*/
 556   0,                              /*tp_print*/
 557   0,                              /*tp_getattr*/
 558   0,                              /*tp_setattr*/
 559   0,                              /*tp_compare*/
 560   0,                              /*tp_repr*/
 561   0,                              /*tp_as_number*/
 562   0,                              /*tp_as_sequence*/
 563   0,                              /*tp_as_mapping*/
 564   0,                              /*tp_hash */
 565   0,                              /*tp_call*/
 566   0,                              /*tp_str*/
 567   0,                              /*tp_getattro*/
 568   0,                              /*tp_setattro*/
 569   0,                              /*tp_as_buffer*/
 570   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,    /*tp_flags*/
 571   "GDB register groups iterator object",        /*tp_doc */
 572   0,                              /*tp_traverse */
 573   0,                              /*tp_clear */
 574   0,                              /*tp_richcompare */
 575   0,                              /*tp_weaklistoffset */
 576   gdbpy_reggroup_iter,            /*tp_iter */
 577   gdbpy_reggroup_iter_next,       /*tp_iternext */
 578   0                               /*tp_methods */
 579 };
 580
 581 static gdb_PyGetSetDef gdbpy_reggroup_getset[] = {
 582   { "name", gdbpy_reggroup_name, NULL,
 583     "The name of this register group.", NULL },
 584   { NULL }  /* Sentinel */
 585 };
 586
 587 PyTypeObject reggroup_object_type = {
 588   PyVarObject_HEAD_INIT (NULL, 0)
 589   "gdb.RegisterGroup",            /*tp_name*/
 590   sizeof (reggroup_object),       /*tp_basicsize*/
 591   0,                              /*tp_itemsize*/
 592   0,                              /*tp_dealloc*/
 593   0,                              /*tp_print*/
 594   0,                              /*tp_getattr*/
 595   0,                              /*tp_setattr*/
 596   0,                              /*tp_compare*/
 597   0,                              /*tp_repr*/
 598   0,                              /*tp_as_number*/
 599   0,                              /*tp_as_sequence*/
 600   0,                              /*tp_as_mapping*/
 601   0,                              /*tp_hash */
 602   0,                              /*tp_call*/
 603   gdbpy_reggroup_to_string,       /*tp_str*/
 604   0,                              /*tp_getattro*/
 605   0,                              /*tp_setattro*/
 606   0,                              /*tp_as_buffer*/
 607   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 608   "GDB register group object",    /*tp_doc */
 609   0,                              /*tp_traverse */
 610   0,                              /*tp_clear */
 611   0,                              /*tp_richcompare */
 612   0,                              /*tp_weaklistoffset */
 613   0,                              /*tp_iter */
 614   0,                              /*tp_iternext */
 615   0,                              /*tp_methods */
 616   0,                              /*tp_members */
 617   gdbpy_reggroup_getset           /*tp_getset */
 618 };