1 /* Python interface to symbol tables.
3 Copyright (C) 2008-2015 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. */
60 symtab_object
*symtab
;
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
= PyString_Decode (filename
, strlen (filename
),
112 host_charset (), NULL
);
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 PyString_Decode (producer
, strlen (producer
),
144 host_charset (), NULL
);
151 stpy_fullname (PyObject
*self
, PyObject
*args
)
153 const char *fullname
;
154 struct symtab
*symtab
= NULL
;
156 STPY_REQUIRE_VALID (self
, symtab
);
158 fullname
= symtab_to_fullname (symtab
);
160 return PyString_Decode (fullname
, strlen (fullname
), host_charset (), NULL
);
163 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
164 Returns True if this Symbol table still exists in GDB. */
167 stpy_is_valid (PyObject
*self
, PyObject
*args
)
169 struct symtab
*symtab
= NULL
;
171 symtab
= symtab_object_to_symtab (self
);
178 /* Return the GLOBAL_BLOCK of the underlying symtab. */
181 stpy_global_block (PyObject
*self
, PyObject
*args
)
183 struct symtab
*symtab
= NULL
;
184 struct block
*block
= NULL
;
185 const struct blockvector
*blockvector
;
187 STPY_REQUIRE_VALID (self
, symtab
);
189 blockvector
= SYMTAB_BLOCKVECTOR (symtab
);
190 block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
191 return block_to_block_object (block
, SYMTAB_OBJFILE (symtab
));
194 /* Return the STATIC_BLOCK of the underlying symtab. */
197 stpy_static_block (PyObject
*self
, PyObject
*args
)
199 struct symtab
*symtab
= NULL
;
200 struct block
*block
= NULL
;
201 const struct blockvector
*blockvector
;
203 STPY_REQUIRE_VALID (self
, symtab
);
205 blockvector
= SYMTAB_BLOCKVECTOR (symtab
);
206 block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
207 return block_to_block_object (block
, SYMTAB_OBJFILE (symtab
));
210 /* Implementation of gdb.Symtab.linetable (self) -> gdb.LineTable.
211 Returns a gdb.LineTable object corresponding to this symbol
215 stpy_get_linetable (PyObject
*self
, PyObject
*args
)
217 struct symtab
*symtab
= NULL
;
219 STPY_REQUIRE_VALID (self
, symtab
);
221 return symtab_to_linetable_object (self
);
225 salpy_str (PyObject
*self
)
228 const char *filename
;
231 struct symtab_and_line
*sal
= NULL
;
233 SALPY_REQUIRE_VALID (self
, sal
);
235 sal_obj
= (sal_object
*) self
;
236 filename
= (sal_obj
->symtab
== (symtab_object
*) Py_None
)
237 ? "<unknown>" : symtab_to_filename_for_display (sal_obj
->symtab
->symtab
);
239 s
= xstrprintf ("symbol and line for %s, line %d", filename
,
242 result
= PyString_FromString (s
);
249 stpy_dealloc (PyObject
*obj
)
251 symtab_object
*symtab
= (symtab_object
*) obj
;
254 symtab
->prev
->next
= symtab
->next
;
255 else if (symtab
->symtab
)
257 set_objfile_data (SYMTAB_OBJFILE (symtab
->symtab
),
258 stpy_objfile_data_key
, symtab
->next
);
261 symtab
->next
->prev
= symtab
->prev
;
262 symtab
->symtab
= NULL
;
267 salpy_get_pc (PyObject
*self
, void *closure
)
269 struct symtab_and_line
*sal
= NULL
;
271 SALPY_REQUIRE_VALID (self
, sal
);
273 return gdb_py_long_from_ulongest (sal
->pc
);
276 /* Implementation of the get method for the 'last' attribute of
277 gdb.Symtab_and_line. */
280 salpy_get_last (PyObject
*self
, void *closure
)
282 struct symtab_and_line
*sal
= NULL
;
284 SALPY_REQUIRE_VALID (self
, sal
);
287 return gdb_py_long_from_ulongest (sal
->end
- 1);
293 salpy_get_line (PyObject
*self
, void *closure
)
295 struct symtab_and_line
*sal
= NULL
;
297 SALPY_REQUIRE_VALID (self
, sal
);
299 return PyInt_FromLong (sal
->line
);
303 salpy_get_symtab (PyObject
*self
, void *closure
)
305 struct symtab_and_line
*sal
;
306 sal_object
*self_sal
= (sal_object
*) self
;
308 SALPY_REQUIRE_VALID (self
, sal
);
310 Py_INCREF (self_sal
->symtab
);
312 return (PyObject
*) self_sal
->symtab
;
315 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
316 Returns True if this Symbol table and line object still exists GDB. */
319 salpy_is_valid (PyObject
*self
, PyObject
*args
)
321 struct symtab_and_line
*sal
;
323 sal
= sal_object_to_symtab_and_line (self
);
331 salpy_dealloc (PyObject
*self
)
333 sal_object
*self_sal
= (sal_object
*) self
;
336 self_sal
->prev
->next
= self_sal
->next
;
337 else if (self_sal
->symtab
!= (symtab_object
* ) Py_None
)
338 set_objfile_data (SYMTAB_OBJFILE (self_sal
->symtab
->symtab
),
339 salpy_objfile_data_key
, self_sal
->next
);
342 self_sal
->next
->prev
= self_sal
->prev
;
344 Py_DECREF (self_sal
->symtab
);
345 xfree (self_sal
->sal
);
346 Py_TYPE (self
)->tp_free (self
);
349 /* Given a sal, and a sal_object that has previously been allocated
350 and initialized, populate the sal_object with the struct sal data.
351 Also, register the sal_object life-cycle with the life-cycle of the
352 object file associated with this sal, if needed. If a failure
353 occurs during the sal population, this function will return -1. */
354 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
355 set_sal (sal_object
*sal_obj
, struct symtab_and_line sal
)
357 symtab_object
*symtab_obj
;
361 symtab_obj
= (symtab_object
*) symtab_to_symtab_object (sal
.symtab
);
362 /* If a symtab existed in the sal, but it cannot be duplicated,
364 if (symtab_obj
== NULL
)
369 symtab_obj
= (symtab_object
*) Py_None
;
373 sal_obj
->sal
= 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
)
382 sal_obj
->next
= objfile_data (SYMTAB_OBJFILE (sal_obj
->symtab
->symtab
),
383 salpy_objfile_data_key
);
385 sal_obj
->next
->prev
= sal_obj
;
387 set_objfile_data (SYMTAB_OBJFILE (sal_obj
->symtab
->symtab
),
388 salpy_objfile_data_key
, sal_obj
);
391 sal_obj
->next
= NULL
;
396 /* Given a symtab, and a symtab_object that has previously been
397 allocated and initialized, populate the symtab_object with the
398 struct symtab data. Also, register the symtab_object life-cycle
399 with the life-cycle of the object file associated with this
400 symtab, if needed. */
402 set_symtab (symtab_object
*obj
, struct symtab
*symtab
)
404 obj
->symtab
= symtab
;
408 obj
->next
= objfile_data (SYMTAB_OBJFILE (symtab
),
409 stpy_objfile_data_key
);
411 obj
->next
->prev
= obj
;
412 set_objfile_data (SYMTAB_OBJFILE (symtab
), stpy_objfile_data_key
, obj
);
418 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
419 symtab structure from GDB. */
421 symtab_to_symtab_object (struct symtab
*symtab
)
423 symtab_object
*symtab_obj
;
425 symtab_obj
= PyObject_New (symtab_object
, &symtab_object_type
);
427 set_symtab (symtab_obj
, symtab
);
429 return (PyObject
*) symtab_obj
;
432 /* Create a new symtab and line (gdb.Symtab_and_line) object
433 that encapsulates the symtab_and_line structure from GDB. */
435 symtab_and_line_to_sal_object (struct symtab_and_line sal
)
440 sal_obj
= PyObject_New (sal_object
, &sal_object_type
);
443 if (set_sal (sal_obj
, sal
) < 0)
450 return (PyObject
*) sal_obj
;
453 /* Return struct symtab_and_line reference that is wrapped by this
455 struct symtab_and_line
*
456 sal_object_to_symtab_and_line (PyObject
*obj
)
458 if (! PyObject_TypeCheck (obj
, &sal_object_type
))
460 return ((sal_object
*) obj
)->sal
;
463 /* Return struct symtab reference that is wrapped by this object. */
465 symtab_object_to_symtab (PyObject
*obj
)
467 if (! PyObject_TypeCheck (obj
, &symtab_object_type
))
469 return ((symtab_object
*) obj
)->symtab
;
472 /* This function is called when an objfile is about to be freed.
473 Invalidate the symbol table as further actions on the symbol table
474 would result in bad data. All access to obj->symtab should be
475 gated by STPY_REQUIRE_VALID which will raise an exception on
476 invalid symbol tables. */
478 del_objfile_symtab (struct objfile
*objfile
, void *datum
)
480 symtab_object
*obj
= datum
;
484 symtab_object
*next
= obj
->next
;
493 /* This function is called when an objfile is about to be freed.
494 Invalidate the sal object as further actions on the sal
495 would result in bad data. All access to obj->sal should be
496 gated by SALPY_REQUIRE_VALID which will raise an exception on
497 invalid symbol table and line objects. */
499 del_objfile_sal (struct objfile
*objfile
, void *datum
)
501 sal_object
*obj
= datum
;
505 sal_object
*next
= obj
->next
;
507 Py_DECREF (obj
->symtab
);
508 obj
->symtab
= (symtab_object
*) Py_None
;
521 gdbpy_initialize_symtabs (void)
523 symtab_object_type
.tp_new
= PyType_GenericNew
;
524 if (PyType_Ready (&symtab_object_type
) < 0)
527 sal_object_type
.tp_new
= PyType_GenericNew
;
528 if (PyType_Ready (&sal_object_type
) < 0)
531 /* Register an objfile "free" callback so we can properly
532 invalidate symbol tables, and symbol table and line data
533 structures when an object file that is about to be
535 stpy_objfile_data_key
536 = register_objfile_data_with_cleanup (NULL
, del_objfile_symtab
);
537 salpy_objfile_data_key
538 = register_objfile_data_with_cleanup (NULL
, del_objfile_sal
);
540 if (gdb_pymodule_addobject (gdb_module
, "Symtab",
541 (PyObject
*) &symtab_object_type
) < 0)
544 return gdb_pymodule_addobject (gdb_module
, "Symtab_and_line",
545 (PyObject
*) &sal_object_type
);
550 static PyGetSetDef symtab_object_getset
[] = {
551 { "filename", stpy_get_filename
, NULL
,
552 "The symbol table's source filename.", NULL
},
553 { "objfile", stpy_get_objfile
, NULL
, "The symtab's objfile.",
555 { "producer", stpy_get_producer
, NULL
,
556 "The name/version of the program that compiled this symtab.", NULL
},
557 {NULL
} /* Sentinel */
560 static PyMethodDef symtab_object_methods
[] = {
561 { "is_valid", stpy_is_valid
, METH_NOARGS
,
562 "is_valid () -> Boolean.\n\
563 Return true if this symbol table is valid, false if not." },
564 { "fullname", stpy_fullname
, METH_NOARGS
,
565 "fullname () -> String.\n\
566 Return the symtab's full source filename." },
567 { "global_block", stpy_global_block
, METH_NOARGS
,
568 "global_block () -> gdb.Block.\n\
569 Return the global block of the symbol table." },
570 { "static_block", stpy_static_block
, METH_NOARGS
,
571 "static_block () -> gdb.Block.\n\
572 Return the static block of the symbol table." },
573 { "linetable", stpy_get_linetable
, METH_NOARGS
,
574 "linetable () -> gdb.LineTable.\n\
575 Return the LineTable associated with this symbol table" },
576 {NULL
} /* Sentinel */
579 PyTypeObject symtab_object_type
= {
580 PyVarObject_HEAD_INIT (NULL
, 0)
581 "gdb.Symtab", /*tp_name*/
582 sizeof (symtab_object
), /*tp_basicsize*/
584 stpy_dealloc
, /*tp_dealloc*/
591 0, /*tp_as_sequence*/
599 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
600 "GDB symtab object", /*tp_doc */
603 0, /*tp_richcompare */
604 0, /*tp_weaklistoffset */
607 symtab_object_methods
, /*tp_methods */
609 symtab_object_getset
/*tp_getset */
612 static PyGetSetDef sal_object_getset
[] = {
613 { "symtab", salpy_get_symtab
, NULL
, "Symtab object.", NULL
},
614 { "pc", salpy_get_pc
, NULL
, "Return the symtab_and_line's pc.", NULL
},
615 { "last", salpy_get_last
, NULL
,
616 "Return the symtab_and_line's last address.", NULL
},
617 { "line", salpy_get_line
, NULL
,
618 "Return the symtab_and_line's line.", NULL
},
619 {NULL
} /* Sentinel */
622 static PyMethodDef sal_object_methods
[] = {
623 { "is_valid", salpy_is_valid
, METH_NOARGS
,
624 "is_valid () -> Boolean.\n\
625 Return true if this symbol table and line is valid, false if not." },
626 {NULL
} /* Sentinel */
629 PyTypeObject sal_object_type
= {
630 PyVarObject_HEAD_INIT (NULL
, 0)
631 "gdb.Symtab_and_line", /*tp_name*/
632 sizeof (sal_object
), /*tp_basicsize*/
634 salpy_dealloc
, /*tp_dealloc*/
641 0, /*tp_as_sequence*/
645 salpy_str
, /*tp_str*/
649 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
650 "GDB symtab_and_line object", /*tp_doc */
653 0, /*tp_richcompare */
654 0, /*tp_weaklistoffset */
657 sal_object_methods
, /*tp_methods */
659 sal_object_getset
/*tp_getset */