1 /* Python interface to symbol tables.
3 Copyright (C) 2008-2019 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 extern PyTypeObject symtab_object_type
41 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symtab_object");
42 static const struct objfile_data
*stpy_objfile_data_key
;
44 /* Require a valid symbol table. All access to symtab_object->symtab
45 should be gated by this call. */
46 #define STPY_REQUIRE_VALID(symtab_obj, symtab) \
48 symtab = symtab_object_to_symtab (symtab_obj); \
51 PyErr_SetString (PyExc_RuntimeError, \
52 _("Symbol Table is invalid.")); \
57 typedef struct salpy_sal_object
{
59 /* The GDB Symbol table structure. */
61 /* The GDB Symbol table and line structure. */
62 struct symtab_and_line
*sal
;
63 /* A Symtab and line object is associated with an objfile, so keep
64 track with a doubly-linked list, rooted in the objfile. This
65 allows invalidation of the underlying struct symtab_and_line
66 when the objfile is deleted. */
67 struct salpy_sal_object
*prev
;
68 struct salpy_sal_object
*next
;
71 extern PyTypeObject sal_object_type
72 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("sal_object");
73 static const struct objfile_data
*salpy_objfile_data_key
;
75 /* Require a valid symbol table and line object. All access to
76 sal_object->sal should be gated by this call. */
77 #define SALPY_REQUIRE_VALID(sal_obj, sal) \
79 sal = sal_object_to_symtab_and_line (sal_obj); \
82 PyErr_SetString (PyExc_RuntimeError, \
83 _("Symbol Table and Line is invalid.")); \
89 stpy_str (PyObject
*self
)
92 struct symtab
*symtab
= NULL
;
94 STPY_REQUIRE_VALID (self
, symtab
);
96 result
= PyString_FromString (symtab_to_filename_for_display (symtab
));
102 stpy_get_filename (PyObject
*self
, void *closure
)
105 struct symtab
*symtab
= NULL
;
106 const char *filename
;
108 STPY_REQUIRE_VALID (self
, symtab
);
109 filename
= symtab_to_filename_for_display (symtab
);
111 str_obj
= host_string_to_python_string (filename
).release ();
116 stpy_get_objfile (PyObject
*self
, void *closure
)
118 struct symtab
*symtab
= NULL
;
120 STPY_REQUIRE_VALID (self
, symtab
);
122 return objfile_to_objfile_object (SYMTAB_OBJFILE (symtab
)).release ();
125 /* Getter function for symtab.producer. */
128 stpy_get_producer (PyObject
*self
, void *closure
)
130 struct symtab
*symtab
= NULL
;
131 struct compunit_symtab
*cust
;
133 STPY_REQUIRE_VALID (self
, symtab
);
134 cust
= SYMTAB_COMPUNIT (symtab
);
135 if (COMPUNIT_PRODUCER (cust
) != NULL
)
137 const char *producer
= COMPUNIT_PRODUCER (cust
);
139 return host_string_to_python_string (producer
).release ();
146 stpy_fullname (PyObject
*self
, PyObject
*args
)
148 const char *fullname
;
149 struct symtab
*symtab
= NULL
;
151 STPY_REQUIRE_VALID (self
, symtab
);
153 fullname
= symtab_to_fullname (symtab
);
155 return host_string_to_python_string (fullname
).release ();
158 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
159 Returns True if this Symbol table still exists in GDB. */
162 stpy_is_valid (PyObject
*self
, PyObject
*args
)
164 struct symtab
*symtab
= NULL
;
166 symtab
= symtab_object_to_symtab (self
);
173 /* Return the GLOBAL_BLOCK of the underlying symtab. */
176 stpy_global_block (PyObject
*self
, PyObject
*args
)
178 struct symtab
*symtab
= NULL
;
179 struct block
*block
= NULL
;
180 const struct blockvector
*blockvector
;
182 STPY_REQUIRE_VALID (self
, symtab
);
184 blockvector
= SYMTAB_BLOCKVECTOR (symtab
);
185 block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
186 return block_to_block_object (block
, SYMTAB_OBJFILE (symtab
));
189 /* Return the STATIC_BLOCK of the underlying symtab. */
192 stpy_static_block (PyObject
*self
, PyObject
*args
)
194 struct symtab
*symtab
= NULL
;
195 struct block
*block
= NULL
;
196 const struct blockvector
*blockvector
;
198 STPY_REQUIRE_VALID (self
, symtab
);
200 blockvector
= SYMTAB_BLOCKVECTOR (symtab
);
201 block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
202 return block_to_block_object (block
, SYMTAB_OBJFILE (symtab
));
205 /* Implementation of gdb.Symtab.linetable (self) -> gdb.LineTable.
206 Returns a gdb.LineTable object corresponding to this symbol
210 stpy_get_linetable (PyObject
*self
, PyObject
*args
)
212 struct symtab
*symtab
= NULL
;
214 STPY_REQUIRE_VALID (self
, symtab
);
216 return symtab_to_linetable_object (self
);
220 salpy_str (PyObject
*self
)
222 const char *filename
;
224 struct symtab_and_line
*sal
= NULL
;
226 SALPY_REQUIRE_VALID (self
, sal
);
228 sal_obj
= (sal_object
*) self
;
229 if (sal_obj
->symtab
== Py_None
)
230 filename
= "<unknown>";
233 symtab
*symtab
= symtab_object_to_symtab (sal_obj
->symtab
);
234 filename
= symtab_to_filename_for_display (symtab
);
237 return PyString_FromFormat ("symbol and line for %s, line %d", filename
,
242 stpy_dealloc (PyObject
*obj
)
244 symtab_object
*symtab
= (symtab_object
*) obj
;
247 symtab
->prev
->next
= symtab
->next
;
248 else if (symtab
->symtab
)
250 set_objfile_data (SYMTAB_OBJFILE (symtab
->symtab
),
251 stpy_objfile_data_key
, symtab
->next
);
254 symtab
->next
->prev
= symtab
->prev
;
255 symtab
->symtab
= NULL
;
260 salpy_get_pc (PyObject
*self
, void *closure
)
262 struct symtab_and_line
*sal
= NULL
;
264 SALPY_REQUIRE_VALID (self
, sal
);
266 return gdb_py_long_from_ulongest (sal
->pc
);
269 /* Implementation of the get method for the 'last' attribute of
270 gdb.Symtab_and_line. */
273 salpy_get_last (PyObject
*self
, void *closure
)
275 struct symtab_and_line
*sal
= NULL
;
277 SALPY_REQUIRE_VALID (self
, sal
);
280 return gdb_py_long_from_ulongest (sal
->end
- 1);
286 salpy_get_line (PyObject
*self
, void *closure
)
288 struct symtab_and_line
*sal
= NULL
;
290 SALPY_REQUIRE_VALID (self
, sal
);
292 return PyInt_FromLong (sal
->line
);
296 salpy_get_symtab (PyObject
*self
, void *closure
)
298 struct symtab_and_line
*sal
;
299 sal_object
*self_sal
= (sal_object
*) self
;
301 SALPY_REQUIRE_VALID (self
, sal
);
303 Py_INCREF (self_sal
->symtab
);
305 return (PyObject
*) self_sal
->symtab
;
308 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
309 Returns True if this Symbol table and line object still exists GDB. */
312 salpy_is_valid (PyObject
*self
, PyObject
*args
)
314 struct symtab_and_line
*sal
;
316 sal
= sal_object_to_symtab_and_line (self
);
324 salpy_dealloc (PyObject
*self
)
326 sal_object
*self_sal
= (sal_object
*) self
;
329 self_sal
->prev
->next
= self_sal
->next
;
330 else if (self_sal
->symtab
!= Py_None
)
332 (SYMTAB_OBJFILE (symtab_object_to_symtab (self_sal
->symtab
)),
333 salpy_objfile_data_key
, self_sal
->next
);
336 self_sal
->next
->prev
= self_sal
->prev
;
338 Py_DECREF (self_sal
->symtab
);
339 xfree (self_sal
->sal
);
340 Py_TYPE (self
)->tp_free (self
);
343 /* Given a sal, and a sal_object that has previously been allocated
344 and initialized, populate the sal_object with the struct sal data.
345 Also, register the sal_object life-cycle with the life-cycle of the
346 object file associated with this sal, if needed. If a failure
347 occurs during the sal population, this function will return -1. */
348 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
349 set_sal (sal_object
*sal_obj
, struct symtab_and_line sal
)
351 PyObject
*symtab_obj
;
355 symtab_obj
= symtab_to_symtab_object (sal
.symtab
);
356 /* If a symtab existed in the sal, but it cannot be duplicated,
358 if (symtab_obj
== NULL
)
363 symtab_obj
= Py_None
;
367 sal_obj
->sal
= ((struct symtab_and_line
*)
368 xmemdup (&sal
, sizeof (struct symtab_and_line
),
369 sizeof (struct symtab_and_line
)));
370 sal_obj
->symtab
= symtab_obj
;
371 sal_obj
->prev
= NULL
;
373 /* If the SAL does not have a symtab, we do not add it to the
374 objfile cleanup observer linked list. */
375 if (sal_obj
->symtab
!= Py_None
)
377 symtab
*symtab
= symtab_object_to_symtab (sal_obj
->symtab
);
380 = ((struct salpy_sal_object
*) objfile_data (SYMTAB_OBJFILE (symtab
),
381 salpy_objfile_data_key
));
383 sal_obj
->next
->prev
= sal_obj
;
385 set_objfile_data (SYMTAB_OBJFILE (symtab
),
386 salpy_objfile_data_key
, sal_obj
);
389 sal_obj
->next
= NULL
;
394 /* Given a symtab, and a symtab_object that has previously been
395 allocated and initialized, populate the symtab_object with the
396 struct symtab data. Also, register the symtab_object life-cycle
397 with the life-cycle of the object file associated with this
398 symtab, if needed. */
400 set_symtab (symtab_object
*obj
, struct symtab
*symtab
)
402 obj
->symtab
= symtab
;
407 = ((struct stpy_symtab_object
*)
408 objfile_data (SYMTAB_OBJFILE (symtab
), stpy_objfile_data_key
));
410 obj
->next
->prev
= obj
;
411 set_objfile_data (SYMTAB_OBJFILE (symtab
), stpy_objfile_data_key
, obj
);
417 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
418 symtab structure from GDB. */
420 symtab_to_symtab_object (struct symtab
*symtab
)
422 symtab_object
*symtab_obj
;
424 symtab_obj
= PyObject_New (symtab_object
, &symtab_object_type
);
426 set_symtab (symtab_obj
, symtab
);
428 return (PyObject
*) symtab_obj
;
431 /* Create a new symtab and line (gdb.Symtab_and_line) object
432 that encapsulates the symtab_and_line structure from GDB. */
434 symtab_and_line_to_sal_object (struct symtab_and_line sal
)
436 gdbpy_ref
<sal_object
> sal_obj (PyObject_New (sal_object
, &sal_object_type
));
439 if (set_sal (sal_obj
.get (), sal
) < 0)
443 return (PyObject
*) sal_obj
.release ();
446 /* Return struct symtab_and_line reference that is wrapped by this
448 struct symtab_and_line
*
449 sal_object_to_symtab_and_line (PyObject
*obj
)
451 if (! PyObject_TypeCheck (obj
, &sal_object_type
))
453 return ((sal_object
*) obj
)->sal
;
456 /* Return struct symtab reference that is wrapped by this object. */
458 symtab_object_to_symtab (PyObject
*obj
)
460 if (! PyObject_TypeCheck (obj
, &symtab_object_type
))
462 return ((symtab_object
*) obj
)->symtab
;
465 /* This function is called when an objfile is about to be freed.
466 Invalidate the symbol table as further actions on the symbol table
467 would result in bad data. All access to obj->symtab should be
468 gated by STPY_REQUIRE_VALID which will raise an exception on
469 invalid symbol tables. */
471 del_objfile_symtab (struct objfile
*objfile
, void *datum
)
473 symtab_object
*obj
= (symtab_object
*) datum
;
477 symtab_object
*next
= obj
->next
;
486 /* This function is called when an objfile is about to be freed.
487 Invalidate the sal object as further actions on the sal
488 would result in bad data. All access to obj->sal should be
489 gated by SALPY_REQUIRE_VALID which will raise an exception on
490 invalid symbol table and line objects. */
492 del_objfile_sal (struct objfile
*objfile
, void *datum
)
494 sal_object
*obj
= (sal_object
*) datum
;
498 sal_object
*next
= obj
->next
;
500 gdbpy_ref
<> tmp (obj
->symtab
);
501 obj
->symtab
= Py_None
;
514 gdbpy_initialize_symtabs (void)
516 symtab_object_type
.tp_new
= PyType_GenericNew
;
517 if (PyType_Ready (&symtab_object_type
) < 0)
520 sal_object_type
.tp_new
= PyType_GenericNew
;
521 if (PyType_Ready (&sal_object_type
) < 0)
524 /* Register an objfile "free" callback so we can properly
525 invalidate symbol tables, and symbol table and line data
526 structures when an object file that is about to be
528 stpy_objfile_data_key
529 = register_objfile_data_with_cleanup (NULL
, del_objfile_symtab
);
530 salpy_objfile_data_key
531 = register_objfile_data_with_cleanup (NULL
, del_objfile_sal
);
533 if (gdb_pymodule_addobject (gdb_module
, "Symtab",
534 (PyObject
*) &symtab_object_type
) < 0)
537 return gdb_pymodule_addobject (gdb_module
, "Symtab_and_line",
538 (PyObject
*) &sal_object_type
);
543 static gdb_PyGetSetDef symtab_object_getset
[] = {
544 { "filename", stpy_get_filename
, NULL
,
545 "The symbol table's source filename.", NULL
},
546 { "objfile", stpy_get_objfile
, NULL
, "The symtab's objfile.",
548 { "producer", stpy_get_producer
, NULL
,
549 "The name/version of the program that compiled this symtab.", NULL
},
550 {NULL
} /* Sentinel */
553 static PyMethodDef symtab_object_methods
[] = {
554 { "is_valid", stpy_is_valid
, METH_NOARGS
,
555 "is_valid () -> Boolean.\n\
556 Return true if this symbol table is valid, false if not." },
557 { "fullname", stpy_fullname
, METH_NOARGS
,
558 "fullname () -> String.\n\
559 Return the symtab's full source filename." },
560 { "global_block", stpy_global_block
, METH_NOARGS
,
561 "global_block () -> gdb.Block.\n\
562 Return the global block of the symbol table." },
563 { "static_block", stpy_static_block
, METH_NOARGS
,
564 "static_block () -> gdb.Block.\n\
565 Return the static block of the symbol table." },
566 { "linetable", stpy_get_linetable
, METH_NOARGS
,
567 "linetable () -> gdb.LineTable.\n\
568 Return the LineTable associated with this symbol table" },
569 {NULL
} /* Sentinel */
572 PyTypeObject symtab_object_type
= {
573 PyVarObject_HEAD_INIT (NULL
, 0)
574 "gdb.Symtab", /*tp_name*/
575 sizeof (symtab_object
), /*tp_basicsize*/
577 stpy_dealloc
, /*tp_dealloc*/
584 0, /*tp_as_sequence*/
592 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
593 "GDB symtab object", /*tp_doc */
596 0, /*tp_richcompare */
597 0, /*tp_weaklistoffset */
600 symtab_object_methods
, /*tp_methods */
602 symtab_object_getset
/*tp_getset */
605 static gdb_PyGetSetDef sal_object_getset
[] = {
606 { "symtab", salpy_get_symtab
, NULL
, "Symtab object.", NULL
},
607 { "pc", salpy_get_pc
, NULL
, "Return the symtab_and_line's pc.", NULL
},
608 { "last", salpy_get_last
, NULL
,
609 "Return the symtab_and_line's last address.", NULL
},
610 { "line", salpy_get_line
, NULL
,
611 "Return the symtab_and_line's line.", NULL
},
612 {NULL
} /* Sentinel */
615 static PyMethodDef sal_object_methods
[] = {
616 { "is_valid", salpy_is_valid
, METH_NOARGS
,
617 "is_valid () -> Boolean.\n\
618 Return true if this symbol table and line is valid, false if not." },
619 {NULL
} /* Sentinel */
622 PyTypeObject sal_object_type
= {
623 PyVarObject_HEAD_INIT (NULL
, 0)
624 "gdb.Symtab_and_line", /*tp_name*/
625 sizeof (sal_object
), /*tp_basicsize*/
627 salpy_dealloc
, /*tp_dealloc*/
634 0, /*tp_as_sequence*/
638 salpy_str
, /*tp_str*/
642 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
643 "GDB symtab_and_line object", /*tp_doc */
646 0, /*tp_richcompare */
647 0, /*tp_weaklistoffset */
650 sal_object_methods
, /*tp_methods */
652 sal_object_getset
/*tp_getset */