gdb/python/py-symbol.c

gdb/python/py-symbol.c - gdb

Source code

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

}







‌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 */

};
gdb/python/py-symbol.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code
