[deliverable/binutils-gdb.git] / gdb / python / py-symbol.c

/* Python interface to symbols.

   Copyright (C) 2008, 2009, 2010, 2011 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 "exceptions.h"
#include "frame.h"
#include "symtab.h"
#include "python-internal.h"
#include "objfiles.h"

typedef struct sympy_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.  */
  struct sympy_symbol_object *prev;
  struct sympy_symbol_object *next;
} symbol_object;

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

static const struct objfile_data *sympy_objfile_data_key;

static PyObject *
sympy_str (PyObject *self)
{
  PyObject *result;
  struct symbol *symbol = NULL;

  SYMPY_REQUIRE_VALID (self, symbol);

  result = PyString_FromString (SYMBOL_PRINT_NAME (symbol));

  return result;
}

static PyObject *
sympy_get_symtab (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;

  SYMPY_REQUIRE_VALID (self, symbol);

  return symtab_to_symtab_object (SYMBOL_SYMTAB (symbol));
}

static PyObject *
sympy_get_name (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;

  SYMPY_REQUIRE_VALID (self, symbol);

  return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
}

static PyObject *
sympy_get_linkage_name (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;

  SYMPY_REQUIRE_VALID (self, symbol);

  return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
}

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 PyInt_FromLong (SYMBOL_CLASS (symbol));
}

static PyObject *
sympy_is_argument (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;

  SYMPY_REQUIRE_VALID (self, symbol);

  return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
}

static PyObject *
sympy_is_constant (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;
  enum address_class class;

  SYMPY_REQUIRE_VALID (self, symbol);

  class = SYMBOL_CLASS (symbol);

  return PyBool_FromLong (class == LOC_CONST || class == LOC_CONST_BYTES);
}

static PyObject *
sympy_is_function (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;
  enum address_class class;

  SYMPY_REQUIRE_VALID (self, symbol);

  class = SYMBOL_CLASS (symbol);

  return PyBool_FromLong (class == LOC_BLOCK);
}

static PyObject *
sympy_is_variable (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;
  enum address_class class;

  SYMPY_REQUIRE_VALID (self, symbol);

  class = SYMBOL_CLASS (symbol);

  return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
			  && (class == LOC_LOCAL || class == LOC_REGISTER
			      || class == LOC_STATIC || class == LOC_COMPUTED
			      || class == LOC_OPTIMIZED_OUT));
}

/* 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 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_SYMTAB (symbol))
    {
      obj->next = objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
				sympy_objfile_data_key);

      if (obj->next)
	obj->next->prev = obj;
      set_objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
			sympy_objfile_data_key, 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 (SYMBOL_SYMTAB (sym_obj->symbol))
    {
      set_objfile_data (SYMBOL_SYMTAB (sym_obj->symbol)->objfile,
			sympy_objfile_data_key, sym_obj->next);
    }
  if (sym_obj->next)
    sym_obj->next->prev = sym_obj->prev;
  sym_obj->symbol = NULL;
}

/* 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, is_a_field_of_this = 0;
  const char *name;
  static char *keywords[] = { "name", "block", "domain", NULL };
  struct symbol *symbol;
  PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
  struct block *block = NULL;

  if (! 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
    {
      struct frame_info *selected_frame;
      volatile struct gdb_exception except;

      TRY_CATCH (except, RETURN_MASK_ALL)
	{
	  selected_frame  = get_selected_frame (_("No frame selected."));
	  block = block_for_pc (get_frame_address_in_block (selected_frame));
	}
      GDB_PY_HANDLE_EXCEPTION (except);
    }

  symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);

  ret_tuple = PyTuple_New (2);
  if (!ret_tuple)
    return NULL;

  if (symbol)
    {
      sym_obj = symbol_to_symbol_object (symbol);
      if (!sym_obj)
	{
	  Py_DECREF (ret_tuple);
	  return NULL;
	}
    }
  else
    {
      sym_obj = Py_None;
      Py_INCREF (Py_None);
    }
  PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);

  bool_obj = is_a_field_of_this? Py_True : Py_False;
  Py_INCREF (bool_obj);
  PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);

  return ret_tuple;
}

/* This function is called when an objfile is about to be freed.
   Invalidate the symbol as further actions on the symbol would result
   in bad data.  All access to obj->symbol should be gated by
   SYMPY_REQUIRE_VALID which will raise an exception on invalid
   symbols.  */
static void
del_objfile_symbols (struct objfile *objfile, void *datum)
{
  symbol_object *obj = datum;
  while (obj)
    {
      symbol_object *next = obj->next;

      obj->symbol = NULL;
      obj->next = NULL;
      obj->prev = NULL;

      obj = next;
    }
}

void
gdbpy_initialize_symbols (void)
{
  if (PyType_Ready (&symbol_object_type) < 0)
    return;

  /* Register an objfile "free" callback so we can properly
     invalidate symbol when an object file that is about to be
     deleted.  */
  sympy_objfile_data_key
    = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);

  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
			   LOC_CONST_BYTES);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
			   LOC_UNRESOLVED);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
			   LOC_OPTIMIZED_OUT);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
			   LOC_REGPARM_ADDR);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
			   VARIABLES_DOMAIN);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
			   FUNCTIONS_DOMAIN);
  PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);

  Py_INCREF (&symbol_object_type);
  PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
}

\f

static PyGetSetDef symbol_object_getset[] = {
  { "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." },
  { NULL }  /* Sentinel */
};

PyTypeObject symbol_object_type = {
  PyObject_HEAD_INIT (NULL)
  0,				  /*ob_size*/
  "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 */
  0,				  /*tp_methods */
  0,				  /*tp_members */
  symbol_object_getset		  /*tp_getset */
};
Commit	Line	Data
f3e9a817 PM	1	/* Python interface to symbols.
f3e9a817 PM	2
7b6bb8da	3	Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
f3e9a817 PM	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 "exceptions.h"
	23	#include "frame.h"
	24	#include "symtab.h"
	25	#include "python-internal.h"
	26	#include "objfiles.h"
	27
	28	typedef struct sympy_symbol_object {
	29	PyObject_HEAD
	30	/* The GDB symbol structure this object is wrapping. */
	31	struct symbol *symbol;
	32	/* A symbol object is associated with an objfile, so keep track with
	33	doubly-linked list, rooted in the objfile. This lets us
	34	invalidate the underlying struct symbol when the objfile is
	35	deleted. */
	36	struct sympy_symbol_object *prev;
	37	struct sympy_symbol_object *next;
	38	} symbol_object;
	39
	40	/* Require a valid symbol. All access to symbol_object->symbol should be
	41	gated by this call. */
	42	#define SYMPY_REQUIRE_VALID(symbol_obj, symbol) \
	43	do { \
	44	symbol = symbol_object_to_symbol (symbol_obj); \
	45	if (symbol == NULL) \
	46	{ \
	47	PyErr_SetString (PyExc_RuntimeError, \
	48	_("Symbol is invalid.")); \
	49	return NULL; \
	50	} \
	51	} while (0)
	52
	53	static const struct objfile_data *sympy_objfile_data_key;
	54
	55	static PyObject *
	56	sympy_str (PyObject *self)
	57	{
	58	PyObject *result;
	59	struct symbol *symbol = NULL;
	60
	61	SYMPY_REQUIRE_VALID (self, symbol);
	62
	63	result = PyString_FromString (SYMBOL_PRINT_NAME (symbol));
	64
	65	return result;
	66	}
	67
68	static PyObject *
69	sympy_get_symtab (PyObject self, void closure)
70	{
71	struct symbol *symbol = NULL;
72
73	SYMPY_REQUIRE_VALID (self, symbol);
74
75	return symtab_to_symtab_object (SYMBOL_SYMTAB (symbol));
76	}
77
78	static PyObject *
79	sympy_get_name (PyObject self, void closure)
80	{
81	struct symbol *symbol = NULL;
82
83	SYMPY_REQUIRE_VALID (self, symbol);
84
85	return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
86	}
87
88	static PyObject *
89	sympy_get_linkage_name (PyObject self, void closure)
90	{
91	struct symbol *symbol = NULL;
92
93	SYMPY_REQUIRE_VALID (self, symbol);
94
95	return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
96	}
97
98	static PyObject *
99	sympy_get_print_name (PyObject self, void closure)
100	{
101	struct symbol *symbol = NULL;
102
103	SYMPY_REQUIRE_VALID (self, symbol);
104
105	return sympy_str (self);
106	}
107
108	static PyObject *
109	sympy_get_addr_class (PyObject self, void closure)
110	{
111	struct symbol *symbol = NULL;
112
113	SYMPY_REQUIRE_VALID (self, symbol);
114
115	return PyInt_FromLong (SYMBOL_CLASS (symbol));
116	}
117
118	static PyObject *
119	sympy_is_argument (PyObject self, void closure)
120	{
121	struct symbol *symbol = NULL;
122
123	SYMPY_REQUIRE_VALID (self, symbol);
124
125	return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
126	}
127
128	static PyObject *
129	sympy_is_constant (PyObject self, void closure)
130	{
131	struct symbol *symbol = NULL;
132	enum address_class class;
133
134	SYMPY_REQUIRE_VALID (self, symbol);
135
136	class = SYMBOL_CLASS (symbol);
137
138	return PyBool_FromLong (class == LOC_CONST \|\| class == LOC_CONST_BYTES);
139	}
140
141	static PyObject *
142	sympy_is_function (PyObject self, void closure)
143	{
144	struct symbol *symbol = NULL;
145	enum address_class class;
146
147	SYMPY_REQUIRE_VALID (self, symbol);
148
149	class = SYMBOL_CLASS (symbol);
150
151	return PyBool_FromLong (class == LOC_BLOCK);
152	}
153
154	static PyObject *
155	sympy_is_variable (PyObject self, void closure)
156	{
157	struct symbol *symbol = NULL;
158	enum address_class class;
159
160	SYMPY_REQUIRE_VALID (self, symbol);
161
162	class = SYMBOL_CLASS (symbol);
163
164	return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
165	&& (class == LOC_LOCAL \|\| class == LOC_REGISTER
166	\|\| class == LOC_STATIC \|\| class == LOC_COMPUTED
167	\|\| class == LOC_OPTIMIZED_OUT));
168	}
169
170	/* Given a symbol, and a symbol_object that has previously been
171	allocated and initialized, populate the symbol_object with the
172	struct symbol data. Also, register the symbol_object life-cycle
173	with the life-cycle of the the object file associated with this
174	symbol, if needed. */
175	static void
176	set_symbol (symbol_object obj, struct symbol symbol)
177	{
178	obj->symbol = symbol;
179	obj->prev = NULL;
180	if (SYMBOL_SYMTAB (symbol))
181	{
182	obj->next = objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
183	sympy_objfile_data_key);
184
185	if (obj->next)
186	obj->next->prev = obj;
187	set_objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
188	sympy_objfile_data_key, obj);
189	}
190	else
191	obj->next = NULL;
192	}
193
194	/* Create a new symbol object (gdb.Symbol) that encapsulates the struct
195	symbol object from GDB. */
196	PyObject *
197	symbol_to_symbol_object (struct symbol *sym)
198	{
199	symbol_object *sym_obj;
200
201	sym_obj = PyObject_New (symbol_object, &symbol_object_type);
202	if (sym_obj)
203	set_symbol (sym_obj, sym);
204
205	return (PyObject *) sym_obj;
206	}
207
208	/* Return the symbol that is wrapped by this symbol object. */
209	struct symbol *
210	symbol_object_to_symbol (PyObject *obj)
211	{
212	if (! PyObject_TypeCheck (obj, &symbol_object_type))
213	return NULL;
214	return ((symbol_object *) obj)->symbol;
215	}
216
217	static void
218	sympy_dealloc (PyObject *obj)
219	{
220	symbol_object sym_obj = (symbol_object ) obj;
221
222	if (sym_obj->prev)
223	sym_obj->prev->next = sym_obj->next;
224	else if (SYMBOL_SYMTAB (sym_obj->symbol))
225	{
226	set_objfile_data (SYMBOL_SYMTAB (sym_obj->symbol)->objfile,
227	sympy_objfile_data_key, sym_obj->next);
228	}
229	if (sym_obj->next)
230	sym_obj->next->prev = sym_obj->prev;
231	sym_obj->symbol = NULL;
232	}
233
234	/* Implementation of
235	gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
236	A tuple with 2 elements is always returned. The first is the symbol
237	object or None, the second is a boolean with the value of
238	is_a_field_of_this (see comment in lookup_symbol_in_language). */
239	PyObject *
240	gdbpy_lookup_symbol (PyObject self, PyObject args, PyObject *kw)
241	{
242	int domain = VAR_DOMAIN, is_a_field_of_this = 0;
243	const char *name;
244	static char *keywords[] = { "name", "block", "domain", NULL };
245	struct symbol *symbol;
246	PyObject block_obj = NULL, ret_tuple, sym_obj, bool_obj;
247	struct block *block = NULL;
248
249	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|O!i", keywords, &name,
250	&block_object_type, &block_obj, &domain))
251	return NULL;
252
253	if (block_obj)
254	block = block_object_to_block (block_obj);
255	else
256	{
257	struct frame_info *selected_frame;
258	volatile struct gdb_exception except;
259
260	TRY_CATCH (except, RETURN_MASK_ALL)
261	{
262	selected_frame = get_selected_frame (_("No frame selected."));
263	block = block_for_pc (get_frame_address_in_block (selected_frame));
264	}
265	GDB_PY_HANDLE_EXCEPTION (except);
266	}
267
268	symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
269
270	ret_tuple = PyTuple_New (2);
271	if (!ret_tuple)
272	return NULL;
273
274	if (symbol)
275	{
276	sym_obj = symbol_to_symbol_object (symbol);
277	if (!sym_obj)
278	{
279	Py_DECREF (ret_tuple);
280	return NULL;
281	}
282	}
283	else
284	{
285	sym_obj = Py_None;
286	Py_INCREF (Py_None);
287	}
288	PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
289
290	bool_obj = is_a_field_of_this? Py_True : Py_False;
291	Py_INCREF (bool_obj);
292	PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
293
294	return ret_tuple;
295	}
296
297	/* This function is called when an objfile is about to be freed.
298	Invalidate the symbol as further actions on the symbol would result
299	in bad data. All access to obj->symbol should be gated by
300	SYMPY_REQUIRE_VALID which will raise an exception on invalid
301	symbols. */
302	static void
303	del_objfile_symbols (struct objfile objfile, void datum)
304	{
305	symbol_object *obj = datum;
306	while (obj)
307	{
308	symbol_object *next = obj->next;
309
310	obj->symbol = NULL;
311	obj->next = NULL;
312	obj->prev = NULL;
313
314	obj = next;
315	}
316	}
317
318	void
319	gdbpy_initialize_symbols (void)
320	{
321	if (PyType_Ready (&symbol_object_type) < 0)
322	return;
323
324	/* Register an objfile "free" callback so we can properly
325	invalidate symbol when an object file that is about to be
326	deleted. */
327	sympy_objfile_data_key
328	= register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
329
330	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
331	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
332	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
333	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
334	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
335	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
336	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
337	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
338	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
339	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
340	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
341	LOC_CONST_BYTES);
9a2b4c1b MS	342	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
9a2b4c1b MS	343	LOC_UNRESOLVED);
f3e9a817 PM	344	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
	345	LOC_OPTIMIZED_OUT);
	346	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
	347	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
	348	LOC_REGPARM_ADDR);
	349	PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
	350	PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
	351	PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
	352	PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
	353	PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
	354	VARIABLES_DOMAIN);
	355	PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
	356	FUNCTIONS_DOMAIN);
	357	PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
	358
	359	Py_INCREF (&symbol_object_type);
	360	PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
	361	}
	362
	363	\f
	364
	365	static PyGetSetDef symbol_object_getset[] = {
	366	{ "symtab", sympy_get_symtab, NULL,
	367	"Symbol table in which the symbol appears.", NULL },
	368	{ "name", sympy_get_name, NULL,
	369	"Name of the symbol, as it appears in the source code.", NULL },
	370	{ "linkage_name", sympy_get_linkage_name, NULL,
9a2b4c1b MS	371	"Name of the symbol, as used by the linker (i.e., may be mangled).",
9a2b4c1b MS	372	NULL },
f3e9a817 PM	373	{ "print_name", sympy_get_print_name, NULL,
	374	"Name of the symbol in a form suitable for output.\n\
	375	This is either name or linkage_name, depending on whether the user asked GDB\n\
	376	to display demangled or mangled names.", NULL },
	377	{ "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
	378	{ "is_argument", sympy_is_argument, NULL,
	379	"True if the symbol is an argument of a function." },
	380	{ "is_constant", sympy_is_constant, NULL,
	381	"True if the symbol is a constant." },
	382	{ "is_function", sympy_is_function, NULL,
	383	"True if the symbol is a function or method." },
	384	{ "is_variable", sympy_is_variable, NULL,
	385	"True if the symbol is a variable." },
	386	{ NULL } /* Sentinel */
	387	};
	388
	389	PyTypeObject symbol_object_type = {
	390	PyObject_HEAD_INIT (NULL)
	391	0, /ob_size/
	392	"gdb.Symbol", /tp_name/
	393	sizeof (symbol_object), /tp_basicsize/
	394	0, /tp_itemsize/
	395	sympy_dealloc, /tp_dealloc/
	396	0, /tp_print/
	397	0, /tp_getattr/
	398	0, /tp_setattr/
	399	0, /tp_compare/
	400	0, /tp_repr/
	401	0, /tp_as_number/
	402	0, /tp_as_sequence/
	403	0, /tp_as_mapping/
	404	0, /tp_hash /
	405	0, /tp_call/
	406	sympy_str, /tp_str/
	407	0, /tp_getattro/
	408	0, /tp_setattro/
	409	0, /tp_as_buffer/
	410	Py_TPFLAGS_DEFAULT, /tp_flags/
	411	"GDB symbol object", /tp_doc /
	412	0, /tp_traverse /
	413	0, /tp_clear /
	414	0, /tp_richcompare /
	415	0, /tp_weaklistoffset /
	416	0, /tp_iter /
	417	0, /tp_iternext /
	418	0, /tp_methods /
	419	0, /tp_members /
	420	symbol_object_getset /tp_getset /
	421	};