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

/* Python interface to symbols.

   Copyright (C) 2008-2012 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_type (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;

  SYMPY_REQUIRE_VALID (self, symbol);

  if (SYMBOL_TYPE (symbol) == NULL)
    {
      Py_INCREF (Py_None);
      return Py_None;
    }

  return type_to_type_object (SYMBOL_TYPE (symbol));
}

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

/* 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;
}

/* 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_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 = NULL;
  PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
  const struct block *block = NULL;
  volatile struct gdb_exception except;

  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 = get_frame_block (selected_frame, NULL);
	}
      GDB_PY_HANDLE_EXCEPTION (except);
    }

  TRY_CATCH (except, RETURN_MASK_ALL)
    {
      symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
    }
  GDB_PY_HANDLE_EXCEPTION (except);

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

/* 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 char *keywords[] = { "name", "domain", NULL };
  struct symbol *symbol = NULL;
  PyObject *sym_obj;
  volatile struct gdb_exception except;

  if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
				     &domain))
    return NULL;

  TRY_CATCH (except, RETURN_MASK_ALL)
    {
      symbol = lookup_symbol_global (name, NULL, domain);
    }
  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;
}

/* 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[] = {
  { "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." },
  { 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." },
  {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 */
  symbol_object_methods,	  /*tp_methods */
  0,				  /*tp_members */
  symbol_object_getset		  /*tp_getset */
};
Commit	Line	Data
f3e9a817 PM	1	/* Python interface to symbols.
f3e9a817 PM	2
0b302171	3	Copyright (C) 2008-2012 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
457e09f0 DE	68	static PyObject *
	69	sympy_get_type (PyObject self, void closure)
	70	{
	71	struct symbol *symbol = NULL;
	72
	73	SYMPY_REQUIRE_VALID (self, symbol);
	74
	75	if (SYMBOL_TYPE (symbol) == NULL)
	76	{
	77	Py_INCREF (Py_None);
	78	return Py_None;
	79	}
	80
	81	return type_to_type_object (SYMBOL_TYPE (symbol));
	82	}
	83
f3e9a817 PM	84	static PyObject *
	85	sympy_get_symtab (PyObject self, void closure)
	86	{
	87	struct symbol *symbol = NULL;
	88
	89	SYMPY_REQUIRE_VALID (self, symbol);
	90
	91	return symtab_to_symtab_object (SYMBOL_SYMTAB (symbol));
	92	}
	93
	94	static PyObject *
	95	sympy_get_name (PyObject self, void closure)
	96	{
	97	struct symbol *symbol = NULL;
	98
	99	SYMPY_REQUIRE_VALID (self, symbol);
	100
	101	return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
	102	}
	103
	104	static PyObject *
	105	sympy_get_linkage_name (PyObject self, void closure)
	106	{
	107	struct symbol *symbol = NULL;
	108
	109	SYMPY_REQUIRE_VALID (self, symbol);
	110
	111	return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
	112	}
	113
	114	static PyObject *
	115	sympy_get_print_name (PyObject self, void closure)
	116	{
	117	struct symbol *symbol = NULL;
	118
	119	SYMPY_REQUIRE_VALID (self, symbol);
	120
	121	return sympy_str (self);
	122	}
	123
	124	static PyObject *
	125	sympy_get_addr_class (PyObject self, void closure)
	126	{
	127	struct symbol *symbol = NULL;
	128
	129	SYMPY_REQUIRE_VALID (self, symbol);
	130
	131	return PyInt_FromLong (SYMBOL_CLASS (symbol));
	132	}
	133
	134	static PyObject *
	135	sympy_is_argument (PyObject self, void closure)
	136	{
	137	struct symbol *symbol = NULL;
	138
	139	SYMPY_REQUIRE_VALID (self, symbol);
	140
	141	return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
	142	}
	143
	144	static PyObject *
	145	sympy_is_constant (PyObject self, void closure)
	146	{
	147	struct symbol *symbol = NULL;
148	enum address_class class;
149
150	SYMPY_REQUIRE_VALID (self, symbol);
151
152	class = SYMBOL_CLASS (symbol);
153
154	return PyBool_FromLong (class == LOC_CONST \|\| class == LOC_CONST_BYTES);
155	}
156
157	static PyObject *
158	sympy_is_function (PyObject self, void closure)
159	{
160	struct symbol *symbol = NULL;
161	enum address_class class;
162
163	SYMPY_REQUIRE_VALID (self, symbol);
164
165	class = SYMBOL_CLASS (symbol);
166
167	return PyBool_FromLong (class == LOC_BLOCK);
168	}
169
170	static PyObject *
171	sympy_is_variable (PyObject self, void closure)
172	{
173	struct symbol *symbol = NULL;
174	enum address_class class;
175
176	SYMPY_REQUIRE_VALID (self, symbol);
177
178	class = SYMBOL_CLASS (symbol);
179
180	return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
181	&& (class == LOC_LOCAL \|\| class == LOC_REGISTER
182	\|\| class == LOC_STATIC \|\| class == LOC_COMPUTED
183	\|\| class == LOC_OPTIMIZED_OUT));
184	}
185
29703da4 PM	186	/* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
	187	Returns True if this Symbol still exists in GDB. */
	188
	189	static PyObject *
	190	sympy_is_valid (PyObject self, PyObject args)
	191	{
	192	struct symbol *symbol = NULL;
	193
	194	symbol = symbol_object_to_symbol (self);
	195	if (symbol == NULL)
	196	Py_RETURN_FALSE;
	197
	198	Py_RETURN_TRUE;
	199	}
	200
f3e9a817 PM	201	/* Given a symbol, and a symbol_object that has previously been
	202	allocated and initialized, populate the symbol_object with the
	203	struct symbol data. Also, register the symbol_object life-cycle
b021a221	204	with the life-cycle of the object file associated with this
f3e9a817 PM	205	symbol, if needed. */
	206	static void
	207	set_symbol (symbol_object obj, struct symbol symbol)
	208	{
	209	obj->symbol = symbol;
	210	obj->prev = NULL;
	211	if (SYMBOL_SYMTAB (symbol))
	212	{
	213	obj->next = objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
	214	sympy_objfile_data_key);
	215
	216	if (obj->next)
	217	obj->next->prev = obj;
	218	set_objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
	219	sympy_objfile_data_key, obj);
	220	}
	221	else
	222	obj->next = NULL;
	223	}
	224
	225	/* Create a new symbol object (gdb.Symbol) that encapsulates the struct
	226	symbol object from GDB. */
	227	PyObject *
	228	symbol_to_symbol_object (struct symbol *sym)
	229	{
	230	symbol_object *sym_obj;
	231
	232	sym_obj = PyObject_New (symbol_object, &symbol_object_type);
	233	if (sym_obj)
	234	set_symbol (sym_obj, sym);
	235
	236	return (PyObject *) sym_obj;
	237	}
	238
	239	/* Return the symbol that is wrapped by this symbol object. */
	240	struct symbol *
	241	symbol_object_to_symbol (PyObject *obj)
	242	{
	243	if (! PyObject_TypeCheck (obj, &symbol_object_type))
	244	return NULL;
	245	return ((symbol_object *) obj)->symbol;
	246	}
	247
	248	static void
	249	sympy_dealloc (PyObject *obj)
	250	{
	251	symbol_object sym_obj = (symbol_object ) obj;
	252
	253	if (sym_obj->prev)
	254	sym_obj->prev->next = sym_obj->next;
	255	else if (SYMBOL_SYMTAB (sym_obj->symbol))
	256	{
	257	set_objfile_data (SYMBOL_SYMTAB (sym_obj->symbol)->objfile,
	258	sympy_objfile_data_key, sym_obj->next);
	259	}
	260	if (sym_obj->next)
	261	sym_obj->next->prev = sym_obj->prev;
	262	sym_obj->symbol = NULL;
	263	}
	264
	265	/* Implementation of
	266	gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
	267	A tuple with 2 elements is always returned. The first is the symbol
	268	object or None, the second is a boolean with the value of
269	is_a_field_of_this (see comment in lookup_symbol_in_language). */
6e6fbe60	270
f3e9a817 PM	271	PyObject *
	272	gdbpy_lookup_symbol (PyObject self, PyObject args, PyObject *kw)
	273	{
	274	int domain = VAR_DOMAIN, is_a_field_of_this = 0;
	275	const char *name;
	276	static char *keywords[] = { "name", "block", "domain", NULL };
76dce0be	277	struct symbol *symbol = NULL;
f3e9a817	278	PyObject block_obj = NULL, ret_tuple, sym_obj, bool_obj;
9df2fbc4	279	const struct block *block = NULL;
76dce0be	280	volatile struct gdb_exception except;
f3e9a817 PM	281
	282	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|O!i", keywords, &name,
	283	&block_object_type, &block_obj, &domain))
	284	return NULL;
	285
	286	if (block_obj)
	287	block = block_object_to_block (block_obj);
	288	else
	289	{
	290	struct frame_info *selected_frame;
	291	volatile struct gdb_exception except;
	292
	293	TRY_CATCH (except, RETURN_MASK_ALL)
	294	{
626e7282 JK	295	selected_frame = get_selected_frame (_("No frame selected."));
626e7282 JK	296	block = get_frame_block (selected_frame, NULL);
f3e9a817 PM	297	}
	298	GDB_PY_HANDLE_EXCEPTION (except);
	299	}
	300
76dce0be PM	301	TRY_CATCH (except, RETURN_MASK_ALL)
	302	{
	303	symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
	304	}
	305	GDB_PY_HANDLE_EXCEPTION (except);
f3e9a817 PM	306
	307	ret_tuple = PyTuple_New (2);
	308	if (!ret_tuple)
	309	return NULL;
	310
	311	if (symbol)
	312	{
	313	sym_obj = symbol_to_symbol_object (symbol);
	314	if (!sym_obj)
	315	{
	316	Py_DECREF (ret_tuple);
	317	return NULL;
	318	}
	319	}
	320	else
	321	{
	322	sym_obj = Py_None;
	323	Py_INCREF (Py_None);
	324	}
	325	PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
	326
	327	bool_obj = is_a_field_of_this? Py_True : Py_False;
	328	Py_INCREF (bool_obj);
	329	PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
	330
	331	return ret_tuple;
	332	}
	333
6e6fbe60 DE	334	/* Implementation of
	335	gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */
	336
	337	PyObject *
	338	gdbpy_lookup_global_symbol (PyObject self, PyObject args, PyObject *kw)
	339	{
	340	int domain = VAR_DOMAIN;
	341	const char *name;
	342	static char *keywords[] = { "name", "domain", NULL };
76dce0be	343	struct symbol *symbol = NULL;
6e6fbe60	344	PyObject *sym_obj;
76dce0be	345	volatile struct gdb_exception except;
6e6fbe60 DE	346
	347	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|i", keywords, &name,
	348	&domain))
	349	return NULL;
	350
76dce0be PM	351	TRY_CATCH (except, RETURN_MASK_ALL)
	352	{
	353	symbol = lookup_symbol_global (name, NULL, domain);
	354	}
	355	GDB_PY_HANDLE_EXCEPTION (except);
6e6fbe60 DE	356
	357	if (symbol)
	358	{
	359	sym_obj = symbol_to_symbol_object (symbol);
	360	if (!sym_obj)
	361	return NULL;
	362	}
	363	else
	364	{
	365	sym_obj = Py_None;
	366	Py_INCREF (Py_None);
	367	}
	368
	369	return sym_obj;
	370	}
	371
f3e9a817 PM	372	/* This function is called when an objfile is about to be freed.
	373	Invalidate the symbol as further actions on the symbol would result
	374	in bad data. All access to obj->symbol should be gated by
	375	SYMPY_REQUIRE_VALID which will raise an exception on invalid
	376	symbols. */
	377	static void
	378	del_objfile_symbols (struct objfile objfile, void datum)
	379	{
	380	symbol_object *obj = datum;
	381	while (obj)
	382	{
	383	symbol_object *next = obj->next;
	384
	385	obj->symbol = NULL;
	386	obj->next = NULL;
	387	obj->prev = NULL;
	388
	389	obj = next;
	390	}
	391	}
	392
	393	void
	394	gdbpy_initialize_symbols (void)
	395	{
	396	if (PyType_Ready (&symbol_object_type) < 0)
	397	return;
	398
	399	/* Register an objfile "free" callback so we can properly
	400	invalidate symbol when an object file that is about to be
	401	deleted. */
	402	sympy_objfile_data_key
	403	= register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
	404
	405	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
	406	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
	407	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
	408	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
	409	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
	410	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
	411	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
	412	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
	413	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
	414	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
	415	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
	416	LOC_CONST_BYTES);
9a2b4c1b MS	417	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
9a2b4c1b MS	418	LOC_UNRESOLVED);
f3e9a817 PM	419	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
	420	LOC_OPTIMIZED_OUT);
	421	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
	422	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
	423	LOC_REGPARM_ADDR);
	424	PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
	425	PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
	426	PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
	427	PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
	428	PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
	429	VARIABLES_DOMAIN);
	430	PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
	431	FUNCTIONS_DOMAIN);
	432	PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
	433
	434	Py_INCREF (&symbol_object_type);
	435	PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
	436	}
	437
	438	\f
	439
	440	static PyGetSetDef symbol_object_getset[] = {
457e09f0 DE	441	{ "type", sympy_get_type, NULL,
457e09f0 DE	442	"Type of the symbol.", NULL },
f3e9a817 PM	443	{ "symtab", sympy_get_symtab, NULL,
	444	"Symbol table in which the symbol appears.", NULL },
	445	{ "name", sympy_get_name, NULL,
	446	"Name of the symbol, as it appears in the source code.", NULL },
	447	{ "linkage_name", sympy_get_linkage_name, NULL,
9a2b4c1b MS	448	"Name of the symbol, as used by the linker (i.e., may be mangled).",
9a2b4c1b MS	449	NULL },
f3e9a817 PM	450	{ "print_name", sympy_get_print_name, NULL,
	451	"Name of the symbol in a form suitable for output.\n\
	452	This is either name or linkage_name, depending on whether the user asked GDB\n\
	453	to display demangled or mangled names.", NULL },
	454	{ "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
	455	{ "is_argument", sympy_is_argument, NULL,
	456	"True if the symbol is an argument of a function." },
	457	{ "is_constant", sympy_is_constant, NULL,
	458	"True if the symbol is a constant." },
	459	{ "is_function", sympy_is_function, NULL,
	460	"True if the symbol is a function or method." },
	461	{ "is_variable", sympy_is_variable, NULL,
	462	"True if the symbol is a variable." },
	463	{ NULL } /* Sentinel */
	464	};
	465
29703da4 PM	466	static PyMethodDef symbol_object_methods[] = {
	467	{ "is_valid", sympy_is_valid, METH_NOARGS,
	468	"is_valid () -> Boolean.\n\
	469	Return true if this symbol is valid, false if not." },
	470	{NULL} /* Sentinel */
	471	};
	472
f3e9a817 PM	473	PyTypeObject symbol_object_type = {
	474	PyObject_HEAD_INIT (NULL)
	475	0, /ob_size/
	476	"gdb.Symbol", /tp_name/
	477	sizeof (symbol_object), /tp_basicsize/
	478	0, /tp_itemsize/
	479	sympy_dealloc, /tp_dealloc/
	480	0, /tp_print/
	481	0, /tp_getattr/
	482	0, /tp_setattr/
	483	0, /tp_compare/
	484	0, /tp_repr/
	485	0, /tp_as_number/
	486	0, /tp_as_sequence/
	487	0, /tp_as_mapping/
	488	0, /tp_hash /
	489	0, /tp_call/
	490	sympy_str, /tp_str/
	491	0, /tp_getattro/
	492	0, /tp_setattro/
	493	0, /tp_as_buffer/
	494	Py_TPFLAGS_DEFAULT, /tp_flags/
	495	"GDB symbol object", /tp_doc /
	496	0, /tp_traverse /
	497	0, /tp_clear /
	498	0, /tp_richcompare /
	499	0, /tp_weaklistoffset /
	500	0, /tp_iter /
	501	0, /tp_iternext /
29703da4	502	symbol_object_methods, /tp_methods /
f3e9a817 PM	503	0, /tp_members /
	504	symbol_object_getset /tp_getset /
	505	};