1 /* Python interface to symbol tables.
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/>. */
24 #include "python-internal.h"
28 typedef struct stpy_symtab_object {
30 /* The GDB Symbol table structure. */
31 struct symtab *symtab;
32 /* A symtab object is associated with an objfile, so keep track with
33 a doubly-linked list, rooted in the objfile. This allows
34 invalidation of the underlying struct symtab when the objfile is
36 struct stpy_symtab_object *prev;
37 struct stpy_symtab_object *next;
40 static PyTypeObject symtab_object_type;
41 static const struct objfile_data *stpy_objfile_data_key;
43 /* Require a valid symbol table. All access to symtab_object->symtab
44 should be gated by this call. */
45 #define STPY_REQUIRE_VALID(symtab_obj, symtab) \
47 symtab = symtab_object_to_symtab (symtab_obj); \
50 PyErr_SetString (PyExc_RuntimeError, \
51 _("Symbol Table is invalid.")); \
56 typedef struct salpy_sal_object {
58 /* The GDB Symbol table structure. */
59 symtab_object *symtab;
60 /* The GDB Symbol table and line structure. */
61 struct symtab_and_line *sal;
62 /* A Symtab and line object is associated with an objfile, so keep
63 track with a doubly-linked list, rooted in the objfile. This
64 allows invalidation of the underlying struct symtab_and_line
65 when the objfile is deleted. */
66 struct salpy_sal_object *prev;
67 struct salpy_sal_object *next;
70 static PyTypeObject sal_object_type;
71 static const struct objfile_data *salpy_objfile_data_key;
73 /* Require a valid symbol table and line object. All access to
74 sal_object->sal should be gated by this call. */
75 #define SALPY_REQUIRE_VALID(sal_obj, sal) \
77 sal = sal_object_to_symtab_and_line (sal_obj); \
80 PyErr_SetString (PyExc_RuntimeError, \
81 _("Symbol Table and Line is invalid.")); \
87 stpy_str (PyObject *self)
90 struct symtab *symtab = NULL;
92 STPY_REQUIRE_VALID (self, symtab);
94 result = PyString_FromString (symtab_to_filename_for_display (symtab));
100 stpy_get_filename (PyObject *self, void *closure)
103 struct symtab *symtab = NULL;
104 const char *filename;
106 STPY_REQUIRE_VALID (self, symtab);
107 filename = symtab_to_filename_for_display (symtab);
109 str_obj = PyString_Decode (filename, strlen (filename),
110 host_charset (), NULL);
115 stpy_get_objfile (PyObject *self, void *closure)
117 struct symtab *symtab = NULL;
120 STPY_REQUIRE_VALID (self, symtab);
122 result = objfile_to_objfile_object (symtab->objfile);
128 stpy_fullname (PyObject *self, PyObject *args)
130 const char *fullname;
131 struct symtab *symtab = NULL;
133 STPY_REQUIRE_VALID (self, symtab);
135 fullname = symtab_to_fullname (symtab);
137 return PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
140 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
141 Returns True if this Symbol table still exists in GDB. */
144 stpy_is_valid (PyObject *self, PyObject *args)
146 struct symtab *symtab = NULL;
148 symtab = symtab_object_to_symtab (self);
155 /* Return the GLOBAL_BLOCK of the underlying symtab. */
158 stpy_global_block (PyObject *self, PyObject *args)
160 struct symtab *symtab = NULL;
161 struct block *block = NULL;
162 struct blockvector *blockvector;
164 STPY_REQUIRE_VALID (self, symtab);
166 blockvector = BLOCKVECTOR (symtab);
167 block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
168 return block_to_block_object (block, symtab->objfile);
171 /* Return the STATIC_BLOCK of the underlying symtab. */
174 stpy_static_block (PyObject *self, PyObject *args)
176 struct symtab *symtab = NULL;
177 struct block *block = NULL;
178 struct blockvector *blockvector;
180 STPY_REQUIRE_VALID (self, symtab);
182 blockvector = BLOCKVECTOR (symtab);
183 block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
184 return block_to_block_object (block, symtab->objfile);
188 salpy_str (PyObject *self)
191 const char *filename;
194 struct symtab_and_line *sal = NULL;
196 SALPY_REQUIRE_VALID (self, sal);
198 sal_obj = (sal_object *) self;
199 filename = (sal_obj->symtab == (symtab_object *) Py_None)
200 ? "<unknown>" : symtab_to_filename_for_display (sal_obj->symtab->symtab);
202 s = xstrprintf ("symbol and line for %s, line %d", filename,
205 result = PyString_FromString (s);
212 stpy_dealloc (PyObject *obj)
214 symtab_object *symtab = (symtab_object *) obj;
217 symtab->prev->next = symtab->next;
218 else if (symtab->symtab)
220 set_objfile_data (symtab->symtab->objfile,
221 stpy_objfile_data_key, symtab->next);
224 symtab->next->prev = symtab->prev;
225 symtab->symtab = NULL;
230 salpy_get_pc (PyObject *self, void *closure)
232 struct symtab_and_line *sal = NULL;
234 SALPY_REQUIRE_VALID (self, sal);
236 return gdb_py_long_from_ulongest (sal->pc);
239 /* Implementation of the get method for the 'last' attribute of
240 gdb.Symtab_and_line. */
243 salpy_get_last (PyObject *self, void *closure)
245 struct symtab_and_line *sal = NULL;
247 SALPY_REQUIRE_VALID (self, sal);
250 return gdb_py_long_from_ulongest (sal->end - 1);
256 salpy_get_line (PyObject *self, void *closure)
258 struct symtab_and_line *sal = NULL;
260 SALPY_REQUIRE_VALID (self, sal);
262 return PyInt_FromLong (sal->line);
266 salpy_get_symtab (PyObject *self, void *closure)
268 struct symtab_and_line *sal;
269 sal_object *self_sal = (sal_object *) self;
271 SALPY_REQUIRE_VALID (self, sal);
273 Py_INCREF (self_sal->symtab);
275 return (PyObject *) self_sal->symtab;
278 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
279 Returns True if this Symbol table and line object still exists GDB. */
282 salpy_is_valid (PyObject *self, PyObject *args)
284 struct symtab_and_line *sal;
286 sal = sal_object_to_symtab_and_line (self);
294 salpy_dealloc (PyObject *self)
296 sal_object *self_sal = (sal_object *) self;
299 self_sal->prev->next = self_sal->next;
300 else if (self_sal->symtab != (symtab_object * ) Py_None)
301 set_objfile_data (self_sal->symtab->symtab->objfile,
302 salpy_objfile_data_key, self_sal->next);
305 self_sal->next->prev = self_sal->prev;
307 Py_DECREF (self_sal->symtab);
308 xfree (self_sal->sal);
309 Py_TYPE (self)->tp_free (self);
312 /* Given a sal, and a sal_object that has previously been allocated
313 and initialized, populate the sal_object with the struct sal data.
314 Also, register the sal_object life-cycle with the life-cycle of the
315 object file associated with this sal, if needed. If a failure
316 occurs during the sal population, this function will return
319 set_sal (sal_object *sal_obj, struct symtab_and_line sal)
321 symtab_object *symtab_obj;
325 symtab_obj = (symtab_object *) symtab_to_symtab_object (sal.symtab);
326 /* If a symtab existed in the sal, but it cannot be duplicated,
328 if (symtab_obj == NULL)
333 symtab_obj = (symtab_object *) Py_None;
337 sal_obj->sal = xmemdup (&sal, sizeof (struct symtab_and_line),
338 sizeof (struct symtab_and_line));
339 sal_obj->symtab = symtab_obj;
340 sal_obj->prev = NULL;
342 /* If the SAL does not have a symtab, we do not add it to the
343 objfile cleanup observer linked list. */
344 if (sal_obj->symtab != (symtab_object *)Py_None)
346 sal_obj->next = objfile_data (sal_obj->symtab->symtab->objfile,
347 salpy_objfile_data_key);
349 sal_obj->next->prev = sal_obj;
351 set_objfile_data (sal_obj->symtab->symtab->objfile,
352 salpy_objfile_data_key, sal_obj);
355 sal_obj->next = NULL;
360 /* Given a symtab, and a symtab_object that has previously been
361 allocated and initialized, populate the symtab_object with the
362 struct symtab data. Also, register the symtab_object life-cycle
363 with the life-cycle of the object file associated with this
364 symtab, if needed. */
366 set_symtab (symtab_object *obj, struct symtab *symtab)
368 obj->symtab = symtab;
372 obj->next = objfile_data (symtab->objfile, stpy_objfile_data_key);
374 obj->next->prev = obj;
375 set_objfile_data (symtab->objfile, stpy_objfile_data_key, obj);
381 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
382 symtab structure from GDB. */
384 symtab_to_symtab_object (struct symtab *symtab)
386 symtab_object *symtab_obj;
388 symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
390 set_symtab (symtab_obj, symtab);
392 return (PyObject *) symtab_obj;
395 /* Create a new symtab and line (gdb.Symtab_and_line) object
396 that encapsulates the symtab_and_line structure from GDB. */
398 symtab_and_line_to_sal_object (struct symtab_and_line sal)
404 sal_obj = PyObject_New (sal_object, &sal_object_type);
407 success = set_sal (sal_obj, sal);
415 return (PyObject *) sal_obj;
418 /* Return struct symtab_and_line reference that is wrapped by this
420 struct symtab_and_line *
421 sal_object_to_symtab_and_line (PyObject *obj)
423 if (! PyObject_TypeCheck (obj, &sal_object_type))
425 return ((sal_object *) obj)->sal;
428 /* Return struct symtab reference that is wrapped by this object. */
430 symtab_object_to_symtab (PyObject *obj)
432 if (! PyObject_TypeCheck (obj, &symtab_object_type))
434 return ((symtab_object *) obj)->symtab;
437 /* This function is called when an objfile is about to be freed.
438 Invalidate the symbol table as further actions on the symbol table
439 would result in bad data. All access to obj->symtab should be
440 gated by STPY_REQUIRE_VALID which will raise an exception on
441 invalid symbol tables. */
443 del_objfile_symtab (struct objfile *objfile, void *datum)
445 symtab_object *obj = datum;
449 symtab_object *next = obj->next;
458 /* This function is called when an objfile is about to be freed.
459 Invalidate the sal object as further actions on the sal
460 would result in bad data. All access to obj->sal should be
461 gated by SALPY_REQUIRE_VALID which will raise an exception on
462 invalid symbol table and line objects. */
464 del_objfile_sal (struct objfile *objfile, void *datum)
466 sal_object *obj = datum;
470 sal_object *next = obj->next;
472 Py_DECREF (obj->symtab);
473 obj->symtab = (symtab_object *) Py_None;
486 gdbpy_initialize_symtabs (void)
488 symtab_object_type.tp_new = PyType_GenericNew;
489 if (PyType_Ready (&symtab_object_type) < 0)
492 sal_object_type.tp_new = PyType_GenericNew;
493 if (PyType_Ready (&sal_object_type) < 0)
496 /* Register an objfile "free" callback so we can properly
497 invalidate symbol tables, and symbol table and line data
498 structures when an object file that is about to be
500 stpy_objfile_data_key
501 = register_objfile_data_with_cleanup (NULL, del_objfile_symtab);
502 salpy_objfile_data_key
503 = register_objfile_data_with_cleanup (NULL, del_objfile_sal);
505 Py_INCREF (&symtab_object_type);
506 PyModule_AddObject (gdb_module, "Symtab",
507 (PyObject *) &symtab_object_type);
509 Py_INCREF (&sal_object_type);
510 PyModule_AddObject (gdb_module, "Symtab_and_line",
511 (PyObject *) &sal_object_type);
516 static PyGetSetDef symtab_object_getset[] = {
517 { "filename", stpy_get_filename, NULL,
518 "The symbol table's source filename.", NULL },
519 { "objfile", stpy_get_objfile, NULL, "The symtab's objfile.",
521 {NULL} /* Sentinel */
524 static PyMethodDef symtab_object_methods[] = {
525 { "is_valid", stpy_is_valid, METH_NOARGS,
526 "is_valid () -> Boolean.\n\
527 Return true if this symbol table is valid, false if not." },
528 { "fullname", stpy_fullname, METH_NOARGS,
529 "fullname () -> String.\n\
530 Return the symtab's full source filename." },
531 { "global_block", stpy_global_block, METH_NOARGS,
532 "global_block () -> gdb.Block.\n\
533 Return the global block of the symbol table." },
534 { "static_block", stpy_static_block, METH_NOARGS,
535 "static_block () -> gdb.Block.\n\
536 Return the static block of the symbol table." },
537 {NULL} /* Sentinel */
540 static PyTypeObject symtab_object_type = {
541 PyVarObject_HEAD_INIT (NULL, 0)
542 "gdb.Symtab", /*tp_name*/
543 sizeof (symtab_object), /*tp_basicsize*/
545 stpy_dealloc, /*tp_dealloc*/
552 0, /*tp_as_sequence*/
560 Py_TPFLAGS_DEFAULT, /*tp_flags*/
561 "GDB symtab object", /*tp_doc */
564 0, /*tp_richcompare */
565 0, /*tp_weaklistoffset */
568 symtab_object_methods, /*tp_methods */
570 symtab_object_getset /*tp_getset */
573 static PyGetSetDef sal_object_getset[] = {
574 { "symtab", salpy_get_symtab, NULL, "Symtab object.", NULL },
575 { "pc", salpy_get_pc, NULL, "Return the symtab_and_line's pc.", NULL },
576 { "last", salpy_get_last, NULL,
577 "Return the symtab_and_line's last address.", NULL },
578 { "line", salpy_get_line, NULL,
579 "Return the symtab_and_line's line.", NULL },
580 {NULL} /* Sentinel */
583 static PyMethodDef sal_object_methods[] = {
584 { "is_valid", salpy_is_valid, METH_NOARGS,
585 "is_valid () -> Boolean.\n\
586 Return true if this symbol table and line is valid, false if not." },
587 {NULL} /* Sentinel */
590 static PyTypeObject sal_object_type = {
591 PyVarObject_HEAD_INIT (NULL, 0)
592 "gdb.Symtab_and_line", /*tp_name*/
593 sizeof (sal_object), /*tp_basicsize*/
595 salpy_dealloc, /*tp_dealloc*/
602 0, /*tp_as_sequence*/
606 salpy_str, /*tp_str*/
610 Py_TPFLAGS_DEFAULT, /*tp_flags*/
611 "GDB symtab_and_line object", /*tp_doc */
614 0, /*tp_richcompare */
615 0, /*tp_weaklistoffset */
618 sal_object_methods, /*tp_methods */
620 sal_object_getset /*tp_getset */