1 /* Python interface to symbol tables.
3 Copyright (C) 2008-2012 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
->filename
);
100 stpy_get_filename (PyObject
*self
, void *closure
)
103 struct symtab
*symtab
= NULL
;
105 STPY_REQUIRE_VALID (self
, symtab
);
107 str_obj
= PyString_Decode (symtab
->filename
,
108 strlen (symtab
->filename
),
109 host_charset (), NULL
);
114 stpy_get_objfile (PyObject
*self
, void *closure
)
116 struct symtab
*symtab
= NULL
;
119 STPY_REQUIRE_VALID (self
, symtab
);
121 result
= objfile_to_objfile_object (symtab
->objfile
);
127 stpy_fullname (PyObject
*self
, PyObject
*args
)
130 struct symtab
*symtab
= NULL
;
132 STPY_REQUIRE_VALID (self
, symtab
);
134 fullname
= symtab_to_fullname (symtab
);
136 return PyString_Decode (fullname
, strlen (fullname
),
137 host_charset (), NULL
);
142 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
143 Returns True if this Symbol table still exists in GDB. */
146 stpy_is_valid (PyObject
*self
, PyObject
*args
)
148 struct symtab
*symtab
= NULL
;
150 symtab
= symtab_object_to_symtab (self
);
157 /* Return the GLOBAL_BLOCK of the underlying symtab. */
160 stpy_global_block (PyObject
*self
, PyObject
*args
)
162 struct symtab
*symtab
= NULL
;
163 struct block
*block
= NULL
;
164 struct blockvector
*blockvector
;
166 STPY_REQUIRE_VALID (self
, symtab
);
168 blockvector
= BLOCKVECTOR (symtab
);
169 block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
170 return block_to_block_object (block
, symtab
->objfile
);
173 /* Return the STATIC_BLOCK of the underlying symtab. */
176 stpy_static_block (PyObject
*self
, PyObject
*args
)
178 struct symtab
*symtab
= NULL
;
179 struct block
*block
= NULL
;
180 struct blockvector
*blockvector
;
182 STPY_REQUIRE_VALID (self
, symtab
);
184 blockvector
= BLOCKVECTOR (symtab
);
185 block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
186 return block_to_block_object (block
, symtab
->objfile
);
190 salpy_str (PyObject
*self
)
195 struct symtab_and_line
*sal
= NULL
;
197 SALPY_REQUIRE_VALID (self
, sal
);
199 sal_obj
= (sal_object
*) self
;
200 filename
= (sal_obj
->symtab
== (symtab_object
*) Py_None
)
201 ? "<unknown>" : sal_obj
->symtab
->symtab
->filename
;
203 s
= xstrprintf ("symbol and line for %s, line %d", filename
,
206 result
= PyString_FromString (s
);
213 stpy_dealloc (PyObject
*obj
)
215 symtab_object
*symtab
= (symtab_object
*) obj
;
218 symtab
->prev
->next
= symtab
->next
;
219 else if (symtab
->symtab
)
221 set_objfile_data (symtab
->symtab
->objfile
,
222 stpy_objfile_data_key
, symtab
->next
);
225 symtab
->next
->prev
= symtab
->prev
;
226 symtab
->symtab
= NULL
;
231 salpy_get_pc (PyObject
*self
, void *closure
)
233 struct symtab_and_line
*sal
= NULL
;
235 SALPY_REQUIRE_VALID (self
, sal
);
237 return gdb_py_long_from_ulongest (sal
->pc
);
241 salpy_get_line (PyObject
*self
, void *closure
)
243 struct symtab_and_line
*sal
= NULL
;
245 SALPY_REQUIRE_VALID (self
, sal
);
247 return PyInt_FromLong (sal
->line
);
251 salpy_get_symtab (PyObject
*self
, void *closure
)
253 struct symtab_and_line
*sal
;
254 sal_object
*self_sal
= (sal_object
*) self
;
256 SALPY_REQUIRE_VALID (self
, sal
);
258 Py_INCREF (self_sal
->symtab
);
260 return (PyObject
*) self_sal
->symtab
;
263 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
264 Returns True if this Symbol table and line object still exists GDB. */
267 salpy_is_valid (PyObject
*self
, PyObject
*args
)
269 struct symtab_and_line
*sal
;
271 sal
= sal_object_to_symtab_and_line (self
);
279 salpy_dealloc (PyObject
*self
)
281 sal_object
*self_sal
= (sal_object
*) self
;
284 self_sal
->prev
->next
= self_sal
->next
;
285 else if (self_sal
->symtab
!= (symtab_object
* ) Py_None
)
286 set_objfile_data (self_sal
->symtab
->symtab
->objfile
,
287 salpy_objfile_data_key
, self_sal
->next
);
290 self_sal
->next
->prev
= self_sal
->prev
;
292 Py_DECREF (self_sal
->symtab
);
293 xfree (self_sal
->sal
);
294 self_sal
->ob_type
->tp_free (self
);
297 /* Given a sal, and a sal_object that has previously been allocated
298 and initialized, populate the sal_object with the struct sal data.
299 Also, register the sal_object life-cycle with the life-cycle of the
300 object file associated with this sal, if needed. If a failure
301 occurs during the sal population, this function will return
304 set_sal (sal_object
*sal_obj
, struct symtab_and_line sal
)
306 symtab_object
*symtab_obj
;
310 symtab_obj
= (symtab_object
*) symtab_to_symtab_object (sal
.symtab
);
311 /* If a symtab existed in the sal, but it cannot be duplicated,
313 if (symtab_obj
== NULL
)
318 symtab_obj
= (symtab_object
*) Py_None
;
322 sal_obj
->sal
= xmemdup (&sal
, sizeof (struct symtab_and_line
),
323 sizeof (struct symtab_and_line
));
324 sal_obj
->symtab
= symtab_obj
;
325 sal_obj
->prev
= NULL
;
327 /* If the SAL does not have a symtab, we do not add it to the
328 objfile cleanup observer linked list. */
329 if (sal_obj
->symtab
!= (symtab_object
*)Py_None
)
331 sal_obj
->next
= objfile_data (sal_obj
->symtab
->symtab
->objfile
,
332 salpy_objfile_data_key
);
334 sal_obj
->next
->prev
= sal_obj
;
336 set_objfile_data (sal_obj
->symtab
->symtab
->objfile
,
337 salpy_objfile_data_key
, sal_obj
);
340 sal_obj
->next
= NULL
;
345 /* Given a symtab, and a symtab_object that has previously been
346 allocated and initialized, populate the symtab_object with the
347 struct symtab data. Also, register the symtab_object life-cycle
348 with the life-cycle of the object file associated with this
349 symtab, if needed. */
351 set_symtab (symtab_object
*obj
, struct symtab
*symtab
)
353 obj
->symtab
= symtab
;
357 obj
->next
= objfile_data (symtab
->objfile
, stpy_objfile_data_key
);
359 obj
->next
->prev
= obj
;
360 set_objfile_data (symtab
->objfile
, stpy_objfile_data_key
, obj
);
366 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
367 symtab structure from GDB. */
369 symtab_to_symtab_object (struct symtab
*symtab
)
371 symtab_object
*symtab_obj
;
373 symtab_obj
= PyObject_New (symtab_object
, &symtab_object_type
);
375 set_symtab (symtab_obj
, symtab
);
377 return (PyObject
*) symtab_obj
;
380 /* Create a new symtab and line (gdb.Symtab_and_line) object
381 that encapsulates the symtab_and_line structure from GDB. */
383 symtab_and_line_to_sal_object (struct symtab_and_line sal
)
389 sal_obj
= PyObject_New (sal_object
, &sal_object_type
);
392 success
= set_sal (sal_obj
, sal
);
400 return (PyObject
*) sal_obj
;
403 /* Return struct symtab_and_line reference that is wrapped by this
405 struct symtab_and_line
*
406 sal_object_to_symtab_and_line (PyObject
*obj
)
408 if (! PyObject_TypeCheck (obj
, &sal_object_type
))
410 return ((sal_object
*) obj
)->sal
;
413 /* Return struct symtab reference that is wrapped by this object. */
415 symtab_object_to_symtab (PyObject
*obj
)
417 if (! PyObject_TypeCheck (obj
, &symtab_object_type
))
419 return ((symtab_object
*) obj
)->symtab
;
422 /* This function is called when an objfile is about to be freed.
423 Invalidate the symbol table as further actions on the symbol table
424 would result in bad data. All access to obj->symtab should be
425 gated by STPY_REQUIRE_VALID which will raise an exception on
426 invalid symbol tables. */
428 del_objfile_symtab (struct objfile
*objfile
, void *datum
)
430 symtab_object
*obj
= datum
;
434 symtab_object
*next
= obj
->next
;
443 /* This function is called when an objfile is about to be freed.
444 Invalidate the sal object as further actions on the sal
445 would result in bad data. All access to obj->sal should be
446 gated by SALPY_REQUIRE_VALID which will raise an exception on
447 invalid symbol table and line objects. */
449 del_objfile_sal (struct objfile
*objfile
, void *datum
)
451 sal_object
*obj
= datum
;
455 sal_object
*next
= obj
->next
;
468 gdbpy_initialize_symtabs (void)
470 symtab_object_type
.tp_new
= PyType_GenericNew
;
471 if (PyType_Ready (&symtab_object_type
) < 0)
474 sal_object_type
.tp_new
= PyType_GenericNew
;
475 if (PyType_Ready (&sal_object_type
) < 0)
478 /* Register an objfile "free" callback so we can properly
479 invalidate symbol tables, and symbol table and line data
480 structures when an object file that is about to be
482 stpy_objfile_data_key
483 = register_objfile_data_with_cleanup (NULL
, del_objfile_symtab
);
484 salpy_objfile_data_key
485 = register_objfile_data_with_cleanup (NULL
, del_objfile_sal
);
487 Py_INCREF (&symtab_object_type
);
488 PyModule_AddObject (gdb_module
, "Symtab",
489 (PyObject
*) &symtab_object_type
);
491 Py_INCREF (&sal_object_type
);
492 PyModule_AddObject (gdb_module
, "Symtab_and_line",
493 (PyObject
*) &sal_object_type
);
498 static PyGetSetDef symtab_object_getset
[] = {
499 { "filename", stpy_get_filename
, NULL
,
500 "The symbol table's source filename.", NULL
},
501 { "objfile", stpy_get_objfile
, NULL
, "The symtab's objfile.",
503 {NULL
} /* Sentinel */
506 static PyMethodDef symtab_object_methods
[] = {
507 { "is_valid", stpy_is_valid
, METH_NOARGS
,
508 "is_valid () -> Boolean.\n\
509 Return true if this symbol table is valid, false if not." },
510 { "fullname", stpy_fullname
, METH_NOARGS
,
511 "fullname () -> String.\n\
512 Return the symtab's full source filename." },
513 { "global_block", stpy_global_block
, METH_NOARGS
,
514 "global_block () -> gdb.Block.\n\
515 Return the global block of the symbol table." },
516 { "static_block", stpy_static_block
, METH_NOARGS
,
517 "static_block () -> gdb.Block.\n\
518 Return the static block of the symbol table." },
519 {NULL
} /* Sentinel */
522 static PyTypeObject symtab_object_type
= {
523 PyObject_HEAD_INIT (NULL
)
525 "gdb.Symtab", /*tp_name*/
526 sizeof (symtab_object
), /*tp_basicsize*/
528 stpy_dealloc
, /*tp_dealloc*/
535 0, /*tp_as_sequence*/
543 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
544 "GDB symtab object", /*tp_doc */
547 0, /*tp_richcompare */
548 0, /*tp_weaklistoffset */
551 symtab_object_methods
, /*tp_methods */
553 symtab_object_getset
/*tp_getset */
556 static PyGetSetDef sal_object_getset
[] = {
557 { "symtab", salpy_get_symtab
, NULL
, "Symtab object.", NULL
},
558 { "pc", salpy_get_pc
, NULL
, "Return the symtab_and_line's pc.", NULL
},
559 { "line", salpy_get_line
, NULL
,
560 "Return the symtab_and_line's line.", NULL
},
561 {NULL
} /* Sentinel */
564 static PyMethodDef sal_object_methods
[] = {
565 { "is_valid", salpy_is_valid
, METH_NOARGS
,
566 "is_valid () -> Boolean.\n\
567 Return true if this symbol table and line is valid, false if not." },
568 {NULL
} /* Sentinel */
571 static PyTypeObject sal_object_type
= {
572 PyObject_HEAD_INIT (NULL
)
574 "gdb.Symtab_and_line", /*tp_name*/
575 sizeof (sal_object
), /*tp_basicsize*/
577 salpy_dealloc
, /*tp_dealloc*/
584 0, /*tp_as_sequence*/
588 salpy_str
, /*tp_str*/
592 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
593 "GDB symtab_and_line object", /*tp_doc */
596 0, /*tp_richcompare */
597 0, /*tp_weaklistoffset */
600 sal_object_methods
, /*tp_methods */
602 sal_object_getset
/*tp_getset */