gdb/python/py-symtab.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  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/>.  */

  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"

  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.  */
  36.   struct stpy_symtab_object *prev;
  37.   struct stpy_symtab_object *next;
  38. ‌} symtab_object;

  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)                 \
  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)

  57. ‌typedef struct salpy_sal_object {
  58.   PyObject_HEAD
  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;
  69. ‌} sal_object;

  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)                                \
  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)

  88. static PyObject *
  89. ‌stpy_str (PyObject *self)
  90. {
  91.   PyObject *result;
  92.   struct symtab *symtab = NULL;

  94.   STPY_REQUIRE_VALID (self, symtab);

  96.   result = PyString_FromString (symtab_to_filename_for_display (symtab));

  98.   return result;
  99. }

  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;

  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);
  113.   return str_obj;
  114. }

  116. static PyObject *
  117. ‌stpy_get_objfile (PyObject *self, void *closure)
  118. {
  119.   struct symtab *symtab = NULL;
  120.   PyObject *result;

  122.   STPY_REQUIRE_VALID (self, symtab);

  124.   result = objfile_to_objfile_object (SYMTAB_OBJFILE (symtab));
  125.   Py_XINCREF (result);
  126.   return result;
  127. }

  129. /* Getter function for symtab.producer.  */

  131. static PyObject *
  132. ‌stpy_get_producer (PyObject *self, void *closure)
  133. {
  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)
  140.     {
  141.       const char *producer = COMPUNIT_PRODUCER (cust);

  143.       return PyString_Decode (producer, strlen (producer),
  144.                               host_charset (), NULL);
  145.     }

  147.   Py_RETURN_NONE;
  148. }

  150. static PyObject *
  151. ‌stpy_fullname (PyObject *self, PyObject *args)
  152. {
  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);
  161. }

  163. /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
  164.    Returns True if this Symbol table still exists in GDB.  */

  166. static PyObject *
  167. ‌stpy_is_valid (PyObject *self, PyObject *args)
  168. {
  169.   struct symtab *symtab = NULL;

  171.   symtab = symtab_object_to_symtab (self);
  172.   if (symtab == NULL)
  173.     Py_RETURN_FALSE;

  175.   Py_RETURN_TRUE;
  176. }

  178. /* Return the GLOBAL_BLOCK of the underlying symtab.  */

  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;

  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));
  192. }

  194. /* Return the STATIC_BLOCK of the underlying symtab.  */

  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;

  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));
  208. }

  210. /* Implementation of gdb.Symtab.linetable (self) -> gdb.Linetable.
  211.    Returns a gdb.Linetable object corresponding to this symbol
  212.    table.  */

  214. static PyObject *
  215. ‌stpy_get_linetable (PyObject *self, PyObject *args)
  216. {
  217.   struct symtab *symtab = NULL;

  219.   STPY_REQUIRE_VALID (self, symtab);

  221.   return symtab_to_linetable_object (self);
  222. }

  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;

  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,
  240.                   sal->line);

  242.   result = PyString_FromString (s);
  243.   xfree (s);

  245.   return result;
  246. }

  248. static void
  249. ‌stpy_dealloc (PyObject *obj)
  250. {
  251.   symtab_object *symtab = (symtab_object *) obj;

  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. }


  266. static PyObject *
  267. ‌salpy_get_pc (PyObject *self, void *closure)
  268. {
  269.   struct symtab_and_line *sal = NULL;

  271.   SALPY_REQUIRE_VALID (self, sal);

  273.   return gdb_py_long_from_ulongest (sal->pc);
  274. }

  276. /* Implementation of the get method for the 'last' attribute of
  277.    gdb.Symtab_and_line.  */

  279. static PyObject *
  280. ‌salpy_get_last (PyObject *self, void *closure)
  281. {
  282.   struct symtab_and_line *sal = NULL;

  284.   SALPY_REQUIRE_VALID (self, sal);

  286.   if (sal->end > 0)
  287.     return gdb_py_long_from_ulongest (sal->end - 1);
  288.   else
  289.     Py_RETURN_NONE;
  290. }

  292. static PyObject *
  293. ‌salpy_get_line (PyObject *self, void *closure)
  294. {
  295.   struct symtab_and_line *sal = NULL;

  297.   SALPY_REQUIRE_VALID (self, sal);

  299.   return PyInt_FromLong (sal->line);
  300. }

  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;

  308.   SALPY_REQUIRE_VALID (self, sal);

  310.   Py_INCREF (self_sal->symtab);

  312.   return (PyObject *) self_sal->symtab;
  313. }

  315. /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
  316.    Returns True if this Symbol table and line object still exists GDB.  */

  318. static PyObject *
  319. ‌salpy_is_valid (PyObject *self, PyObject *args)
  320. {
  321.   struct symtab_and_line *sal;

  323.   sal = sal_object_to_symtab_and_line (self);
  324.   if (sal == NULL)
  325.     Py_RETURN_FALSE;

  327.   Py_RETURN_TRUE;
  328. }

  330. static void
  331. ‌salpy_dealloc (PyObject *self)
  332. {
  333.   sal_object *self_sal = (sal_object *) self;

  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);

  341.   if (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);
  347. }

  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)
  356. {
  357.   symtab_object *symtab_obj;

  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.     }

  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)
  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;

  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;

  393.   return 0;
  394. }

  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
  402. ‌set_symtab (symtab_object *obj, struct symtab *symtab)
  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. }

  418. /* Create a new symbol table (gdb.Symtab) object that encapsulates the
  419.    symtab structure from GDB.  */
  420. PyObject *
  421. ‌symtab_to_symtab_object (struct symtab *symtab)
  422. {
  423.   symtab_object *symtab_obj;

  425.   symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
  426.   if (symtab_obj)
  427.     set_symtab (symtab_obj, symtab);

  429.   return (PyObject *) symtab_obj;
  430. }

  432. /* Create a new symtab and line (gdb.Symtab_and_line) object
  433.    that encapsulates the symtab_and_line structure from GDB.  */
  434. PyObject *
  435. ‌symtab_and_line_to_sal_object (struct symtab_and_line sal)
  436. {
  437.   sal_object *sal_obj;
  438.   int success = 0;

  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.     }

  450.   return (PyObject *) sal_obj;
  451. }

  453. /* Return struct symtab_and_line reference that is wrapped by this
  454.    object.  */
  455. struct symtab_and_line *
  456. ‌sal_object_to_symtab_and_line (PyObject *obj)
  457. {
  458.   if (! PyObject_TypeCheck (obj, &sal_object_type))
  459.     return NULL;
  460.   return ((sal_object *) obj)->sal;
  461. }

  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. }

  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;

  482.   while (obj)
  483.     {
  484.       symtab_object *next = obj->next;

  486.       obj->symtab = NULL;
  487.       obj->next = NULL;
  488.       obj->prev = NULL;
  489.       obj = next;
  490.     }
  491. }

  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;

  503.   while (obj)
  504.     {
  505.       sal_object *next = obj->next;

  507.       Py_DECREF (obj->symtab);
  508.       obj->symtab = (symtab_object *) Py_None;
  509.       Py_INCREF (Py_None);

  511.       obj->next = NULL;
  512.       obj->prev = NULL;
  513.       xfree (obj->sal);
  514.       obj->sal = NULL;

  516.       obj = next;
  517.     }
  518. }

  520. int
  521. ‌gdbpy_initialize_symtabs (void)
  522. {
  523.   symtab_object_type.tp_new = PyType_GenericNew;
  524.   if (PyType_Ready (&symtab_object_type) < 0)
  525.     return -1;

  527.   sal_object_type.tp_new = PyType_GenericNew;
  528.   if (PyType_Ready (&sal_object_type) < 0)
  529.     return -1;

  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);

  540.   if (gdb_pymodule_addobject (gdb_module, "Symtab",
  541.                               (PyObject *) &symtab_object_type) < 0)
  542.     return -1;

  544.   return gdb_pymodule_addobject (gdb_module, "Symtab_and_line",
  545.                                  (PyObject *) &sal_object_type);
  546. }



  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. };

  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. };

  579. ‌static 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. };

  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. };

  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. };

  629. ‌static 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. };