GDB (xrefs)
py-symtab.c
Go to the documentation of this file.
1 /* Python interface to symbol tables.
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 "charset.h"
22 #include "symtab.h"
23 #include "source.h"
24 #include "python-internal.h"
25 #include "objfiles.h"
26 #include "block.h"
27 
28 typedef struct stpy_symtab_object {
29  PyObject_HEAD
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
35  deleted. */
39 
40 extern PyTypeObject symtab_object_type
41  CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symtab_object");
42 static const struct objfile_data *stpy_objfile_data_key;
43 
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) \
47  do { \
48  symtab = symtab_object_to_symtab (symtab_obj); \
49  if (symtab == NULL) \
50  { \
51  PyErr_SetString (PyExc_RuntimeError, \
52  _("Symbol Table is invalid.")); \
53  return NULL; \
54  } \
55  } while (0)
56 
57 typedef struct salpy_sal_object {
58  PyObject_HEAD
59  /* The GDB Symbol table structure. */
61  /* The GDB Symbol table and line structure. */
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. */
69 } sal_object;
70 
71 extern PyTypeObject sal_object_type
73 static const struct objfile_data *salpy_objfile_data_key;
74 
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) \
78  do { \
79  sal = sal_object_to_symtab_and_line (sal_obj); \
80  if (sal == NULL) \
81  { \
82  PyErr_SetString (PyExc_RuntimeError, \
83  _("Symbol Table and Line is invalid.")); \
84  return NULL; \
85  } \
86  } while (0)
87 
88 static PyObject *
89 stpy_str (PyObject *self)
90 {
91  PyObject *result;
92  struct symtab *symtab = NULL;
93 
94  STPY_REQUIRE_VALID (self, symtab);
95 
96  result = PyString_FromString (symtab_to_filename_for_display (symtab));
97 
98  return result;
99 }
100 
101 static PyObject *
102 stpy_get_filename (PyObject *self, void *closure)
103 {
104  PyObject *str_obj;
105  struct symtab *symtab = NULL;
106  const char *filename;
107 
108  STPY_REQUIRE_VALID (self, symtab);
109  filename = symtab_to_filename_for_display (symtab);
110 
111  str_obj = PyString_Decode (filename, strlen (filename),
112  host_charset (), NULL);
113  return str_obj;
114 }
115 
116 static PyObject *
117 stpy_get_objfile (PyObject *self, void *closure)
118 {
119  struct symtab *symtab = NULL;
120  PyObject *result;
121 
122  STPY_REQUIRE_VALID (self, symtab);
123 
124  result = objfile_to_objfile_object (SYMTAB_OBJFILE (symtab));
125  Py_XINCREF (result);
126  return result;
127 }
128 
129 /* Getter function for symtab.producer. */
130 
131 static PyObject *
132 stpy_get_producer (PyObject *self, void *closure)
133 {
134  struct symtab *symtab = NULL;
135  struct compunit_symtab *cust;
136 
137  STPY_REQUIRE_VALID (self, symtab);
138  cust = SYMTAB_COMPUNIT (symtab);
139  if (COMPUNIT_PRODUCER (cust) != NULL)
140  {
141  const char *producer = COMPUNIT_PRODUCER (cust);
142 
143  return PyString_Decode (producer, strlen (producer),
144  host_charset (), NULL);
145  }
146 
147  Py_RETURN_NONE;
148 }
149 
150 static PyObject *
151 stpy_fullname (PyObject *self, PyObject *args)
152 {
153  const char *fullname;
154  struct symtab *symtab = NULL;
155 
156  STPY_REQUIRE_VALID (self, symtab);
157 
158  fullname = symtab_to_fullname (symtab);
159 
160  return PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
161 }
162 
163 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
164  Returns True if this Symbol table still exists in GDB. */
165 
166 static PyObject *
167 stpy_is_valid (PyObject *self, PyObject *args)
168 {
169  struct symtab *symtab = NULL;
170 
171  symtab = symtab_object_to_symtab (self);
172  if (symtab == NULL)
173  Py_RETURN_FALSE;
174 
175  Py_RETURN_TRUE;
176 }
177 
178 /* Return the GLOBAL_BLOCK of the underlying symtab. */
179 
180 static PyObject *
181 stpy_global_block (PyObject *self, PyObject *args)
182 {
183  struct symtab *symtab = NULL;
184  struct block *block = NULL;
185  const struct blockvector *blockvector;
186 
187  STPY_REQUIRE_VALID (self, symtab);
188 
189  blockvector = SYMTAB_BLOCKVECTOR (symtab);
190  block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
191  return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
192 }
193 
194 /* Return the STATIC_BLOCK of the underlying symtab. */
195 
196 static PyObject *
197 stpy_static_block (PyObject *self, PyObject *args)
198 {
199  struct symtab *symtab = NULL;
200  struct block *block = NULL;
201  const struct blockvector *blockvector;
202 
203  STPY_REQUIRE_VALID (self, symtab);
204 
205  blockvector = SYMTAB_BLOCKVECTOR (symtab);
206  block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
207  return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
208 }
209 
210 /* Implementation of gdb.Symtab.linetable (self) -> gdb.Linetable.
211  Returns a gdb.Linetable object corresponding to this symbol
212  table. */
213 
214 static PyObject *
215 stpy_get_linetable (PyObject *self, PyObject *args)
216 {
217  struct symtab *symtab = NULL;
218 
219  STPY_REQUIRE_VALID (self, symtab);
220 
221  return symtab_to_linetable_object (self);
222 }
223 
224 static PyObject *
225 salpy_str (PyObject *self)
226 {
227  char *s;
228  const char *filename;
229  sal_object *sal_obj;
230  PyObject *result;
231  struct symtab_and_line *sal = NULL;
232 
233  SALPY_REQUIRE_VALID (self, sal);
234 
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);
238 
239  s = xstrprintf ("symbol and line for %s, line %d", filename,
240  sal->line);
241 
242  result = PyString_FromString (s);
243  xfree (s);
244 
245  return result;
246 }
247 
248 static void
249 stpy_dealloc (PyObject *obj)
250 {
252 
253  if (symtab->prev)
254  symtab->prev->next = symtab->next;
255  else if (symtab->symtab)
256  {
257  set_objfile_data (SYMTAB_OBJFILE (symtab->symtab),
258  stpy_objfile_data_key, symtab->next);
259  }
260  if (symtab->next)
261  symtab->next->prev = symtab->prev;
262  symtab->symtab = NULL;
263 }
264 
265 
266 static PyObject *
267 salpy_get_pc (PyObject *self, void *closure)
268 {
269  struct symtab_and_line *sal = NULL;
270 
271  SALPY_REQUIRE_VALID (self, sal);
272 
273  return gdb_py_long_from_ulongest (sal->pc);
274 }
275 
276 /* Implementation of the get method for the 'last' attribute of
277  gdb.Symtab_and_line. */
278 
279 static PyObject *
280 salpy_get_last (PyObject *self, void *closure)
281 {
282  struct symtab_and_line *sal = NULL;
283 
284  SALPY_REQUIRE_VALID (self, sal);
285 
286  if (sal->end > 0)
287  return gdb_py_long_from_ulongest (sal->end - 1);
288  else
289  Py_RETURN_NONE;
290 }
291 
292 static PyObject *
293 salpy_get_line (PyObject *self, void *closure)
294 {
295  struct symtab_and_line *sal = NULL;
296 
297  SALPY_REQUIRE_VALID (self, sal);
298 
299  return PyInt_FromLong (sal->line);
300 }
301 
302 static PyObject *
303 salpy_get_symtab (PyObject *self, void *closure)
304 {
305  struct symtab_and_line *sal;
306  sal_object *self_sal = (sal_object *) self;
307 
308  SALPY_REQUIRE_VALID (self, sal);
309 
310  Py_INCREF (self_sal->symtab);
311 
312  return (PyObject *) self_sal->symtab;
313 }
314 
315 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
316  Returns True if this Symbol table and line object still exists GDB. */
317 
318 static PyObject *
319 salpy_is_valid (PyObject *self, PyObject *args)
320 {
321  struct symtab_and_line *sal;
322 
323  sal = sal_object_to_symtab_and_line (self);
324  if (sal == NULL)
325  Py_RETURN_FALSE;
326 
327  Py_RETURN_TRUE;
328 }
329 
330 static void
331 salpy_dealloc (PyObject *self)
332 {
333  sal_object *self_sal = (sal_object *) self;
334 
335  if (self_sal->prev)
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);
340 
341  if (self_sal->next)
342  self_sal->next->prev = self_sal->prev;
343 
344  Py_DECREF (self_sal->symtab);
345  xfree (self_sal->sal);
346  Py_TYPE (self)->tp_free (self);
347 }
348 
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. */
355 set_sal (sal_object *sal_obj, struct symtab_and_line sal)
356 {
357  symtab_object *symtab_obj;
358 
359  if (sal.symtab)
360  {
361  symtab_obj = (symtab_object *) symtab_to_symtab_object (sal.symtab);
362  /* If a symtab existed in the sal, but it cannot be duplicated,
363  we exit. */
364  if (symtab_obj == NULL)
365  return -1;
366  }
367  else
368  {
369  symtab_obj = (symtab_object *) Py_None;
370  Py_INCREF (Py_None);
371  }
372 
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;
377 
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)
381  {
382  sal_obj->next = objfile_data (SYMTAB_OBJFILE (sal_obj->symtab->symtab),
383  salpy_objfile_data_key);
384  if (sal_obj->next)
385  sal_obj->next->prev = sal_obj;
386 
387  set_objfile_data (SYMTAB_OBJFILE (sal_obj->symtab->symtab),
388  salpy_objfile_data_key, sal_obj);
389  }
390  else
391  sal_obj->next = NULL;
392 
393  return 0;
394 }
395 
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. */
401 static void
403 {
404  obj->symtab = symtab;
405  obj->prev = NULL;
406  if (symtab)
407  {
408  obj->next = objfile_data (SYMTAB_OBJFILE (symtab),
409  stpy_objfile_data_key);
410  if (obj->next)
411  obj->next->prev = obj;
412  set_objfile_data (SYMTAB_OBJFILE (symtab), stpy_objfile_data_key, obj);
413  }
414  else
415  obj->next = NULL;
416 }
417 
418 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
419  symtab structure from GDB. */
420 PyObject *
422 {
423  symtab_object *symtab_obj;
424 
425  symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
426  if (symtab_obj)
427  set_symtab (symtab_obj, symtab);
428 
429  return (PyObject *) symtab_obj;
430 }
431 
432 /* Create a new symtab and line (gdb.Symtab_and_line) object
433  that encapsulates the symtab_and_line structure from GDB. */
434 PyObject *
436 {
437  sal_object *sal_obj;
438  int success = 0;
439 
440  sal_obj = PyObject_New (sal_object, &sal_object_type);
441  if (sal_obj)
442  {
443  if (set_sal (sal_obj, sal) < 0)
444  {
445  Py_DECREF (sal_obj);
446  return NULL;
447  }
448  }
449 
450  return (PyObject *) sal_obj;
451 }
452 
453 /* Return struct symtab_and_line reference that is wrapped by this
454  object. */
455 struct symtab_and_line *
457 {
458  if (! PyObject_TypeCheck (obj, &sal_object_type))
459  return NULL;
460  return ((sal_object *) obj)->sal;
461 }
462 
463 /* Return struct symtab reference that is wrapped by this object. */
464 struct symtab *
465 symtab_object_to_symtab (PyObject *obj)
466 {
467  if (! PyObject_TypeCheck (obj, &symtab_object_type))
468  return NULL;
469  return ((symtab_object *) obj)->symtab;
470 }
471 
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. */
477 static void
478 del_objfile_symtab (struct objfile *objfile, void *datum)
479 {
480  symtab_object *obj = datum;
481 
482  while (obj)
483  {
484  symtab_object *next = obj->next;
485 
486  obj->symtab = NULL;
487  obj->next = NULL;
488  obj->prev = NULL;
489  obj = next;
490  }
491 }
492 
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. */
498 static void
499 del_objfile_sal (struct objfile *objfile, void *datum)
500 {
501  sal_object *obj = datum;
502 
503  while (obj)
504  {
505  sal_object *next = obj->next;
506 
507  Py_DECREF (obj->symtab);
508  obj->symtab = (symtab_object *) Py_None;
509  Py_INCREF (Py_None);
510 
511  obj->next = NULL;
512  obj->prev = NULL;
513  xfree (obj->sal);
514  obj->sal = NULL;
515 
516  obj = next;
517  }
518 }
519 
520 int
522 {
523  symtab_object_type.tp_new = PyType_GenericNew;
524  if (PyType_Ready (&symtab_object_type) < 0)
525  return -1;
526 
527  sal_object_type.tp_new = PyType_GenericNew;
528  if (PyType_Ready (&sal_object_type) < 0)
529  return -1;
530 
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
534  deleted. */
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);
539 
540  if (gdb_pymodule_addobject (gdb_module, "Symtab",
541  (PyObject *) &symtab_object_type) < 0)
542  return -1;
543 
544  return gdb_pymodule_addobject (gdb_module, "Symtab_and_line",
545  (PyObject *) &sal_object_type);
546 }
547 
548 
549 
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.",
554  NULL },
555  { "producer", stpy_get_producer, NULL,
556  "The name/version of the program that compiled this symtab.", NULL },
557  {NULL} /* Sentinel */
558 };
559 
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 */
577 };
578 
579 PyTypeObject symtab_object_type = {
580  PyVarObject_HEAD_INIT (NULL, 0)
581  "gdb.Symtab", /*tp_name*/
582  sizeof (symtab_object), /*tp_basicsize*/
583  0, /*tp_itemsize*/
584  stpy_dealloc, /*tp_dealloc*/
585  0, /*tp_print*/
586  0, /*tp_getattr*/
587  0, /*tp_setattr*/
588  0, /*tp_compare*/
589  0, /*tp_repr*/
590  0, /*tp_as_number*/
591  0, /*tp_as_sequence*/
592  0, /*tp_as_mapping*/
593  0, /*tp_hash */
594  0, /*tp_call*/
595  stpy_str, /*tp_str*/
596  0, /*tp_getattro*/
597  0, /*tp_setattro*/
598  0, /*tp_as_buffer*/
599  Py_TPFLAGS_DEFAULT, /*tp_flags*/
600  "GDB symtab object", /*tp_doc */
601  0, /*tp_traverse */
602  0, /*tp_clear */
603  0, /*tp_richcompare */
604  0, /*tp_weaklistoffset */
605  0, /*tp_iter */
606  0, /*tp_iternext */
607  symtab_object_methods, /*tp_methods */
608  0, /*tp_members */
609  symtab_object_getset /*tp_getset */
610 };
611 
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 */
620 };
621 
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 */
627 };
628 
629 PyTypeObject sal_object_type = {
630  PyVarObject_HEAD_INIT (NULL, 0)
631  "gdb.Symtab_and_line", /*tp_name*/
632  sizeof (sal_object), /*tp_basicsize*/
633  0, /*tp_itemsize*/
634  salpy_dealloc, /*tp_dealloc*/
635  0, /*tp_print*/
636  0, /*tp_getattr*/
637  0, /*tp_setattr*/
638  0, /*tp_compare*/
639  0, /*tp_repr*/
640  0, /*tp_as_number*/
641  0, /*tp_as_sequence*/
642  0, /*tp_as_mapping*/
643  0, /*tp_hash */
644  0, /*tp_call*/
645  salpy_str, /*tp_str*/
646  0, /*tp_getattro*/
647  0, /*tp_setattro*/
648  0, /*tp_as_buffer*/
649  Py_TPFLAGS_DEFAULT, /*tp_flags*/
650  "GDB symtab_and_line object", /*tp_doc */
651  0, /*tp_traverse */
652  0, /*tp_clear */
653  0, /*tp_richcompare */
654  0, /*tp_weaklistoffset */
655  0, /*tp_iter */
656  0, /*tp_iternext */
657  sal_object_methods, /*tp_methods */
658  0, /*tp_members */
659  sal_object_getset /*tp_getset */
660 };
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:437
static PyObject * salpy_get_pc(PyObject *self, void *closure)
Definition: py-symtab.c:267
struct symtab_and_line * sal
Definition: py-symtab.c:62
#define Py_DECREF(op)
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1171
#define SYMTAB_COMPUNIT(symtab)
Definition: symtab.h:965
struct symtab * next
Definition: symtab.h:930
PyObject * block_to_block_object(const struct block *block, struct objfile *objfile)
Definition: py-block.c:271
PyObject * symtab_and_line_to_sal_object(struct symtab_and_line sal)
Definition: py-symtab.c:435
static const struct objfile_data * salpy_objfile_data_key
Definition: py-symtab.c:73
static PyObject * stpy_fullname(PyObject *self, PyObject *args)
Definition: py-symtab.c:151
void xfree(void *)
Definition: common-utils.c:97
struct salpy_sal_object sal_object
CORE_ADDR end
Definition: symtab.h:1377
#define SALPY_REQUIRE_VALID(sal_obj, sal)
Definition: py-symtab.c:77
static void salpy_dealloc(PyObject *self)
Definition: py-symtab.c:331
static PyObject * stpy_get_filename(PyObject *self, void *closure)
Definition: py-symtab.c:102
static PyObject * stpy_get_objfile(PyObject *self, void *closure)
Definition: py-symtab.c:117
static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION set_sal(sal_object *sal_obj, struct symtab_and_line sal)
Definition: py-symtab.c:355
#define gdb_py_long_from_ulongest
struct stpy_symtab_object * next
Definition: py-symtab.c:37
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
const char * filename
Definition: symtab.h:943
PyObject * symtab_to_linetable_object(PyObject *symtab)
Definition: py-linetable.c:85
const char * producer
Definition: symtab.h:1047
static void del_objfile_sal(struct objfile *objfile, void *datum)
Definition: py-symtab.c:499
static PyObject * stpy_static_block(PyObject *self, PyObject *args)
Definition: py-symtab.c:197
static void set_symtab(symtab_object *obj, struct symtab *symtab)
Definition: py-symtab.c:402
PyObject * symtab_to_symtab_object(struct symtab *symtab)
Definition: py-symtab.c:421
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:968
PyObject_HEAD symtab_object * symtab
Definition: py-symtab.c:60
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:970
struct symtab * symtab_object_to_symtab(PyObject *obj)
Definition: py-symtab.c:465
PyObject * objfile_to_objfile_object(struct objfile *objfile)
Definition: py-objfile.c:632
#define COMPUNIT_PRODUCER(cust)
Definition: symtab.h:1097
PyTypeObject symtab_object_type
Definition: py-symtab.c:579
static PyObject * salpy_get_last(PyObject *self, void *closure)
Definition: py-symtab.c:280
static PyObject * salpy_str(PyObject *self)
Definition: py-symtab.c:225
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
Definition: symtab.h:925
static PyObject * stpy_get_linetable(PyObject *self, PyObject *args)
Definition: py-symtab.c:215
struct symtab * symtab
Definition: symtab.h:1369
#define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
struct stpy_symtab_object symtab_object
Definition: block.h:60
static PyObject * stpy_is_valid(PyObject *self, PyObject *args)
Definition: py-symtab.c:167
struct symtab_and_line * sal_object_to_symtab_and_line(PyObject *obj)
Definition: py-symtab.c:456
static PyObject * salpy_get_line(PyObject *self, void *closure)
Definition: py-symtab.c:293
struct salpy_sal_object * next
Definition: py-symtab.c:68
static PyMethodDef symtab_object_methods[]
Definition: py-symtab.c:560
static PyObject * salpy_is_valid(PyObject *self, PyObject *args)
Definition: py-symtab.c:319
int gdbpy_initialize_symtabs(void)
Definition: py-symtab.c:521
static const struct objfile_data * stpy_objfile_data_key
Definition: py-symtab.c:42
static void stpy_dealloc(PyObject *obj)
Definition: py-symtab.c:249
CORE_ADDR pc
Definition: symtab.h:1376
PyObject_HEAD struct symtab * symtab
Definition: py-symtab.c:31
static void del_objfile_symtab(struct objfile *objfile, void *datum)
Definition: py-symtab.c:478
static PyObject * stpy_global_block(PyObject *self, PyObject *args)
Definition: py-symtab.c:181
PyObject * gdb_module
Definition: python.c:112
const char * host_charset(void)
Definition: charset.c:399
struct salpy_sal_object * prev
Definition: py-symtab.c:67
static PyObject * stpy_str(PyObject *self)
Definition: py-symtab.c:89
PyTypeObject symtab_object_type CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("symtab_object")
#define STPY_REQUIRE_VALID(symtab_obj, symtab)
Definition: py-symtab.c:46
static PyObject * salpy_get_symtab(PyObject *self, void *closure)
Definition: py-symtab.c:303
#define Py_TYPE(ob)
static PyGetSetDef symtab_object_getset[]
Definition: py-symtab.c:550
static PyObject * stpy_get_producer(PyObject *self, void *closure)
Definition: py-symtab.c:132
struct stpy_symtab_object * prev
Definition: py-symtab.c:36
#define PyVarObject_HEAD_INIT(type, size)