gdb/python/py-progspace.c

   1 /* Python interface to program spaces.
   2
   3    Copyright (C) 2010-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 "python-internal.h"
  22 #include "charset.h"
  23 #include "progspace.h"
  24 #include "objfiles.h"
  25 #include "language.h"
  26 #include "arch-utils.h"
  27 #include "solib.h"
  28 #include "block.h"
  29
  30 struct pspace_object
  31 {
  32   PyObject_HEAD
  33
  34   /* The corresponding pspace.  */
  35   struct program_space *pspace;
  36
  37   /* Dictionary holding user-added attributes.
  38      This is the __dict__ attribute of the object.  */
  39   PyObject *dict;
  40
  41   /* The pretty-printer list of functions.  */
  42   PyObject *printers;
  43
  44   /* The frame filter list of functions.  */
  45   PyObject *frame_filters;
  46
  47   /* The frame unwinder list.  */
  48   PyObject *frame_unwinders;
  49
  50   /* The type-printer list.  */
  51   PyObject *type_printers;
  52
  53   /* The debug method list.  */
  54   PyObject *xmethods;
  55 };
  56
  57 extern PyTypeObject pspace_object_type
  58     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pspace_object");
  59
  60 static const struct program_space_data *pspy_pspace_data_key;
  61
  62 /* Require that PSPACE_OBJ be a valid program space ID.  */
  63 #define PSPY_REQUIRE_VALID(pspace_obj)                          \
  64   do {                                                          \
  65     if (pspace_obj->pspace == nullptr)                          \
  66       {                                                         \
  67         PyErr_SetString (PyExc_RuntimeError,                    \
  68                          _("Program space no longer exists.")); \
  69         return NULL;                                            \
  70       }                                                         \
  71   } while (0)
  72
  73 /* An Objfile method which returns the objfile's file name, or None.  */
  74
  75 static PyObject *
  76 pspy_get_filename (PyObject *self, void *closure)
  77 {
  78   pspace_object *obj = (pspace_object *) self;
  79
  80   if (obj->pspace)
  81     {
  82       struct objfile *objfile = obj->pspace->symfile_object_file;
  83
  84       if (objfile)
  85         return (host_string_to_python_string (objfile_name (objfile))
  86                 .release ());
  87     }
  88   Py_RETURN_NONE;
  89 }
  90
  91 static void
  92 pspy_dealloc (PyObject *self)
  93 {
  94   pspace_object *ps_self = (pspace_object *) self;
  95
  96   Py_XDECREF (ps_self->dict);
  97   Py_XDECREF (ps_self->printers);
  98   Py_XDECREF (ps_self->frame_filters);
  99   Py_XDECREF (ps_self->frame_unwinders);
 100   Py_XDECREF (ps_self->type_printers);
 101   Py_XDECREF (ps_self->xmethods);
 102   Py_TYPE (self)->tp_free (self);
 103 }
 104
 105 /* Initialize a pspace_object.
 106    The result is a boolean indicating success.  */
 107
 108 static int
 109 pspy_initialize (pspace_object *self)
 110 {
 111   self->pspace = NULL;
 112
 113   self->dict = PyDict_New ();
 114   if (self->dict == NULL)
 115     return 0;
 116
 117   self->printers = PyList_New (0);
 118   if (self->printers == NULL)
 119     return 0;
 120
 121   self->frame_filters = PyDict_New ();
 122   if (self->frame_filters == NULL)
 123     return 0;
 124
 125   self->frame_unwinders = PyList_New (0);
 126   if (self->frame_unwinders == NULL)
 127     return 0;
 128
 129   self->type_printers = PyList_New (0);
 130   if (self->type_printers == NULL)
 131     return 0;
 132
 133   self->xmethods = PyList_New (0);
 134   if (self->xmethods == NULL)
 135     return 0;
 136
 137   return 1;
 138 }
 139
 140 static PyObject *
 141 pspy_new (PyTypeObject *type, PyObject *args, PyObject *keywords)
 142 {
 143   gdbpy_ref<pspace_object> self ((pspace_object *) type->tp_alloc (type, 0));
 144
 145   if (self != NULL)
 146     {
 147       if (!pspy_initialize (self.get ()))
 148         return NULL;
 149     }
 150
 151   return (PyObject *) self.release ();
 152 }
 153
 154 PyObject *
 155 pspy_get_printers (PyObject *o, void *ignore)
 156 {
 157   pspace_object *self = (pspace_object *) o;
 158
 159   Py_INCREF (self->printers);
 160   return self->printers;
 161 }
 162
 163 static int
 164 pspy_set_printers (PyObject *o, PyObject *value, void *ignore)
 165 {
 166   pspace_object *self = (pspace_object *) o;
 167
 168   if (! value)
 169     {
 170       PyErr_SetString (PyExc_TypeError,
 171                        "cannot delete the pretty_printers attribute");
 172       return -1;
 173     }
 174
 175   if (! PyList_Check (value))
 176     {
 177       PyErr_SetString (PyExc_TypeError,
 178                        "the pretty_printers attribute must be a list");
 179       return -1;
 180     }
 181
 182   /* Take care in case the LHS and RHS are related somehow.  */
 183   gdbpy_ref<> tmp (self->printers);
 184   Py_INCREF (value);
 185   self->printers = value;
 186
 187   return 0;
 188 }
 189
 190 /* Return the Python dictionary attribute containing frame filters for
 191    this program space.  */
 192 PyObject *
 193 pspy_get_frame_filters (PyObject *o, void *ignore)
 194 {
 195   pspace_object *self = (pspace_object *) o;
 196
 197   Py_INCREF (self->frame_filters);
 198   return self->frame_filters;
 199 }
 200
 201 /* Set this object file's frame filters dictionary to FILTERS.  */
 202 static int
 203 pspy_set_frame_filters (PyObject *o, PyObject *frame, void *ignore)
 204 {
 205   pspace_object *self = (pspace_object *) o;
 206
 207   if (! frame)
 208     {
 209       PyErr_SetString (PyExc_TypeError,
 210                        "cannot delete the frame filter attribute");
 211       return -1;
 212     }
 213
 214   if (! PyDict_Check (frame))
 215     {
 216       PyErr_SetString (PyExc_TypeError,
 217                        "the frame filter attribute must be a dictionary");
 218       return -1;
 219     }
 220
 221   /* Take care in case the LHS and RHS are related somehow.  */
 222   gdbpy_ref<> tmp (self->frame_filters);
 223   Py_INCREF (frame);
 224   self->frame_filters = frame;
 225
 226   return 0;
 227 }
 228
 229 /* Return the list of the frame unwinders for this program space.  */
 230
 231 PyObject *
 232 pspy_get_frame_unwinders (PyObject *o, void *ignore)
 233 {
 234   pspace_object *self = (pspace_object *) o;
 235
 236   Py_INCREF (self->frame_unwinders);
 237   return self->frame_unwinders;
 238 }
 239
 240 /* Set this program space's list of the unwinders to UNWINDERS.  */
 241
 242 static int
 243 pspy_set_frame_unwinders (PyObject *o, PyObject *unwinders, void *ignore)
 244 {
 245   pspace_object *self = (pspace_object *) o;
 246
 247   if (!unwinders)
 248     {
 249       PyErr_SetString (PyExc_TypeError,
 250                        "cannot delete the frame unwinders list");
 251       return -1;
 252     }
 253
 254   if (!PyList_Check (unwinders))
 255     {
 256       PyErr_SetString (PyExc_TypeError,
 257                        "the frame unwinders attribute must be a list");
 258       return -1;
 259     }
 260
 261   /* Take care in case the LHS and RHS are related somehow.  */
 262   gdbpy_ref<> tmp (self->frame_unwinders);
 263   Py_INCREF (unwinders);
 264   self->frame_unwinders = unwinders;
 265
 266   return 0;
 267 }
 268
 269 /* Get the 'type_printers' attribute.  */
 270
 271 static PyObject *
 272 pspy_get_type_printers (PyObject *o, void *ignore)
 273 {
 274   pspace_object *self = (pspace_object *) o;
 275
 276   Py_INCREF (self->type_printers);
 277   return self->type_printers;
 278 }
 279
 280 /* Get the 'xmethods' attribute.  */
 281
 282 PyObject *
 283 pspy_get_xmethods (PyObject *o, void *ignore)
 284 {
 285   pspace_object *self = (pspace_object *) o;
 286
 287   Py_INCREF (self->xmethods);
 288   return self->xmethods;
 289 }
 290
 291 /* Set the 'type_printers' attribute.  */
 292
 293 static int
 294 pspy_set_type_printers (PyObject *o, PyObject *value, void *ignore)
 295 {
 296   pspace_object *self = (pspace_object *) o;
 297
 298   if (! value)
 299     {
 300       PyErr_SetString (PyExc_TypeError,
 301                        "cannot delete the type_printers attribute");
 302       return -1;
 303     }
 304
 305   if (! PyList_Check (value))
 306     {
 307       PyErr_SetString (PyExc_TypeError,
 308                        "the type_printers attribute must be a list");
 309       return -1;
 310     }
 311
 312   /* Take care in case the LHS and RHS are related somehow.  */
 313   gdbpy_ref<> tmp (self->type_printers);
 314   Py_INCREF (value);
 315   self->type_printers = value;
 316
 317   return 0;
 318 }
 319
 320 /* Implement the objfiles method.  */
 321
 322 static PyObject *
 323 pspy_get_objfiles (PyObject *self_, PyObject *args)
 324 {
 325   pspace_object *self = (pspace_object *) self_;
 326
 327   PSPY_REQUIRE_VALID (self);
 328
 329   gdbpy_ref<> list (PyList_New (0));
 330   if (list == NULL)
 331     return NULL;
 332
 333   if (self->pspace != NULL)
 334     {
 335       for (objfile *objf : self->pspace->objfiles ())
 336         {
 337           gdbpy_ref<> item = objfile_to_objfile_object (objf);
 338
 339           if (item == nullptr
 340               || PyList_Append (list.get (), item.get ()) == -1)
 341             return NULL;
 342         }
 343     }
 344
 345   return list.release ();
 346 }
 347
 348 /* Implementation of solib_name (Long) -> String.
 349    Returns the name of the shared library holding a given address, or None.  */
 350
 351 static PyObject *
 352 pspy_solib_name (PyObject *o, PyObject *args)
 353 {
 354   char *soname;
 355   gdb_py_ulongest pc;
 356   pspace_object *self = (pspace_object *) o;
 357
 358   PSPY_REQUIRE_VALID (self);
 359
 360   if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
 361     return NULL;
 362
 363   soname = solib_name_from_address (self->pspace, pc);
 364   if (soname == nullptr)
 365     Py_RETURN_NONE;
 366   return host_string_to_python_string (soname).release ();
 367 }
 368
 369 /* Return the innermost lexical block containing the specified pc value,
 370    or 0 if there is none.  */
 371 static PyObject *
 372 pspy_block_for_pc (PyObject *o, PyObject *args)
 373 {
 374   pspace_object *self = (pspace_object *) o;
 375   gdb_py_ulongest pc;
 376   const struct block *block = NULL;
 377   struct compunit_symtab *cust = NULL;
 378
 379   PSPY_REQUIRE_VALID (self);
 380
 381   if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
 382     return NULL;
 383
 384   try
 385     {
 386       scoped_restore_current_program_space saver;
 387
 388       set_current_program_space (self->pspace);
 389       cust = find_pc_compunit_symtab (pc);
 390
 391       if (cust != NULL && COMPUNIT_OBJFILE (cust) != NULL)
 392         block = block_for_pc (pc);
 393     }
 394   catch (const gdb_exception &except)
 395     {
 396       GDB_PY_HANDLE_EXCEPTION (except);
 397     }
 398
 399   if (cust == NULL || COMPUNIT_OBJFILE (cust) == NULL)
 400     Py_RETURN_NONE;
 401
 402   if (block)
 403     return block_to_block_object (block, COMPUNIT_OBJFILE (cust));
 404
 405   Py_RETURN_NONE;
 406 }
 407
 408 /* Implementation of the find_pc_line function.
 409    Returns the gdb.Symtab_and_line object corresponding to a PC value.  */
 410
 411 static PyObject *
 412 pspy_find_pc_line (PyObject *o, PyObject *args)
 413 {
 414   gdb_py_ulongest pc_llu;
 415   PyObject *result = NULL; /* init for gcc -Wall */
 416   pspace_object *self = (pspace_object *) o;
 417
 418   PSPY_REQUIRE_VALID (self);
 419
 420   if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
 421     return NULL;
 422
 423   try
 424     {
 425       struct symtab_and_line sal;
 426       CORE_ADDR pc;
 427       scoped_restore_current_program_space saver;
 428
 429       set_current_program_space (self->pspace);
 430
 431       pc = (CORE_ADDR) pc_llu;
 432       sal = find_pc_line (pc, 0);
 433       result = symtab_and_line_to_sal_object (sal);
 434     }
 435   catch (const gdb_exception &except)
 436     {
 437       GDB_PY_HANDLE_EXCEPTION (except);
 438     }
 439
 440   return result;
 441 }
 442
 443 /* Implementation of is_valid (self) -> Boolean.
 444    Returns True if this program space still exists in GDB.  */
 445
 446 static PyObject *
 447 pspy_is_valid (PyObject *o, PyObject *args)
 448 {
 449   pspace_object *self = (pspace_object *) o;
 450
 451   if (self->pspace == NULL)
 452     Py_RETURN_FALSE;
 453
 454   Py_RETURN_TRUE;
 455 }
 456
 457 \f
 458
 459 /* Clear the PSPACE pointer in a Pspace object and remove the reference.  */
 460
 461 static void
 462 py_free_pspace (struct program_space *pspace, void *datum)
 463 {
 464   /* This is a fiction, but we're in a nasty spot: The pspace is in the
 465      process of being deleted, we can't rely on anything in it.  Plus
 466      this is one time when the current program space and current inferior
 467      are not in sync: All inferiors that use PSPACE may no longer exist.
 468      We don't need to do much here, and since "there is always an inferior"
 469      using target_gdbarch suffices.
 470      Note: We cannot call get_current_arch because it may try to access
 471      the target, which may involve accessing data in the pspace currently
 472      being deleted.  */
 473   struct gdbarch *arch = target_gdbarch ();
 474
 475   gdbpy_enter enter_py (arch, current_language);
 476   gdbpy_ref<pspace_object> object ((pspace_object *) datum);
 477   object->pspace = NULL;
 478 }
 479
 480 /* Return a new reference to the Python object of type Pspace
 481    representing PSPACE.  If the object has already been created,
 482    return it.  Otherwise, create it.  Return NULL and set the Python
 483    error on failure.  */
 484
 485 gdbpy_ref<>
 486 pspace_to_pspace_object (struct program_space *pspace)
 487 {
 488   PyObject *result
 489     ((PyObject *) program_space_data (pspace, pspy_pspace_data_key));
 490   if (result == NULL)
 491     {
 492       gdbpy_ref<pspace_object> object
 493         ((pspace_object *) PyObject_New (pspace_object, &pspace_object_type));
 494       if (object == NULL)
 495         return NULL;
 496       if (!pspy_initialize (object.get ()))
 497         return NULL;
 498
 499       object->pspace = pspace;
 500       set_program_space_data (pspace, pspy_pspace_data_key, object.get ());
 501       result = (PyObject *) object.release ();
 502     }
 503
 504   return gdbpy_ref<>::new_reference (result);
 505 }
 506
 507 int
 508 gdbpy_initialize_pspace (void)
 509 {
 510   pspy_pspace_data_key
 511     = register_program_space_data_with_cleanup (NULL, py_free_pspace);
 512
 513   if (PyType_Ready (&pspace_object_type) < 0)
 514     return -1;
 515
 516   return gdb_pymodule_addobject (gdb_module, "Progspace",
 517                                  (PyObject *) &pspace_object_type);
 518 }
 519
 520 \f
 521
 522 static gdb_PyGetSetDef pspace_getset[] =
 523 {
 524   { "__dict__", gdb_py_generic_dict, NULL,
 525     "The __dict__ for this progspace.", &pspace_object_type },
 526   { "filename", pspy_get_filename, NULL,
 527     "The progspace's main filename, or None.", NULL },
 528   { "pretty_printers", pspy_get_printers, pspy_set_printers,
 529     "Pretty printers.", NULL },
 530   { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
 531     "Frame filters.", NULL },
 532   { "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders,
 533     "Frame unwinders.", NULL },
 534   { "type_printers", pspy_get_type_printers, pspy_set_type_printers,
 535     "Type printers.", NULL },
 536   { "xmethods", pspy_get_xmethods, NULL,
 537     "Debug methods.", NULL },
 538   { NULL }
 539 };
 540
 541 static PyMethodDef progspace_object_methods[] =
 542 {
 543   { "objfiles", pspy_get_objfiles, METH_NOARGS,
 544     "Return a sequence of objfiles associated to this program space." },
 545   { "solib_name", pspy_solib_name, METH_VARARGS,
 546     "solib_name (Long) -> String.\n\
 547 Return the name of the shared library holding a given address, or None." },
 548   { "block_for_pc", pspy_block_for_pc, METH_VARARGS,
 549     "Return the block containing the given pc value, or None." },
 550   { "find_pc_line", pspy_find_pc_line, METH_VARARGS,
 551     "find_pc_line (pc) -> Symtab_and_line.\n\
 552 Return the gdb.Symtab_and_line object corresponding to the pc value." },
 553   { "is_valid", pspy_is_valid, METH_NOARGS,
 554     "is_valid () -> Boolean.\n\
 555 Return true if this program space is valid, false if not." },
 556   { NULL }
 557 };
 558
 559 PyTypeObject pspace_object_type =
 560 {
 561   PyVarObject_HEAD_INIT (NULL, 0)
 562   "gdb.Progspace",                /*tp_name*/
 563   sizeof (pspace_object),         /*tp_basicsize*/
 564   0,                              /*tp_itemsize*/
 565   pspy_dealloc,                   /*tp_dealloc*/
 566   0,                              /*tp_print*/
 567   0,                              /*tp_getattr*/
 568   0,                              /*tp_setattr*/
 569   0,                              /*tp_compare*/
 570   0,                              /*tp_repr*/
 571   0,                              /*tp_as_number*/
 572   0,                              /*tp_as_sequence*/
 573   0,                              /*tp_as_mapping*/
 574   0,                              /*tp_hash */
 575   0,                              /*tp_call*/
 576   0,                              /*tp_str*/
 577   0,                              /*tp_getattro*/
 578   0,                              /*tp_setattro*/
 579   0,                              /*tp_as_buffer*/
 580   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 581   "GDB progspace object",         /* tp_doc */
 582   0,                              /* tp_traverse */
 583   0,                              /* tp_clear */
 584   0,                              /* tp_richcompare */
 585   0,                              /* tp_weaklistoffset */
 586   0,                              /* tp_iter */
 587   0,                              /* tp_iternext */
 588   progspace_object_methods,       /* tp_methods */
 589   0,                              /* tp_members */
 590   pspace_getset,                  /* tp_getset */
 591   0,                              /* tp_base */
 592   0,                              /* tp_dict */
 593   0,                              /* tp_descr_get */
 594   0,                              /* tp_descr_set */
 595   offsetof (pspace_object, dict), /* tp_dictoffset */
 596   0,                              /* tp_init */
 597   0,                              /* tp_alloc */
 598   pspy_new,                       /* tp_new */
 599 };