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

/* Python interface to symbols.

   Copyright (C) 2008-2014 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.needs_frame -> Boolean.
   Returns true iff the symbol needs a frame for evaluation.  */

static PyObject *
sympy_needs_frame (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;
  volatile struct gdb_exception except;
  int result = 0;

  SYMPY_REQUIRE_VALID (self, symbol);

  TRY_CATCH (except, RETURN_MASK_ALL)
    {
      result = symbol_read_needs_frame (symbol);
    }
  GDB_PY_HANDLE_EXCEPTION (except);

  if (result)
    Py_RETURN_TRUE;
  Py_RETURN_FALSE;
}

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

/* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value.  Returns
   the value of the symbol, or an error in various circumstances.  */

static PyObject *
sympy_value (PyObject *self, PyObject *args)
{
  struct symbol *symbol = NULL;
  struct frame_info *frame_info = NULL;
  PyObject *frame_obj = NULL;
  struct value *value = NULL;
  volatile struct gdb_exception except;

  if (!PyArg_ParseTuple (args, "|O", &frame_obj))
    return NULL;

  if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
    {
      PyErr_SetString (PyExc_TypeError, "argument is not a frame");
      return NULL;
    }

  SYMPY_REQUIRE_VALID (self, symbol);
  if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
    {
      PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
      return NULL;
    }

  TRY_CATCH (except, RETURN_MASK_ALL)
    {
      if (frame_obj != NULL)
	{
	  frame_info = frame_object_to_frame_info (frame_obj);
	  if (frame_info == NULL)
	    error (_("invalid frame"));
	}

      if (symbol_read_needs_frame (symbol) && frame_info == NULL)
	error (_("symbol requires a frame to compute its value"));

      value = read_var_value (symbol, frame_info);
    }
  GDB_PY_HANDLE_EXCEPTION (except);

  return value_to_value_object (value);
}

/* 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 (sym_obj->symbol && 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;
  struct field_of_this_result is_a_field_of_this;
  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.type != NULL) ? 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;
    }
}

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

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

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

  return gdb_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." },
  { "needs_frame", sympy_needs_frame, NULL,
    "True if the symbol requires a frame for evaluation." },
  { "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." },
  { "value", sympy_value, METH_VARARGS,
    "value ([frame]) -> gdb.Value\n\
Return the value of the symbol." },
  {NULL}  /* Sentinel */
};

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