gdb/python/py-progspace.c

   1 /* Python interface to program spaces.
   2
   3    Copyright (C) 2010-2017 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
  28 typedef struct
  29 {
  30   PyObject_HEAD
  31
  32   /* The corresponding pspace.  */
  33   struct program_space *pspace;
  34
  35   /* Dictionary holding user-added attributes.
  36      This is the __dict__ attribute of the object.  */
  37   PyObject *dict;
  38
  39   /* The pretty-printer list of functions.  */
  40   PyObject *printers;
  41
  42   /* The frame filter list of functions.  */
  43   PyObject *frame_filters;
  44
  45   /* The frame unwinder list.  */
  46   PyObject *frame_unwinders;
  47
  48   /* The type-printer list.  */
  49   PyObject *type_printers;
  50
  51   /* The debug method list.  */
  52   PyObject *xmethods;
  53 } pspace_object;
  54
  55 extern PyTypeObject pspace_object_type
  56     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pspace_object");
  57
  58 static const struct program_space_data *pspy_pspace_data_key;
  59
  60 \f
  61
  62 /* An Objfile method which returns the objfile's file name, or None.  */
  63
  64 static PyObject *
  65 pspy_get_filename (PyObject *self, void *closure)
  66 {
  67   pspace_object *obj = (pspace_object *) self;
  68
  69   if (obj->pspace)
  70     {
  71       struct objfile *objfile = obj->pspace->symfile_object_file;
  72
  73       if (objfile)
  74         return host_string_to_python_string (objfile_name (objfile));
  75     }
  76   Py_RETURN_NONE;
  77 }
  78
  79 static void
  80 pspy_dealloc (PyObject *self)
  81 {
  82   pspace_object *ps_self = (pspace_object *) self;
  83
  84   Py_XDECREF (ps_self->dict);
  85   Py_XDECREF (ps_self->printers);
  86   Py_XDECREF (ps_self->frame_filters);
  87   Py_XDECREF (ps_self->frame_unwinders);
  88   Py_XDECREF (ps_self->type_printers);
  89   Py_XDECREF (ps_self->xmethods);
  90   Py_TYPE (self)->tp_free (self);
  91 }
  92
  93 /* Initialize a pspace_object.
  94    The result is a boolean indicating success.  */
  95
  96 static int
  97 pspy_initialize (pspace_object *self)
  98 {
  99   self->pspace = NULL;
 100
 101   self->dict = PyDict_New ();
 102   if (self->dict == NULL)
 103     return 0;
 104
 105   self->printers = PyList_New (0);
 106   if (self->printers == NULL)
 107     return 0;
 108
 109   self->frame_filters = PyDict_New ();
 110   if (self->frame_filters == NULL)
 111     return 0;
 112
 113   self->frame_unwinders = PyList_New (0);
 114   if (self->frame_unwinders == NULL)
 115     return 0;
 116
 117   self->type_printers = PyList_New (0);
 118   if (self->type_printers == NULL)
 119     return 0;
 120
 121   self->xmethods = PyList_New (0);
 122   if (self->xmethods == NULL)
 123     return 0;
 124
 125   return 1;
 126 }
 127
 128 static PyObject *
 129 pspy_new (PyTypeObject *type, PyObject *args, PyObject *keywords)
 130 {
 131   pspace_object *self = (pspace_object *) type->tp_alloc (type, 0);
 132
 133   if (self)
 134     {
 135       if (!pspy_initialize (self))
 136         {
 137           Py_DECREF (self);
 138           return NULL;
 139         }
 140     }
 141
 142   return (PyObject *) self;
 143 }
 144
 145 PyObject *
 146 pspy_get_printers (PyObject *o, void *ignore)
 147 {
 148   pspace_object *self = (pspace_object *) o;
 149
 150   Py_INCREF (self->printers);
 151   return self->printers;
 152 }
 153
 154 static int
 155 pspy_set_printers (PyObject *o, PyObject *value, void *ignore)
 156 {
 157   PyObject *tmp;
 158   pspace_object *self = (pspace_object *) o;
 159
 160   if (! value)
 161     {
 162       PyErr_SetString (PyExc_TypeError,
 163                        "cannot delete the pretty_printers attribute");
 164       return -1;
 165     }
 166
 167   if (! PyList_Check (value))
 168     {
 169       PyErr_SetString (PyExc_TypeError,
 170                        "the pretty_printers attribute must be a list");
 171       return -1;
 172     }
 173
 174   /* Take care in case the LHS and RHS are related somehow.  */
 175   tmp = self->printers;
 176   Py_INCREF (value);
 177   self->printers = value;
 178   Py_XDECREF (tmp);
 179
 180   return 0;
 181 }
 182
 183 /* Return the Python dictionary attribute containing frame filters for
 184    this program space.  */
 185 PyObject *
 186 pspy_get_frame_filters (PyObject *o, void *ignore)
 187 {
 188   pspace_object *self = (pspace_object *) o;
 189
 190   Py_INCREF (self->frame_filters);
 191   return self->frame_filters;
 192 }
 193
 194 /* Set this object file's frame filters dictionary to FILTERS.  */
 195 static int
 196 pspy_set_frame_filters (PyObject *o, PyObject *frame, void *ignore)
 197 {
 198   PyObject *tmp;
 199   pspace_object *self = (pspace_object *) o;
 200
 201   if (! frame)
 202     {
 203       PyErr_SetString (PyExc_TypeError,
 204                        "cannot delete the frame filter attribute");
 205       return -1;
 206     }
 207
 208   if (! PyDict_Check (frame))
 209     {
 210       PyErr_SetString (PyExc_TypeError,
 211                        "the frame filter attribute must be a dictionary");
 212       return -1;
 213     }
 214
 215   /* Take care in case the LHS and RHS are related somehow.  */
 216   tmp = self->frame_filters;
 217   Py_INCREF (frame);
 218   self->frame_filters = frame;
 219   Py_XDECREF (tmp);
 220
 221   return 0;
 222 }
 223
 224 /* Return the list of the frame unwinders for this program space.  */
 225
 226 PyObject *
 227 pspy_get_frame_unwinders (PyObject *o, void *ignore)
 228 {
 229   pspace_object *self = (pspace_object *) o;
 230
 231   Py_INCREF (self->frame_unwinders);
 232   return self->frame_unwinders;
 233 }
 234
 235 /* Set this program space's list of the unwinders to UNWINDERS.  */
 236
 237 static int
 238 pspy_set_frame_unwinders (PyObject *o, PyObject *unwinders, void *ignore)
 239 {
 240   PyObject *tmp;
 241   pspace_object *self = (pspace_object *) o;
 242
 243   if (!unwinders)
 244     {
 245       PyErr_SetString (PyExc_TypeError,
 246                        "cannot delete the frame unwinders list");
 247       return -1;
 248     }
 249
 250   if (!PyList_Check (unwinders))
 251     {
 252       PyErr_SetString (PyExc_TypeError,
 253                        "the frame unwinders attribute must be a list");
 254       return -1;
 255     }
 256
 257   /* Take care in case the LHS and RHS are related somehow.  */
 258   tmp = self->frame_unwinders;
 259   Py_INCREF (unwinders);
 260   self->frame_unwinders = unwinders;
 261   Py_XDECREF (tmp);
 262
 263   return 0;
 264 }
 265
 266 /* Get the 'type_printers' attribute.  */
 267
 268 static PyObject *
 269 pspy_get_type_printers (PyObject *o, void *ignore)
 270 {
 271   pspace_object *self = (pspace_object *) o;
 272
 273   Py_INCREF (self->type_printers);
 274   return self->type_printers;
 275 }
 276
 277 /* Get the 'xmethods' attribute.  */
 278
 279 PyObject *
 280 pspy_get_xmethods (PyObject *o, void *ignore)
 281 {
 282   pspace_object *self = (pspace_object *) o;
 283
 284   Py_INCREF (self->xmethods);
 285   return self->xmethods;
 286 }
 287
 288 /* Set the 'type_printers' attribute.  */
 289
 290 static int
 291 pspy_set_type_printers (PyObject *o, PyObject *value, void *ignore)
 292 {
 293   PyObject *tmp;
 294   pspace_object *self = (pspace_object *) o;
 295
 296   if (! value)
 297     {
 298       PyErr_SetString (PyExc_TypeError,
 299                        "cannot delete the type_printers attribute");
 300       return -1;
 301     }
 302
 303   if (! PyList_Check (value))
 304     {
 305       PyErr_SetString (PyExc_TypeError,
 306                        "the type_printers attribute must be a list");
 307       return -1;
 308     }
 309
 310   /* Take care in case the LHS and RHS are related somehow.  */
 311   tmp = self->type_printers;
 312   Py_INCREF (value);
 313   self->type_printers = value;
 314   Py_XDECREF (tmp);
 315
 316   return 0;
 317 }
 318
 319 \f
 320
 321 /* Clear the PSPACE pointer in a Pspace object and remove the reference.  */
 322
 323 static void
 324 py_free_pspace (struct program_space *pspace, void *datum)
 325 {
 326   pspace_object *object = (pspace_object *) datum;
 327   /* This is a fiction, but we're in a nasty spot: The pspace is in the
 328      process of being deleted, we can't rely on anything in it.  Plus
 329      this is one time when the current program space and current inferior
 330      are not in sync: All inferiors that use PSPACE may no longer exist.
 331      We don't need to do much here, and since "there is always an inferior"
 332      using target_gdbarch suffices.
 333      Note: We cannot call get_current_arch because it may try to access
 334      the target, which may involve accessing data in the pspace currently
 335      being deleted.  */
 336   struct gdbarch *arch = target_gdbarch ();
 337
 338   gdbpy_enter enter_py (arch, current_language);
 339   object->pspace = NULL;
 340   Py_DECREF ((PyObject *) object);
 341 }
 342
 343 /* Return a borrowed reference to the Python object of type Pspace
 344    representing PSPACE.  If the object has already been created,
 345    return it.  Otherwise, create it.  Return NULL and set the Python
 346    error on failure.  */
 347
 348 PyObject *
 349 pspace_to_pspace_object (struct program_space *pspace)
 350 {
 351   pspace_object *object;
 352
 353   object = (pspace_object *) program_space_data (pspace, pspy_pspace_data_key);
 354   if (!object)
 355     {
 356       object = PyObject_New (pspace_object, &pspace_object_type);
 357       if (object)
 358         {
 359           if (!pspy_initialize (object))
 360             {
 361               Py_DECREF (object);
 362               return NULL;
 363             }
 364
 365           object->pspace = pspace;
 366           set_program_space_data (pspace, pspy_pspace_data_key, object);
 367         }
 368     }
 369
 370   return (PyObject *) object;
 371 }
 372
 373 int
 374 gdbpy_initialize_pspace (void)
 375 {
 376   pspy_pspace_data_key
 377     = register_program_space_data_with_cleanup (NULL, py_free_pspace);
 378
 379   if (PyType_Ready (&pspace_object_type) < 0)
 380     return -1;
 381
 382   return gdb_pymodule_addobject (gdb_module, "Progspace",
 383                                  (PyObject *) &pspace_object_type);
 384 }
 385
 386 \f
 387
 388 static PyGetSetDef pspace_getset[] =
 389 {
 390   { "__dict__", gdb_py_generic_dict, NULL,
 391     "The __dict__ for this progspace.", &pspace_object_type },
 392   { "filename", pspy_get_filename, NULL,
 393     "The progspace's main filename, or None.", NULL },
 394   { "pretty_printers", pspy_get_printers, pspy_set_printers,
 395     "Pretty printers.", NULL },
 396   { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
 397     "Frame filters.", NULL },
 398   { "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders,
 399     "Frame unwinders.", NULL },
 400   { "type_printers", pspy_get_type_printers, pspy_set_type_printers,
 401     "Type printers.", NULL },
 402   { "xmethods", pspy_get_xmethods, NULL,
 403     "Debug methods.", NULL },
 404   { NULL }
 405 };
 406
 407 PyTypeObject pspace_object_type =
 408 {
 409   PyVarObject_HEAD_INIT (NULL, 0)
 410   "gdb.Progspace",                /*tp_name*/
 411   sizeof (pspace_object),         /*tp_basicsize*/
 412   0,                              /*tp_itemsize*/
 413   pspy_dealloc,                   /*tp_dealloc*/
 414   0,                              /*tp_print*/
 415   0,                              /*tp_getattr*/
 416   0,                              /*tp_setattr*/
 417   0,                              /*tp_compare*/
 418   0,                              /*tp_repr*/
 419   0,                              /*tp_as_number*/
 420   0,                              /*tp_as_sequence*/
 421   0,                              /*tp_as_mapping*/
 422   0,                              /*tp_hash */
 423   0,                              /*tp_call*/
 424   0,                              /*tp_str*/
 425   0,                              /*tp_getattro*/
 426   0,                              /*tp_setattro*/
 427   0,                              /*tp_as_buffer*/
 428   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 429   "GDB progspace object",         /* tp_doc */
 430   0,                              /* tp_traverse */
 431   0,                              /* tp_clear */
 432   0,                              /* tp_richcompare */
 433   0,                              /* tp_weaklistoffset */
 434   0,                              /* tp_iter */
 435   0,                              /* tp_iternext */
 436   0,                              /* tp_methods */
 437   0,                              /* tp_members */
 438   pspace_getset,                  /* tp_getset */
 439   0,                              /* tp_base */
 440   0,                              /* tp_dict */
 441   0,                              /* tp_descr_get */
 442   0,                              /* tp_descr_set */
 443   offsetof (pspace_object, dict), /* tp_dictoffset */
 444   0,                              /* tp_init */
 445   0,                              /* tp_alloc */
 446   pspy_new,                       /* tp_new */
 447 };