gdb/python/py-progspace.c

   1 /* Python interface to program spaces.
   2
   3    Copyright (C) 2010-2019 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 typedef struct
  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 } pspace_object;
  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 (except, RETURN_MASK_ALL)
 395     {
 396       GDB_PY_HANDLE_EXCEPTION (except);
 397     }
 398   END_CATCH
 399
 400   if (cust == NULL || COMPUNIT_OBJFILE (cust) == NULL)
 401     {
 402       PyErr_SetString (PyExc_RuntimeError,
 403                        _("Cannot locate object file for block."));
 404       return NULL;
 405     }
 406
 407   if (block)
 408     return block_to_block_object (block, COMPUNIT_OBJFILE (cust));
 409
 410   Py_RETURN_NONE;
 411 }
 412
 413 /* Implementation of the find_pc_line function.
 414    Returns the gdb.Symtab_and_line object corresponding to a PC value.  */
 415
 416 static PyObject *
 417 pspy_find_pc_line (PyObject *o, PyObject *args)
 418 {
 419   gdb_py_ulongest pc_llu;
 420   PyObject *result = NULL; /* init for gcc -Wall */
 421   pspace_object *self = (pspace_object *) o;
 422
 423   PSPY_REQUIRE_VALID (self);
 424
 425   if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
 426     return NULL;
 427
 428   TRY
 429     {
 430       struct symtab_and_line sal;
 431       CORE_ADDR pc;
 432       scoped_restore_current_program_space saver;
 433
 434       set_current_program_space (self->pspace);
 435
 436       pc = (CORE_ADDR) pc_llu;
 437       sal = find_pc_line (pc, 0);
 438       result = symtab_and_line_to_sal_object (sal);
 439     }
 440   CATCH (except, RETURN_MASK_ALL)
 441     {
 442       GDB_PY_HANDLE_EXCEPTION (except);
 443     }
 444   END_CATCH
 445
 446   return result;
 447 }
 448
 449 /* Implementation of is_valid (self) -> Boolean.
 450    Returns True if this program space still exists in GDB.  */
 451
 452 static PyObject *
 453 pspy_is_valid (PyObject *o, PyObject *args)
 454 {
 455   pspace_object *self = (pspace_object *) o;
 456
 457   if (self->pspace == NULL)
 458     Py_RETURN_FALSE;
 459
 460   Py_RETURN_TRUE;
 461 }
 462
 463 \f
 464
 465 /* Clear the PSPACE pointer in a Pspace object and remove the reference.  */
 466
 467 static void
 468 py_free_pspace (struct program_space *pspace, void *datum)
 469 {
 470   /* This is a fiction, but we're in a nasty spot: The pspace is in the
 471      process of being deleted, we can't rely on anything in it.  Plus
 472      this is one time when the current program space and current inferior
 473      are not in sync: All inferiors that use PSPACE may no longer exist.
 474      We don't need to do much here, and since "there is always an inferior"
 475      using target_gdbarch suffices.
 476      Note: We cannot call get_current_arch because it may try to access
 477      the target, which may involve accessing data in the pspace currently
 478      being deleted.  */
 479   struct gdbarch *arch = target_gdbarch ();
 480
 481   gdbpy_enter enter_py (arch, current_language);
 482   gdbpy_ref<pspace_object> object ((pspace_object *) datum);
 483   object->pspace = NULL;
 484 }
 485
 486 /* Return a new reference to the Python object of type Pspace
 487    representing PSPACE.  If the object has already been created,
 488    return it.  Otherwise, create it.  Return NULL and set the Python
 489    error on failure.  */
 490
 491 gdbpy_ref<>
 492 pspace_to_pspace_object (struct program_space *pspace)
 493 {
 494   PyObject *result
 495     ((PyObject *) program_space_data (pspace, pspy_pspace_data_key));
 496   if (result == NULL)
 497     {
 498       gdbpy_ref<pspace_object> object
 499         ((pspace_object *) PyObject_New (pspace_object, &pspace_object_type));
 500       if (object == NULL)
 501         return NULL;
 502       if (!pspy_initialize (object.get ()))
 503         return NULL;
 504
 505       object->pspace = pspace;
 506       set_program_space_data (pspace, pspy_pspace_data_key, object.get ());
 507       result = (PyObject *) object.release ();
 508     }
 509
 510   return gdbpy_ref<>::new_reference (result);
 511 }
 512
 513 int
 514 gdbpy_initialize_pspace (void)
 515 {
 516   pspy_pspace_data_key
 517     = register_program_space_data_with_cleanup (NULL, py_free_pspace);
 518
 519   if (PyType_Ready (&pspace_object_type) < 0)
 520     return -1;
 521
 522   return gdb_pymodule_addobject (gdb_module, "Progspace",
 523                                  (PyObject *) &pspace_object_type);
 524 }
 525
 526 \f
 527
 528 static gdb_PyGetSetDef pspace_getset[] =
 529 {
 530   { "__dict__", gdb_py_generic_dict, NULL,
 531     "The __dict__ for this progspace.", &pspace_object_type },
 532   { "filename", pspy_get_filename, NULL,
 533     "The progspace's main filename, or None.", NULL },
 534   { "pretty_printers", pspy_get_printers, pspy_set_printers,
 535     "Pretty printers.", NULL },
 536   { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
 537     "Frame filters.", NULL },
 538   { "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders,
 539     "Frame unwinders.", NULL },
 540   { "type_printers", pspy_get_type_printers, pspy_set_type_printers,
 541     "Type printers.", NULL },
 542   { "xmethods", pspy_get_xmethods, NULL,
 543     "Debug methods.", NULL },
 544   { NULL }
 545 };
 546
 547 static PyMethodDef progspace_object_methods[] =
 548 {
 549   { "objfiles", pspy_get_objfiles, METH_NOARGS,
 550     "Return a sequence of objfiles associated to this program space." },
 551   { "solib_name", pspy_solib_name, METH_VARARGS,
 552     "solib_name (Long) -> String.\n\
 553 Return the name of the shared library holding a given address, or None." },
 554   { "block_for_pc", pspy_block_for_pc, METH_VARARGS,
 555     "Return the block containing the given pc value, or None." },
 556   { "find_pc_line", pspy_find_pc_line, METH_VARARGS,
 557     "find_pc_line (pc) -> Symtab_and_line.\n\
 558 Return the gdb.Symtab_and_line object corresponding to the pc value." },
 559   { "is_valid", pspy_is_valid, METH_NOARGS,
 560     "is_valid () -> Boolean.\n\
 561 Return true if this program space is valid, false if not." },
 562   { NULL }
 563 };
 564
 565 PyTypeObject pspace_object_type =
 566 {
 567   PyVarObject_HEAD_INIT (NULL, 0)
 568   "gdb.Progspace",                /*tp_name*/
 569   sizeof (pspace_object),         /*tp_basicsize*/
 570   0,                              /*tp_itemsize*/
 571   pspy_dealloc,                   /*tp_dealloc*/
 572   0,                              /*tp_print*/
 573   0,                              /*tp_getattr*/
 574   0,                              /*tp_setattr*/
 575   0,                              /*tp_compare*/
 576   0,                              /*tp_repr*/
 577   0,                              /*tp_as_number*/
 578   0,                              /*tp_as_sequence*/
 579   0,                              /*tp_as_mapping*/
 580   0,                              /*tp_hash */
 581   0,                              /*tp_call*/
 582   0,                              /*tp_str*/
 583   0,                              /*tp_getattro*/
 584   0,                              /*tp_setattro*/
 585   0,                              /*tp_as_buffer*/
 586   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 587   "GDB progspace object",         /* tp_doc */
 588   0,                              /* tp_traverse */
 589   0,                              /* tp_clear */
 590   0,                              /* tp_richcompare */
 591   0,                              /* tp_weaklistoffset */
 592   0,                              /* tp_iter */
 593   0,                              /* tp_iternext */
 594   progspace_object_methods,       /* tp_methods */
 595   0,                              /* tp_members */
 596   pspace_getset,                  /* tp_getset */
 597   0,                              /* tp_base */
 598   0,                              /* tp_dict */
 599   0,                              /* tp_descr_get */
 600   0,                              /* tp_descr_set */
 601   offsetof (pspace_object, dict), /* tp_dictoffset */
 602   0,                              /* tp_init */
 603   0,                              /* tp_alloc */
 604   pspy_new,                       /* tp_new */
 605 };