1 /* Python interface to blocks.
3 Copyright (C) 2008-2013 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/>. */
22 #include "dictionary.h"
24 #include "python-internal.h"
28 typedef struct blpy_block_object {
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;
45 const struct block *block;
46 /* The iterator for that block. */
47 struct block_iterator iter;
48 /* Has the iterator been initialized flag. */
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) \
60 block = block_object_to_block (block_obj); \
63 PyErr_SetString (PyExc_RuntimeError, \
64 _("Block is invalid.")); \
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) \
73 if (block_obj->block == NULL) \
75 PyErr_SetString (PyExc_RuntimeError, \
76 _("Source block for iterator is invalid.")); \
81 static PyTypeObject block_syms_iterator_object_type;
82 static const struct objfile_data *blpy_objfile_data_key;
85 blpy_iter (PyObject *self)
87 block_syms_iterator_object *block_iter_obj;
88 const struct block *block = NULL;
90 BLPY_REQUIRE_VALID (self, block);
92 block_iter_obj = PyObject_New (block_syms_iterator_object,
93 &block_syms_iterator_object_type);
94 if (block_iter_obj == NULL)
97 block_iter_obj->block = block;
98 block_iter_obj->initialized_p = 0;
100 block_iter_obj->source = (block_object *) self;
102 return (PyObject *) block_iter_obj;
106 blpy_get_start (PyObject *self, void *closure)
108 const struct block *block = NULL;
110 BLPY_REQUIRE_VALID (self, block);
112 return gdb_py_object_from_ulongest (BLOCK_START (block));
116 blpy_get_end (PyObject *self, void *closure)
118 const struct block *block = NULL;
120 BLPY_REQUIRE_VALID (self, block);
122 return gdb_py_object_from_ulongest (BLOCK_END (block));
126 blpy_get_function (PyObject *self, void *closure)
129 const struct block *block;
131 BLPY_REQUIRE_VALID (self, block);
133 sym = BLOCK_FUNCTION (block);
135 return symbol_to_symbol_object (sym);
141 blpy_get_superblock (PyObject *self, void *closure)
143 const struct block *block;
144 const struct block *super_block;
145 block_object *self_obj = (block_object *) self;
147 BLPY_REQUIRE_VALID (self, block);
149 super_block = BLOCK_SUPERBLOCK (block);
151 return block_to_block_object (super_block, self_obj->objfile);
156 /* Return the global block associated to this block. */
159 blpy_get_global_block (PyObject *self, void *closure)
161 const struct block *block;
162 const struct block *global_block;
163 block_object *self_obj = (block_object *) self;
165 BLPY_REQUIRE_VALID (self, block);
167 global_block = block_global_block (block);
169 return block_to_block_object (global_block,
174 /* Return the static block associated to this block. Return None
175 if we cannot get the static block (this is the global block). */
178 blpy_get_static_block (PyObject *self, void *closure)
180 const struct block *block;
181 const struct block *static_block;
182 block_object *self_obj = (block_object *) self;
184 BLPY_REQUIRE_VALID (self, block);
186 if (BLOCK_SUPERBLOCK (block) == NULL)
189 static_block = block_static_block (block);
191 return block_to_block_object (static_block, self_obj->objfile);
194 /* Implementation of gdb.Block.is_global (self) -> Boolean.
195 Returns True if this block object is a global block. */
198 blpy_is_global (PyObject *self, void *closure)
200 const struct block *block;
202 BLPY_REQUIRE_VALID (self, block);
204 if (BLOCK_SUPERBLOCK (block))
210 /* Implementation of gdb.Block.is_static (self) -> Boolean.
211 Returns True if this block object is a static block. */
214 blpy_is_static (PyObject *self, void *closure)
216 const struct block *block;
218 BLPY_REQUIRE_VALID (self, block);
220 if (BLOCK_SUPERBLOCK (block) != NULL
221 && BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL)
228 blpy_dealloc (PyObject *obj)
230 block_object *block = (block_object *) obj;
233 block->prev->next = block->next;
234 else if (block->objfile)
236 set_objfile_data (block->objfile, blpy_objfile_data_key,
240 block->next->prev = block->prev;
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
250 set_block (block_object *obj, const struct block *block,
251 struct objfile *objfile)
257 obj->objfile = objfile;
258 obj->next = objfile_data (objfile, blpy_objfile_data_key);
260 obj->next->prev = obj;
261 set_objfile_data (objfile, blpy_objfile_data_key, obj);
267 /* Create a new block object (gdb.Block) that encapsulates the struct
268 block object from GDB. */
270 block_to_block_object (const struct block *block, struct objfile *objfile)
272 block_object *block_obj;
274 block_obj = PyObject_New (block_object, &block_object_type);
276 set_block (block_obj, block, objfile);
278 return (PyObject *) block_obj;
281 /* Return struct block reference that is wrapped by this object. */
283 block_object_to_block (PyObject *obj)
285 if (! PyObject_TypeCheck (obj, &block_object_type))
287 return ((block_object *) obj)->block;
290 /* Return a reference to the block iterator. */
292 blpy_block_syms_iter (PyObject *self)
294 block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
296 BLPY_ITER_REQUIRE_VALID (iter_obj->source);
302 /* Return the next symbol in the iteration through the block's
305 blpy_block_syms_iternext (PyObject *self)
307 block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
310 BLPY_ITER_REQUIRE_VALID (iter_obj->source);
312 if (!iter_obj->initialized_p)
314 sym = block_iterator_first (iter_obj->block, &(iter_obj->iter));
315 iter_obj->initialized_p = 1;
318 sym = block_iterator_next (&(iter_obj->iter));
322 PyErr_SetString (PyExc_StopIteration, _("Symbol is null."));
326 return symbol_to_symbol_object (sym);
330 blpy_block_syms_dealloc (PyObject *obj)
332 block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) obj;
334 Py_XDECREF (iter_obj->source);
337 /* Implementation of gdb.Block.is_valid (self) -> Boolean.
338 Returns True if this block object still exists in GDB. */
341 blpy_is_valid (PyObject *self, PyObject *args)
343 const struct block *block;
345 block = block_object_to_block (self);
352 /* Implementation of gdb.BlockIterator.is_valid (self) -> Boolean.
353 Returns True if this block iterator object still exists in GDB */
356 blpy_iter_is_valid (PyObject *self, PyObject *args)
358 block_syms_iterator_object *iter_obj =
359 (block_syms_iterator_object *) self;
361 if (iter_obj->source->block == NULL)
367 /* Return the innermost lexical block containing the specified pc value,
368 or 0 if there is none. */
370 gdbpy_block_for_pc (PyObject *self, PyObject *args)
373 struct block *block = NULL;
374 struct obj_section *section = NULL;
375 struct symtab *symtab = NULL;
376 volatile struct gdb_exception except;
378 if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
381 TRY_CATCH (except, RETURN_MASK_ALL)
383 section = find_pc_mapped_section (pc);
384 symtab = find_pc_sect_symtab (pc, section);
386 if (symtab != NULL && symtab->objfile != NULL)
387 block = block_for_pc (pc);
389 GDB_PY_HANDLE_EXCEPTION (except);
391 if (!symtab || symtab->objfile == NULL)
393 PyErr_SetString (PyExc_RuntimeError,
394 _("Cannot locate object file for block."));
399 return block_to_block_object (block, symtab->objfile);
404 /* This function is called when an objfile is about to be freed.
405 Invalidate the block as further actions on the block would result
406 in bad data. All access to obj->symbol should be gated by
407 BLPY_REQUIRE_VALID which will raise an exception on invalid
410 del_objfile_blocks (struct objfile *objfile, void *datum)
412 block_object *obj = datum;
416 block_object *next = obj->next;
428 gdbpy_initialize_blocks (void)
430 block_object_type.tp_new = PyType_GenericNew;
431 if (PyType_Ready (&block_object_type) < 0)
434 block_syms_iterator_object_type.tp_new = PyType_GenericNew;
435 if (PyType_Ready (&block_syms_iterator_object_type) < 0)
438 /* Register an objfile "free" callback so we can properly
439 invalidate blocks when an object file is about to be
441 blpy_objfile_data_key
442 = register_objfile_data_with_cleanup (NULL, del_objfile_blocks);
444 Py_INCREF (&block_object_type);
445 PyModule_AddObject (gdb_module, "Block", (PyObject *) &block_object_type);
447 Py_INCREF (&block_syms_iterator_object_type);
448 PyModule_AddObject (gdb_module, "BlockIterator",
449 (PyObject *) &block_syms_iterator_object_type);
454 static PyMethodDef block_object_methods[] = {
455 { "is_valid", blpy_is_valid, METH_NOARGS,
456 "is_valid () -> Boolean.\n\
457 Return true if this block is valid, false if not." },
458 {NULL} /* Sentinel */
461 static PyGetSetDef block_object_getset[] = {
462 { "start", blpy_get_start, NULL, "Start address of the block.", NULL },
463 { "end", blpy_get_end, NULL, "End address of the block.", NULL },
464 { "function", blpy_get_function, NULL,
465 "Symbol that names the block, or None.", NULL },
466 { "superblock", blpy_get_superblock, NULL,
467 "Block containing the block, or None.", NULL },
468 { "global_block", blpy_get_global_block, NULL,
469 "Block containing the global block.", NULL },
470 { "static_block", blpy_get_static_block, NULL,
471 "Block containing the static block.", NULL },
472 { "is_static", blpy_is_static, NULL,
473 "Whether this block is a static block.", NULL },
474 { "is_global", blpy_is_global, NULL,
475 "Whether this block is a global block.", NULL },
476 { NULL } /* Sentinel */
479 PyTypeObject block_object_type = {
480 PyVarObject_HEAD_INIT (NULL, 0)
481 "gdb.Block", /*tp_name*/
482 sizeof (block_object), /*tp_basicsize*/
484 blpy_dealloc, /*tp_dealloc*/
491 0, /*tp_as_sequence*/
499 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
500 "GDB block object", /* tp_doc */
503 0, /* tp_richcompare */
504 0, /* tp_weaklistoffset */
505 blpy_iter, /* tp_iter */
507 block_object_methods, /* tp_methods */
509 block_object_getset /* tp_getset */
512 static PyMethodDef block_iterator_object_methods[] = {
513 { "is_valid", blpy_iter_is_valid, METH_NOARGS,
514 "is_valid () -> Boolean.\n\
515 Return true if this block iterator is valid, false if not." },
516 {NULL} /* Sentinel */
519 static PyTypeObject block_syms_iterator_object_type = {
520 PyVarObject_HEAD_INIT (NULL, 0)
521 "gdb.BlockIterator", /*tp_name*/
522 sizeof (block_syms_iterator_object), /*tp_basicsize*/
524 blpy_block_syms_dealloc, /*tp_dealloc*/
531 0, /*tp_as_sequence*/
539 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
540 "GDB block syms iterator object", /*tp_doc */
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 */