gdb/python/py-block.c

   1 /* Python interface to blocks.
   2
   3    Copyright (C) 2008-2012 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 "block.h"
  22 #include "dictionary.h"
  23 #include "symtab.h"
  24 #include "python-internal.h"
  25 #include "objfiles.h"
  26 #include "symtab.h"
  27
  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;
  41
  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;
  55
  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)
  68
  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)
  80
  81 static PyTypeObject block_syms_iterator_object_type;
  82 static const struct objfile_data *blpy_objfile_data_key;
  83
  84 static PyObject *
  85 blpy_iter (PyObject *self)
  86 {
  87   block_syms_iterator_object *block_iter_obj;
  88   const struct block *block = NULL;
  89
  90   BLPY_REQUIRE_VALID (self, block);
  91
  92   block_iter_obj = PyObject_New (block_syms_iterator_object,
  93                                  &block_syms_iterator_object_type);
  94   if (block_iter_obj == NULL)
  95       return NULL;
  96
  97   block_iter_obj->block = block;
  98   block_iter_obj->initialized_p = 0;
  99   Py_INCREF (self);
 100   block_iter_obj->source = (block_object *) self;
 101
 102   return (PyObject *) block_iter_obj;
 103 }
 104
 105 static PyObject *
 106 blpy_get_start (PyObject *self, void *closure)
 107 {
 108   const struct block *block = NULL;
 109
 110   BLPY_REQUIRE_VALID (self, block);
 111
 112   return gdb_py_object_from_ulongest (BLOCK_START (block));
 113 }
 114
 115 static PyObject *
 116 blpy_get_end (PyObject *self, void *closure)
 117 {
 118   const struct block *block = NULL;
 119
 120   BLPY_REQUIRE_VALID (self, block);
 121
 122   return gdb_py_object_from_ulongest (BLOCK_END (block));
 123 }
 124
 125 static PyObject *
 126 blpy_get_function (PyObject *self, void *closure)
 127 {
 128   struct symbol *sym;
 129   const struct block *block;
 130
 131   BLPY_REQUIRE_VALID (self, block);
 132
 133   sym = BLOCK_FUNCTION (block);
 134   if (sym)
 135     return symbol_to_symbol_object (sym);
 136
 137   Py_RETURN_NONE;
 138 }
 139
 140 static PyObject *
 141 blpy_get_superblock (PyObject *self, void *closure)
 142 {
 143   const struct block *block;
 144   const struct block *super_block;
 145   block_object *self_obj  = (block_object *) self;
 146
 147   BLPY_REQUIRE_VALID (self, block);
 148
 149   super_block = BLOCK_SUPERBLOCK (block);
 150   if (super_block)
 151     return block_to_block_object (super_block, self_obj->objfile);
 152
 153   Py_RETURN_NONE;
 154 }
 155
 156 /* Return the global block associated to this block.  */
 157
 158 static PyObject *
 159 blpy_get_global_block (PyObject *self, void *closure)
 160 {
 161   const struct block *block;
 162   const struct block *global_block;
 163   block_object *self_obj  = (block_object *) self;
 164
 165   BLPY_REQUIRE_VALID (self, block);
 166
 167   global_block = block_global_block (block);
 168
 169   return block_to_block_object (global_block,
 170                                 self_obj->objfile);
 171
 172 }
 173
 174 /* Return the static block associated to this block.  Return None
 175    if we cannot get the static block (this is the global block).  */
 176
 177 static PyObject *
 178 blpy_get_static_block (PyObject *self, void *closure)
 179 {
 180   const struct block *block;
 181   const struct block *static_block;
 182   block_object *self_obj  = (block_object *) self;
 183
 184   BLPY_REQUIRE_VALID (self, block);
 185
 186   if (BLOCK_SUPERBLOCK (block) == NULL)
 187     Py_RETURN_NONE;
 188
 189   static_block = block_static_block (block);
 190
 191   return block_to_block_object (static_block, self_obj->objfile);
 192 }
 193
 194 /* Implementation of gdb.Block.is_global (self) -> Boolean.
 195    Returns True if this block object is a global block.  */
 196
 197 static PyObject *
 198 blpy_is_global (PyObject *self, void *closure)
 199 {
 200   const struct block *block;
 201
 202   BLPY_REQUIRE_VALID (self, block);
 203
 204   if (BLOCK_SUPERBLOCK (block))
 205     Py_RETURN_FALSE;
 206
 207   Py_RETURN_TRUE;
 208 }
 209
 210 /* Implementation of gdb.Block.is_static (self) -> Boolean.
 211    Returns True if this block object is a static block.  */
 212
 213 static PyObject *
 214 blpy_is_static (PyObject *self, void *closure)
 215 {
 216   const struct block *block;
 217
 218   BLPY_REQUIRE_VALID (self, block);
 219
 220   if (BLOCK_SUPERBLOCK (block) != NULL
 221      && BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL)
 222     Py_RETURN_TRUE;
 223
 224   Py_RETURN_FALSE;
 225 }
 226
 227 static void
 228 blpy_dealloc (PyObject *obj)
 229 {
 230   block_object *block = (block_object *) obj;
 231
 232   if (block->prev)
 233     block->prev->next = block->next;
 234   else if (block->objfile)
 235     {
 236       set_objfile_data (block->objfile, blpy_objfile_data_key,
 237                         block->next);
 238     }
 239   if (block->next)
 240     block->next->prev = block->prev;
 241   block->block = NULL;
 242 }
 243
 244 /* Given a block, and a block_object that has previously been
 245    allocated and initialized, populate the block_object with the
 246    struct block data.  Also, register the block_object life-cycle
 247    with the life-cycle of the object file associated with this
 248    block, if needed.  */
 249 static void
 250 set_block (block_object *obj, const struct block *block,
 251            struct objfile *objfile)
 252 {
 253   obj->block = block;
 254   obj->prev = NULL;
 255   if (objfile)
 256     {
 257       obj->objfile = objfile;
 258       obj->next = objfile_data (objfile, blpy_objfile_data_key);
 259       if (obj->next)
 260         obj->next->prev = obj;
 261       set_objfile_data (objfile, blpy_objfile_data_key, obj);
 262     }
 263   else
 264     obj->next = NULL;
 265 }
 266
 267 /* Create a new block object (gdb.Block) that encapsulates the struct
 268    block object from GDB.  */
 269 PyObject *
 270 block_to_block_object (const struct block *block, struct objfile *objfile)
 271 {
 272   block_object *block_obj;
 273
 274   block_obj = PyObject_New (block_object, &block_object_type);
 275   if (block_obj)
 276     set_block (block_obj, block, objfile);
 277
 278   return (PyObject *) block_obj;
 279 }
 280
 281 /* Return struct block reference that is wrapped by this object.  */
 282 const struct block *
 283 block_object_to_block (PyObject *obj)
 284 {
 285   if (! PyObject_TypeCheck (obj, &block_object_type))
 286     return NULL;
 287   return ((block_object *) obj)->block;
 288 }
 289
 290 /* Return a reference to the block iterator.  */
 291 static PyObject *
 292 blpy_block_syms_iter (PyObject *self)
 293 {
 294   block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
 295
 296   BLPY_ITER_REQUIRE_VALID (iter_obj->source);
 297
 298   Py_INCREF (self);
 299   return self;
 300 }
 301
 302 /* Return the next symbol in the iteration through the block's
 303    dictionary.  */
 304 static PyObject *
 305 blpy_block_syms_iternext (PyObject *self)
 306 {
 307   block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
 308   struct symbol *sym;
 309
 310   BLPY_ITER_REQUIRE_VALID (iter_obj->source);
 311
 312   if (!iter_obj->initialized_p)
 313     {
 314       sym = block_iterator_first (iter_obj->block,  &(iter_obj->iter));
 315       iter_obj->initialized_p = 1;
 316     }
 317   else
 318     sym = block_iterator_next (&(iter_obj->iter));
 319
 320   if (sym == NULL)
 321     {
 322       PyErr_SetString (PyExc_StopIteration, _("Symbol is null."));
 323       return NULL;
 324     }
 325
 326   return symbol_to_symbol_object (sym);
 327 }
 328
 329 static void
 330 blpy_block_syms_dealloc (PyObject *obj)
 331 {
 332   block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) obj;
 333
 334   Py_XDECREF (iter_obj->source);
 335 }
 336
 337 /* Implementation of gdb.Block.is_valid (self) -> Boolean.
 338    Returns True if this block object still exists in GDB.  */
 339
 340 static PyObject *
 341 blpy_is_valid (PyObject *self, PyObject *args)
 342 {
 343   const struct block *block;
 344
 345   block = block_object_to_block (self);
 346   if (block == NULL)
 347     Py_RETURN_FALSE;
 348
 349   Py_RETURN_TRUE;
 350 }
 351
 352 /* Implementation of gdb.BlockIterator.is_valid (self) -> Boolean.
 353    Returns True if this block iterator object still exists in GDB  */
 354
 355 static PyObject *
 356 blpy_iter_is_valid (PyObject *self, PyObject *args)
 357 {
 358   block_syms_iterator_object *iter_obj =
 359     (block_syms_iterator_object *) self;
 360
 361   if (iter_obj->source->block == NULL)
 362     Py_RETURN_FALSE;
 363
 364   Py_RETURN_TRUE;
 365 }
 366
 367 /* Return the innermost lexical block containing the specified pc value,
 368    or 0 if there is none.  */
 369 PyObject *
 370 gdbpy_block_for_pc (PyObject *self, PyObject *args)
 371 {
 372   gdb_py_ulongest pc;
 373   struct block *block;
 374   struct obj_section *section = NULL;
 375   struct symtab *symtab = NULL;
 376   volatile struct gdb_exception except;
 377
 378   if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
 379     return NULL;
 380
 381   TRY_CATCH (except, RETURN_MASK_ALL)
 382     {
 383       section = find_pc_mapped_section (pc);
 384       symtab = find_pc_sect_symtab (pc, section);
 385     }
 386   GDB_PY_HANDLE_EXCEPTION (except);
 387
 388   if (!symtab || symtab->objfile == NULL)
 389     {
 390       PyErr_SetString (PyExc_RuntimeError,
 391                        _("Cannot locate object file for block."));
 392       return NULL;
 393     }
 394
 395   block = block_for_pc (pc);
 396   if (block)
 397     return block_to_block_object (block, symtab->objfile);
 398
 399   Py_RETURN_NONE;
 400 }
 401
 402 /* This function is called when an objfile is about to be freed.
 403    Invalidate the block as further actions on the block would result
 404    in bad data.  All access to obj->symbol should be gated by
 405    BLPY_REQUIRE_VALID which will raise an exception on invalid
 406    blocks.  */
 407 static void
 408 del_objfile_blocks (struct objfile *objfile, void *datum)
 409 {
 410   block_object *obj = datum;
 411
 412   while (obj)
 413     {
 414       block_object *next = obj->next;
 415
 416       obj->block = NULL;
 417       obj->objfile = NULL;
 418       obj->next = NULL;
 419       obj->prev = NULL;
 420
 421       obj = next;
 422     }
 423 }
 424
 425 void
 426 gdbpy_initialize_blocks (void)
 427 {
 428   block_object_type.tp_new = PyType_GenericNew;
 429   if (PyType_Ready (&block_object_type) < 0)
 430     return;
 431
 432   block_syms_iterator_object_type.tp_new = PyType_GenericNew;
 433   if (PyType_Ready (&block_syms_iterator_object_type) < 0)
 434     return;
 435
 436   /* Register an objfile "free" callback so we can properly
 437      invalidate blocks when an object file is about to be
 438      deleted.  */
 439   blpy_objfile_data_key
 440     = register_objfile_data_with_cleanup (NULL, del_objfile_blocks);
 441
 442   Py_INCREF (&block_object_type);
 443   PyModule_AddObject (gdb_module, "Block", (PyObject *) &block_object_type);
 444
 445   Py_INCREF (&block_syms_iterator_object_type);
 446   PyModule_AddObject (gdb_module, "BlockIterator",
 447                       (PyObject *) &block_syms_iterator_object_type);
 448 }
 449
 450 \f
 451
 452 static PyMethodDef block_object_methods[] = {
 453   { "is_valid", blpy_is_valid, METH_NOARGS,
 454     "is_valid () -> Boolean.\n\
 455 Return true if this block is valid, false if not." },
 456   {NULL}  /* Sentinel */
 457 };
 458
 459 static PyGetSetDef block_object_getset[] = {
 460   { "start", blpy_get_start, NULL, "Start address of the block.", NULL },
 461   { "end", blpy_get_end, NULL, "End address of the block.", NULL },
 462   { "function", blpy_get_function, NULL,
 463     "Symbol that names the block, or None.", NULL },
 464   { "superblock", blpy_get_superblock, NULL,
 465     "Block containing the block, or None.", NULL },
 466   { "global_block", blpy_get_global_block, NULL,
 467     "Block containing the global block.", NULL },
 468   { "static_block", blpy_get_static_block, NULL,
 469     "Block containing the static block.", NULL },
 470   { "is_static", blpy_is_static, NULL,
 471     "Whether this block is a static block.", NULL },
 472   { "is_global", blpy_is_global, NULL,
 473     "Whether this block is a global block.", NULL },
 474   { NULL }  /* Sentinel */
 475 };
 476
 477 PyTypeObject block_object_type = {
 478   PyObject_HEAD_INIT (NULL)
 479   0,                              /*ob_size*/
 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 };
 510
 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 };
 517
 518 static PyTypeObject block_syms_iterator_object_type = {
 519   PyObject_HEAD_INIT (NULL)
 520   0,                              /*ob_size*/
 521   "gdb.BlockIterator",            /*tp_name*/
 522   sizeof (block_syms_iterator_object),        /*tp_basicsize*/
 523   0,                              /*tp_itemsize*/
 524   blpy_block_syms_dealloc,        /*tp_dealloc*/
 525   0,                              /*tp_print*/
 526   0,                              /*tp_getattr*/
 527   0,                              /*tp_setattr*/
 528   0,                              /*tp_compare*/
 529   0,                              /*tp_repr*/
 530   0,                              /*tp_as_number*/
 531   0,                              /*tp_as_sequence*/
 532   0,                              /*tp_as_mapping*/
 533   0,                              /*tp_hash */
 534   0,                              /*tp_call*/
 535   0,                              /*tp_str*/
 536   0,                              /*tp_getattro*/
 537   0,                              /*tp_setattro*/
 538   0,                              /*tp_as_buffer*/
 539   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
 540   "GDB block syms iterator object",           /*tp_doc */
 541   0,                              /*tp_traverse */
 542   0,                              /*tp_clear */
 543   0,                              /*tp_richcompare */
 544   0,                              /*tp_weaklistoffset */
 545   blpy_block_syms_iter,           /*tp_iter */
 546   blpy_block_syms_iternext,       /*tp_iternext */
 547   block_iterator_object_methods   /*tp_methods */
 548 };