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

/* Python interface to symbols.

   Copyright (C) 2008-2018 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"
#include "py-ref.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 theclass;

  SYMPY_REQUIRE_VALID (self, symbol);

  theclass = SYMBOL_CLASS (symbol);

  return PyBool_FromLong (theclass == LOC_CONST || theclass == LOC_CONST_BYTES);
}

static PyObject *
sympy_is_function (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;
  enum address_class theclass;

  SYMPY_REQUIRE_VALID (self, symbol);

  theclass = SYMBOL_CLASS (symbol);

  return PyBool_FromLong (theclass == LOC_BLOCK);
}

static PyObject *
sympy_is_variable (PyObject *self, void *closure)
{
  struct symbol *symbol = NULL;
  enum address_class theclass;

  SYMPY_REQUIRE_VALID (self, symbol);

  theclass = SYMBOL_CLASS (symbol);

  return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
			  && (theclass == LOC_LOCAL || theclass == LOC_REGISTER
			      || theclass == LOC_STATIC || theclass == LOC_COMPUTED
			      || theclass == 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;
  int result = 0;

  SYMPY_REQUIRE_VALID (self, symbol);

  TRY
    {
      result = symbol_read_needs_frame (symbol);
    }
  CATCH (except, RETURN_MASK_ALL)
    {
      GDB_PY_HANDLE_EXCEPTION (except);
    }
  END_CATCH

  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;

  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
    {
      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"));

      /* TODO: currently, we have no way to recover the block in which SYMBOL
	 was found, so we have no block to pass to read_var_value.  This will
	 yield an incorrect value when symbol is not local to FRAME_INFO (this
	 can happen with nested functions).  */
      value = read_var_value (symbol, NULL, frame_info);
    }
  CATCH (except, RETURN_MASK_ALL)
    {
      GDB_PY_HANDLE_EXCEPTION (except);
    }
  END_CATCH

  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 = ((struct sympy_symbol_object *)
		   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 const char *keywords[] = { "name", "block", "domain", NULL };
  struct symbol *symbol = NULL;
  PyObject *block_obj = NULL, *sym_obj, *bool_obj;
  const struct block *block = NULL;

  if (!gdb_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;

      TRY
	{
	  selected_frame = get_selected_frame (_("No frame selected."));
	  block = get_frame_block (selected_frame, NULL);
	}
      CATCH (except, RETURN_MASK_ALL)
	{
	  GDB_PY_HANDLE_EXCEPTION (except);
	}
      END_CATCH
    }

  TRY
    {
      symbol = lookup_symbol (name, block, (domain_enum) domain,
			      &is_a_field_of_this).symbol;
    }
  CATCH (except, RETURN_MASK_ALL)
    {
      GDB_PY_HANDLE_EXCEPTION (except);
    }
  END_CATCH

  gdbpy_ref<> ret_tuple (PyTuple_New (2));
  if (ret_tuple == NULL)
    return NULL;

  if (symbol)
    {
      sym_obj = symbol_to_symbol_object (symbol);
      if (!sym_obj)
	return NULL;
    }
  else
    {
      sym_obj = Py_None;
      Py_INCREF (Py_None);
    }
  PyTuple_SET_ITEM (ret_tuple.get (), 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.get (), 1, bool_obj);

  return ret_tuple.release ();
}

/* 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 const char *keywords[] = { "name", "domain", NULL };
  struct symbol *symbol = NULL;
  PyObject *sym_obj;

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

  TRY
    {
      symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
    }
  CATCH (except, RETURN_MASK_ALL)
    {
      GDB_PY_HANDLE_EXCEPTION (except);
    }
  END_CATCH

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