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 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 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 struct cleanup *cleanup; 327 pspace_object *object = (pspace_object *) datum; 328 /* This is a fiction, but we're in a nasty spot: The pspace is in the 329 process of being deleted, we can't rely on anything in it. Plus 330 this is one time when the current program space and current inferior 331 are not in sync: All inferiors that use PSPACE may no longer exist. 332 We don't need to do much here, and since "there is always an inferior" 333 using target_gdbarch suffices. 334 Note: We cannot call get_current_arch because it may try to access 335 the target, which may involve accessing data in the pspace currently 336 being deleted. */ 337 struct gdbarch *arch = target_gdbarch (); 338 339 cleanup = ensure_python_env (arch, current_language); 340 object->pspace = NULL; 341 Py_DECREF ((PyObject *) object); 342 do_cleanups (cleanup); 343 } 344 345 /* Return a borrowed reference to the Python object of type Pspace 346 representing PSPACE. If the object has already been created, 347 return it. Otherwise, create it. Return NULL and set the Python 348 error on failure. */ 349 350 PyObject * 351 pspace_to_pspace_object (struct program_space *pspace) 352 { 353 pspace_object *object; 354 355 object = (pspace_object *) program_space_data (pspace, pspy_pspace_data_key); 356 if (!object) 357 { 358 object = PyObject_New (pspace_object, &pspace_object_type); 359 if (object) 360 { 361 if (!pspy_initialize (object)) 362 { 363 Py_DECREF (object); 364 return NULL; 365 } 366 367 object->pspace = pspace; 368 set_program_space_data (pspace, pspy_pspace_data_key, object); 369 } 370 } 371 372 return (PyObject *) object; 373 } 374 375 int 376 gdbpy_initialize_pspace (void) 377 { 378 pspy_pspace_data_key 379 = register_program_space_data_with_cleanup (NULL, py_free_pspace); 380 381 if (PyType_Ready (&pspace_object_type) < 0) 382 return -1; 383 384 return gdb_pymodule_addobject (gdb_module, "Progspace", 385 (PyObject *) &pspace_object_type); 386 } 387 388 389 390 static PyGetSetDef pspace_getset[] = 391 { 392 { "__dict__", gdb_py_generic_dict, NULL, 393 "The __dict__ for this progspace.", &pspace_object_type }, 394 { "filename", pspy_get_filename, NULL, 395 "The progspace's main filename, or None.", NULL }, 396 { "pretty_printers", pspy_get_printers, pspy_set_printers, 397 "Pretty printers.", NULL }, 398 { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters, 399 "Frame filters.", NULL }, 400 { "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders, 401 "Frame unwinders.", NULL }, 402 { "type_printers", pspy_get_type_printers, pspy_set_type_printers, 403 "Type printers.", NULL }, 404 { "xmethods", pspy_get_xmethods, NULL, 405 "Debug methods.", NULL }, 406 { NULL } 407 }; 408 409 PyTypeObject pspace_object_type = 410 { 411 PyVarObject_HEAD_INIT (NULL, 0) 412 "gdb.Progspace", /*tp_name*/ 413 sizeof (pspace_object), /*tp_basicsize*/ 414 0, /*tp_itemsize*/ 415 pspy_dealloc, /*tp_dealloc*/ 416 0, /*tp_print*/ 417 0, /*tp_getattr*/ 418 0, /*tp_setattr*/ 419 0, /*tp_compare*/ 420 0, /*tp_repr*/ 421 0, /*tp_as_number*/ 422 0, /*tp_as_sequence*/ 423 0, /*tp_as_mapping*/ 424 0, /*tp_hash */ 425 0, /*tp_call*/ 426 0, /*tp_str*/ 427 0, /*tp_getattro*/ 428 0, /*tp_setattro*/ 429 0, /*tp_as_buffer*/ 430 Py_TPFLAGS_DEFAULT, /*tp_flags*/ 431 "GDB progspace object", /* tp_doc */ 432 0, /* tp_traverse */ 433 0, /* tp_clear */ 434 0, /* tp_richcompare */ 435 0, /* tp_weaklistoffset */ 436 0, /* tp_iter */ 437 0, /* tp_iternext */ 438 0, /* tp_methods */ 439 0, /* tp_members */ 440 pspace_getset, /* tp_getset */ 441 0, /* tp_base */ 442 0, /* tp_dict */ 443 0, /* tp_descr_get */ 444 0, /* tp_descr_set */ 445 offsetof (pspace_object, dict), /* tp_dictoffset */ 446 0, /* tp_init */ 447 0, /* tp_alloc */ 448 pspy_new, /* tp_new */ 449 }; 450