binutils-gdb/gdb/python/py-symbol.c
Tom Tromey f3d3bbbcdd Fix value chain use-after-free
Hannes filed a bug showing a crash, where a pretty-printer written in
Python could cause a use-after-free.  He sent a patch, but I thought a
different approach was needed.

In a much earlier patch (see bug #12533), we changed the Python code
to release new values from the value chain when constructing a
gdb.Value.  The rationale for this is that if you write a command that
does a lot of computations in a loop, all the values will be kept live
by the value chain, resulting in gdb using a large amount of memory.

However, suppose a value is passed to Python from some code in gdb
that needs to use the value after the call into Python.  In this
scenario, value_to_value_object will still release the value -- and
because gdb code doesn't generally keep strong references to values (a
consequence of the ancient decision to use the value chain to avoid
memory management), this will result in a use-after-free.

This scenario can happen, as it turns out, when a value is passed to
Python for pretty-printing.  Now, normally this route boxes the value
via value_to_value_object_no_release, avoiding the problematic release
from the value chain.  However, if you then call Value.cast, the
underlying value API might return the same value, when is then
released from the chain.

This patch fixes the problem by changing how value boxing is done.
value_to_value_object no longer removes a value from the chain.
Instead, every spot in gdb that might construct new values uses a
scoped_value_mark to ensure that the requirements of bug #12533 are
met.  And, because incoming values aren't ever released from the chain
(the Value.cast one comes earlier on the chain than the
scoped_value_mark), the bug can no longer occur.  (Note that many
spots in the Python layer already take this approach, so not many
places needed to be touched.)

In the future I think we should replace the use of raw "value *" with
value_ref_ptr pretty much everywhere.  This will ensure lifetime
safety throughout gdb.

The test case in this patch comes from Hannes' original patch.  I only
made a trivial ("require") change to it.  However, while this fails
for him, I can't make it fail on this machine; nevertheless, he tried
my patch and reported the bug as being fixed.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=30044
2023-02-27 15:46:31 -07:00

758 lines
20 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Python interface to symbols.
Copyright (C) 2008-2023 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "block.h"
#include "frame.h"
#include "symtab.h"
#include "python-internal.h"
#include "objfiles.h"
#include "symfile.h"
struct symbol_object {
PyObject_HEAD
/* The GDB symbol structure this object is wrapping. */
struct symbol *symbol;
/* A symbol object is associated with an objfile, so keep track with
doubly-linked list, rooted in the objfile. This lets us
invalidate the underlying struct symbol when the objfile is
deleted. */
symbol_object *prev;
symbol_object *next;
};
/* Require a valid symbol. All access to symbol_object->symbol should be
gated by this call. */
#define SYMPY_REQUIRE_VALID(symbol_obj, symbol) \
do { \
symbol = symbol_object_to_symbol (symbol_obj); \
if (symbol == NULL) \
{ \
PyErr_SetString (PyExc_RuntimeError, \
_("Symbol is invalid.")); \
return NULL; \
} \
} while (0)
/* A deleter that is used when an objfile is about to be freed. */
struct symbol_object_deleter
{
void operator() (symbol_object *obj)
{
while (obj)
{
symbol_object *next = obj->next;
obj->symbol = NULL;
obj->next = NULL;
obj->prev = NULL;
obj = next;
}
}
};
static const registry<objfile>::key<symbol_object, symbol_object_deleter>
sympy_objfile_data_key;
static PyObject *
sympy_str (PyObject *self)
{
PyObject *result;
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
result = PyUnicode_FromString (symbol->print_name ());
return result;
}
static PyObject *
sympy_get_type (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
if (symbol->type () == NULL)
{
Py_INCREF (Py_None);
return Py_None;
}
return type_to_type_object (symbol->type ());
}
static PyObject *
sympy_get_symtab (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
if (!symbol->is_objfile_owned ())
Py_RETURN_NONE;
return symtab_to_symtab_object (symbol->symtab ());
}
static PyObject *
sympy_get_name (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
return PyUnicode_FromString (symbol->natural_name ());
}
static PyObject *
sympy_get_linkage_name (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
return PyUnicode_FromString (symbol->linkage_name ());
}
static PyObject *
sympy_get_print_name (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
return sympy_str (self);
}
static PyObject *
sympy_get_addr_class (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
return gdb_py_object_from_longest (symbol->aclass ()).release ();
}
static PyObject *
sympy_is_argument (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
return PyBool_FromLong (symbol->is_argument ());
}
static PyObject *
sympy_is_constant (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
enum address_class theclass;
SYMPY_REQUIRE_VALID (self, symbol);
theclass = symbol->aclass ();
return PyBool_FromLong (theclass == LOC_CONST || theclass == LOC_CONST_BYTES);
}
static PyObject *
sympy_is_function (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
enum address_class theclass;
SYMPY_REQUIRE_VALID (self, symbol);
theclass = symbol->aclass ();
return PyBool_FromLong (theclass == LOC_BLOCK);
}
static PyObject *
sympy_is_variable (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
enum address_class theclass;
SYMPY_REQUIRE_VALID (self, symbol);
theclass = symbol->aclass ();
return PyBool_FromLong (!symbol->is_argument ()
&& (theclass == LOC_LOCAL || theclass == LOC_REGISTER
|| theclass == LOC_STATIC || theclass == LOC_COMPUTED
|| theclass == LOC_OPTIMIZED_OUT));
}
/* Implementation of gdb.Symbol.needs_frame -> Boolean.
Returns true iff the symbol needs a frame for evaluation. */
static PyObject *
sympy_needs_frame (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
int result = 0;
SYMPY_REQUIRE_VALID (self, symbol);
try
{
result = symbol_read_needs_frame (symbol);
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (result)
Py_RETURN_TRUE;
Py_RETURN_FALSE;
}
/* Implementation of gdb.Symbol.line -> int.
Returns the line number at which the symbol was defined. */
static PyObject *
sympy_line (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
return gdb_py_object_from_longest (symbol->line ()).release ();
}
/* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
Returns True if this Symbol still exists in GDB. */
static PyObject *
sympy_is_valid (PyObject *self, PyObject *args)
{
struct symbol *symbol = NULL;
symbol = symbol_object_to_symbol (self);
if (symbol == NULL)
Py_RETURN_FALSE;
Py_RETURN_TRUE;
}
/* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value. Returns
the value of the symbol, or an error in various circumstances. */
static PyObject *
sympy_value (PyObject *self, PyObject *args)
{
struct symbol *symbol = NULL;
frame_info_ptr frame_info = NULL;
PyObject *frame_obj = NULL;
if (!PyArg_ParseTuple (args, "|O", &frame_obj))
return NULL;
if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
{
PyErr_SetString (PyExc_TypeError, "argument is not a frame");
return NULL;
}
SYMPY_REQUIRE_VALID (self, symbol);
if (symbol->aclass () == LOC_TYPEDEF)
{
PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
return NULL;
}
PyObject *result = nullptr;
try
{
if (frame_obj != NULL)
{
frame_info = frame_object_to_frame_info (frame_obj);
if (frame_info == NULL)
error (_("invalid frame"));
}
if (symbol_read_needs_frame (symbol) && frame_info == NULL)
error (_("symbol requires a frame to compute its value"));
/* TODO: currently, we have no way to recover the block in which SYMBOL
was found, so we have no block to pass to read_var_value. This will
yield an incorrect value when symbol is not local to FRAME_INFO (this
can happen with nested functions). */
scoped_value_mark free_values;
struct value *value = read_var_value (symbol, NULL, frame_info);
result = value_to_value_object (value);
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
return result;
}
/* Given a symbol, and a symbol_object that has previously been
allocated and initialized, populate the symbol_object with the
struct symbol data. Also, register the symbol_object life-cycle
with the life-cycle of the object file associated with this
symbol, if needed. */
static void
set_symbol (symbol_object *obj, struct symbol *symbol)
{
obj->symbol = symbol;
obj->prev = NULL;
if (symbol->is_objfile_owned ()
&& symbol->symtab () != NULL)
{
struct objfile *objfile = symbol->objfile ();
obj->next = sympy_objfile_data_key.get (objfile);
if (obj->next)
obj->next->prev = obj;
sympy_objfile_data_key.set (objfile, obj);
}
else
obj->next = NULL;
}
/* Create a new symbol object (gdb.Symbol) that encapsulates the struct
symbol object from GDB. */
PyObject *
symbol_to_symbol_object (struct symbol *sym)
{
symbol_object *sym_obj;
sym_obj = PyObject_New (symbol_object, &symbol_object_type);
if (sym_obj)
set_symbol (sym_obj, sym);
return (PyObject *) sym_obj;
}
/* Return the symbol that is wrapped by this symbol object. */
struct symbol *
symbol_object_to_symbol (PyObject *obj)
{
if (! PyObject_TypeCheck (obj, &symbol_object_type))
return NULL;
return ((symbol_object *) obj)->symbol;
}
static void
sympy_dealloc (PyObject *obj)
{
symbol_object *sym_obj = (symbol_object *) obj;
if (sym_obj->prev)
sym_obj->prev->next = sym_obj->next;
else if (sym_obj->symbol != NULL
&& sym_obj->symbol->is_objfile_owned ()
&& sym_obj->symbol->symtab () != NULL)
sympy_objfile_data_key.set (sym_obj->symbol->objfile (), sym_obj->next);
if (sym_obj->next)
sym_obj->next->prev = sym_obj->prev;
sym_obj->symbol = NULL;
Py_TYPE (obj)->tp_free (obj);
}
/* Implementation of
gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
A tuple with 2 elements is always returned. The first is the symbol
object or None, the second is a boolean with the value of
is_a_field_of_this (see comment in lookup_symbol_in_language). */
PyObject *
gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
{
int domain = VAR_DOMAIN;
struct field_of_this_result is_a_field_of_this;
const char *name;
static const char *keywords[] = { "name", "block", "domain", NULL };
struct symbol *symbol = NULL;
PyObject *block_obj = NULL, *sym_obj, *bool_obj;
const struct block *block = NULL;
if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
&block_object_type, &block_obj,
&domain))
return NULL;
if (block_obj)
block = block_object_to_block (block_obj);
else
{
frame_info_ptr selected_frame;
try
{
selected_frame = get_selected_frame (_("No frame selected."));
block = get_frame_block (selected_frame, NULL);
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
}
try
{
symbol = lookup_symbol (name, block, (domain_enum) domain,
&is_a_field_of_this).symbol;
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
gdbpy_ref<> ret_tuple (PyTuple_New (2));
if (ret_tuple == NULL)
return NULL;
if (symbol)
{
sym_obj = symbol_to_symbol_object (symbol);
if (!sym_obj)
return NULL;
}
else
{
sym_obj = Py_None;
Py_INCREF (Py_None);
}
PyTuple_SET_ITEM (ret_tuple.get (), 0, sym_obj);
bool_obj = PyBool_FromLong (is_a_field_of_this.type != NULL);
PyTuple_SET_ITEM (ret_tuple.get (), 1, bool_obj);
return ret_tuple.release ();
}
/* Implementation of
gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */
PyObject *
gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
{
int domain = VAR_DOMAIN;
const char *name;
static const char *keywords[] = { "name", "domain", NULL };
struct symbol *symbol = NULL;
PyObject *sym_obj;
if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
&domain))
return NULL;
try
{
symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (symbol)
{
sym_obj = symbol_to_symbol_object (symbol);
if (!sym_obj)
return NULL;
}
else
{
sym_obj = Py_None;
Py_INCREF (Py_None);
}
return sym_obj;
}
/* Implementation of
gdb.lookup_static_symbol (name [, domain]) -> symbol or None. */
PyObject *
gdbpy_lookup_static_symbol (PyObject *self, PyObject *args, PyObject *kw)
{
const char *name;
int domain = VAR_DOMAIN;
static const char *keywords[] = { "name", "domain", NULL };
struct symbol *symbol = NULL;
PyObject *sym_obj;
if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
&domain))
return NULL;
/* In order to find static symbols associated with the "current" object
file ahead of those from other object files, we first need to see if
we can acquire a current block. If this fails however, then we still
want to search all static symbols, so don't throw an exception just
yet. */
const struct block *block = NULL;
try
{
frame_info_ptr selected_frame
= get_selected_frame (_("No frame selected."));
block = get_frame_block (selected_frame, NULL);
}
catch (const gdb_exception &except)
{
/* Nothing. */
}
try
{
if (block != nullptr)
symbol
= lookup_symbol_in_static_block (name, block,
(domain_enum) domain).symbol;
if (symbol == nullptr)
symbol = lookup_static_symbol (name, (domain_enum) domain).symbol;
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (symbol)
{
sym_obj = symbol_to_symbol_object (symbol);
if (!sym_obj)
return NULL;
}
else
{
sym_obj = Py_None;
Py_INCREF (Py_None);
}
return sym_obj;
}
/* Implementation of
gdb.lookup_static_symbols (name [, domain]) -> symbol list.
Returns a list of all static symbols matching NAME in DOMAIN. */
PyObject *
gdbpy_lookup_static_symbols (PyObject *self, PyObject *args, PyObject *kw)
{
const char *name;
int domain = VAR_DOMAIN;
static const char *keywords[] = { "name", "domain", NULL };
if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
&domain))
return NULL;
gdbpy_ref<> return_list (PyList_New (0));
if (return_list == NULL)
return NULL;
try
{
/* Expand any symtabs that contain potentially matching symbols. */
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
expand_symtabs_matching (NULL, lookup_name, NULL, NULL,
SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
ALL_DOMAIN);
for (objfile *objfile : current_program_space->objfiles ())
{
for (compunit_symtab *cust : objfile->compunits ())
{
const struct blockvector *bv;
bv = cust->blockvector ();
const struct block *block = bv->static_block ();
if (block != nullptr)
{
symbol *symbol = lookup_symbol_in_static_block
(name, block, (domain_enum) domain).symbol;
if (symbol != nullptr)
{
PyObject *sym_obj
= symbol_to_symbol_object (symbol);
if (PyList_Append (return_list.get (), sym_obj) == -1)
return NULL;
}
}
}
}
}
catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
return return_list.release ();
}
int
gdbpy_initialize_symbols (void)
{
if (PyType_Ready (&symbol_object_type) < 0)
return -1;
if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST",
LOC_CONST) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC",
LOC_STATIC) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER",
LOC_REGISTER) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG",
LOC_ARG) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG",
LOC_REF_ARG) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL",
LOC_LOCAL) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF",
LOC_TYPEDEF) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL",
LOC_LABEL) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK",
LOC_BLOCK) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
LOC_CONST_BYTES) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
LOC_UNRESOLVED) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
LOC_OPTIMIZED_OUT) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED",
LOC_COMPUTED) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMMON_BLOCK",
LOC_COMMON_BLOCK) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
LOC_REGPARM_ADDR) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN",
UNDEF_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN",
VAR_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN",
STRUCT_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN",
LABEL_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_MODULE_DOMAIN",
MODULE_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_COMMON_BLOCK_DOMAIN",
COMMON_BLOCK_DOMAIN) < 0)
return -1;
/* These remain defined for compatibility, but as they were never
correct, they are no longer documented. Eventually we can remove
them. These exist because at one time, enum search_domain and
enum domain_enum_tag were combined -- but different values were
used differently. Here we try to give them values that will make
sense if they are passed to gdb.lookup_symbol. */
if (PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
VAR_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
VAR_DOMAIN) < 0
|| PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN",
VAR_DOMAIN) < 0)
return -1;
return gdb_pymodule_addobject (gdb_module, "Symbol",
(PyObject *) &symbol_object_type);
}
static gdb_PyGetSetDef symbol_object_getset[] = {
{ "type", sympy_get_type, NULL,
"Type of the symbol.", NULL },
{ "symtab", sympy_get_symtab, NULL,
"Symbol table in which the symbol appears.", NULL },
{ "name", sympy_get_name, NULL,
"Name of the symbol, as it appears in the source code.", NULL },
{ "linkage_name", sympy_get_linkage_name, NULL,
"Name of the symbol, as used by the linker (i.e., may be mangled).",
NULL },
{ "print_name", sympy_get_print_name, NULL,
"Name of the symbol in a form suitable for output.\n\
This is either name or linkage_name, depending on whether the user asked GDB\n\
to display demangled or mangled names.", NULL },
{ "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
{ "is_argument", sympy_is_argument, NULL,
"True if the symbol is an argument of a function." },
{ "is_constant", sympy_is_constant, NULL,
"True if the symbol is a constant." },
{ "is_function", sympy_is_function, NULL,
"True if the symbol is a function or method." },
{ "is_variable", sympy_is_variable, NULL,
"True if the symbol is a variable." },
{ "needs_frame", sympy_needs_frame, NULL,
"True if the symbol requires a frame for evaluation." },
{ "line", sympy_line, NULL,
"The source line number at which the symbol was defined." },
{ NULL } /* Sentinel */
};
static PyMethodDef symbol_object_methods[] = {
{ "is_valid", sympy_is_valid, METH_NOARGS,
"is_valid () -> Boolean.\n\
Return true if this symbol is valid, false if not." },
{ "value", sympy_value, METH_VARARGS,
"value ([frame]) -> gdb.Value\n\
Return the value of the symbol." },
{NULL} /* Sentinel */
};
PyTypeObject symbol_object_type = {
PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symbol", /*tp_name*/
sizeof (symbol_object), /*tp_basicsize*/
0, /*tp_itemsize*/
sympy_dealloc, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash */
0, /*tp_call*/
sympy_str, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT, /*tp_flags*/
"GDB symbol object", /*tp_doc */
0, /*tp_traverse */
0, /*tp_clear */
0, /*tp_richcompare */
0, /*tp_weaklistoffset */
0, /*tp_iter */
0, /*tp_iternext */
symbol_object_methods, /*tp_methods */
0, /*tp_members */
symbol_object_getset /*tp_getset */
};