gdb/python/py-symbol.c

   1 /* Python interface to symbols.
   2
   3    Copyright (C) 2008-2019 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.  */
  35   struct sympy_symbol_object *prev;
  36   struct sympy_symbol_object *next;
  37 } symbol_object;
  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       /* TODO: currently, we have no way to recover the block in which SYMBOL
 282          was found, so we have no block to pass to read_var_value.  This will
 283          yield an incorrect value when symbol is not local to FRAME_INFO (this
 284          can happen with nested functions).  */
 285       value = read_var_value (symbol, NULL, frame_info);
 286     }
 287   CATCH (except, RETURN_MASK_ALL)
 288     {
 289       GDB_PY_HANDLE_EXCEPTION (except);
 290     }
 291   END_CATCH
 292
 293   return value_to_value_object (value);
 294 }
 295
 296 /* Given a symbol, and a symbol_object that has previously been
 297    allocated and initialized, populate the symbol_object with the
 298    struct symbol data.  Also, register the symbol_object life-cycle
 299    with the life-cycle of the object file associated with this
 300    symbol, if needed.  */
 301 static void
 302 set_symbol (symbol_object *obj, struct symbol *symbol)
 303 {
 304   obj->symbol = symbol;
 305   obj->prev = NULL;
 306   if (SYMBOL_OBJFILE_OWNED (symbol)
 307       && symbol_symtab (symbol) != NULL)
 308     {
 309       struct objfile *objfile = symbol_objfile (symbol);
 310
 311       obj->next = ((struct sympy_symbol_object *)
 312                    objfile_data (objfile, sympy_objfile_data_key));
 313       if (obj->next)
 314         obj->next->prev = obj;
 315       set_objfile_data (objfile, sympy_objfile_data_key, obj);
 316     }
 317   else
 318     obj->next = NULL;
 319 }
 320
 321 /* Create a new symbol object (gdb.Symbol) that encapsulates the struct
 322    symbol object from GDB.  */
 323 PyObject *
 324 symbol_to_symbol_object (struct symbol *sym)
 325 {
 326   symbol_object *sym_obj;
 327
 328   sym_obj = PyObject_New (symbol_object, &symbol_object_type);
 329   if (sym_obj)
 330     set_symbol (sym_obj, sym);
 331
 332   return (PyObject *) sym_obj;
 333 }
 334
 335 /* Return the symbol that is wrapped by this symbol object.  */
 336 struct symbol *
 337 symbol_object_to_symbol (PyObject *obj)
 338 {
 339   if (! PyObject_TypeCheck (obj, &symbol_object_type))
 340     return NULL;
 341   return ((symbol_object *) obj)->symbol;
 342 }
 343
 344 static void
 345 sympy_dealloc (PyObject *obj)
 346 {
 347   symbol_object *sym_obj = (symbol_object *) obj;
 348
 349   if (sym_obj->prev)
 350     sym_obj->prev->next = sym_obj->next;
 351   else if (sym_obj->symbol != NULL
 352            && SYMBOL_OBJFILE_OWNED (sym_obj->symbol)
 353            && symbol_symtab (sym_obj->symbol) != NULL)
 354     {
 355       set_objfile_data (symbol_objfile (sym_obj->symbol),
 356                         sympy_objfile_data_key, sym_obj->next);
 357     }
 358   if (sym_obj->next)
 359     sym_obj->next->prev = sym_obj->prev;
 360   sym_obj->symbol = NULL;
 361 }
 362
 363 /* Implementation of
 364    gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
 365    A tuple with 2 elements is always returned.  The first is the symbol
 366    object or None, the second is a boolean with the value of
 367    is_a_field_of_this (see comment in lookup_symbol_in_language).  */
 368
 369 PyObject *
 370 gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
 371 {
 372   int domain = VAR_DOMAIN;
 373   struct field_of_this_result is_a_field_of_this;
 374   const char *name;
 375   static const char *keywords[] = { "name", "block", "domain", NULL };
 376   struct symbol *symbol = NULL;
 377   PyObject *block_obj = NULL, *sym_obj, *bool_obj;
 378   const struct block *block = NULL;
 379
 380   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
 381                                         &block_object_type, &block_obj,
 382                                         &domain))
 383     return NULL;
 384
 385   if (block_obj)
 386     block = block_object_to_block (block_obj);
 387   else
 388     {
 389       struct frame_info *selected_frame;
 390
 391       TRY
 392         {
 393           selected_frame = get_selected_frame (_("No frame selected."));
 394           block = get_frame_block (selected_frame, NULL);
 395         }
 396       CATCH (except, RETURN_MASK_ALL)
 397         {
 398           GDB_PY_HANDLE_EXCEPTION (except);
 399         }
 400       END_CATCH
 401     }
 402
 403   TRY
 404     {
 405       symbol = lookup_symbol (name, block, (domain_enum) domain,
 406                               &is_a_field_of_this).symbol;
 407     }
 408   CATCH (except, RETURN_MASK_ALL)
 409     {
 410       GDB_PY_HANDLE_EXCEPTION (except);
 411     }
 412   END_CATCH
 413
 414   gdbpy_ref<> ret_tuple (PyTuple_New (2));
 415   if (ret_tuple == NULL)
 416     return NULL;
 417
 418   if (symbol)
 419     {
 420       sym_obj = symbol_to_symbol_object (symbol);
 421       if (!sym_obj)
 422         return NULL;
 423     }
 424   else
 425     {
 426       sym_obj = Py_None;
 427       Py_INCREF (Py_None);
 428     }
 429   PyTuple_SET_ITEM (ret_tuple.get (), 0, sym_obj);
 430
 431   bool_obj = (is_a_field_of_this.type != NULL) ? Py_True : Py_False;
 432   Py_INCREF (bool_obj);
 433   PyTuple_SET_ITEM (ret_tuple.get (), 1, bool_obj);
 434
 435   return ret_tuple.release ();
 436 }
 437
 438 /* Implementation of
 439    gdb.lookup_global_symbol (name [, domain]) -> symbol or None.  */
 440
 441 PyObject *
 442 gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
 443 {
 444   int domain = VAR_DOMAIN;
 445   const char *name;
 446   static const char *keywords[] = { "name", "domain", NULL };
 447   struct symbol *symbol = NULL;
 448   PyObject *sym_obj;
 449
 450   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
 451                                         &domain))
 452     return NULL;
 453
 454   TRY
 455     {
 456       symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
 457     }
 458   CATCH (except, RETURN_MASK_ALL)
 459     {
 460       GDB_PY_HANDLE_EXCEPTION (except);
 461     }
 462   END_CATCH
 463
 464   if (symbol)
 465     {
 466       sym_obj = symbol_to_symbol_object (symbol);
 467       if (!sym_obj)
 468         return NULL;
 469     }
 470   else
 471     {
 472       sym_obj = Py_None;
 473       Py_INCREF (Py_None);
 474     }
 475
 476   return sym_obj;
 477 }
 478
 479 /* This function is called when an objfile is about to be freed.
 480    Invalidate the symbol as further actions on the symbol would result
 481    in bad data.  All access to obj->symbol should be gated by
 482    SYMPY_REQUIRE_VALID which will raise an exception on invalid
 483    symbols.  */
 484 static void
 485 del_objfile_symbols (struct objfile *objfile, void *datum)
 486 {
 487   symbol_object *obj = (symbol_object *) datum;
 488   while (obj)
 489     {
 490       symbol_object *next = obj->next;
 491
 492       obj->symbol = NULL;
 493       obj->next = NULL;
 494       obj->prev = NULL;
 495
 496       obj = next;
 497     }
 498 }
 499
 500 int
 501 gdbpy_initialize_symbols (void)
 502 {
 503   if (PyType_Ready (&symbol_object_type) < 0)
 504     return -1;
 505
 506   /* Register an objfile "free" callback so we can properly
 507      invalidate symbol when an object file that is about to be
 508      deleted.  */
 509   sympy_objfile_data_key
 510     = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
 511
 512   if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0
 513       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST",
 514                                   LOC_CONST) < 0
 515       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC",
 516                                   LOC_STATIC) < 0
 517       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER",
 518                                   LOC_REGISTER) < 0
 519       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG",
 520                                   LOC_ARG) < 0
 521       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG",
 522                                   LOC_REF_ARG) < 0
 523       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL",
 524                                   LOC_LOCAL) < 0
 525       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF",
 526                                   LOC_TYPEDEF) < 0
 527       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL",
 528                                   LOC_LABEL) < 0
 529       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK",
 530                                   LOC_BLOCK) < 0
 531       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
 532                                   LOC_CONST_BYTES) < 0
 533       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
 534                                   LOC_UNRESOLVED) < 0
 535       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
 536                                   LOC_OPTIMIZED_OUT) < 0
 537       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED",
 538                                   LOC_COMPUTED) < 0
 539       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMMON_BLOCK",
 540                                   LOC_COMMON_BLOCK) < 0
 541       || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
 542                                   LOC_REGPARM_ADDR) < 0
 543       || PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN",
 544                                   UNDEF_DOMAIN) < 0
 545       || PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN",
 546                                   VAR_DOMAIN) < 0
 547       || PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN",
 548                                   STRUCT_DOMAIN) < 0
 549       || PyModule_AddIntConstant (gdb_module, "SYMBOL_MODULE_DOMAIN",
 550                                   MODULE_DOMAIN) < 0
 551       || PyModule_AddIntConstant (gdb_module, "SYMBOL_COMMON_BLOCK_DOMAIN",
 552                                   COMMON_BLOCK_DOMAIN) < 0)
 553     return -1;
 554
 555   /* These remain defined for compatibility, but as they were never
 556      correct, they are no longer documented.  Eventually we can remove
 557      them.  These exist because at one time, enum search_domain and
 558      enum domain_enum_tag were combined -- but different values were
 559      used differently.  Here we try to give them values that will make
 560      sense if they are passed to gdb.lookup_symbol.  */
 561   if (PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
 562                                VAR_DOMAIN) < 0
 563       || PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
 564                                   VAR_DOMAIN) < 0
 565       || PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN",
 566                                   VAR_DOMAIN) < 0)
 567     return -1;
 568
 569   return gdb_pymodule_addobject (gdb_module, "Symbol",
 570                                  (PyObject *) &symbol_object_type);
 571 }
 572
 573 \f
 574
 575 static gdb_PyGetSetDef symbol_object_getset[] = {
 576   { "type", sympy_get_type, NULL,
 577     "Type of the symbol.", NULL },
 578   { "symtab", sympy_get_symtab, NULL,
 579     "Symbol table in which the symbol appears.", NULL },
 580   { "name", sympy_get_name, NULL,
 581     "Name of the symbol, as it appears in the source code.", NULL },
 582   { "linkage_name", sympy_get_linkage_name, NULL,
 583     "Name of the symbol, as used by the linker (i.e., may be mangled).",
 584     NULL },
 585   { "print_name", sympy_get_print_name, NULL,
 586     "Name of the symbol in a form suitable for output.\n\
 587 This is either name or linkage_name, depending on whether the user asked GDB\n\
 588 to display demangled or mangled names.", NULL },
 589   { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
 590   { "is_argument", sympy_is_argument, NULL,
 591     "True if the symbol is an argument of a function." },
 592   { "is_constant", sympy_is_constant, NULL,
 593     "True if the symbol is a constant." },
 594   { "is_function", sympy_is_function, NULL,
 595     "True if the symbol is a function or method." },
 596   { "is_variable", sympy_is_variable, NULL,
 597     "True if the symbol is a variable." },
 598   { "needs_frame", sympy_needs_frame, NULL,
 599     "True if the symbol requires a frame for evaluation." },
 600   { "line", sympy_line, NULL,
 601     "The source line number at which the symbol was defined." },
 602   { NULL }  /* Sentinel */
 603 };
 604
 605 static PyMethodDef symbol_object_methods[] = {
 606   { "is_valid", sympy_is_valid, METH_NOARGS,
 607     "is_valid () -> Boolean.\n\
 608 Return true if this symbol is valid, false if not." },
 609   { "value", sympy_value, METH_VARARGS,
 610     "value ([frame]) -> gdb.Value\n\
 611 Return the value of the symbol." },
 612   {NULL}  /* Sentinel */
 613 };
 614
 615 PyTypeObject symbol_object_type = {
 616   PyVarObject_HEAD_INIT (NULL, 0)
 617   "gdb.Symbol",                   /*tp_name*/
 618   sizeof (symbol_object),         /*tp_basicsize*/
 619   0,                              /*tp_itemsize*/
 620   sympy_dealloc,                  /*tp_dealloc*/
 621   0,                              /*tp_print*/
 622   0,                              /*tp_getattr*/
 623   0,                              /*tp_setattr*/
 624   0,                              /*tp_compare*/
 625   0,                              /*tp_repr*/
 626   0,                              /*tp_as_number*/
 627   0,                              /*tp_as_sequence*/
 628   0,                              /*tp_as_mapping*/
 629   0,                              /*tp_hash */
 630   0,                              /*tp_call*/
 631   sympy_str,                      /*tp_str*/
 632   0,                              /*tp_getattro*/
 633   0,                              /*tp_setattro*/
 634   0,                              /*tp_as_buffer*/
 635   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 636   "GDB symbol object",            /*tp_doc */
 637   0,                              /*tp_traverse */
 638   0,                              /*tp_clear */
 639   0,                              /*tp_richcompare */
 640   0,                              /*tp_weaklistoffset */
 641   0,                              /*tp_iter */
 642   0,                              /*tp_iternext */
 643   symbol_object_methods,          /*tp_methods */
 644   0,                              /*tp_members */
 645   symbol_object_getset            /*tp_getset */
 646 };