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

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

/* 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;
  PyObject *sym_obj;

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

  symbol = lookup_symbol_global (name, NULL, domain);

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