[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.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 PyInt_FromLong (SYMBOL_LINE (symbol));
}

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