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. */ 30static struct gdbarch_data *gdbpy_register_object_data = NULL; 31 32/* Structure for iterator over register descriptors. */ 33typedef 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 47extern PyTypeObject register_descriptor_iterator_object_type 48 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_iterator_object"); 49 50/* A register descriptor. */ 51typedef 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 61extern PyTypeObject register_descriptor_object_type 62 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_object"); 63 64/* Structure for iterator over register groups. */ 65typedef 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 75extern PyTypeObject reggroup_iterator_object_type 76 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_iterator_object"); 77 78/* A register group object. */ 79typedef struct { 80 PyObject_HEAD 81 82 /* The register group being described. */ 83 struct reggroup *reggroup; 84} reggroup_object; 85 86extern 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 93static void * 94gdbpy_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 103static gdbpy_ref<> 104gdbpy_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, ®group_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 134static PyObject * 135gdbpy_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 147static PyObject * 148gdbpy_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 157static gdbpy_ref<> 158gdbpy_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 ®ister_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 190static PyObject * 191gdbpy_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 206static PyObject * 207gdbpy_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 214static PyObject * 215gdbpy_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 223static PyObject * 224gdbpy_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 244PyObject * 245gdbpy_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 ®group_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 268PyObject * 269gdbpy_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 ®ister_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 304static PyObject * 305gdbpy_register_descriptor_iter (PyObject *self) 306{ 307 Py_INCREF (self); 308 return self; 309} 310 311/* Return the next register name. */ 312 313static PyObject * 314gdbpy_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 348static PyObject * 349register_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 ®ister_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 375bool 376gdbpy_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 *) ®ister_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/* Initializes the new Python classes from this file in the gdb module. */ 427 428int 429gdbpy_initialize_registers () 430{ 431 gdbpy_register_object_data 432 = gdbarch_data_register_post_init (gdbpy_register_object_data_init); 433 434 register_descriptor_object_type.tp_new = PyType_GenericNew; 435 if (PyType_Ready (®ister_descriptor_object_type) < 0) 436 return -1; 437 if (gdb_pymodule_addobject 438 (gdb_module, "RegisterDescriptor", 439 (PyObject *) ®ister_descriptor_object_type) < 0) 440 return -1; 441 442 reggroup_iterator_object_type.tp_new = PyType_GenericNew; 443 if (PyType_Ready (®group_iterator_object_type) < 0) 444 return -1; 445 if (gdb_pymodule_addobject 446 (gdb_module, "RegisterGroupsIterator", 447 (PyObject *) ®group_iterator_object_type) < 0) 448 return -1; 449 450 reggroup_object_type.tp_new = PyType_GenericNew; 451 if (PyType_Ready (®group_object_type) < 0) 452 return -1; 453 if (gdb_pymodule_addobject 454 (gdb_module, "RegisterGroup", 455 (PyObject *) ®group_object_type) < 0) 456 return -1; 457 458 register_descriptor_iterator_object_type.tp_new = PyType_GenericNew; 459 if (PyType_Ready (®ister_descriptor_iterator_object_type) < 0) 460 return -1; 461 return (gdb_pymodule_addobject 462 (gdb_module, "RegisterDescriptorIterator", 463 (PyObject *) ®ister_descriptor_iterator_object_type)); 464} 465 466static PyMethodDef register_descriptor_iterator_object_methods [] = { 467 { "find", (PyCFunction) register_descriptor_iter_find, 468 METH_VARARGS | METH_KEYWORDS, 469 "registers (name) -> gdb.RegisterDescriptor.\n\ 470Return a register descriptor for the register NAME, or None if no register\n\ 471with that name exists in this iterator." }, 472 {NULL} /* Sentinel */ 473}; 474 475PyTypeObject register_descriptor_iterator_object_type = { 476 PyVarObject_HEAD_INIT (NULL, 0) 477 "gdb.RegisterDescriptorIterator", /*tp_name*/ 478 sizeof (register_descriptor_iterator_object), /*tp_basicsize*/ 479 0, /*tp_itemsize*/ 480 0, /*tp_dealloc*/ 481 0, /*tp_print*/ 482 0, /*tp_getattr*/ 483 0, /*tp_setattr*/ 484 0, /*tp_compare*/ 485 0, /*tp_repr*/ 486 0, /*tp_as_number*/ 487 0, /*tp_as_sequence*/ 488 0, /*tp_as_mapping*/ 489 0, /*tp_hash */ 490 0, /*tp_call*/ 491 0, /*tp_str*/ 492 0, /*tp_getattro*/ 493 0, /*tp_setattro*/ 494 0, /*tp_as_buffer*/ 495 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/ 496 "GDB architecture register descriptor iterator object", /*tp_doc */ 497 0, /*tp_traverse */ 498 0, /*tp_clear */ 499 0, /*tp_richcompare */ 500 0, /*tp_weaklistoffset */ 501 gdbpy_register_descriptor_iter, /*tp_iter */ 502 gdbpy_register_descriptor_iter_next, /*tp_iternext */ 503 register_descriptor_iterator_object_methods /*tp_methods */ 504}; 505 506static gdb_PyGetSetDef gdbpy_register_descriptor_getset[] = { 507 { "name", gdbpy_register_descriptor_name, NULL, 508 "The name of this register.", NULL }, 509 { NULL } /* Sentinel */ 510}; 511 512PyTypeObject register_descriptor_object_type = { 513 PyVarObject_HEAD_INIT (NULL, 0) 514 "gdb.RegisterDescriptor", /*tp_name*/ 515 sizeof (register_descriptor_object), /*tp_basicsize*/ 516 0, /*tp_itemsize*/ 517 0, /*tp_dealloc*/ 518 0, /*tp_print*/ 519 0, /*tp_getattr*/ 520 0, /*tp_setattr*/ 521 0, /*tp_compare*/ 522 0, /*tp_repr*/ 523 0, /*tp_as_number*/ 524 0, /*tp_as_sequence*/ 525 0, /*tp_as_mapping*/ 526 0, /*tp_hash */ 527 0, /*tp_call*/ 528 gdbpy_register_descriptor_to_string, /*tp_str*/ 529 0, /*tp_getattro*/ 530 0, /*tp_setattro*/ 531 0, /*tp_as_buffer*/ 532 Py_TPFLAGS_DEFAULT, /*tp_flags*/ 533 "GDB architecture register descriptor object", /*tp_doc */ 534 0, /*tp_traverse */ 535 0, /*tp_clear */ 536 0, /*tp_richcompare */ 537 0, /*tp_weaklistoffset */ 538 0, /*tp_iter */ 539 0, /*tp_iternext */ 540 0, /*tp_methods */ 541 0, /*tp_members */ 542 gdbpy_register_descriptor_getset /*tp_getset */ 543}; 544 545PyTypeObject reggroup_iterator_object_type = { 546 PyVarObject_HEAD_INIT (NULL, 0) 547 "gdb.RegisterGroupsIterator", /*tp_name*/ 548 sizeof (reggroup_iterator_object), /*tp_basicsize*/ 549 0, /*tp_itemsize*/ 550 0, /*tp_dealloc*/ 551 0, /*tp_print*/ 552 0, /*tp_getattr*/ 553 0, /*tp_setattr*/ 554 0, /*tp_compare*/ 555 0, /*tp_repr*/ 556 0, /*tp_as_number*/ 557 0, /*tp_as_sequence*/ 558 0, /*tp_as_mapping*/ 559 0, /*tp_hash */ 560 0, /*tp_call*/ 561 0, /*tp_str*/ 562 0, /*tp_getattro*/ 563 0, /*tp_setattro*/ 564 0, /*tp_as_buffer*/ 565 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/ 566 "GDB register groups iterator object", /*tp_doc */ 567 0, /*tp_traverse */ 568 0, /*tp_clear */ 569 0, /*tp_richcompare */ 570 0, /*tp_weaklistoffset */ 571 gdbpy_reggroup_iter, /*tp_iter */ 572 gdbpy_reggroup_iter_next, /*tp_iternext */ 573 0 /*tp_methods */ 574}; 575 576static gdb_PyGetSetDef gdbpy_reggroup_getset[] = { 577 { "name", gdbpy_reggroup_name, NULL, 578 "The name of this register group.", NULL }, 579 { NULL } /* Sentinel */ 580}; 581 582PyTypeObject reggroup_object_type = { 583 PyVarObject_HEAD_INIT (NULL, 0) 584 "gdb.RegisterGroup", /*tp_name*/ 585 sizeof (reggroup_object), /*tp_basicsize*/ 586 0, /*tp_itemsize*/ 587 0, /*tp_dealloc*/ 588 0, /*tp_print*/ 589 0, /*tp_getattr*/ 590 0, /*tp_setattr*/ 591 0, /*tp_compare*/ 592 0, /*tp_repr*/ 593 0, /*tp_as_number*/ 594 0, /*tp_as_sequence*/ 595 0, /*tp_as_mapping*/ 596 0, /*tp_hash */ 597 0, /*tp_call*/ 598 gdbpy_reggroup_to_string, /*tp_str*/ 599 0, /*tp_getattro*/ 600 0, /*tp_setattro*/ 601 0, /*tp_as_buffer*/ 602 Py_TPFLAGS_DEFAULT, /*tp_flags*/ 603 "GDB register group object", /*tp_doc */ 604 0, /*tp_traverse */ 605 0, /*tp_clear */ 606 0, /*tp_richcompare */ 607 0, /*tp_weaklistoffset */ 608 0, /*tp_iter */ 609 0, /*tp_iternext */ 610 0, /*tp_methods */ 611 0, /*tp_members */ 612 gdbpy_reggroup_getset /*tp_getset */ 613}; 614