gdb/python/py-block.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Python interface to blocks.

  3.    Copyright (C) 2008-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 "block.h"
  22. #include "dictionary.h"
  23. #include "symtab.h"
  24. #include "python-internal.h"
  25. #include "objfiles.h"
  26. #include "symtab.h"

  28. ‌typedef struct blpy_block_object {
  29.   PyObject_HEAD
  30.   /* The GDB block structure that represents a frame's code block.  */
  31.   const struct block *block;
  32.   /* The backing object file.  There is no direct relationship in GDB
  33.      between a block and an object file.  When a block is created also
  34.      store a pointer to the object file for later use.  */
  35.   struct objfile *objfile;
  36.   /* Keep track of all blocks with a doubly-linked list.  Needed for
  37.      block invalidation if the source object file has been freed.  */
  38.   struct blpy_block_object *prev;
  39.   struct blpy_block_object *next;
  40. ‌} block_object;

  42. typedef struct {
  43.   PyObject_HEAD
  44.   /* The block.  */
  45.   const struct block *block;
  46.   /* The iterator for that block.  */
  47.   struct block_iterator iter;
  48.   /* Has the iterator been initialized flag.  */
  49.   int initialized_p;
  50.   /* Pointer back to the original source block object.  Needed to
  51.      check if the block is still valid, and has not been invalidated
  52.      when an object file has been freed.  */
  53.   struct blpy_block_object *source;
  54. ‌} block_syms_iterator_object;

  56. /* Require a valid block.  All access to block_object->block should be
  57.    gated by this call.  */
  58. ‌#define BLPY_REQUIRE_VALID(block_obj, block)                \
  59.   do {                                                        \
  60.     block = block_object_to_block (block_obj);                \
  61.     if (block == NULL)                                        \
  62.       {                                                        \
  63.         PyErr_SetString (PyExc_RuntimeError,                \
  64.                          _("Block is invalid."));        \
  65.         return NULL;                                        \
  66.       }                                                        \
  67.   } while (0)

  69. /* Require a valid block.  This macro is called during block iterator
  70.    creation, and at each next call.  */
  71. ‌#define BLPY_ITER_REQUIRE_VALID(block_obj)                                \
  72.   do {                                                                        \
  73.     if (block_obj->block == NULL)                                        \
  74.       {                                                                        \
  75.         PyErr_SetString (PyExc_RuntimeError,                                \
  76.                          _("Source block for iterator is invalid."));        \
  77.         return NULL;                                                        \
  78.       }                                                                        \
  79.   } while (0)

  81. static PyTypeObject block_syms_iterator_object_type
  82.     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("block_syms_iterator_object");
  83. ‌static const struct objfile_data *blpy_objfile_data_key;

  85. static PyObject *
  86. ‌blpy_iter (PyObject *self)
  87. {
  88.   block_syms_iterator_object *block_iter_obj;
  89.   const struct block *block = NULL;

  91.   BLPY_REQUIRE_VALID (self, block);

  93.   block_iter_obj = PyObject_New (block_syms_iterator_object,
  94.                                  &block_syms_iterator_object_type);
  95.   if (block_iter_obj == NULL)
  96.       return NULL;

  98.   block_iter_obj->block = block;
  99.   block_iter_obj->initialized_p = 0;
  100.   Py_INCREF (self);
  101.   block_iter_obj->source = (block_object *) self;

  103.   return (PyObject *) block_iter_obj;
  104. }

  106. static PyObject *
  107. ‌blpy_get_start (PyObject *self, void *closure)
  108. {
  109.   const struct block *block = NULL;

  111.   BLPY_REQUIRE_VALID (self, block);

  113.   return gdb_py_object_from_ulongest (BLOCK_START (block));
  114. }

  116. static PyObject *
  117. ‌blpy_get_end (PyObject *self, void *closure)
  118. {
  119.   const struct block *block = NULL;

  121.   BLPY_REQUIRE_VALID (self, block);

  123.   return gdb_py_object_from_ulongest (BLOCK_END (block));
  124. }

  126. static PyObject *
  127. ‌blpy_get_function (PyObject *self, void *closure)
  128. {
  129.   struct symbol *sym;
  130.   const struct block *block;

  132.   BLPY_REQUIRE_VALID (self, block);

  134.   sym = BLOCK_FUNCTION (block);
  135.   if (sym)
  136.     return symbol_to_symbol_object (sym);

  138.   Py_RETURN_NONE;
  139. }

  141. static PyObject *
  142. ‌blpy_get_superblock (PyObject *self, void *closure)
  143. {
  144.   const struct block *block;
  145.   const struct block *super_block;
  146.   block_object *self_obj  = (block_object *) self;

  148.   BLPY_REQUIRE_VALID (self, block);

  150.   super_block = BLOCK_SUPERBLOCK (block);
  151.   if (super_block)
  152.     return block_to_block_object (super_block, self_obj->objfile);

  154.   Py_RETURN_NONE;
  155. }

  157. /* Return the global block associated to this block.  */

  159. static PyObject *
  160. ‌blpy_get_global_block (PyObject *self, void *closure)
  161. {
  162.   const struct block *block;
  163.   const struct block *global_block;
  164.   block_object *self_obj  = (block_object *) self;

  166.   BLPY_REQUIRE_VALID (self, block);

  168.   global_block = block_global_block (block);

  170.   return block_to_block_object (global_block,
  171.                                 self_obj->objfile);

  173. }

  175. /* Return the static block associated to this block.  Return None
  176.    if we cannot get the static block (this is the global block).  */

  178. static PyObject *
  179. ‌blpy_get_static_block (PyObject *self, void *closure)
  180. {
  181.   const struct block *block;
  182.   const struct block *static_block;
  183.   block_object *self_obj  = (block_object *) self;

  185.   BLPY_REQUIRE_VALID (self, block);

  187.   if (BLOCK_SUPERBLOCK (block) == NULL)
  188.     Py_RETURN_NONE;

  190.   static_block = block_static_block (block);

  192.   return block_to_block_object (static_block, self_obj->objfile);
  193. }

  195. /* Implementation of gdb.Block.is_global (self) -> Boolean.
  196.    Returns True if this block object is a global block.  */

  198. static PyObject *
  199. ‌blpy_is_global (PyObject *self, void *closure)
  200. {
  201.   const struct block *block;

  203.   BLPY_REQUIRE_VALID (self, block);

  205.   if (BLOCK_SUPERBLOCK (block))
  206.     Py_RETURN_FALSE;

  208.   Py_RETURN_TRUE;
  209. }

  211. /* Implementation of gdb.Block.is_static (self) -> Boolean.
  212.    Returns True if this block object is a static block.  */

  214. static PyObject *
  215. ‌blpy_is_static (PyObject *self, void *closure)
  216. {
  217.   const struct block *block;

  219.   BLPY_REQUIRE_VALID (self, block);

  221.   if (BLOCK_SUPERBLOCK (block) != NULL
  222.      && BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL)
  223.     Py_RETURN_TRUE;

  225.   Py_RETURN_FALSE;
  226. }

  228. static void
  229. ‌blpy_dealloc (PyObject *obj)
  230. {
  231.   block_object *block = (block_object *) obj;

  233.   if (block->prev)
  234.     block->prev->next = block->next;
  235.   else if (block->objfile)
  236.     {
  237.       set_objfile_data (block->objfile, blpy_objfile_data_key,
  238.                         block->next);
  239.     }
  240.   if (block->next)
  241.     block->next->prev = block->prev;
  242.   block->block = NULL;
  243. }

  245. /* Given a block, and a block_object that has previously been
  246.    allocated and initialized, populate the block_object with the
  247.    struct block data.  Also, register the block_object life-cycle
  248.    with the life-cycle of the object file associated with this
  249.    block, if needed.  */
  250. static void
  251. ‌set_block (block_object *obj, const struct block *block,
  252.            struct objfile *objfile)
  253. {
  254.   obj->block = block;
  255.   obj->prev = NULL;
  256.   if (objfile)
  257.     {
  258.       obj->objfile = objfile;
  259.       obj->next = objfile_data (objfile, blpy_objfile_data_key);
  260.       if (obj->next)
  261.         obj->next->prev = obj;
  262.       set_objfile_data (objfile, blpy_objfile_data_key, obj);
  263.     }
  264.   else
  265.     obj->next = NULL;
  266. }

  268. /* Create a new block object (gdb.Block) that encapsulates the struct
  269.    block object from GDB.  */
  270. PyObject *
  271. ‌block_to_block_object (const struct block *block, struct objfile *objfile)
  272. {
  273.   block_object *block_obj;

  275.   block_obj = PyObject_New (block_object, &block_object_type);
  276.   if (block_obj)
  277.     set_block (block_obj, block, objfile);

  279.   return (PyObject *) block_obj;
  280. }

  282. /* Return struct block reference that is wrapped by this object.  */
  283. const struct block *
  284. ‌block_object_to_block (PyObject *obj)
  285. {
  286.   if (! PyObject_TypeCheck (obj, &block_object_type))
  287.     return NULL;
  288.   return ((block_object *) obj)->block;
  289. }

  291. /* Return a reference to the block iterator.  */
  292. static PyObject *
  293. ‌blpy_block_syms_iter (PyObject *self)
  294. {
  295.   block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;

  297.   BLPY_ITER_REQUIRE_VALID (iter_obj->source);

  299.   Py_INCREF (self);
  300.   return self;
  301. }

  303. /* Return the next symbol in the iteration through the block's
  304.    dictionary.  */
  305. static PyObject *
  306. ‌blpy_block_syms_iternext (PyObject *self)
  307. {
  308.   block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
  309.   struct symbol *sym;

  311.   BLPY_ITER_REQUIRE_VALID (iter_obj->source);

  313.   if (!iter_obj->initialized_p)
  314.     {
  315.       sym = block_iterator_first (iter_obj->block,  &(iter_obj->iter));
  316.       iter_obj->initialized_p = 1;
  317.     }
  318.   else
  319.     sym = block_iterator_next (&(iter_obj->iter));

  321.   if (sym == NULL)
  322.     {
  323.       PyErr_SetString (PyExc_StopIteration, _("Symbol is null."));
  324.       return NULL;
  325.     }

  327.   return symbol_to_symbol_object (sym);
  328. }

  330. static void
  331. ‌blpy_block_syms_dealloc (PyObject *obj)
  332. {
  333.   block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) obj;

  335.   Py_XDECREF (iter_obj->source);
  336. }

  338. /* Implementation of gdb.Block.is_valid (self) -> Boolean.
  339.    Returns True if this block object still exists in GDB.  */

  341. static PyObject *
  342. ‌blpy_is_valid (PyObject *self, PyObject *args)
  343. {
  344.   const struct block *block;

  346.   block = block_object_to_block (self);
  347.   if (block == NULL)
  348.     Py_RETURN_FALSE;

  350.   Py_RETURN_TRUE;
  351. }

  353. /* Implementation of gdb.BlockIterator.is_valid (self) -> Boolean.
  354.    Returns True if this block iterator object still exists in GDB  */

  356. static PyObject *
  357. ‌blpy_iter_is_valid (PyObject *self, PyObject *args)
  358. {
  359.   block_syms_iterator_object *iter_obj =
  360.     (block_syms_iterator_object *) self;

  362.   if (iter_obj->source->block == NULL)
  363.     Py_RETURN_FALSE;

  365.   Py_RETURN_TRUE;
  366. }

  368. /* Return the innermost lexical block containing the specified pc value,
  369.    or 0 if there is none.  */
  370. PyObject *
  371. ‌gdbpy_block_for_pc (PyObject *self, PyObject *args)
  372. {
  373.   gdb_py_ulongest pc;
  374.   const struct block *block = NULL;
  375.   struct compunit_symtab *cust = NULL;
  376.   volatile struct gdb_exception except;

  378.   if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
  379.     return NULL;

  381.   TRY_CATCH (except, RETURN_MASK_ALL)
  382.     {
  383.       cust = find_pc_compunit_symtab (pc);

  385.       if (cust != NULL && COMPUNIT_OBJFILE (cust) != NULL)
  386.         block = block_for_pc (pc);
  387.     }
  388.   GDB_PY_HANDLE_EXCEPTION (except);

  390.   if (cust == NULL || COMPUNIT_OBJFILE (cust) == NULL)
  391.     {
  392.       PyErr_SetString (PyExc_RuntimeError,
  393.                        _("Cannot locate object file for block."));
  394.       return NULL;
  395.     }

  397.   if (block)
  398.     return block_to_block_object (block, COMPUNIT_OBJFILE (cust));

  400.   Py_RETURN_NONE;
  401. }

  403. /* This function is called when an objfile is about to be freed.
  404.    Invalidate the block as further actions on the block would result
  405.    in bad data.  All access to obj->symbol should be gated by
  406.    BLPY_REQUIRE_VALID which will raise an exception on invalid
  407.    blocks.  */
  408. static void
  409. ‌del_objfile_blocks (struct objfile *objfile, void *datum)
  410. {
  411.   block_object *obj = datum;

  413.   while (obj)
  414.     {
  415.       block_object *next = obj->next;

  417.       obj->block = NULL;
  418.       obj->objfile = NULL;
  419.       obj->next = NULL;
  420.       obj->prev = NULL;

  422.       obj = next;
  423.     }
  424. }

  426. int
  427. ‌gdbpy_initialize_blocks (void)
  428. {
  429.   block_object_type.tp_new = PyType_GenericNew;
  430.   if (PyType_Ready (&block_object_type) < 0)
  431.     return -1;

  433.   block_syms_iterator_object_type.tp_new = PyType_GenericNew;
  434.   if (PyType_Ready (&block_syms_iterator_object_type) < 0)
  435.     return -1;

  437.   /* Register an objfile "free" callback so we can properly
  438.      invalidate blocks when an object file is about to be
  439.      deleted.  */
  440.   blpy_objfile_data_key
  441.     = register_objfile_data_with_cleanup (NULL, del_objfile_blocks);

  443.   if (gdb_pymodule_addobject (gdb_module, "Block",
  444.                               (PyObject *) &block_object_type) < 0)
  445.     return -1;

  447.   return gdb_pymodule_addobject (gdb_module, "BlockIterator",
  448.                                  (PyObject *) &block_syms_iterator_object_type);
  449. }



  453. ‌static PyMethodDef block_object_methods[] = {
  454.   { "is_valid", blpy_is_valid, METH_NOARGS,
  455.     "is_valid () -> Boolean.\n\
  456. Return true if this block is valid, false if not." },
  457.   {NULL}  /* Sentinel */
  458. };

  460. ‌static PyGetSetDef block_object_getset[] = {
  461.   { "start", blpy_get_start, NULL, "Start address of the block.", NULL },
  462.   { "end", blpy_get_end, NULL, "End address of the block.", NULL },
  463.   { "function", blpy_get_function, NULL,
  464.     "Symbol that names the block, or None.", NULL },
  465.   { "superblock", blpy_get_superblock, NULL,
  466.     "Block containing the block, or None.", NULL },
  467.   { "global_block", blpy_get_global_block, NULL,
  468.     "Block containing the global block.", NULL },
  469.   { "static_block", blpy_get_static_block, NULL,
  470.     "Block containing the static block.", NULL },
  471.   { "is_static", blpy_is_static, NULL,
  472.     "Whether this block is a static block.", NULL },
  473.   { "is_global", blpy_is_global, NULL,
  474.     "Whether this block is a global block.", NULL },
  475.   { NULL }  /* Sentinel */
  476. };

  478. ‌PyTypeObject block_object_type = {
  479.   PyVarObject_HEAD_INIT (NULL, 0)
  480.   "gdb.Block",                          /*tp_name*/
  481.   sizeof (block_object),          /*tp_basicsize*/
  482.   0,                                  /*tp_itemsize*/
  483.   blpy_dealloc,                   /*tp_dealloc*/
  484.   0,                                  /*tp_print*/
  485.   0,                                  /*tp_getattr*/
  486.   0,                                  /*tp_setattr*/
  487.   0,                                  /*tp_compare*/
  488.   0,                                  /*tp_repr*/
  489.   0,                                  /*tp_as_number*/
  490.   0,                                  /*tp_as_sequence*/
  491.   0,                                  /*tp_as_mapping*/
  492.   0,                                  /*tp_hash */
  493.   0,                                  /*tp_call*/
  494.   0,                                  /*tp_str*/
  495.   0,                                  /*tp_getattro*/
  496.   0,                                  /*tp_setattro*/
  497.   0,                                  /*tp_as_buffer*/
  498.   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
  499.   "GDB block object",                  /* tp_doc */
  500.   0,                                  /* tp_traverse */
  501.   0,                                  /* tp_clear */
  502.   0,                                  /* tp_richcompare */
  503.   0,                                  /* tp_weaklistoffset */
  504.   blpy_iter,                          /* tp_iter */
  505.   0,                                  /* tp_iternext */
  506.   block_object_methods,                  /* tp_methods */
  507.   0,                                  /* tp_members */
  508.   block_object_getset                  /* tp_getset */
  509. };

  511. ‌static PyMethodDef block_iterator_object_methods[] = {
  512.   { "is_valid", blpy_iter_is_valid, METH_NOARGS,
  513.     "is_valid () -> Boolean.\n\
  514. Return true if this block iterator is valid, false if not." },
  515.   {NULL}  /* Sentinel */
  516. };

  518. ‌static PyTypeObject block_syms_iterator_object_type = {
  519.   PyVarObject_HEAD_INIT (NULL, 0)
  520.   "gdb.BlockIterator",                  /*tp_name*/
  521.   sizeof (block_syms_iterator_object),              /*tp_basicsize*/
  522.   0,                                  /*tp_itemsize*/
  523.   blpy_block_syms_dealloc,          /*tp_dealloc*/
  524.   0,                                  /*tp_print*/
  525.   0,                                  /*tp_getattr*/
  526.   0,                                  /*tp_setattr*/
  527.   0,                                  /*tp_compare*/
  528.   0,                                  /*tp_repr*/
  529.   0,                                  /*tp_as_number*/
  530.   0,                                  /*tp_as_sequence*/
  531.   0,                                  /*tp_as_mapping*/
  532.   0,                                  /*tp_hash */
  533.   0,                                  /*tp_call*/
  534.   0,                                  /*tp_str*/
  535.   0,                                  /*tp_getattro*/
  536.   0,                                  /*tp_setattro*/
  537.   0,                                  /*tp_as_buffer*/
  538.   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
  539.   "GDB block syms iterator object",              /*tp_doc */
  540.   0,                                  /*tp_traverse */
  541.   0,                                  /*tp_clear */
  542.   0,                                  /*tp_richcompare */
  543.   0,                                  /*tp_weaklistoffset */
  544.   blpy_block_syms_iter,           /*tp_iter */
  545.   blpy_block_syms_iternext,          /*tp_iternext */
  546.   block_iterator_object_methods   /*tp_methods */
  547. };