GDB (xrefs)
py-symbol.c
Go to the documentation of this file.
1 /* Python interface to symbols.
2 
3  Copyright (C) 2008-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
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.
11 
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.
16 
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/>. */
19 
20 #include "defs.h"
21 #include "block.h"
22 #include "frame.h"
23 #include "symtab.h"
24 #include "python-internal.h"
25 #include "objfiles.h"
26 
27 typedef struct sympy_symbol_object {
28  PyObject_HEAD
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
34  deleted. */
38 
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) \
42  do { \
43  symbol = symbol_object_to_symbol (symbol_obj); \
44  if (symbol == NULL) \
45  { \
46  PyErr_SetString (PyExc_RuntimeError, \
47  _("Symbol is invalid.")); \
48  return NULL; \
49  } \
50  } while (0)
51 
52 static const struct objfile_data *sympy_objfile_data_key;
53 
54 static PyObject *
55 sympy_str (PyObject *self)
56 {
57  PyObject *result;
58  struct symbol *symbol = NULL;
59 
60  SYMPY_REQUIRE_VALID (self, symbol);
61 
62  result = PyString_FromString (SYMBOL_PRINT_NAME (symbol));
63 
64  return result;
65 }
66 
67 static PyObject *
68 sympy_get_type (PyObject *self, void *closure)
69 {
70  struct symbol *symbol = NULL;
71 
72  SYMPY_REQUIRE_VALID (self, symbol);
73 
74  if (SYMBOL_TYPE (symbol) == NULL)
75  {
76  Py_INCREF (Py_None);
77  return Py_None;
78  }
79 
80  return type_to_type_object (SYMBOL_TYPE (symbol));
81 }
82 
83 static PyObject *
84 sympy_get_symtab (PyObject *self, void *closure)
85 {
86  struct symbol *symbol = NULL;
87 
88  SYMPY_REQUIRE_VALID (self, symbol);
89 
90  if (!SYMBOL_OBJFILE_OWNED (symbol))
91  Py_RETURN_NONE;
92 
93  return symtab_to_symtab_object (symbol_symtab (symbol));
94 }
95 
96 static PyObject *
97 sympy_get_name (PyObject *self, void *closure)
98 {
99  struct symbol *symbol = NULL;
100 
101  SYMPY_REQUIRE_VALID (self, symbol);
102 
103  return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
104 }
105 
106 static PyObject *
107 sympy_get_linkage_name (PyObject *self, void *closure)
108 {
109  struct symbol *symbol = NULL;
110 
111  SYMPY_REQUIRE_VALID (self, symbol);
112 
113  return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
114 }
115 
116 static PyObject *
117 sympy_get_print_name (PyObject *self, void *closure)
118 {
119  struct symbol *symbol = NULL;
120 
121  SYMPY_REQUIRE_VALID (self, symbol);
122 
123  return sympy_str (self);
124 }
125 
126 static PyObject *
127 sympy_get_addr_class (PyObject *self, void *closure)
128 {
129  struct symbol *symbol = NULL;
130 
131  SYMPY_REQUIRE_VALID (self, symbol);
132 
133  return PyInt_FromLong (SYMBOL_CLASS (symbol));
134 }
135 
136 static PyObject *
137 sympy_is_argument (PyObject *self, void *closure)
138 {
139  struct symbol *symbol = NULL;
140 
141  SYMPY_REQUIRE_VALID (self, symbol);
142 
143  return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
144 }
145 
146 static PyObject *
147 sympy_is_constant (PyObject *self, void *closure)
148 {
149  struct symbol *symbol = NULL;
150  enum address_class theclass;
151 
152  SYMPY_REQUIRE_VALID (self, symbol);
153 
154  theclass = SYMBOL_CLASS (symbol);
155 
156  return PyBool_FromLong (theclass == LOC_CONST || theclass == LOC_CONST_BYTES);
157 }
158 
159 static PyObject *
160 sympy_is_function (PyObject *self, void *closure)
161 {
162  struct symbol *symbol = NULL;
163  enum address_class theclass;
164 
165  SYMPY_REQUIRE_VALID (self, symbol);
166 
167  theclass = SYMBOL_CLASS (symbol);
168 
169  return PyBool_FromLong (theclass == LOC_BLOCK);
170 }
171 
172 static PyObject *
173 sympy_is_variable (PyObject *self, void *closure)
174 {
175  struct symbol *symbol = NULL;
176  enum address_class theclass;
177 
178  SYMPY_REQUIRE_VALID (self, symbol);
179 
180  theclass = SYMBOL_CLASS (symbol);
181 
182  return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
183  && (theclass == LOC_LOCAL || theclass == LOC_REGISTER
184  || theclass == LOC_STATIC || theclass == LOC_COMPUTED
185  || theclass == LOC_OPTIMIZED_OUT));
186 }
187 
188 /* Implementation of gdb.Symbol.needs_frame -> Boolean.
189  Returns true iff the symbol needs a frame for evaluation. */
190 
191 static PyObject *
192 sympy_needs_frame (PyObject *self, void *closure)
193 {
194  struct symbol *symbol = NULL;
195  int result = 0;
196 
197  SYMPY_REQUIRE_VALID (self, symbol);
198 
199  TRY
200  {
201  result = symbol_read_needs_frame (symbol);
202  }
203  CATCH (except, RETURN_MASK_ALL)
204  {
205  GDB_PY_HANDLE_EXCEPTION (except);
206  }
207  END_CATCH
208 
209  if (result)
210  Py_RETURN_TRUE;
211  Py_RETURN_FALSE;
212 }
213 
214 /* Implementation of gdb.Symbol.line -> int.
215  Returns the line number at which the symbol was defined. */
216 
217 static PyObject *
218 sympy_line (PyObject *self, void *closure)
219 {
220  struct symbol *symbol = NULL;
221 
222  SYMPY_REQUIRE_VALID (self, symbol);
223 
224  return PyInt_FromLong (SYMBOL_LINE (symbol));
225 }
226 
227 /* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
228  Returns True if this Symbol still exists in GDB. */
229 
230 static PyObject *
231 sympy_is_valid (PyObject *self, PyObject *args)
232 {
233  struct symbol *symbol = NULL;
234 
235  symbol = symbol_object_to_symbol (self);
236  if (symbol == NULL)
237  Py_RETURN_FALSE;
238 
239  Py_RETURN_TRUE;
240 }
241 
242 /* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value. Returns
243  the value of the symbol, or an error in various circumstances. */
244 
245 static PyObject *
246 sympy_value (PyObject *self, PyObject *args)
247 {
248  struct symbol *symbol = NULL;
249  struct frame_info *frame_info = NULL;
250  PyObject *frame_obj = NULL;
251  struct value *value = NULL;
252 
253  if (!PyArg_ParseTuple (args, "|O", &frame_obj))
254  return NULL;
255 
256  if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
257  {
258  PyErr_SetString (PyExc_TypeError, "argument is not a frame");
259  return NULL;
260  }
261 
262  SYMPY_REQUIRE_VALID (self, symbol);
263  if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
264  {
265  PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
266  return NULL;
267  }
268 
269  TRY
270  {
271  if (frame_obj != NULL)
272  {
273  frame_info = frame_object_to_frame_info (frame_obj);
274  if (frame_info == NULL)
275  error (_("invalid frame"));
276  }
277 
278  if (symbol_read_needs_frame (symbol) && frame_info == NULL)
279  error (_("symbol requires a frame to compute its value"));
280 
281  value = read_var_value (symbol, frame_info);
282  }
283  CATCH (except, RETURN_MASK_ALL)
284  {
285  GDB_PY_HANDLE_EXCEPTION (except);
286  }
287  END_CATCH
288 
289  return value_to_value_object (value);
290 }
291 
292 /* Given a symbol, and a symbol_object that has previously been
293  allocated and initialized, populate the symbol_object with the
294  struct symbol data. Also, register the symbol_object life-cycle
295  with the life-cycle of the object file associated with this
296  symbol, if needed. */
297 static void
299 {
300  obj->symbol = symbol;
301  obj->prev = NULL;
302  if (SYMBOL_OBJFILE_OWNED (symbol)
303  && symbol_symtab (symbol) != NULL)
304  {
305  struct objfile *objfile = symbol_objfile (symbol);
306 
307  obj->next = objfile_data (objfile, sympy_objfile_data_key);
308  if (obj->next)
309  obj->next->prev = obj;
310  set_objfile_data (objfile, sympy_objfile_data_key, obj);
311  }
312  else
313  obj->next = NULL;
314 }
315 
316 /* Create a new symbol object (gdb.Symbol) that encapsulates the struct
317  symbol object from GDB. */
318 PyObject *
320 {
321  symbol_object *sym_obj;
322 
323  sym_obj = PyObject_New (symbol_object, &symbol_object_type);
324  if (sym_obj)
325  set_symbol (sym_obj, sym);
326 
327  return (PyObject *) sym_obj;
328 }
329 
330 /* Return the symbol that is wrapped by this symbol object. */
331 struct symbol *
332 symbol_object_to_symbol (PyObject *obj)
333 {
334  if (! PyObject_TypeCheck (obj, &symbol_object_type))
335  return NULL;
336  return ((symbol_object *) obj)->symbol;
337 }
338 
339 static void
340 sympy_dealloc (PyObject *obj)
341 {
342  symbol_object *sym_obj = (symbol_object *) obj;
343 
344  if (sym_obj->prev)
345  sym_obj->prev->next = sym_obj->next;
346  else if (sym_obj->symbol != NULL
347  && SYMBOL_OBJFILE_OWNED (sym_obj->symbol)
348  && symbol_symtab (sym_obj->symbol) != NULL)
349  {
350  set_objfile_data (symbol_objfile (sym_obj->symbol),
351  sympy_objfile_data_key, sym_obj->next);
352  }
353  if (sym_obj->next)
354  sym_obj->next->prev = sym_obj->prev;
355  sym_obj->symbol = NULL;
356 }
357 
358 /* Implementation of
359  gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
360  A tuple with 2 elements is always returned. The first is the symbol
361  object or None, the second is a boolean with the value of
362  is_a_field_of_this (see comment in lookup_symbol_in_language). */
363 
364 PyObject *
365 gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
366 {
367  int domain = VAR_DOMAIN;
368  struct field_of_this_result is_a_field_of_this;
369  const char *name;
370  static char *keywords[] = { "name", "block", "domain", NULL };
371  struct symbol *symbol = NULL;
372  PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
373  const struct block *block = NULL;
374 
375  if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
376  &block_object_type, &block_obj, &domain))
377  return NULL;
378 
379  if (block_obj)
380  block = block_object_to_block (block_obj);
381  else
382  {
383  struct frame_info *selected_frame;
384 
385  TRY
386  {
387  selected_frame = get_selected_frame (_("No frame selected."));
388  block = get_frame_block (selected_frame, NULL);
389  }
390  CATCH (except, RETURN_MASK_ALL)
391  {
392  GDB_PY_HANDLE_EXCEPTION (except);
393  }
394  END_CATCH
395  }
396 
397  TRY
398  {
399  symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
400  }
401  CATCH (except, RETURN_MASK_ALL)
402  {
403  GDB_PY_HANDLE_EXCEPTION (except);
404  }
405  END_CATCH
406 
407  ret_tuple = PyTuple_New (2);
408  if (!ret_tuple)
409  return NULL;
410 
411  if (symbol)
412  {
413  sym_obj = symbol_to_symbol_object (symbol);
414  if (!sym_obj)
415  {
416  Py_DECREF (ret_tuple);
417  return NULL;
418  }
419  }
420  else
421  {
422  sym_obj = Py_None;
423  Py_INCREF (Py_None);
424  }
425  PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
426 
427  bool_obj = (is_a_field_of_this.type != NULL) ? Py_True : Py_False;
428  Py_INCREF (bool_obj);
429  PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
430 
431  return ret_tuple;
432 }
433 
434 /* Implementation of
435  gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */
436 
437 PyObject *
438 gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
439 {
440  int domain = VAR_DOMAIN;
441  const char *name;
442  static char *keywords[] = { "name", "domain", NULL };
443  struct symbol *symbol = NULL;
444  PyObject *sym_obj;
445 
446  if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
447  &domain))
448  return NULL;
449 
450  TRY
451  {
452  symbol = lookup_global_symbol (name, NULL, domain);
453  }
454  CATCH (except, RETURN_MASK_ALL)
455  {
456  GDB_PY_HANDLE_EXCEPTION (except);
457  }
458  END_CATCH
459 
460  if (symbol)
461  {
462  sym_obj = symbol_to_symbol_object (symbol);
463  if (!sym_obj)
464  return NULL;
465  }
466  else
467  {
468  sym_obj = Py_None;
469  Py_INCREF (Py_None);
470  }
471 
472  return sym_obj;
473 }
474 
475 /* This function is called when an objfile is about to be freed.
476  Invalidate the symbol as further actions on the symbol would result
477  in bad data. All access to obj->symbol should be gated by
478  SYMPY_REQUIRE_VALID which will raise an exception on invalid
479  symbols. */
480 static void
481 del_objfile_symbols (struct objfile *objfile, void *datum)
482 {
483  symbol_object *obj = datum;
484  while (obj)
485  {
486  symbol_object *next = obj->next;
487 
488  obj->symbol = NULL;
489  obj->next = NULL;
490  obj->prev = NULL;
491 
492  obj = next;
493  }
494 }
495 
496 int
498 {
499  if (PyType_Ready (&symbol_object_type) < 0)
500  return -1;
501 
502  /* Register an objfile "free" callback so we can properly
503  invalidate symbol when an object file that is about to be
504  deleted. */
505  sympy_objfile_data_key
506  = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
507 
508  if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0
509  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST",
510  LOC_CONST) < 0
511  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC",
512  LOC_STATIC) < 0
513  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER",
514  LOC_REGISTER) < 0
515  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG",
516  LOC_ARG) < 0
517  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG",
518  LOC_REF_ARG) < 0
519  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL",
520  LOC_LOCAL) < 0
521  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF",
522  LOC_TYPEDEF) < 0
523  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL",
524  LOC_LABEL) < 0
525  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK",
526  LOC_BLOCK) < 0
527  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
528  LOC_CONST_BYTES) < 0
529  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
530  LOC_UNRESOLVED) < 0
531  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
532  LOC_OPTIMIZED_OUT) < 0
533  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED",
534  LOC_COMPUTED) < 0
535  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
536  LOC_REGPARM_ADDR) < 0
537  || PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN",
538  UNDEF_DOMAIN) < 0
539  || PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN",
540  VAR_DOMAIN) < 0
541  || PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN",
542  STRUCT_DOMAIN) < 0
543  || PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN",
544  LABEL_DOMAIN) < 0
545  || PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
546  VARIABLES_DOMAIN) < 0
547  || PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
548  FUNCTIONS_DOMAIN) < 0
549  || PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN",
550  TYPES_DOMAIN) < 0)
551  return -1;
552 
553  return gdb_pymodule_addobject (gdb_module, "Symbol",
554  (PyObject *) &symbol_object_type);
555 }
556 
557 
558 
559 static PyGetSetDef symbol_object_getset[] = {
560  { "type", sympy_get_type, NULL,
561  "Type of the symbol.", NULL },
562  { "symtab", sympy_get_symtab, NULL,
563  "Symbol table in which the symbol appears.", NULL },
564  { "name", sympy_get_name, NULL,
565  "Name of the symbol, as it appears in the source code.", NULL },
566  { "linkage_name", sympy_get_linkage_name, NULL,
567  "Name of the symbol, as used by the linker (i.e., may be mangled).",
568  NULL },
569  { "print_name", sympy_get_print_name, NULL,
570  "Name of the symbol in a form suitable for output.\n\
571 This is either name or linkage_name, depending on whether the user asked GDB\n\
572 to display demangled or mangled names.", NULL },
573  { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
574  { "is_argument", sympy_is_argument, NULL,
575  "True if the symbol is an argument of a function." },
576  { "is_constant", sympy_is_constant, NULL,
577  "True if the symbol is a constant." },
578  { "is_function", sympy_is_function, NULL,
579  "True if the symbol is a function or method." },
580  { "is_variable", sympy_is_variable, NULL,
581  "True if the symbol is a variable." },
582  { "needs_frame", sympy_needs_frame, NULL,
583  "True if the symbol requires a frame for evaluation." },
584  { "line", sympy_line, NULL,
585  "The source line number at which the symbol was defined." },
586  { NULL } /* Sentinel */
587 };
588 
589 static PyMethodDef symbol_object_methods[] = {
590  { "is_valid", sympy_is_valid, METH_NOARGS,
591  "is_valid () -> Boolean.\n\
592 Return true if this symbol is valid, false if not." },
593  { "value", sympy_value, METH_VARARGS,
594  "value ([frame]) -> gdb.Value\n\
595 Return the value of the symbol." },
596  {NULL} /* Sentinel */
597 };
598 
599 PyTypeObject symbol_object_type = {
600  PyVarObject_HEAD_INIT (NULL, 0)
601  "gdb.Symbol", /*tp_name*/
602  sizeof (symbol_object), /*tp_basicsize*/
603  0, /*tp_itemsize*/
604  sympy_dealloc, /*tp_dealloc*/
605  0, /*tp_print*/
606  0, /*tp_getattr*/
607  0, /*tp_setattr*/
608  0, /*tp_compare*/
609  0, /*tp_repr*/
610  0, /*tp_as_number*/
611  0, /*tp_as_sequence*/
612  0, /*tp_as_mapping*/
613  0, /*tp_hash */
614  0, /*tp_call*/
615  sympy_str, /*tp_str*/
616  0, /*tp_getattro*/
617  0, /*tp_setattro*/
618  0, /*tp_as_buffer*/
619  Py_TPFLAGS_DEFAULT, /*tp_flags*/
620  "GDB symbol object", /*tp_doc */
621  0, /*tp_traverse */
622  0, /*tp_clear */
623  0, /*tp_richcompare */
624  0, /*tp_weaklistoffset */
625  0, /*tp_iter */
626  0, /*tp_iternext */
627  symbol_object_methods, /*tp_methods */
628  0, /*tp_members */
629  symbol_object_getset /*tp_getset */
630 };
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:437
#define Py_DECREF(op)
int gdbpy_initialize_symbols(void)
Definition: py-symbol.c:497
static PyObject * sympy_value(PyObject *self, PyObject *args)
Definition: py-symbol.c:246
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
static struct frame_info * selected_frame
Definition: frame.c:1503
struct sympy_symbol_object * next
Definition: py-symbol.c:36
static void sympy_dealloc(PyObject *obj)
Definition: py-symbol.c:340
static void set_symbol(symbol_object *obj, struct symbol *symbol)
Definition: py-symbol.c:298
static PyObject * sympy_get_linkage_name(PyObject *self, void *closure)
Definition: py-symbol.c:107
PyTypeObject block_object_type
Definition: py-block.c:481
struct sympy_symbol_object symbol_object
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
PyObject_HEAD struct symbol * symbol
Definition: py-symbol.c:30
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:613
#define _(String)
Definition: gdb_locale.h:40
struct symbol * symbol_object_to_symbol(PyObject *obj)
Definition: py-symbol.c:332
PyTypeObject frame_object_type
Definition: py-frame.c:781
#define END_CATCH
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:6231
static PyObject * sympy_get_addr_class(PyObject *self, void *closure)
Definition: py-symbol.c:127
static PyObject * sympy_line(PyObject *self, void *closure)
Definition: py-symbol.c:218
PyObject * symtab_to_symtab_object(struct symtab *symtab)
Definition: py-symtab.c:421
static const struct objfile_data * sympy_objfile_data_key
Definition: py-symbol.c:52
#define GDB_PY_HANDLE_EXCEPTION(Exception)
PyTypeObject symbol_object_type
Definition: py-symbol.c:599
#define TRY
const char *const name
Definition: aarch64-tdep.c:68
#define CATCH(EXCEPTION, MASK)
static PyObject * sympy_is_function(PyObject *self, void *closure)
Definition: py-symbol.c:160
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
int symbol_read_needs_frame(struct symbol *sym)
Definition: findvar.c:343
const struct block * block_object_to_block(PyObject *obj)
Definition: py-block.c:284
address_class
Definition: symtab.h:493
#define SYMBOL_LINE(symbol)
Definition: symtab.h:800
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1523
PyObject * gdbpy_lookup_symbol(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-symbol.c:365
static PyObject * sympy_is_variable(PyObject *self, void *closure)
Definition: py-symbol.c:173
static void del_objfile_symbols(struct objfile *objfile, void *datum)
Definition: py-symbol.c:481
static PyObject * sympy_str(PyObject *self)
Definition: py-symbol.c:55
static PyObject * sympy_get_name(PyObject *self, void *closure)
Definition: py-symbol.c:97
Definition: block.h:60
struct type * type
Definition: symtab.h:1173
Definition: value.c:172
#define SYMBOL_OBJFILE_OWNED(symbol)
Definition: symtab.h:794
#define SYMPY_REQUIRE_VALID(symbol_obj, symbol)
Definition: py-symbol.c:41
static PyObject * sympy_get_symtab(PyObject *self, void *closure)
Definition: py-symbol.c:84
struct symbol * lookup_global_symbol(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2709
static PyObject * sympy_get_print_name(PyObject *self, void *closure)
Definition: py-symbol.c:117
static PyMethodDef symbol_object_methods[]
Definition: py-symbol.c:589
static PyObject * sympy_is_constant(PyObject *self, void *closure)
Definition: py-symbol.c:147
const char * symbol
Definition: signals.c:48
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
PyObject * gdbpy_lookup_global_symbol(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-symbol.c:438
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:231
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
PyObject * gdb_module
Definition: python.c:112
struct sympy_symbol_object * prev
Definition: py-symbol.c:35
static PyGetSetDef symbol_object_getset[]
Definition: py-symbol.c:559
static PyObject * sympy_is_argument(PyObject *self, void *closure)
Definition: py-symbol.c:137
PyObject * symbol_to_symbol_object(struct symbol *sym)
Definition: py-symbol.c:319
struct frame_info * frame_object_to_frame_info(PyObject *obj)
Definition: py-frame.c:62
static PyObject * sympy_is_valid(PyObject *self, PyObject *args)
Definition: py-symbol.c:231
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:6250
void error(const char *fmt,...)
Definition: errors.c:38
static PyObject * sympy_get_type(PyObject *self, void *closure)
Definition: py-symbol.c:68
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
static PyObject * sympy_needs_frame(PyObject *self, void *closure)
Definition: py-symbol.c:192
__extension__ enum domain_enum_tag domain
Definition: symtab.h:730
#define PyVarObject_HEAD_INIT(type, size)
PyObject * type_to_type_object(struct type *type)
Definition: py-type.c:1382