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

/* Python interface to symbols.

   Copyright (C) 2008-2015 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 "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);

  if (!SYMBOL_OBJFILE_OWNED (symbol))
    Py_RETURN_NONE;

  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_OBJFILE_OWNED (symbol)
      && symbol_symtab (symbol) != NULL)
    {
      struct objfile *objfile = symbol_objfile (symbol);

      obj->next = objfile_data (objfile, sympy_objfile_data_key);
      if (obj->next)
	obj->next->prev = obj;
      set_objfile_data (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 != NULL
	   && SYMBOL_OBJFILE_OWNED (sym_obj->symbol)
	   && symbol_symtab (sym_obj->symbol) != NULL)
    {
      set_objfile_data (symbol_objfile (sym_obj->symbol),
			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_global_symbol (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
32d0add0	3	Copyright (C) 2008-2015 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"
f3e9a817 PM	22	#include "frame.h"
	23	#include "symtab.h"
	24	#include "python-internal.h"
	25	#include "objfiles.h"
	26
	27	typedef struct sympy_symbol_object {
	28	PyObject_HEAD
	29	/* The GDB symbol structure this object is wrapping. */
	30	struct symbol *symbol;
	31	/* A symbol object is associated with an objfile, so keep track with
	32	doubly-linked list, rooted in the objfile. This lets us
	33	invalidate the underlying struct symbol when the objfile is
	34	deleted. */
	35	struct sympy_symbol_object *prev;
	36	struct sympy_symbol_object *next;
	37	} symbol_object;
	38
	39	/* Require a valid symbol. All access to symbol_object->symbol should be
	40	gated by this call. */
	41	#define SYMPY_REQUIRE_VALID(symbol_obj, symbol) \
	42	do { \
	43	symbol = symbol_object_to_symbol (symbol_obj); \
	44	if (symbol == NULL) \
	45	{ \
	46	PyErr_SetString (PyExc_RuntimeError, \
	47	_("Symbol is invalid.")); \
	48	return NULL; \
	49	} \
	50	} while (0)
	51
	52	static const struct objfile_data *sympy_objfile_data_key;
	53
	54	static PyObject *
	55	sympy_str (PyObject *self)
	56	{
	57	PyObject *result;
	58	struct symbol *symbol = NULL;
	59
	60	SYMPY_REQUIRE_VALID (self, symbol);
	61
	62	result = PyString_FromString (SYMBOL_PRINT_NAME (symbol));
	63
	64	return result;
	65	}
	66
457e09f0 DE	67	static PyObject *
	68	sympy_get_type (PyObject self, void closure)
	69	{
	70	struct symbol *symbol = NULL;
	71
	72	SYMPY_REQUIRE_VALID (self, symbol);
	73
	74	if (SYMBOL_TYPE (symbol) == NULL)
	75	{
	76	Py_INCREF (Py_None);
	77	return Py_None;
	78	}
	79
	80	return type_to_type_object (SYMBOL_TYPE (symbol));
	81	}
	82
f3e9a817 PM	83	static PyObject *
	84	sympy_get_symtab (PyObject self, void closure)
	85	{
	86	struct symbol *symbol = NULL;
	87
	88	SYMPY_REQUIRE_VALID (self, symbol);
	89
1994afbf DE	90	if (!SYMBOL_OBJFILE_OWNED (symbol))
	91	Py_RETURN_NONE;
	92
08be3fe3	93	return symtab_to_symtab_object (symbol_symtab (symbol));
f3e9a817 PM	94	}
	95
	96	static PyObject *
	97	sympy_get_name (PyObject self, void closure)
	98	{
	99	struct symbol *symbol = NULL;
	100
	101	SYMPY_REQUIRE_VALID (self, symbol);
	102
	103	return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
	104	}
	105
	106	static PyObject *
	107	sympy_get_linkage_name (PyObject self, void closure)
	108	{
	109	struct symbol *symbol = NULL;
	110
	111	SYMPY_REQUIRE_VALID (self, symbol);
	112
	113	return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
	114	}
	115
	116	static PyObject *
	117	sympy_get_print_name (PyObject self, void closure)
	118	{
	119	struct symbol *symbol = NULL;
	120
	121	SYMPY_REQUIRE_VALID (self, symbol);
	122
	123	return sympy_str (self);
	124	}
	125
	126	static PyObject *
	127	sympy_get_addr_class (PyObject self, void closure)
	128	{
	129	struct symbol *symbol = NULL;
	130
	131	SYMPY_REQUIRE_VALID (self, symbol);
	132
	133	return PyInt_FromLong (SYMBOL_CLASS (symbol));
	134	}
	135
	136	static PyObject *
	137	sympy_is_argument (PyObject self, void closure)
	138	{
	139	struct symbol *symbol = NULL;
	140
	141	SYMPY_REQUIRE_VALID (self, symbol);
	142
	143	return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
	144	}
	145
	146	static PyObject *
	147	sympy_is_constant (PyObject self, void closure)
	148	{
	149	struct symbol *symbol = NULL;
	150	enum address_class class;
	151
	152	SYMPY_REQUIRE_VALID (self, symbol);
	153
	154	class = SYMBOL_CLASS (symbol);
	155
	156	return PyBool_FromLong (class == LOC_CONST \|\| class == LOC_CONST_BYTES);
	157	}
158
159	static PyObject *
160	sympy_is_function (PyObject self, void closure)
161	{
162	struct symbol *symbol = NULL;
163	enum address_class class;
164
165	SYMPY_REQUIRE_VALID (self, symbol);
166
167	class = SYMBOL_CLASS (symbol);
168
169	return PyBool_FromLong (class == LOC_BLOCK);
170	}
171
172	static PyObject *
173	sympy_is_variable (PyObject self, void closure)
174	{
175	struct symbol *symbol = NULL;
176	enum address_class class;
177
178	SYMPY_REQUIRE_VALID (self, symbol);
179
180	class = SYMBOL_CLASS (symbol);
181
182	return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
183	&& (class == LOC_LOCAL \|\| class == LOC_REGISTER
184	\|\| class == LOC_STATIC \|\| class == LOC_COMPUTED
185	\|\| class == LOC_OPTIMIZED_OUT));
186	}
187
f0823d2c TT	188	/* Implementation of gdb.Symbol.needs_frame -> Boolean.
	189	Returns true iff the symbol needs a frame for evaluation. */
	190
	191	static PyObject *
	192	sympy_needs_frame (PyObject self, void closure)
	193	{
	194	struct symbol *symbol = NULL;
	195	volatile struct gdb_exception except;
	196	int result = 0;
	197
	198	SYMPY_REQUIRE_VALID (self, symbol);
	199
	200	TRY_CATCH (except, RETURN_MASK_ALL)
	201	{
	202	result = symbol_read_needs_frame (symbol);
	203	}
	204	GDB_PY_HANDLE_EXCEPTION (except);
	205
	206	if (result)
	207	Py_RETURN_TRUE;
	208	Py_RETURN_FALSE;
	209	}
	210
64e7d9dd TT	211	/* Implementation of gdb.Symbol.line -> int.
	212	Returns the line number at which the symbol was defined. */
	213
	214	static PyObject *
	215	sympy_line (PyObject self, void closure)
	216	{
	217	struct symbol *symbol = NULL;
	218
	219	SYMPY_REQUIRE_VALID (self, symbol);
	220
	221	return PyInt_FromLong (SYMBOL_LINE (symbol));
	222	}
	223
29703da4 PM	224	/* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
	225	Returns True if this Symbol still exists in GDB. */
	226
	227	static PyObject *
	228	sympy_is_valid (PyObject self, PyObject args)
	229	{
	230	struct symbol *symbol = NULL;
	231
	232	symbol = symbol_object_to_symbol (self);
	233	if (symbol == NULL)
	234	Py_RETURN_FALSE;
	235
	236	Py_RETURN_TRUE;
	237	}
	238
f0823d2c TT	239	/* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value. Returns
	240	the value of the symbol, or an error in various circumstances. */
	241
	242	static PyObject *
	243	sympy_value (PyObject self, PyObject args)
	244	{
	245	struct symbol *symbol = NULL;
	246	struct frame_info *frame_info = NULL;
	247	PyObject *frame_obj = NULL;
	248	struct value *value = NULL;
	249	volatile struct gdb_exception except;
	250
	251	if (!PyArg_ParseTuple (args, "\|O", &frame_obj))
	252	return NULL;
	253
	254	if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
	255	{
	256	PyErr_SetString (PyExc_TypeError, "argument is not a frame");
	257	return NULL;
	258	}
	259
	260	SYMPY_REQUIRE_VALID (self, symbol);
	261	if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
	262	{
	263	PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
	264	return NULL;
	265	}
	266
	267	TRY_CATCH (except, RETURN_MASK_ALL)
	268	{
	269	if (frame_obj != NULL)
	270	{
	271	frame_info = frame_object_to_frame_info (frame_obj);
	272	if (frame_info == NULL)
c6910659	273	error (_("invalid frame"));
f0823d2c	274	}
256458bc	275
f0823d2c	276	if (symbol_read_needs_frame (symbol) && frame_info == NULL)
c6910659	277	error (_("symbol requires a frame to compute its value"));
f0823d2c TT	278
	279	value = read_var_value (symbol, frame_info);
	280	}
	281	GDB_PY_HANDLE_EXCEPTION (except);
	282
	283	return value_to_value_object (value);
	284	}
	285
f3e9a817 PM	286	/* Given a symbol, and a symbol_object that has previously been
	287	allocated and initialized, populate the symbol_object with the
	288	struct symbol data. Also, register the symbol_object life-cycle
b021a221	289	with the life-cycle of the object file associated with this
f3e9a817 PM	290	symbol, if needed. */
	291	static void
	292	set_symbol (symbol_object obj, struct symbol symbol)
	293	{
	294	obj->symbol = symbol;
	295	obj->prev = NULL;
1994afbf DE	296	if (SYMBOL_OBJFILE_OWNED (symbol)
1994afbf DE	297	&& symbol_symtab (symbol) != NULL)
f3e9a817	298	{
08be3fe3	299	struct objfile *objfile = symbol_objfile (symbol);
f3e9a817	300
08be3fe3	301	obj->next = objfile_data (objfile, sympy_objfile_data_key);
f3e9a817 PM	302	if (obj->next)
f3e9a817 PM	303	obj->next->prev = obj;
08be3fe3	304	set_objfile_data (objfile, sympy_objfile_data_key, obj);
f3e9a817 PM	305	}
	306	else
	307	obj->next = NULL;
	308	}
	309
	310	/* Create a new symbol object (gdb.Symbol) that encapsulates the struct
	311	symbol object from GDB. */
	312	PyObject *
	313	symbol_to_symbol_object (struct symbol *sym)
	314	{
	315	symbol_object *sym_obj;
	316
	317	sym_obj = PyObject_New (symbol_object, &symbol_object_type);
	318	if (sym_obj)
	319	set_symbol (sym_obj, sym);
	320
	321	return (PyObject *) sym_obj;
	322	}
	323
	324	/* Return the symbol that is wrapped by this symbol object. */
	325	struct symbol *
	326	symbol_object_to_symbol (PyObject *obj)
	327	{
	328	if (! PyObject_TypeCheck (obj, &symbol_object_type))
	329	return NULL;
	330	return ((symbol_object *) obj)->symbol;
	331	}
	332
	333	static void
	334	sympy_dealloc (PyObject *obj)
	335	{
	336	symbol_object sym_obj = (symbol_object ) obj;
	337
	338	if (sym_obj->prev)
	339	sym_obj->prev->next = sym_obj->next;
08be3fe3	340	else if (sym_obj->symbol != NULL
1994afbf	341	&& SYMBOL_OBJFILE_OWNED (sym_obj->symbol)
08be3fe3	342	&& symbol_symtab (sym_obj->symbol) != NULL)
f3e9a817	343	{
08be3fe3	344	set_objfile_data (symbol_objfile (sym_obj->symbol),
f3e9a817 PM	345	sympy_objfile_data_key, sym_obj->next);
	346	}
	347	if (sym_obj->next)
	348	sym_obj->next->prev = sym_obj->prev;
	349	sym_obj->symbol = NULL;
	350	}
	351
	352	/* Implementation of
	353	gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
	354	A tuple with 2 elements is always returned. The first is the symbol
	355	object or None, the second is a boolean with the value of
	356	is_a_field_of_this (see comment in lookup_symbol_in_language). */
6e6fbe60	357
f3e9a817 PM	358	PyObject *
	359	gdbpy_lookup_symbol (PyObject self, PyObject args, PyObject *kw)
	360	{
1993b719 TT	361	int domain = VAR_DOMAIN;
1993b719 TT	362	struct field_of_this_result is_a_field_of_this;
f3e9a817 PM	363	const char *name;
f3e9a817 PM	364	static char *keywords[] = { "name", "block", "domain", NULL };
76dce0be	365	struct symbol *symbol = NULL;
f3e9a817	366	PyObject block_obj = NULL, ret_tuple, sym_obj, bool_obj;
9df2fbc4	367	const struct block *block = NULL;
76dce0be	368	volatile struct gdb_exception except;
f3e9a817 PM	369
	370	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|O!i", keywords, &name,
	371	&block_object_type, &block_obj, &domain))
	372	return NULL;
	373
	374	if (block_obj)
	375	block = block_object_to_block (block_obj);
	376	else
	377	{
	378	struct frame_info *selected_frame;
	379	volatile struct gdb_exception except;
	380
	381	TRY_CATCH (except, RETURN_MASK_ALL)
	382	{
626e7282 JK	383	selected_frame = get_selected_frame (_("No frame selected."));
626e7282 JK	384	block = get_frame_block (selected_frame, NULL);
f3e9a817 PM	385	}
	386	GDB_PY_HANDLE_EXCEPTION (except);
	387	}
	388
76dce0be PM	389	TRY_CATCH (except, RETURN_MASK_ALL)
	390	{
	391	symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
	392	}
	393	GDB_PY_HANDLE_EXCEPTION (except);
f3e9a817 PM	394
	395	ret_tuple = PyTuple_New (2);
	396	if (!ret_tuple)
	397	return NULL;
	398
	399	if (symbol)
	400	{
	401	sym_obj = symbol_to_symbol_object (symbol);
	402	if (!sym_obj)
	403	{
	404	Py_DECREF (ret_tuple);
	405	return NULL;
	406	}
	407	}
	408	else
	409	{
	410	sym_obj = Py_None;
	411	Py_INCREF (Py_None);
	412	}
	413	PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
	414
1993b719	415	bool_obj = (is_a_field_of_this.type != NULL) ? Py_True : Py_False;
f3e9a817 PM	416	Py_INCREF (bool_obj);
	417	PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
	418
	419	return ret_tuple;
	420	}
	421
6e6fbe60 DE	422	/* Implementation of
	423	gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */
	424
	425	PyObject *
	426	gdbpy_lookup_global_symbol (PyObject self, PyObject args, PyObject *kw)
	427	{
	428	int domain = VAR_DOMAIN;
	429	const char *name;
	430	static char *keywords[] = { "name", "domain", NULL };
76dce0be	431	struct symbol *symbol = NULL;
6e6fbe60	432	PyObject *sym_obj;
76dce0be	433	volatile struct gdb_exception except;
6e6fbe60 DE	434
	435	if (! PyArg_ParseTupleAndKeywords (args, kw, "s\|i", keywords, &name,
	436	&domain))
	437	return NULL;
	438
76dce0be PM	439	TRY_CATCH (except, RETURN_MASK_ALL)
76dce0be PM	440	{
08724ab7	441	symbol = lookup_global_symbol (name, NULL, domain);
76dce0be PM	442	}
76dce0be PM	443	GDB_PY_HANDLE_EXCEPTION (except);
6e6fbe60 DE	444
	445	if (symbol)
	446	{
	447	sym_obj = symbol_to_symbol_object (symbol);
	448	if (!sym_obj)
	449	return NULL;
	450	}
	451	else
	452	{
	453	sym_obj = Py_None;
	454	Py_INCREF (Py_None);
	455	}
	456
	457	return sym_obj;
	458	}
	459
f3e9a817 PM	460	/* This function is called when an objfile is about to be freed.
	461	Invalidate the symbol as further actions on the symbol would result
	462	in bad data. All access to obj->symbol should be gated by
	463	SYMPY_REQUIRE_VALID which will raise an exception on invalid
	464	symbols. */
	465	static void
	466	del_objfile_symbols (struct objfile objfile, void datum)
	467	{
	468	symbol_object *obj = datum;
	469	while (obj)
	470	{
	471	symbol_object *next = obj->next;
	472
	473	obj->symbol = NULL;
	474	obj->next = NULL;
	475	obj->prev = NULL;
	476
	477	obj = next;
	478	}
	479	}
	480
999633ed	481	int
f3e9a817 PM	482	gdbpy_initialize_symbols (void)
	483	{
	484	if (PyType_Ready (&symbol_object_type) < 0)
999633ed	485	return -1;
f3e9a817 PM	486
	487	/* Register an objfile "free" callback so we can properly
	488	invalidate symbol when an object file that is about to be
	489	deleted. */
	490	sympy_objfile_data_key
	491	= register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
	492
999633ed TT	493	if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0
	494	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST",
	495	LOC_CONST) < 0
	496	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC",
	497	LOC_STATIC) < 0
	498	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER",
	499	LOC_REGISTER) < 0
	500	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG",
	501	LOC_ARG) < 0
	502	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG",
	503	LOC_REF_ARG) < 0
	504	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL",
	505	LOC_LOCAL) < 0
	506	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF",
	507	LOC_TYPEDEF) < 0
	508	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL",
	509	LOC_LABEL) < 0
	510	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK",
	511	LOC_BLOCK) < 0
	512	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
	513	LOC_CONST_BYTES) < 0
	514	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
	515	LOC_UNRESOLVED) < 0
	516	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
	517	LOC_OPTIMIZED_OUT) < 0
	518	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED",
	519	LOC_COMPUTED) < 0
	520	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
	521	LOC_REGPARM_ADDR) < 0
	522	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN",
	523	UNDEF_DOMAIN) < 0
	524	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN",
	525	VAR_DOMAIN) < 0
	526	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN",
	527	STRUCT_DOMAIN) < 0
	528	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN",
	529	LABEL_DOMAIN) < 0
	530	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
	531	VARIABLES_DOMAIN) < 0
	532	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
	533	FUNCTIONS_DOMAIN) < 0
	534	\|\| PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN",
	535	TYPES_DOMAIN) < 0)
	536	return -1;
f3e9a817	537
aa36459a TT	538	return gdb_pymodule_addobject (gdb_module, "Symbol",
aa36459a TT	539	(PyObject *) &symbol_object_type);
f3e9a817 PM	540	}
	541
	542	\f
	543
	544	static PyGetSetDef symbol_object_getset[] = {
457e09f0 DE	545	{ "type", sympy_get_type, NULL,
457e09f0 DE	546	"Type of the symbol.", NULL },
f3e9a817 PM	547	{ "symtab", sympy_get_symtab, NULL,
	548	"Symbol table in which the symbol appears.", NULL },
	549	{ "name", sympy_get_name, NULL,
	550	"Name of the symbol, as it appears in the source code.", NULL },
	551	{ "linkage_name", sympy_get_linkage_name, NULL,
9a2b4c1b MS	552	"Name of the symbol, as used by the linker (i.e., may be mangled).",
9a2b4c1b MS	553	NULL },
f3e9a817 PM	554	{ "print_name", sympy_get_print_name, NULL,
	555	"Name of the symbol in a form suitable for output.\n\
	556	This is either name or linkage_name, depending on whether the user asked GDB\n\
	557	to display demangled or mangled names.", NULL },
	558	{ "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
	559	{ "is_argument", sympy_is_argument, NULL,
	560	"True if the symbol is an argument of a function." },
	561	{ "is_constant", sympy_is_constant, NULL,
	562	"True if the symbol is a constant." },
	563	{ "is_function", sympy_is_function, NULL,
	564	"True if the symbol is a function or method." },
	565	{ "is_variable", sympy_is_variable, NULL,
	566	"True if the symbol is a variable." },
f0823d2c TT	567	{ "needs_frame", sympy_needs_frame, NULL,
f0823d2c TT	568	"True if the symbol requires a frame for evaluation." },
64e7d9dd TT	569	{ "line", sympy_line, NULL,
64e7d9dd TT	570	"The source line number at which the symbol was defined." },
f3e9a817 PM	571	{ NULL } /* Sentinel */
	572	};
	573
29703da4 PM	574	static PyMethodDef symbol_object_methods[] = {
	575	{ "is_valid", sympy_is_valid, METH_NOARGS,
	576	"is_valid () -> Boolean.\n\
	577	Return true if this symbol is valid, false if not." },
f0823d2c TT	578	{ "value", sympy_value, METH_VARARGS,
	579	"value ([frame]) -> gdb.Value\n\
	580	Return the value of the symbol." },
29703da4 PM	581	{NULL} /* Sentinel */
	582	};
	583
f3e9a817	584	PyTypeObject symbol_object_type = {
9a27f2c6	585	PyVarObject_HEAD_INIT (NULL, 0)
f3e9a817 PM	586	"gdb.Symbol", /tp_name/
	587	sizeof (symbol_object), /tp_basicsize/
	588	0, /tp_itemsize/
	589	sympy_dealloc, /tp_dealloc/
	590	0, /tp_print/
	591	0, /tp_getattr/
	592	0, /tp_setattr/
	593	0, /tp_compare/
	594	0, /tp_repr/
	595	0, /tp_as_number/
	596	0, /tp_as_sequence/
	597	0, /tp_as_mapping/
	598	0, /tp_hash /
	599	0, /tp_call/
	600	sympy_str, /tp_str/
	601	0, /tp_getattro/
	602	0, /tp_setattro/
	603	0, /tp_as_buffer/
	604	Py_TPFLAGS_DEFAULT, /tp_flags/
	605	"GDB symbol object", /tp_doc /
	606	0, /tp_traverse /
	607	0, /tp_clear /
	608	0, /tp_richcompare /
	609	0, /tp_weaklistoffset /
	610	0, /tp_iter /
	611	0, /tp_iternext /
29703da4	612	symbol_object_methods, /tp_methods /
f3e9a817 PM	613	0, /tp_members /
	614	symbol_object_getset /tp_getset /
	615	};