gdb/python/py-progspace.c

   1 /* Python interface to program spaces.
   2
   3    Copyright (C) 2010-2016 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 PyString_Decode (objfile_name (objfile),
  75                                 strlen (objfile_name (objfile)),
  76                                 host_charset (), NULL);
  77     }
  78   Py_RETURN_NONE;
  79 }
  80
  81 static void
  82 pspy_dealloc (PyObject *self)
  83 {
  84   pspace_object *ps_self = (pspace_object *) self;
  85
  86   Py_XDECREF (ps_self->dict);
  87   Py_XDECREF (ps_self->printers);
  88   Py_XDECREF (ps_self->frame_filters);
  89   Py_XDECREF (ps_self->frame_unwinders);
  90   Py_XDECREF (ps_self->type_printers);
  91   Py_XDECREF (ps_self->xmethods);
  92   Py_TYPE (self)->tp_free (self);
  93 }
  94
  95 /* Initialize a pspace_object.
  96    The result is a boolean indicating success.  */
  97
  98 static int
  99 pspy_initialize (pspace_object *self)
 100 {
 101   self->pspace = NULL;
 102   self->dict = NULL;
 103
 104   self->printers = PyList_New (0);
 105   if (self->printers == NULL)
 106     return 0;
 107
 108   self->frame_filters = PyDict_New ();
 109   if (self->frame_filters == NULL)
 110     return 0;
 111
 112   self->frame_unwinders = PyList_New (0);
 113   if (self->frame_unwinders == NULL)
 114     return 0;
 115
 116   self->type_printers = PyList_New (0);
 117   if (self->type_printers == NULL)
 118     return 0;
 119
 120   self->xmethods = PyList_New (0);
 121   if (self->xmethods == NULL)
 122     return 0;
 123
 124   return 1;
 125 }
 126
 127 static PyObject *
 128 pspy_new (PyTypeObject *type, PyObject *args, PyObject *keywords)
 129 {
 130   pspace_object *self = (pspace_object *) type->tp_alloc (type, 0);
 131
 132   if (self)
 133     {
 134       if (!pspy_initialize (self))
 135         {
 136           Py_DECREF (self);
 137           return NULL;
 138         }
 139     }
 140
 141   return (PyObject *) self;
 142 }
 143
 144 PyObject *
 145 pspy_get_printers (PyObject *o, void *ignore)
 146 {
 147   pspace_object *self = (pspace_object *) o;
 148
 149   Py_INCREF (self->printers);
 150   return self->printers;
 151 }
 152
 153 static int
 154 pspy_set_printers (PyObject *o, PyObject *value, void *ignore)
 155 {
 156   PyObject *tmp;
 157   pspace_object *self = (pspace_object *) o;
 158
 159   if (! value)
 160     {
 161       PyErr_SetString (PyExc_TypeError,
 162                        "cannot delete the pretty_printers attribute");
 163       return -1;
 164     }
 165
 166   if (! PyList_Check (value))
 167     {
 168       PyErr_SetString (PyExc_TypeError,
 169                        "the pretty_printers attribute must be a list");
 170       return -1;
 171     }
 172
 173   /* Take care in case the LHS and RHS are related somehow.  */
 174   tmp = self->printers;
 175   Py_INCREF (value);
 176   self->printers = value;
 177   Py_XDECREF (tmp);
 178
 179   return 0;
 180 }
 181
 182 /* Return the Python dictionary attribute containing frame filters for
 183    this program space.  */
 184 PyObject *
 185 pspy_get_frame_filters (PyObject *o, void *ignore)
 186 {
 187   pspace_object *self = (pspace_object *) o;
 188
 189   Py_INCREF (self->frame_filters);
 190   return self->frame_filters;
 191 }
 192
 193 /* Set this object file's frame filters dictionary to FILTERS.  */
 194 static int
 195 pspy_set_frame_filters (PyObject *o, PyObject *frame, void *ignore)
 196 {
 197   PyObject *tmp;
 198   pspace_object *self = (pspace_object *) o;
 199
 200   if (! frame)
 201     {
 202       PyErr_SetString (PyExc_TypeError,
 203                        "cannot delete the frame filter attribute");
 204       return -1;
 205     }
 206
 207   if (! PyDict_Check (frame))
 208     {
 209       PyErr_SetString (PyExc_TypeError,
 210                        "the frame filter attribute must be a dictionary");
 211       return -1;
 212     }
 213
 214   /* Take care in case the LHS and RHS are related somehow.  */
 215   tmp = self->frame_filters;
 216   Py_INCREF (frame);
 217   self->frame_filters = frame;
 218   Py_XDECREF (tmp);
 219
 220   return 0;
 221 }
 222
 223 /* Return the list of the frame unwinders for this program space.  */
 224
 225 PyObject *
 226 pspy_get_frame_unwinders (PyObject *o, void *ignore)
 227 {
 228   pspace_object *self = (pspace_object *) o;
 229
 230   Py_INCREF (self->frame_unwinders);
 231   return self->frame_unwinders;
 232 }
 233
 234 /* Set this program space's list of the unwinders to UNWINDERS.  */
 235
 236 static int
 237 pspy_set_frame_unwinders (PyObject *o, PyObject *unwinders, void *ignore)
 238 {
 239   PyObject *tmp;
 240   pspace_object *self = (pspace_object *) o;
 241
 242   if (!unwinders)
 243     {
 244       PyErr_SetString (PyExc_TypeError,
 245                        "cannot delete the frame unwinders list");
 246       return -1;
 247     }
 248
 249   if (!PyList_Check (unwinders))
 250     {
 251       PyErr_SetString (PyExc_TypeError,
 252                        "the frame unwinders attribute must be a list");
 253       return -1;
 254     }
 255
 256   /* Take care in case the LHS and RHS are related somehow.  */
 257   tmp = self->frame_unwinders;
 258   Py_INCREF (unwinders);
 259   self->frame_unwinders = unwinders;
 260   Py_XDECREF (tmp);
 261
 262   return 0;
 263 }
 264
 265 /* Get the 'type_printers' attribute.  */
 266
 267 static PyObject *
 268 pspy_get_type_printers (PyObject *o, void *ignore)
 269 {
 270   pspace_object *self = (pspace_object *) o;
 271
 272   Py_INCREF (self->type_printers);
 273   return self->type_printers;
 274 }
 275
 276 /* Get the 'xmethods' attribute.  */
 277
 278 PyObject *
 279 pspy_get_xmethods (PyObject *o, void *ignore)
 280 {
 281   pspace_object *self = (pspace_object *) o;
 282
 283   Py_INCREF (self->xmethods);
 284   return self->xmethods;
 285 }
 286
 287 /* Set the 'type_printers' attribute.  */
 288
 289 static int
 290 pspy_set_type_printers (PyObject *o, PyObject *value, void *ignore)
 291 {
 292   PyObject *tmp;
 293   pspace_object *self = (pspace_object *) o;
 294
 295   if (! value)
 296     {
 297       PyErr_SetString (PyExc_TypeError,
 298                        "cannot delete the type_printers attribute");
 299       return -1;
 300     }
 301
 302   if (! PyList_Check (value))
 303     {
 304       PyErr_SetString (PyExc_TypeError,
 305                        "the type_printers attribute must be a list");
 306       return -1;
 307     }
 308
 309   /* Take care in case the LHS and RHS are related somehow.  */
 310   tmp = self->type_printers;
 311   Py_INCREF (value);
 312   self->type_printers = value;
 313   Py_XDECREF (tmp);
 314
 315   return 0;
 316 }
 317
 318 \f
 319
 320 /* Clear the PSPACE pointer in a Pspace object and remove the reference.  */
 321
 322 static void
 323 py_free_pspace (struct program_space *pspace, void *datum)
 324 {
 325   struct cleanup *cleanup;
 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   cleanup = ensure_python_env (arch, current_language);
 339   object->pspace = NULL;
 340   Py_DECREF ((PyObject *) object);
 341   do_cleanups (cleanup);
 342 }
 343
 344 /* Return a borrowed reference to the Python object of type Pspace
 345    representing PSPACE.  If the object has already been created,
 346    return it.  Otherwise, create it.  Return NULL and set the Python
 347    error on failure.  */
 348
 349 PyObject *
 350 pspace_to_pspace_object (struct program_space *pspace)
 351 {
 352   pspace_object *object;
 353
 354   object = (pspace_object *) program_space_data (pspace, pspy_pspace_data_key);
 355   if (!object)
 356     {
 357       object = PyObject_New (pspace_object, &pspace_object_type);
 358       if (object)
 359         {
 360           if (!pspy_initialize (object))
 361             {
 362               Py_DECREF (object);
 363               return NULL;
 364             }
 365
 366           object->pspace = pspace;
 367           set_program_space_data (pspace, pspy_pspace_data_key, object);
 368         }
 369     }
 370
 371   return (PyObject *) object;
 372 }
 373
 374 int
 375 gdbpy_initialize_pspace (void)
 376 {
 377   pspy_pspace_data_key
 378     = register_program_space_data_with_cleanup (NULL, py_free_pspace);
 379
 380   if (PyType_Ready (&pspace_object_type) < 0)
 381     return -1;
 382
 383   return gdb_pymodule_addobject (gdb_module, "Progspace",
 384                                  (PyObject *) &pspace_object_type);
 385 }
 386
 387 \f
 388
 389 static PyGetSetDef pspace_getset[] =
 390 {
 391   { "__dict__", gdb_py_generic_dict, NULL,
 392     "The __dict__ for this progspace.", &pspace_object_type },
 393   { "filename", pspy_get_filename, NULL,
 394     "The progspace's main filename, or None.", NULL },
 395   { "pretty_printers", pspy_get_printers, pspy_set_printers,
 396     "Pretty printers.", NULL },
 397   { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
 398     "Frame filters.", NULL },
 399   { "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders,
 400     "Frame unwinders.", NULL },
 401   { "type_printers", pspy_get_type_printers, pspy_set_type_printers,
 402     "Type printers.", NULL },
 403   { "xmethods", pspy_get_xmethods, NULL,
 404     "Debug methods.", NULL },
 405   { NULL }
 406 };
 407
 408 PyTypeObject pspace_object_type =
 409 {
 410   PyVarObject_HEAD_INIT (NULL, 0)
 411   "gdb.Progspace",                /*tp_name*/
 412   sizeof (pspace_object),         /*tp_basicsize*/
 413   0,                              /*tp_itemsize*/
 414   pspy_dealloc,                   /*tp_dealloc*/
 415   0,                              /*tp_print*/
 416   0,                              /*tp_getattr*/
 417   0,                              /*tp_setattr*/
 418   0,                              /*tp_compare*/
 419   0,                              /*tp_repr*/
 420   0,                              /*tp_as_number*/
 421   0,                              /*tp_as_sequence*/
 422   0,                              /*tp_as_mapping*/
 423   0,                              /*tp_hash */
 424   0,                              /*tp_call*/
 425   0,                              /*tp_str*/
 426   0,                              /*tp_getattro*/
 427   0,                              /*tp_setattro*/
 428   0,                              /*tp_as_buffer*/
 429   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 430   "GDB progspace object",         /* tp_doc */
 431   0,                              /* tp_traverse */
 432   0,                              /* tp_clear */
 433   0,                              /* tp_richcompare */
 434   0,                              /* tp_weaklistoffset */
 435   0,                              /* tp_iter */
 436   0,                              /* tp_iternext */
 437   0,                              /* tp_methods */
 438   0,                              /* tp_members */
 439   pspace_getset,                  /* tp_getset */
 440   0,                              /* tp_base */
 441   0,                              /* tp_dict */
 442   0,                              /* tp_descr_get */
 443   0,                              /* tp_descr_set */
 444   offsetof (pspace_object, dict), /* tp_dictoffset */
 445   0,                              /* tp_init */
 446   0,                              /* tp_alloc */
 447   pspy_new,                       /* tp_new */
 448 };