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

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

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
b021a221	173	with the life-cycle of the object file associated with this
f3e9a817 PM	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). */
6e6fbe60	239
f3e9a817 PM	240	PyObject *
	241	gdbpy_lookup_symbol (PyObject self, PyObject args, PyObject *kw)
	242	{
	243	int domain = VAR_DOMAIN, is_a_field_of_this = 0;
	244	const char *name;
	245	static char *keywords[] = { "name", "block", "domain", NULL };
	246	struct symbol *symbol;
	247	PyObject block_obj = NULL, ret_tuple, sym_obj, bool_obj;
	248	struct block *block = NULL;
	249
	250	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|O!i", keywords, &name,
	251	&block_object_type, &block_obj, &domain))
	252	return NULL;
	253
	254	if (block_obj)
	255	block = block_object_to_block (block_obj);
	256	else
	257	{
	258	struct frame_info *selected_frame;
	259	volatile struct gdb_exception except;
	260
	261	TRY_CATCH (except, RETURN_MASK_ALL)
	262	{
	263	selected_frame = get_selected_frame (_("No frame selected."));
	264	block = block_for_pc (get_frame_address_in_block (selected_frame));
	265	}
	266	GDB_PY_HANDLE_EXCEPTION (except);
	267	}
	268
	269	symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
	270
	271	ret_tuple = PyTuple_New (2);
	272	if (!ret_tuple)
	273	return NULL;
	274
	275	if (symbol)
	276	{
	277	sym_obj = symbol_to_symbol_object (symbol);
	278	if (!sym_obj)
	279	{
	280	Py_DECREF (ret_tuple);
	281	return NULL;
	282	}
	283	}
	284	else
	285	{
	286	sym_obj = Py_None;
	287	Py_INCREF (Py_None);
	288	}
	289	PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
	290
	291	bool_obj = is_a_field_of_this? Py_True : Py_False;
	292	Py_INCREF (bool_obj);
	293	PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
	294
	295	return ret_tuple;
	296	}
	297
6e6fbe60 DE	298	/* Implementation of
	299	gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */
	300
	301	PyObject *
	302	gdbpy_lookup_global_symbol (PyObject self, PyObject args, PyObject *kw)
	303	{
	304	int domain = VAR_DOMAIN;
	305	const char *name;
	306	static char *keywords[] = { "name", "domain", NULL };
	307	struct symbol *symbol;
	308	PyObject *sym_obj;
	309
	310	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|i", keywords, &name,
	311	&domain))
	312	return NULL;
	313
	314	symbol = lookup_symbol_global (name, NULL, domain);
	315
	316	if (symbol)
	317	{
	318	sym_obj = symbol_to_symbol_object (symbol);
	319	if (!sym_obj)
	320	return NULL;
	321	}
	322	else
	323	{
	324	sym_obj = Py_None;
	325	Py_INCREF (Py_None);
	326	}
	327
	328	return sym_obj;
	329	}
	330
f3e9a817 PM	331	/* This function is called when an objfile is about to be freed.
	332	Invalidate the symbol as further actions on the symbol would result
	333	in bad data. All access to obj->symbol should be gated by
	334	SYMPY_REQUIRE_VALID which will raise an exception on invalid
	335	symbols. */
	336	static void
	337	del_objfile_symbols (struct objfile objfile, void datum)
	338	{
	339	symbol_object *obj = datum;
	340	while (obj)
	341	{
	342	symbol_object *next = obj->next;
	343
	344	obj->symbol = NULL;
	345	obj->next = NULL;
	346	obj->prev = NULL;
	347
	348	obj = next;
	349	}
	350	}
	351
	352	void
	353	gdbpy_initialize_symbols (void)
	354	{
	355	if (PyType_Ready (&symbol_object_type) < 0)
	356	return;
	357
	358	/* Register an objfile "free" callback so we can properly
	359	invalidate symbol when an object file that is about to be
	360	deleted. */
	361	sympy_objfile_data_key
	362	= register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
	363
	364	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
	365	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
	366	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
	367	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
	368	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
	369	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
	370	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
	371	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
	372	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
	373	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
	374	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
	375	LOC_CONST_BYTES);
9a2b4c1b MS	376	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
9a2b4c1b MS	377	LOC_UNRESOLVED);
f3e9a817 PM	378	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
	379	LOC_OPTIMIZED_OUT);
	380	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
	381	PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
	382	LOC_REGPARM_ADDR);
	383	PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
	384	PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
	385	PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
	386	PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
	387	PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
	388	VARIABLES_DOMAIN);
	389	PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
	390	FUNCTIONS_DOMAIN);
	391	PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
	392
	393	Py_INCREF (&symbol_object_type);
	394	PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
	395	}
	396
	397	\f
	398
	399	static PyGetSetDef symbol_object_getset[] = {
	400	{ "symtab", sympy_get_symtab, NULL,
	401	"Symbol table in which the symbol appears.", NULL },
	402	{ "name", sympy_get_name, NULL,
	403	"Name of the symbol, as it appears in the source code.", NULL },
	404	{ "linkage_name", sympy_get_linkage_name, NULL,
9a2b4c1b MS	405	"Name of the symbol, as used by the linker (i.e., may be mangled).",
9a2b4c1b MS	406	NULL },
f3e9a817 PM	407	{ "print_name", sympy_get_print_name, NULL,
	408	"Name of the symbol in a form suitable for output.\n\
	409	This is either name or linkage_name, depending on whether the user asked GDB\n\
	410	to display demangled or mangled names.", NULL },
	411	{ "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
	412	{ "is_argument", sympy_is_argument, NULL,
	413	"True if the symbol is an argument of a function." },
	414	{ "is_constant", sympy_is_constant, NULL,
	415	"True if the symbol is a constant." },
	416	{ "is_function", sympy_is_function, NULL,
	417	"True if the symbol is a function or method." },
	418	{ "is_variable", sympy_is_variable, NULL,
	419	"True if the symbol is a variable." },
	420	{ NULL } /* Sentinel */
	421	};
	422
	423	PyTypeObject symbol_object_type = {
	424	PyObject_HEAD_INIT (NULL)
	425	0, /ob_size/
	426	"gdb.Symbol", /tp_name/
	427	sizeof (symbol_object), /tp_basicsize/
	428	0, /tp_itemsize/
	429	sympy_dealloc, /tp_dealloc/
	430	0, /tp_print/
	431	0, /tp_getattr/
	432	0, /tp_setattr/
	433	0, /tp_compare/
	434	0, /tp_repr/
	435	0, /tp_as_number/
	436	0, /tp_as_sequence/
	437	0, /tp_as_mapping/
	438	0, /tp_hash /
	439	0, /tp_call/
	440	sympy_str, /tp_str/
	441	0, /tp_getattro/
	442	0, /tp_setattro/
	443	0, /tp_as_buffer/
	444	Py_TPFLAGS_DEFAULT, /tp_flags/
	445	"GDB symbol object", /tp_doc /
	446	0, /tp_traverse /
	447	0, /tp_clear /
	448	0, /tp_richcompare /
	449	0, /tp_weaklistoffset /
	450	0, /tp_iter /
	451	0, /tp_iternext /
	452	0, /tp_methods /
	453	0, /tp_members /
	454	symbol_object_getset /tp_getset /
	455	};