gdb/python/py-progspace.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Python interface to program spaces.

  3.    Copyright (C) 2010-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  28. typedef struct
  29. {
  30.   PyObject_HEAD

  32.   /* The corresponding pspace.  */
  33.   struct program_space *pspace;

  35.   /* Dictionary holding user-added attributes.
  36.      This is the __dict__ attribute of the object.  */
  37.   PyObject *dict;

  39.   /* The pretty-printer list of functions.  */
  40.   PyObject *printers;

  42.   /* The frame filter list of functions.  */
  43.   PyObject *frame_filters;
  44.   /* The type-printer list.  */
  45.   PyObject *type_printers;

  47.   /* The debug method list.  */
  48.   PyObject *xmethods;
  49. ‌} pspace_object;

  51. static PyTypeObject pspace_object_type
  52.     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pspace_object");

  54. ‌static const struct program_space_data *pspy_pspace_data_key;



  58. /* An Objfile method which returns the objfile's file name, or None.  */

  60. static PyObject *
  61. ‌pspy_get_filename (PyObject *self, void *closure)
  62. {
  63.   pspace_object *obj = (pspace_object *) self;

  65.   if (obj->pspace)
  66.     {
  67.       struct objfile *objfile = obj->pspace->symfile_object_file;

  69.       if (objfile)
  70.         return PyString_Decode (objfile_name (objfile),
  71.                                 strlen (objfile_name (objfile)),
  72.                                 host_charset (), NULL);
  73.     }
  74.   Py_RETURN_NONE;
  75. }

  77. static void
  78. ‌pspy_dealloc (PyObject *self)
  79. {
  80.   pspace_object *ps_self = (pspace_object *) self;

  82.   Py_XDECREF (ps_self->dict);
  83.   Py_XDECREF (ps_self->printers);
  84.   Py_XDECREF (ps_self->frame_filters);
  85.   Py_XDECREF (ps_self->type_printers);
  86.   Py_XDECREF (ps_self->xmethods);
  87.   Py_TYPE (self)->tp_free (self);
  88. }

  90. /* Initialize a pspace_object.
  91.    The result is a boolean indicating success.  */

  93. static int
  94. ‌pspy_initialize (pspace_object *self)
  95. {
  96.   self->pspace = NULL;
  97.   self->dict = NULL;

  99.   self->printers = PyList_New (0);
  100.   if (self->printers == NULL)
  101.     return 0;

  103.   self->frame_filters = PyDict_New ();
  104.   if (self->frame_filters == NULL)
  105.     return 0;

  107.   self->type_printers = PyList_New (0);
  108.   if (self->type_printers == NULL)
  109.     return 0;

  111.   self->xmethods = PyList_New (0);
  112.   if (self->xmethods == NULL)
  113.     return 0;

  115.   return 1;
  116. }

  118. static PyObject *
  119. ‌pspy_new (PyTypeObject *type, PyObject *args, PyObject *keywords)
  120. {
  121.   pspace_object *self = (pspace_object *) type->tp_alloc (type, 0);

  123.   if (self)
  124.     {
  125.       if (!pspy_initialize (self))
  126.         {
  127.           Py_DECREF (self);
  128.           return NULL;
  129.         }
  130.     }

  132.   return (PyObject *) self;
  133. }

  135. PyObject *
  136. ‌pspy_get_printers (PyObject *o, void *ignore)
  137. {
  138.   pspace_object *self = (pspace_object *) o;

  140.   Py_INCREF (self->printers);
  141.   return self->printers;
  142. }

  144. static int
  145. ‌pspy_set_printers (PyObject *o, PyObject *value, void *ignore)
  146. {
  147.   PyObject *tmp;
  148.   pspace_object *self = (pspace_object *) o;

  150.   if (! value)
  151.     {
  152.       PyErr_SetString (PyExc_TypeError,
  153.                        "cannot delete the pretty_printers attribute");
  154.       return -1;
  155.     }

  157.   if (! PyList_Check (value))
  158.     {
  159.       PyErr_SetString (PyExc_TypeError,
  160.                        "the pretty_printers attribute must be a list");
  161.       return -1;
  162.     }

  164.   /* Take care in case the LHS and RHS are related somehow.  */
  165.   tmp = self->printers;
  166.   Py_INCREF (value);
  167.   self->printers = value;
  168.   Py_XDECREF (tmp);

  170.   return 0;
  171. }

  173. /* Return the Python dictionary attribute containing frame filters for
  174.    this program space.  */
  175. PyObject *
  176. ‌pspy_get_frame_filters (PyObject *o, void *ignore)
  177. {
  178.   pspace_object *self = (pspace_object *) o;

  180.   Py_INCREF (self->frame_filters);
  181.   return self->frame_filters;
  182. }

  184. /* Set this object file's frame filters dictionary to FILTERS.  */
  185. static int
  186. ‌pspy_set_frame_filters (PyObject *o, PyObject *frame, void *ignore)
  187. {
  188.   PyObject *tmp;
  189.   pspace_object *self = (pspace_object *) o;

  191.   if (! frame)
  192.     {
  193.       PyErr_SetString (PyExc_TypeError,
  194.                        "cannot delete the frame filter attribute");
  195.       return -1;
  196.     }

  198.   if (! PyDict_Check (frame))
  199.     {
  200.       PyErr_SetString (PyExc_TypeError,
  201.                        "the frame filter attribute must be a dictionary");
  202.       return -1;
  203.     }

  205.   /* Take care in case the LHS and RHS are related somehow.  */
  206.   tmp = self->frame_filters;
  207.   Py_INCREF (frame);
  208.   self->frame_filters = frame;
  209.   Py_XDECREF (tmp);

  211.   return 0;
  212. }

  214. /* Get the 'type_printers' attribute.  */

  216. static PyObject *
  217. ‌pspy_get_type_printers (PyObject *o, void *ignore)
  218. {
  219.   pspace_object *self = (pspace_object *) o;

  221.   Py_INCREF (self->type_printers);
  222.   return self->type_printers;
  223. }

  225. /* Get the 'xmethods' attribute.  */

  227. PyObject *
  228. ‌pspy_get_xmethods (PyObject *o, void *ignore)
  229. {
  230.   pspace_object *self = (pspace_object *) o;

  232.   Py_INCREF (self->xmethods);
  233.   return self->xmethods;
  234. }

  236. /* Set the 'type_printers' attribute.  */

  238. static int
  239. ‌pspy_set_type_printers (PyObject *o, PyObject *value, void *ignore)
  240. {
  241.   PyObject *tmp;
  242.   pspace_object *self = (pspace_object *) o;

  244.   if (! value)
  245.     {
  246.       PyErr_SetString (PyExc_TypeError,
  247.                        "cannot delete the type_printers attribute");
  248.       return -1;
  249.     }

  251.   if (! PyList_Check (value))
  252.     {
  253.       PyErr_SetString (PyExc_TypeError,
  254.                        "the type_printers attribute must be a list");
  255.       return -1;
  256.     }

  258.   /* Take care in case the LHS and RHS are related somehow.  */
  259.   tmp = self->type_printers;
  260.   Py_INCREF (value);
  261.   self->type_printers = value;
  262.   Py_XDECREF (tmp);

  264.   return 0;
  265. }



  269. /* Clear the PSPACE pointer in a Pspace object and remove the reference.  */

  271. static void
  272. ‌py_free_pspace (struct program_space *pspace, void *datum)
  273. {
  274.   struct cleanup *cleanup;
  275.   pspace_object *object = datum;
  276.   /* This is a fiction, but we're in a nasty spot: The pspace is in the
  277.      process of being deleted, we can't rely on anything in it.  Plus
  278.      this is one time when the current program space and current inferior
  279.      are not in sync: All inferiors that use PSPACE may no longer exist.
  280.      We don't need to do much here, and since "there is always an inferior"
  281.      using target_gdbarch suffices.
  282.      Note: We cannot call get_current_arch because it may try to access
  283.      the target, which may involve accessing data in the pspace currently
  284.      being deleted.  */
  285.   struct gdbarch *arch = target_gdbarch ();

  287.   cleanup = ensure_python_env (arch, current_language);
  288.   object->pspace = NULL;
  289.   Py_DECREF ((PyObject *) object);
  290.   do_cleanups (cleanup);
  291. }

  293. /* Return a borrowed reference to the Python object of type Pspace
  294.    representing PSPACE.  If the object has already been created,
  295.    return it.  Otherwise, create it.  Return NULL and set the Python
  296.    error on failure.  */

  298. PyObject *
  299. ‌pspace_to_pspace_object (struct program_space *pspace)
  300. {
  301.   pspace_object *object;

  303.   object = program_space_data (pspace, pspy_pspace_data_key);
  304.   if (!object)
  305.     {
  306.       object = PyObject_New (pspace_object, &pspace_object_type);
  307.       if (object)
  308.         {
  309.           if (!pspy_initialize (object))
  310.             {
  311.               Py_DECREF (object);
  312.               return NULL;
  313.             }

  315.           object->pspace = pspace;
  316.           set_program_space_data (pspace, pspy_pspace_data_key, object);
  317.         }
  318.     }

  320.   return (PyObject *) object;
  321. }

  323. int
  324. ‌gdbpy_initialize_pspace (void)
  325. {
  326.   pspy_pspace_data_key
  327.     = register_program_space_data_with_cleanup (NULL, py_free_pspace);

  329.   if (PyType_Ready (&pspace_object_type) < 0)
  330.     return -1;

  332.   return gdb_pymodule_addobject (gdb_module, "Progspace",
  333.                                  (PyObject *) &pspace_object_type);
  334. }



  338. ‌static PyGetSetDef pspace_getset[] =
  339. {
  340.   { "__dict__", gdb_py_generic_dict, NULL,
  341.     "The __dict__ for this progspace.", &pspace_object_type },
  342.   { "filename", pspy_get_filename, NULL,
  343.     "The progspace's main filename, or None.", NULL },
  344.   { "pretty_printers", pspy_get_printers, pspy_set_printers,
  345.     "Pretty printers.", NULL },
  346.   { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
  347.     "Frame filters.", NULL },
  348.   { "type_printers", pspy_get_type_printers, pspy_set_type_printers,
  349.     "Type printers.", NULL },
  350.   { "xmethods", pspy_get_xmethods, NULL,
  351.     "Debug methods.", NULL },
  352.   { NULL }
  353. };

  355. ‌static PyTypeObject pspace_object_type =
  356. {
  357.   PyVarObject_HEAD_INIT (NULL, 0)
  358.   "gdb.Progspace",                  /*tp_name*/
  359.   sizeof (pspace_object),          /*tp_basicsize*/
  360.   0,                                  /*tp_itemsize*/
  361.   pspy_dealloc,                          /*tp_dealloc*/
  362.   0,                                  /*tp_print*/
  363.   0,                                  /*tp_getattr*/
  364.   0,                                  /*tp_setattr*/
  365.   0,                                  /*tp_compare*/
  366.   0,                                  /*tp_repr*/
  367.   0,                                  /*tp_as_number*/
  368.   0,                                  /*tp_as_sequence*/
  369.   0,                                  /*tp_as_mapping*/
  370.   0,                                  /*tp_hash */
  371.   0,                                  /*tp_call*/
  372.   0,                                  /*tp_str*/
  373.   0,                                  /*tp_getattro*/
  374.   0,                                  /*tp_setattro*/
  375.   0,                                  /*tp_as_buffer*/
  376.   Py_TPFLAGS_DEFAULT,                  /*tp_flags*/
  377.   "GDB progspace object",          /* tp_doc */
  378.   0,                                  /* tp_traverse */
  379.   0,                                  /* tp_clear */
  380.   0,                                  /* tp_richcompare */
  381.   0,                                  /* tp_weaklistoffset */
  382.   0,                                  /* tp_iter */
  383.   0,                                  /* tp_iternext */
  384.   0,                                  /* tp_methods */
  385.   0,                                  /* tp_members */
  386.   pspace_getset,                  /* tp_getset */
  387.   0,                                  /* tp_base */
  388.   0,                                  /* tp_dict */
  389.   0,                                  /* tp_descr_get */
  390.   0,                                  /* tp_descr_set */
  391.   offsetof (pspace_object, dict), /* tp_dictoffset */
  392.   0,                                  /* tp_init */
  393.   0,                                  /* tp_alloc */
  394.   pspy_new,                          /* tp_new */
  395. };