1 /* Python interface to symbols.
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"
27 typedef struct sympy_symbol_object {
29 /* The GDB symbol structure this object is wrapping. */
30 struct symbol *symbol;
31 /* A symbol object is associated with an objfile, so keep track with
32 doubly-linked list, rooted in the objfile. This lets us
33 invalidate the underlying struct symbol when the objfile is
35 struct sympy_symbol_object *prev;
36 struct sympy_symbol_object *next;
39 /* Require a valid symbol. All access to symbol_object->symbol should be
40 gated by this call. */
41 #define SYMPY_REQUIRE_VALID(symbol_obj, symbol) \
43 symbol = symbol_object_to_symbol (symbol_obj); \
46 PyErr_SetString (PyExc_RuntimeError, \
47 _("Symbol is invalid.")); \
52 static const struct objfile_data *sympy_objfile_data_key;
55 sympy_str (PyObject *self)
58 struct symbol *symbol = NULL;
60 SYMPY_REQUIRE_VALID (self, symbol);
62 result = PyString_FromString (SYMBOL_PRINT_NAME (symbol));
68 sympy_get_type (PyObject *self, void *closure)
70 struct symbol *symbol = NULL;
72 SYMPY_REQUIRE_VALID (self, symbol);
74 if (SYMBOL_TYPE (symbol) == NULL)
80 return type_to_type_object (SYMBOL_TYPE (symbol));
84 sympy_get_symtab (PyObject *self, void *closure)
86 struct symbol *symbol = NULL;
88 SYMPY_REQUIRE_VALID (self, symbol);
90 if (!SYMBOL_OBJFILE_OWNED (symbol))
93 return symtab_to_symtab_object (symbol_symtab (symbol));
97 sympy_get_name (PyObject *self, void *closure)
99 struct symbol *symbol = NULL;
101 SYMPY_REQUIRE_VALID (self, symbol);
103 return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
107 sympy_get_linkage_name (PyObject *self, void *closure)
109 struct symbol *symbol = NULL;
111 SYMPY_REQUIRE_VALID (self, symbol);
113 return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
117 sympy_get_print_name (PyObject *self, void *closure)
119 struct symbol *symbol = NULL;
121 SYMPY_REQUIRE_VALID (self, symbol);
123 return sympy_str (self);
127 sympy_get_addr_class (PyObject *self, void *closure)
129 struct symbol *symbol = NULL;
131 SYMPY_REQUIRE_VALID (self, symbol);
133 return PyInt_FromLong (SYMBOL_CLASS (symbol));
137 sympy_is_argument (PyObject *self, void *closure)
139 struct symbol *symbol = NULL;
141 SYMPY_REQUIRE_VALID (self, symbol);
143 return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
147 sympy_is_constant (PyObject *self, void *closure)
149 struct symbol *symbol = NULL;
150 enum address_class class;
152 SYMPY_REQUIRE_VALID (self, symbol);
154 class = SYMBOL_CLASS (symbol);
156 return PyBool_FromLong (class == LOC_CONST || class == LOC_CONST_BYTES);
160 sympy_is_function (PyObject *self, void *closure)
162 struct symbol *symbol = NULL;
163 enum address_class class;
165 SYMPY_REQUIRE_VALID (self, symbol);
167 class = SYMBOL_CLASS (symbol);
169 return PyBool_FromLong (class == LOC_BLOCK);
173 sympy_is_variable (PyObject *self, void *closure)
175 struct symbol *symbol = NULL;
176 enum address_class class;
178 SYMPY_REQUIRE_VALID (self, symbol);
180 class = SYMBOL_CLASS (symbol);
182 return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
183 && (class == LOC_LOCAL || class == LOC_REGISTER
184 || class == LOC_STATIC || class == LOC_COMPUTED
185 || class == LOC_OPTIMIZED_OUT));
188 /* Implementation of gdb.Symbol.needs_frame -> Boolean.
189 Returns true iff the symbol needs a frame for evaluation. */
192 sympy_needs_frame (PyObject *self, void *closure)
194 struct symbol *symbol = NULL;
195 volatile struct gdb_exception except;
198 SYMPY_REQUIRE_VALID (self, symbol);
200 TRY_CATCH (except, RETURN_MASK_ALL)
202 result = symbol_read_needs_frame (symbol);
204 GDB_PY_HANDLE_EXCEPTION (except);
211 /* Implementation of gdb.Symbol.line -> int.
212 Returns the line number at which the symbol was defined. */
215 sympy_line (PyObject *self, void *closure)
217 struct symbol *symbol = NULL;
219 SYMPY_REQUIRE_VALID (self, symbol);
221 return PyInt_FromLong (SYMBOL_LINE (symbol));
224 /* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
225 Returns True if this Symbol still exists in GDB. */
228 sympy_is_valid (PyObject *self, PyObject *args)
230 struct symbol *symbol = NULL;
232 symbol = symbol_object_to_symbol (self);
239 /* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value. Returns
240 the value of the symbol, or an error in various circumstances. */
243 sympy_value (PyObject *self, PyObject *args)
245 struct symbol *symbol = NULL;
246 struct frame_info *frame_info = NULL;
247 PyObject *frame_obj = NULL;
248 struct value *value = NULL;
249 volatile struct gdb_exception except;
251 if (!PyArg_ParseTuple (args, "|O", &frame_obj))
254 if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
256 PyErr_SetString (PyExc_TypeError, "argument is not a frame");
260 SYMPY_REQUIRE_VALID (self, symbol);
261 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
263 PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
267 TRY_CATCH (except, RETURN_MASK_ALL)
269 if (frame_obj != NULL)
271 frame_info = frame_object_to_frame_info (frame_obj);
272 if (frame_info == NULL)
273 error (_("invalid frame"));
276 if (symbol_read_needs_frame (symbol) && frame_info == NULL)
277 error (_("symbol requires a frame to compute its value"));
279 value = read_var_value (symbol, frame_info);
281 GDB_PY_HANDLE_EXCEPTION (except);
283 return value_to_value_object (value);
286 /* Given a symbol, and a symbol_object that has previously been
287 allocated and initialized, populate the symbol_object with the
288 struct symbol data. Also, register the symbol_object life-cycle
289 with the life-cycle of the object file associated with this
290 symbol, if needed. */
292 set_symbol (symbol_object *obj, struct symbol *symbol)
294 obj->symbol = symbol;
296 if (SYMBOL_OBJFILE_OWNED (symbol)
297 && symbol_symtab (symbol) != NULL)
299 struct objfile *objfile = symbol_objfile (symbol);
301 obj->next = objfile_data (objfile, sympy_objfile_data_key);
303 obj->next->prev = obj;
304 set_objfile_data (objfile, sympy_objfile_data_key, obj);
310 /* Create a new symbol object (gdb.Symbol) that encapsulates the struct
311 symbol object from GDB. */
313 symbol_to_symbol_object (struct symbol *sym)
315 symbol_object *sym_obj;
317 sym_obj = PyObject_New (symbol_object, &symbol_object_type);
319 set_symbol (sym_obj, sym);
321 return (PyObject *) sym_obj;
324 /* Return the symbol that is wrapped by this symbol object. */
326 symbol_object_to_symbol (PyObject *obj)
328 if (! PyObject_TypeCheck (obj, &symbol_object_type))
330 return ((symbol_object *) obj)->symbol;
334 sympy_dealloc (PyObject *obj)
336 symbol_object *sym_obj = (symbol_object *) obj;
339 sym_obj->prev->next = sym_obj->next;
340 else if (sym_obj->symbol != NULL
341 && SYMBOL_OBJFILE_OWNED (sym_obj->symbol)
342 && symbol_symtab (sym_obj->symbol) != NULL)
344 set_objfile_data (symbol_objfile (sym_obj->symbol),
345 sympy_objfile_data_key, sym_obj->next);
348 sym_obj->next->prev = sym_obj->prev;
349 sym_obj->symbol = NULL;
353 gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
354 A tuple with 2 elements is always returned. The first is the symbol
355 object or None, the second is a boolean with the value of
356 is_a_field_of_this (see comment in lookup_symbol_in_language). */
359 gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
361 int domain = VAR_DOMAIN;
362 struct field_of_this_result is_a_field_of_this;
364 static char *keywords[] = { "name", "block", "domain", NULL };
365 struct symbol *symbol = NULL;
366 PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
367 const struct block *block = NULL;
368 volatile struct gdb_exception except;
370 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
371 &block_object_type, &block_obj, &domain))
375 block = block_object_to_block (block_obj);
378 struct frame_info *selected_frame;
379 volatile struct gdb_exception except;
381 TRY_CATCH (except, RETURN_MASK_ALL)
383 selected_frame = get_selected_frame (_("No frame selected."));
384 block = get_frame_block (selected_frame, NULL);
386 GDB_PY_HANDLE_EXCEPTION (except);
389 TRY_CATCH (except, RETURN_MASK_ALL)
391 symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
393 GDB_PY_HANDLE_EXCEPTION (except);
395 ret_tuple = PyTuple_New (2);
401 sym_obj = symbol_to_symbol_object (symbol);
404 Py_DECREF (ret_tuple);
413 PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
415 bool_obj = (is_a_field_of_this.type != NULL) ? Py_True : Py_False;
416 Py_INCREF (bool_obj);
417 PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
423 gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */
426 gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
428 int domain = VAR_DOMAIN;
430 static char *keywords[] = { "name", "domain", NULL };
431 struct symbol *symbol = NULL;
433 volatile struct gdb_exception except;
435 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
439 TRY_CATCH (except, RETURN_MASK_ALL)
441 symbol = lookup_global_symbol (name, NULL, domain);
443 GDB_PY_HANDLE_EXCEPTION (except);
447 sym_obj = symbol_to_symbol_object (symbol);
460 /* This function is called when an objfile is about to be freed.
461 Invalidate the symbol as further actions on the symbol would result
462 in bad data. All access to obj->symbol should be gated by
463 SYMPY_REQUIRE_VALID which will raise an exception on invalid
466 del_objfile_symbols (struct objfile *objfile, void *datum)
468 symbol_object *obj = datum;
471 symbol_object *next = obj->next;
482 gdbpy_initialize_symbols (void)
484 if (PyType_Ready (&symbol_object_type) < 0)
487 /* Register an objfile "free" callback so we can properly
488 invalidate symbol when an object file that is about to be
490 sympy_objfile_data_key
491 = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
493 if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0
494 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST",
496 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC",
498 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER",
500 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG",
502 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG",
504 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL",
506 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF",
508 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL",
510 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK",
512 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
514 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
516 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
517 LOC_OPTIMIZED_OUT) < 0
518 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED",
520 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
521 LOC_REGPARM_ADDR) < 0
522 || PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN",
524 || PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN",
526 || PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN",
528 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN",
530 || PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
531 VARIABLES_DOMAIN) < 0
532 || PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
533 FUNCTIONS_DOMAIN) < 0
534 || PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN",
538 return gdb_pymodule_addobject (gdb_module, "Symbol",
539 (PyObject *) &symbol_object_type);
544 static PyGetSetDef symbol_object_getset[] = {
545 { "type", sympy_get_type, NULL,
546 "Type of the symbol.", NULL },
547 { "symtab", sympy_get_symtab, NULL,
548 "Symbol table in which the symbol appears.", NULL },
549 { "name", sympy_get_name, NULL,
550 "Name of the symbol, as it appears in the source code.", NULL },
551 { "linkage_name", sympy_get_linkage_name, NULL,
552 "Name of the symbol, as used by the linker (i.e., may be mangled).",
554 { "print_name", sympy_get_print_name, NULL,
555 "Name of the symbol in a form suitable for output.\n\
556 This is either name or linkage_name, depending on whether the user asked GDB\n\
557 to display demangled or mangled names.", NULL },
558 { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
559 { "is_argument", sympy_is_argument, NULL,
560 "True if the symbol is an argument of a function." },
561 { "is_constant", sympy_is_constant, NULL,
562 "True if the symbol is a constant." },
563 { "is_function", sympy_is_function, NULL,
564 "True if the symbol is a function or method." },
565 { "is_variable", sympy_is_variable, NULL,
566 "True if the symbol is a variable." },
567 { "needs_frame", sympy_needs_frame, NULL,
568 "True if the symbol requires a frame for evaluation." },
569 { "line", sympy_line, NULL,
570 "The source line number at which the symbol was defined." },
571 { NULL } /* Sentinel */
574 static PyMethodDef symbol_object_methods[] = {
575 { "is_valid", sympy_is_valid, METH_NOARGS,
576 "is_valid () -> Boolean.\n\
577 Return true if this symbol is valid, false if not." },
578 { "value", sympy_value, METH_VARARGS,
579 "value ([frame]) -> gdb.Value\n\
580 Return the value of the symbol." },
581 {NULL} /* Sentinel */
584 PyTypeObject symbol_object_type = {
585 PyVarObject_HEAD_INIT (NULL, 0)
586 "gdb.Symbol", /*tp_name*/
587 sizeof (symbol_object), /*tp_basicsize*/
589 sympy_dealloc, /*tp_dealloc*/
596 0, /*tp_as_sequence*/
600 sympy_str, /*tp_str*/
604 Py_TPFLAGS_DEFAULT, /*tp_flags*/
605 "GDB symbol object", /*tp_doc */
608 0, /*tp_richcompare */
609 0, /*tp_weaklistoffset */
612 symbol_object_methods, /*tp_methods */
614 symbol_object_getset /*tp_getset */