1 /* Python interface to symbol tables.
3 Copyright (C) 2008-2014 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 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 static 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
);
130 stpy_fullname (PyObject
*self
, PyObject
*args
)
132 const char *fullname
;
133 struct symtab
*symtab
= NULL
;
135 STPY_REQUIRE_VALID (self
, symtab
);
137 fullname
= symtab_to_fullname (symtab
);
139 return PyString_Decode (fullname
, strlen (fullname
), 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
);
189 /* Implementation of gdb.Symtab.linetable (self) -> gdb.Linetable.
190 Returns a gdb.Linetable object corresponding to this symbol
194 stpy_get_linetable (PyObject
*self
, PyObject
*args
)
196 struct symtab
*symtab
= NULL
;
198 STPY_REQUIRE_VALID (self
, symtab
);
200 return symtab_to_linetable_object (self
);
204 salpy_str (PyObject
*self
)
207 const char *filename
;
210 struct symtab_and_line
*sal
= NULL
;
212 SALPY_REQUIRE_VALID (self
, sal
);
214 sal_obj
= (sal_object
*) self
;
215 filename
= (sal_obj
->symtab
== (symtab_object
*) Py_None
)
216 ? "<unknown>" : symtab_to_filename_for_display (sal_obj
->symtab
->symtab
);
218 s
= xstrprintf ("symbol and line for %s, line %d", filename
,
221 result
= PyString_FromString (s
);
228 stpy_dealloc (PyObject
*obj
)
230 symtab_object
*symtab
= (symtab_object
*) obj
;
233 symtab
->prev
->next
= symtab
->next
;
234 else if (symtab
->symtab
)
236 set_objfile_data (symtab
->symtab
->objfile
,
237 stpy_objfile_data_key
, symtab
->next
);
240 symtab
->next
->prev
= symtab
->prev
;
241 symtab
->symtab
= NULL
;
246 salpy_get_pc (PyObject
*self
, void *closure
)
248 struct symtab_and_line
*sal
= NULL
;
250 SALPY_REQUIRE_VALID (self
, sal
);
252 return gdb_py_long_from_ulongest (sal
->pc
);
255 /* Implementation of the get method for the 'last' attribute of
256 gdb.Symtab_and_line. */
259 salpy_get_last (PyObject
*self
, void *closure
)
261 struct symtab_and_line
*sal
= NULL
;
263 SALPY_REQUIRE_VALID (self
, sal
);
266 return gdb_py_long_from_ulongest (sal
->end
- 1);
272 salpy_get_line (PyObject
*self
, void *closure
)
274 struct symtab_and_line
*sal
= NULL
;
276 SALPY_REQUIRE_VALID (self
, sal
);
278 return PyInt_FromLong (sal
->line
);
282 salpy_get_symtab (PyObject
*self
, void *closure
)
284 struct symtab_and_line
*sal
;
285 sal_object
*self_sal
= (sal_object
*) self
;
287 SALPY_REQUIRE_VALID (self
, sal
);
289 Py_INCREF (self_sal
->symtab
);
291 return (PyObject
*) self_sal
->symtab
;
294 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
295 Returns True if this Symbol table and line object still exists GDB. */
298 salpy_is_valid (PyObject
*self
, PyObject
*args
)
300 struct symtab_and_line
*sal
;
302 sal
= sal_object_to_symtab_and_line (self
);
310 salpy_dealloc (PyObject
*self
)
312 sal_object
*self_sal
= (sal_object
*) self
;
315 self_sal
->prev
->next
= self_sal
->next
;
316 else if (self_sal
->symtab
!= (symtab_object
* ) Py_None
)
317 set_objfile_data (self_sal
->symtab
->symtab
->objfile
,
318 salpy_objfile_data_key
, self_sal
->next
);
321 self_sal
->next
->prev
= self_sal
->prev
;
323 Py_DECREF (self_sal
->symtab
);
324 xfree (self_sal
->sal
);
325 Py_TYPE (self
)->tp_free (self
);
328 /* Given a sal, and a sal_object that has previously been allocated
329 and initialized, populate the sal_object with the struct sal data.
330 Also, register the sal_object life-cycle with the life-cycle of the
331 object file associated with this sal, if needed. If a failure
332 occurs during the sal population, this function will return -1. */
333 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
334 set_sal (sal_object
*sal_obj
, struct symtab_and_line sal
)
336 symtab_object
*symtab_obj
;
340 symtab_obj
= (symtab_object
*) symtab_to_symtab_object (sal
.symtab
);
341 /* If a symtab existed in the sal, but it cannot be duplicated,
343 if (symtab_obj
== NULL
)
348 symtab_obj
= (symtab_object
*) Py_None
;
352 sal_obj
->sal
= xmemdup (&sal
, sizeof (struct symtab_and_line
),
353 sizeof (struct symtab_and_line
));
354 sal_obj
->symtab
= symtab_obj
;
355 sal_obj
->prev
= NULL
;
357 /* If the SAL does not have a symtab, we do not add it to the
358 objfile cleanup observer linked list. */
359 if (sal_obj
->symtab
!= (symtab_object
*)Py_None
)
361 sal_obj
->next
= objfile_data (sal_obj
->symtab
->symtab
->objfile
,
362 salpy_objfile_data_key
);
364 sal_obj
->next
->prev
= sal_obj
;
366 set_objfile_data (sal_obj
->symtab
->symtab
->objfile
,
367 salpy_objfile_data_key
, sal_obj
);
370 sal_obj
->next
= NULL
;
375 /* Given a symtab, and a symtab_object that has previously been
376 allocated and initialized, populate the symtab_object with the
377 struct symtab data. Also, register the symtab_object life-cycle
378 with the life-cycle of the object file associated with this
379 symtab, if needed. */
381 set_symtab (symtab_object
*obj
, struct symtab
*symtab
)
383 obj
->symtab
= symtab
;
387 obj
->next
= objfile_data (symtab
->objfile
, stpy_objfile_data_key
);
389 obj
->next
->prev
= obj
;
390 set_objfile_data (symtab
->objfile
, stpy_objfile_data_key
, obj
);
396 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
397 symtab structure from GDB. */
399 symtab_to_symtab_object (struct symtab
*symtab
)
401 symtab_object
*symtab_obj
;
403 symtab_obj
= PyObject_New (symtab_object
, &symtab_object_type
);
405 set_symtab (symtab_obj
, symtab
);
407 return (PyObject
*) symtab_obj
;
410 /* Create a new symtab and line (gdb.Symtab_and_line) object
411 that encapsulates the symtab_and_line structure from GDB. */
413 symtab_and_line_to_sal_object (struct symtab_and_line sal
)
418 sal_obj
= PyObject_New (sal_object
, &sal_object_type
);
421 if (set_sal (sal_obj
, sal
) < 0)
428 return (PyObject
*) sal_obj
;
431 /* Return struct symtab_and_line reference that is wrapped by this
433 struct symtab_and_line
*
434 sal_object_to_symtab_and_line (PyObject
*obj
)
436 if (! PyObject_TypeCheck (obj
, &sal_object_type
))
438 return ((sal_object
*) obj
)->sal
;
441 /* Return struct symtab reference that is wrapped by this object. */
443 symtab_object_to_symtab (PyObject
*obj
)
445 if (! PyObject_TypeCheck (obj
, &symtab_object_type
))
447 return ((symtab_object
*) obj
)->symtab
;
450 /* This function is called when an objfile is about to be freed.
451 Invalidate the symbol table as further actions on the symbol table
452 would result in bad data. All access to obj->symtab should be
453 gated by STPY_REQUIRE_VALID which will raise an exception on
454 invalid symbol tables. */
456 del_objfile_symtab (struct objfile
*objfile
, void *datum
)
458 symtab_object
*obj
= datum
;
462 symtab_object
*next
= obj
->next
;
471 /* This function is called when an objfile is about to be freed.
472 Invalidate the sal object as further actions on the sal
473 would result in bad data. All access to obj->sal should be
474 gated by SALPY_REQUIRE_VALID which will raise an exception on
475 invalid symbol table and line objects. */
477 del_objfile_sal (struct objfile
*objfile
, void *datum
)
479 sal_object
*obj
= datum
;
483 sal_object
*next
= obj
->next
;
485 Py_DECREF (obj
->symtab
);
486 obj
->symtab
= (symtab_object
*) Py_None
;
499 gdbpy_initialize_symtabs (void)
501 symtab_object_type
.tp_new
= PyType_GenericNew
;
502 if (PyType_Ready (&symtab_object_type
) < 0)
505 sal_object_type
.tp_new
= PyType_GenericNew
;
506 if (PyType_Ready (&sal_object_type
) < 0)
509 /* Register an objfile "free" callback so we can properly
510 invalidate symbol tables, and symbol table and line data
511 structures when an object file that is about to be
513 stpy_objfile_data_key
514 = register_objfile_data_with_cleanup (NULL
, del_objfile_symtab
);
515 salpy_objfile_data_key
516 = register_objfile_data_with_cleanup (NULL
, del_objfile_sal
);
518 if (gdb_pymodule_addobject (gdb_module
, "Symtab",
519 (PyObject
*) &symtab_object_type
) < 0)
522 return gdb_pymodule_addobject (gdb_module
, "Symtab_and_line",
523 (PyObject
*) &sal_object_type
);
528 static PyGetSetDef symtab_object_getset
[] = {
529 { "filename", stpy_get_filename
, NULL
,
530 "The symbol table's source filename.", NULL
},
531 { "objfile", stpy_get_objfile
, NULL
, "The symtab's objfile.",
533 {NULL
} /* Sentinel */
536 static PyMethodDef symtab_object_methods
[] = {
537 { "is_valid", stpy_is_valid
, METH_NOARGS
,
538 "is_valid () -> Boolean.\n\
539 Return true if this symbol table is valid, false if not." },
540 { "fullname", stpy_fullname
, METH_NOARGS
,
541 "fullname () -> String.\n\
542 Return the symtab's full source filename." },
543 { "global_block", stpy_global_block
, METH_NOARGS
,
544 "global_block () -> gdb.Block.\n\
545 Return the global block of the symbol table." },
546 { "static_block", stpy_static_block
, METH_NOARGS
,
547 "static_block () -> gdb.Block.\n\
548 Return the static block of the symbol table." },
549 { "linetable", stpy_get_linetable
, METH_NOARGS
,
550 "linetable () -> gdb.Linetable.\n\
551 Return the Linetable associated with this symbol table" },
552 {NULL
} /* Sentinel */
555 static PyTypeObject symtab_object_type
= {
556 PyVarObject_HEAD_INIT (NULL
, 0)
557 "gdb.Symtab", /*tp_name*/
558 sizeof (symtab_object
), /*tp_basicsize*/
560 stpy_dealloc
, /*tp_dealloc*/
567 0, /*tp_as_sequence*/
575 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
576 "GDB symtab object", /*tp_doc */
579 0, /*tp_richcompare */
580 0, /*tp_weaklistoffset */
583 symtab_object_methods
, /*tp_methods */
585 symtab_object_getset
/*tp_getset */
588 static PyGetSetDef sal_object_getset
[] = {
589 { "symtab", salpy_get_symtab
, NULL
, "Symtab object.", NULL
},
590 { "pc", salpy_get_pc
, NULL
, "Return the symtab_and_line's pc.", NULL
},
591 { "last", salpy_get_last
, NULL
,
592 "Return the symtab_and_line's last address.", NULL
},
593 { "line", salpy_get_line
, NULL
,
594 "Return the symtab_and_line's line.", NULL
},
595 {NULL
} /* Sentinel */
598 static PyMethodDef sal_object_methods
[] = {
599 { "is_valid", salpy_is_valid
, METH_NOARGS
,
600 "is_valid () -> Boolean.\n\
601 Return true if this symbol table and line is valid, false if not." },
602 {NULL
} /* Sentinel */
605 static PyTypeObject sal_object_type
= {
606 PyVarObject_HEAD_INIT (NULL
, 0)
607 "gdb.Symtab_and_line", /*tp_name*/
608 sizeof (sal_object
), /*tp_basicsize*/
610 salpy_dealloc
, /*tp_dealloc*/
617 0, /*tp_as_sequence*/
621 salpy_str
, /*tp_str*/
625 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
626 "GDB symtab_and_line object", /*tp_doc */
629 0, /*tp_richcompare */
630 0, /*tp_weaklistoffset */
633 sal_object_methods
, /*tp_methods */
635 sal_object_getset
/*tp_getset */