1 /* Python interface to symbol tables.
3 Copyright (C) 2008-2017 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"
29 typedef struct stpy_symtab_object
{
31 /* The GDB Symbol table structure. */
32 struct symtab
*symtab
;
33 /* A symtab object is associated with an objfile, so keep track with
34 a doubly-linked list, rooted in the objfile. This allows
35 invalidation of the underlying struct symtab when the objfile is
37 struct stpy_symtab_object
*prev
;
38 struct stpy_symtab_object
*next
;
41 extern PyTypeObject symtab_object_type
42 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symtab_object");
43 static const struct objfile_data
*stpy_objfile_data_key
;
45 /* Require a valid symbol table. All access to symtab_object->symtab
46 should be gated by this call. */
47 #define STPY_REQUIRE_VALID(symtab_obj, symtab) \
49 symtab = symtab_object_to_symtab (symtab_obj); \
52 PyErr_SetString (PyExc_RuntimeError, \
53 _("Symbol Table is invalid.")); \
58 typedef struct salpy_sal_object
{
60 /* The GDB Symbol table structure. */
61 symtab_object
*symtab
;
62 /* The GDB Symbol table and line structure. */
63 struct symtab_and_line
*sal
;
64 /* A Symtab and line object is associated with an objfile, so keep
65 track with a doubly-linked list, rooted in the objfile. This
66 allows invalidation of the underlying struct symtab_and_line
67 when the objfile is deleted. */
68 struct salpy_sal_object
*prev
;
69 struct salpy_sal_object
*next
;
72 extern PyTypeObject sal_object_type
73 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("sal_object");
74 static const struct objfile_data
*salpy_objfile_data_key
;
76 /* Require a valid symbol table and line object. All access to
77 sal_object->sal should be gated by this call. */
78 #define SALPY_REQUIRE_VALID(sal_obj, sal) \
80 sal = sal_object_to_symtab_and_line (sal_obj); \
83 PyErr_SetString (PyExc_RuntimeError, \
84 _("Symbol Table and Line is invalid.")); \
90 stpy_str (PyObject
*self
)
93 struct symtab
*symtab
= NULL
;
95 STPY_REQUIRE_VALID (self
, symtab
);
97 result
= PyString_FromString (symtab_to_filename_for_display (symtab
));
103 stpy_get_filename (PyObject
*self
, void *closure
)
106 struct symtab
*symtab
= NULL
;
107 const char *filename
;
109 STPY_REQUIRE_VALID (self
, symtab
);
110 filename
= symtab_to_filename_for_display (symtab
);
112 str_obj
= host_string_to_python_string (filename
);
117 stpy_get_objfile (PyObject
*self
, void *closure
)
119 struct symtab
*symtab
= NULL
;
122 STPY_REQUIRE_VALID (self
, symtab
);
124 result
= objfile_to_objfile_object (SYMTAB_OBJFILE (symtab
));
129 /* Getter function for symtab.producer. */
132 stpy_get_producer (PyObject
*self
, void *closure
)
134 struct symtab
*symtab
= NULL
;
135 struct compunit_symtab
*cust
;
137 STPY_REQUIRE_VALID (self
, symtab
);
138 cust
= SYMTAB_COMPUNIT (symtab
);
139 if (COMPUNIT_PRODUCER (cust
) != NULL
)
141 const char *producer
= COMPUNIT_PRODUCER (cust
);
143 return host_string_to_python_string (producer
);
150 stpy_fullname (PyObject
*self
, PyObject
*args
)
152 const char *fullname
;
153 struct symtab
*symtab
= NULL
;
155 STPY_REQUIRE_VALID (self
, symtab
);
157 fullname
= symtab_to_fullname (symtab
);
159 return host_string_to_python_string (fullname
);
162 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
163 Returns True if this Symbol table still exists in GDB. */
166 stpy_is_valid (PyObject
*self
, PyObject
*args
)
168 struct symtab
*symtab
= NULL
;
170 symtab
= symtab_object_to_symtab (self
);
177 /* Return the GLOBAL_BLOCK of the underlying symtab. */
180 stpy_global_block (PyObject
*self
, PyObject
*args
)
182 struct symtab
*symtab
= NULL
;
183 struct block
*block
= NULL
;
184 const struct blockvector
*blockvector
;
186 STPY_REQUIRE_VALID (self
, symtab
);
188 blockvector
= SYMTAB_BLOCKVECTOR (symtab
);
189 block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
190 return block_to_block_object (block
, SYMTAB_OBJFILE (symtab
));
193 /* Return the STATIC_BLOCK of the underlying symtab. */
196 stpy_static_block (PyObject
*self
, PyObject
*args
)
198 struct symtab
*symtab
= NULL
;
199 struct block
*block
= NULL
;
200 const struct blockvector
*blockvector
;
202 STPY_REQUIRE_VALID (self
, symtab
);
204 blockvector
= SYMTAB_BLOCKVECTOR (symtab
);
205 block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
206 return block_to_block_object (block
, SYMTAB_OBJFILE (symtab
));
209 /* Implementation of gdb.Symtab.linetable (self) -> gdb.LineTable.
210 Returns a gdb.LineTable object corresponding to this symbol
214 stpy_get_linetable (PyObject
*self
, PyObject
*args
)
216 struct symtab
*symtab
= NULL
;
218 STPY_REQUIRE_VALID (self
, symtab
);
220 return symtab_to_linetable_object (self
);
224 salpy_str (PyObject
*self
)
227 const char *filename
;
230 struct symtab_and_line
*sal
= NULL
;
232 SALPY_REQUIRE_VALID (self
, sal
);
234 sal_obj
= (sal_object
*) self
;
235 filename
= (sal_obj
->symtab
== (symtab_object
*) Py_None
)
236 ? "<unknown>" : symtab_to_filename_for_display (sal_obj
->symtab
->symtab
);
238 s
= xstrprintf ("symbol and line for %s, line %d", filename
,
241 result
= PyString_FromString (s
);
248 stpy_dealloc (PyObject
*obj
)
250 symtab_object
*symtab
= (symtab_object
*) obj
;
253 symtab
->prev
->next
= symtab
->next
;
254 else if (symtab
->symtab
)
256 set_objfile_data (SYMTAB_OBJFILE (symtab
->symtab
),
257 stpy_objfile_data_key
, symtab
->next
);
260 symtab
->next
->prev
= symtab
->prev
;
261 symtab
->symtab
= NULL
;
266 salpy_get_pc (PyObject
*self
, void *closure
)
268 struct symtab_and_line
*sal
= NULL
;
270 SALPY_REQUIRE_VALID (self
, sal
);
272 return gdb_py_long_from_ulongest (sal
->pc
);
275 /* Implementation of the get method for the 'last' attribute of
276 gdb.Symtab_and_line. */
279 salpy_get_last (PyObject
*self
, void *closure
)
281 struct symtab_and_line
*sal
= NULL
;
283 SALPY_REQUIRE_VALID (self
, sal
);
286 return gdb_py_long_from_ulongest (sal
->end
- 1);
292 salpy_get_line (PyObject
*self
, void *closure
)
294 struct symtab_and_line
*sal
= NULL
;
296 SALPY_REQUIRE_VALID (self
, sal
);
298 return PyInt_FromLong (sal
->line
);
302 salpy_get_symtab (PyObject
*self
, void *closure
)
304 struct symtab_and_line
*sal
;
305 sal_object
*self_sal
= (sal_object
*) self
;
307 SALPY_REQUIRE_VALID (self
, sal
);
309 Py_INCREF (self_sal
->symtab
);
311 return (PyObject
*) self_sal
->symtab
;
314 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
315 Returns True if this Symbol table and line object still exists GDB. */
318 salpy_is_valid (PyObject
*self
, PyObject
*args
)
320 struct symtab_and_line
*sal
;
322 sal
= sal_object_to_symtab_and_line (self
);
330 salpy_dealloc (PyObject
*self
)
332 sal_object
*self_sal
= (sal_object
*) self
;
335 self_sal
->prev
->next
= self_sal
->next
;
336 else if (self_sal
->symtab
!= (symtab_object
* ) Py_None
)
337 set_objfile_data (SYMTAB_OBJFILE (self_sal
->symtab
->symtab
),
338 salpy_objfile_data_key
, self_sal
->next
);
341 self_sal
->next
->prev
= self_sal
->prev
;
343 Py_DECREF (self_sal
->symtab
);
344 xfree (self_sal
->sal
);
345 Py_TYPE (self
)->tp_free (self
);
348 /* Given a sal, and a sal_object that has previously been allocated
349 and initialized, populate the sal_object with the struct sal data.
350 Also, register the sal_object life-cycle with the life-cycle of the
351 object file associated with this sal, if needed. If a failure
352 occurs during the sal population, this function will return -1. */
353 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
354 set_sal (sal_object
*sal_obj
, struct symtab_and_line sal
)
356 symtab_object
*symtab_obj
;
360 symtab_obj
= (symtab_object
*) symtab_to_symtab_object (sal
.symtab
);
361 /* If a symtab existed in the sal, but it cannot be duplicated,
363 if (symtab_obj
== NULL
)
368 symtab_obj
= (symtab_object
*) Py_None
;
372 sal_obj
->sal
= ((struct symtab_and_line
*)
373 xmemdup (&sal
, sizeof (struct symtab_and_line
),
374 sizeof (struct symtab_and_line
)));
375 sal_obj
->symtab
= symtab_obj
;
376 sal_obj
->prev
= NULL
;
378 /* If the SAL does not have a symtab, we do not add it to the
379 objfile cleanup observer linked list. */
380 if (sal_obj
->symtab
!= (symtab_object
*)Py_None
)
383 = ((struct salpy_sal_object
*)
384 objfile_data (SYMTAB_OBJFILE (sal_obj
->symtab
->symtab
),
385 salpy_objfile_data_key
));
387 sal_obj
->next
->prev
= sal_obj
;
389 set_objfile_data (SYMTAB_OBJFILE (sal_obj
->symtab
->symtab
),
390 salpy_objfile_data_key
, sal_obj
);
393 sal_obj
->next
= NULL
;
398 /* Given a symtab, and a symtab_object that has previously been
399 allocated and initialized, populate the symtab_object with the
400 struct symtab data. Also, register the symtab_object life-cycle
401 with the life-cycle of the object file associated with this
402 symtab, if needed. */
404 set_symtab (symtab_object
*obj
, struct symtab
*symtab
)
406 obj
->symtab
= symtab
;
411 = ((struct stpy_symtab_object
*)
412 objfile_data (SYMTAB_OBJFILE (symtab
), stpy_objfile_data_key
));
414 obj
->next
->prev
= obj
;
415 set_objfile_data (SYMTAB_OBJFILE (symtab
), stpy_objfile_data_key
, obj
);
421 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
422 symtab structure from GDB. */
424 symtab_to_symtab_object (struct symtab
*symtab
)
426 symtab_object
*symtab_obj
;
428 symtab_obj
= PyObject_New (symtab_object
, &symtab_object_type
);
430 set_symtab (symtab_obj
, symtab
);
432 return (PyObject
*) symtab_obj
;
435 /* Create a new symtab and line (gdb.Symtab_and_line) object
436 that encapsulates the symtab_and_line structure from GDB. */
438 symtab_and_line_to_sal_object (struct symtab_and_line sal
)
440 gdbpy_ref
<sal_object
> sal_obj (PyObject_New (sal_object
, &sal_object_type
));
443 if (set_sal (sal_obj
.get (), sal
) < 0)
447 return (PyObject
*) sal_obj
.release ();
450 /* Return struct symtab_and_line reference that is wrapped by this
452 struct symtab_and_line
*
453 sal_object_to_symtab_and_line (PyObject
*obj
)
455 if (! PyObject_TypeCheck (obj
, &sal_object_type
))
457 return ((sal_object
*) obj
)->sal
;
460 /* Return struct symtab reference that is wrapped by this object. */
462 symtab_object_to_symtab (PyObject
*obj
)
464 if (! PyObject_TypeCheck (obj
, &symtab_object_type
))
466 return ((symtab_object
*) obj
)->symtab
;
469 /* This function is called when an objfile is about to be freed.
470 Invalidate the symbol table as further actions on the symbol table
471 would result in bad data. All access to obj->symtab should be
472 gated by STPY_REQUIRE_VALID which will raise an exception on
473 invalid symbol tables. */
475 del_objfile_symtab (struct objfile
*objfile
, void *datum
)
477 symtab_object
*obj
= (symtab_object
*) datum
;
481 symtab_object
*next
= obj
->next
;
490 /* This function is called when an objfile is about to be freed.
491 Invalidate the sal object as further actions on the sal
492 would result in bad data. All access to obj->sal should be
493 gated by SALPY_REQUIRE_VALID which will raise an exception on
494 invalid symbol table and line objects. */
496 del_objfile_sal (struct objfile
*objfile
, void *datum
)
498 sal_object
*obj
= (sal_object
*) datum
;
502 sal_object
*next
= obj
->next
;
504 Py_DECREF (obj
->symtab
);
505 obj
->symtab
= (symtab_object
*) Py_None
;
518 gdbpy_initialize_symtabs (void)
520 symtab_object_type
.tp_new
= PyType_GenericNew
;
521 if (PyType_Ready (&symtab_object_type
) < 0)
524 sal_object_type
.tp_new
= PyType_GenericNew
;
525 if (PyType_Ready (&sal_object_type
) < 0)
528 /* Register an objfile "free" callback so we can properly
529 invalidate symbol tables, and symbol table and line data
530 structures when an object file that is about to be
532 stpy_objfile_data_key
533 = register_objfile_data_with_cleanup (NULL
, del_objfile_symtab
);
534 salpy_objfile_data_key
535 = register_objfile_data_with_cleanup (NULL
, del_objfile_sal
);
537 if (gdb_pymodule_addobject (gdb_module
, "Symtab",
538 (PyObject
*) &symtab_object_type
) < 0)
541 return gdb_pymodule_addobject (gdb_module
, "Symtab_and_line",
542 (PyObject
*) &sal_object_type
);
547 static gdb_PyGetSetDef symtab_object_getset
[] = {
548 { "filename", stpy_get_filename
, NULL
,
549 "The symbol table's source filename.", NULL
},
550 { "objfile", stpy_get_objfile
, NULL
, "The symtab's objfile.",
552 { "producer", stpy_get_producer
, NULL
,
553 "The name/version of the program that compiled this symtab.", NULL
},
554 {NULL
} /* Sentinel */
557 static PyMethodDef symtab_object_methods
[] = {
558 { "is_valid", stpy_is_valid
, METH_NOARGS
,
559 "is_valid () -> Boolean.\n\
560 Return true if this symbol table is valid, false if not." },
561 { "fullname", stpy_fullname
, METH_NOARGS
,
562 "fullname () -> String.\n\
563 Return the symtab's full source filename." },
564 { "global_block", stpy_global_block
, METH_NOARGS
,
565 "global_block () -> gdb.Block.\n\
566 Return the global block of the symbol table." },
567 { "static_block", stpy_static_block
, METH_NOARGS
,
568 "static_block () -> gdb.Block.\n\
569 Return the static block of the symbol table." },
570 { "linetable", stpy_get_linetable
, METH_NOARGS
,
571 "linetable () -> gdb.LineTable.\n\
572 Return the LineTable associated with this symbol table" },
573 {NULL
} /* Sentinel */
576 PyTypeObject symtab_object_type
= {
577 PyVarObject_HEAD_INIT (NULL
, 0)
578 "gdb.Symtab", /*tp_name*/
579 sizeof (symtab_object
), /*tp_basicsize*/
581 stpy_dealloc
, /*tp_dealloc*/
588 0, /*tp_as_sequence*/
596 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
597 "GDB symtab object", /*tp_doc */
600 0, /*tp_richcompare */
601 0, /*tp_weaklistoffset */
604 symtab_object_methods
, /*tp_methods */
606 symtab_object_getset
/*tp_getset */
609 static gdb_PyGetSetDef sal_object_getset
[] = {
610 { "symtab", salpy_get_symtab
, NULL
, "Symtab object.", NULL
},
611 { "pc", salpy_get_pc
, NULL
, "Return the symtab_and_line's pc.", NULL
},
612 { "last", salpy_get_last
, NULL
,
613 "Return the symtab_and_line's last address.", NULL
},
614 { "line", salpy_get_line
, NULL
,
615 "Return the symtab_and_line's line.", NULL
},
616 {NULL
} /* Sentinel */
619 static PyMethodDef sal_object_methods
[] = {
620 { "is_valid", salpy_is_valid
, METH_NOARGS
,
621 "is_valid () -> Boolean.\n\
622 Return true if this symbol table and line is valid, false if not." },
623 {NULL
} /* Sentinel */
626 PyTypeObject sal_object_type
= {
627 PyVarObject_HEAD_INIT (NULL
, 0)
628 "gdb.Symtab_and_line", /*tp_name*/
629 sizeof (sal_object
), /*tp_basicsize*/
631 salpy_dealloc
, /*tp_dealloc*/
638 0, /*tp_as_sequence*/
642 salpy_str
, /*tp_str*/
646 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
647 "GDB symtab_and_line object", /*tp_doc */
650 0, /*tp_richcompare */
651 0, /*tp_weaklistoffset */
654 sal_object_methods
, /*tp_methods */
656 sal_object_getset
/*tp_getset */