gdb/python/py-symbol.c

   1 /* Python interface to symbols.
   2
   3    Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "block.h"
  22 #include "exceptions.h"
  23 #include "frame.h"
  24 #include "symtab.h"
  25 #include "python-internal.h"
  26 #include "objfiles.h"
  27
  28 typedef struct sympy_symbol_object {
  29   PyObject_HEAD
  30   /* The GDB symbol structure this object is wrapping.  */
  31   struct symbol *symbol;
  32   /* A symbol object is associated with an objfile, so keep track with
  33      doubly-linked list, rooted in the objfile.  This lets us
  34      invalidate the underlying struct symbol when the objfile is
  35      deleted.  */
  36   struct sympy_symbol_object *prev;
  37   struct sympy_symbol_object *next;
  38 } symbol_object;
  39
  40 /* Require a valid symbol.  All access to symbol_object->symbol should be
  41    gated by this call.  */
  42 #define SYMPY_REQUIRE_VALID(symbol_obj, symbol)         \
  43   do {                                                  \
  44     symbol = symbol_object_to_symbol (symbol_obj);      \
  45     if (symbol == NULL)                                 \
  46       {                                                 \
  47         PyErr_SetString (PyExc_RuntimeError,            \
  48                          _("Symbol is invalid."));      \
  49         return NULL;                                    \
  50       }                                                 \
  51   } while (0)
  52
  53 static const struct objfile_data *sympy_objfile_data_key;
  54
  55 static PyObject *
  56 sympy_str (PyObject *self)
  57 {
  58   PyObject *result;
  59   struct symbol *symbol = NULL;
  60
  61   SYMPY_REQUIRE_VALID (self, symbol);
  62
  63   result = PyString_FromString (SYMBOL_PRINT_NAME (symbol));
  64
  65   return result;
  66 }
  67
  68 static PyObject *
  69 sympy_get_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
  84 static PyObject *
  85 sympy_get_symtab (PyObject *self, void *closure)
  86 {
  87   struct symbol *symbol = NULL;
  88
  89   SYMPY_REQUIRE_VALID (self, symbol);
  90
  91   return symtab_to_symtab_object (SYMBOL_SYMTAB (symbol));
  92 }
  93
  94 static PyObject *
  95 sympy_get_name (PyObject *self, void *closure)
  96 {
  97   struct symbol *symbol = NULL;
  98
  99   SYMPY_REQUIRE_VALID (self, symbol);
 100
 101   return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
 102 }
 103
 104 static PyObject *
 105 sympy_get_linkage_name (PyObject *self, void *closure)
 106 {
 107   struct symbol *symbol = NULL;
 108
 109   SYMPY_REQUIRE_VALID (self, symbol);
 110
 111   return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
 112 }
 113
 114 static PyObject *
 115 sympy_get_print_name (PyObject *self, void *closure)
 116 {
 117   struct symbol *symbol = NULL;
 118
 119   SYMPY_REQUIRE_VALID (self, symbol);
 120
 121   return sympy_str (self);
 122 }
 123
 124 static PyObject *
 125 sympy_get_addr_class (PyObject *self, void *closure)
 126 {
 127   struct symbol *symbol = NULL;
 128
 129   SYMPY_REQUIRE_VALID (self, symbol);
 130
 131   return PyInt_FromLong (SYMBOL_CLASS (symbol));
 132 }
 133
 134 static PyObject *
 135 sympy_is_argument (PyObject *self, void *closure)
 136 {
 137   struct symbol *symbol = NULL;
 138
 139   SYMPY_REQUIRE_VALID (self, symbol);
 140
 141   return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
 142 }
 143
 144 static PyObject *
 145 sympy_is_constant (PyObject *self, void *closure)
 146 {
 147   struct symbol *symbol = NULL;
 148   enum address_class class;
 149
 150   SYMPY_REQUIRE_VALID (self, symbol);
 151
 152   class = SYMBOL_CLASS (symbol);
 153
 154   return PyBool_FromLong (class == LOC_CONST || class == LOC_CONST_BYTES);
 155 }
 156
 157 static PyObject *
 158 sympy_is_function (PyObject *self, void *closure)
 159 {
 160   struct symbol *symbol = NULL;
 161   enum address_class class;
 162
 163   SYMPY_REQUIRE_VALID (self, symbol);
 164
 165   class = SYMBOL_CLASS (symbol);
 166
 167   return PyBool_FromLong (class == LOC_BLOCK);
 168 }
 169
 170 static PyObject *
 171 sympy_is_variable (PyObject *self, void *closure)
 172 {
 173   struct symbol *symbol = NULL;
 174   enum address_class class;
 175
 176   SYMPY_REQUIRE_VALID (self, symbol);
 177
 178   class = SYMBOL_CLASS (symbol);
 179
 180   return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
 181                           && (class == LOC_LOCAL || class == LOC_REGISTER
 182                               || class == LOC_STATIC || class == LOC_COMPUTED
 183                               || class == LOC_OPTIMIZED_OUT));
 184 }
 185
 186 /* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
 187    Returns True if this Symbol still exists in GDB.  */
 188
 189 static PyObject *
 190 sympy_is_valid (PyObject *self, PyObject *args)
 191 {
 192   struct symbol *symbol = NULL;
 193
 194   symbol = symbol_object_to_symbol (self);
 195   if (symbol == NULL)
 196     Py_RETURN_FALSE;
 197
 198   Py_RETURN_TRUE;
 199 }
 200
 201 /* Given a symbol, and a symbol_object that has previously been
 202    allocated and initialized, populate the symbol_object with the
 203    struct symbol data.  Also, register the symbol_object life-cycle
 204    with the life-cycle of the object file associated with this
 205    symbol, if needed.  */
 206 static void
 207 set_symbol (symbol_object *obj, struct symbol *symbol)
 208 {
 209   obj->symbol = symbol;
 210   obj->prev = NULL;
 211   if (SYMBOL_SYMTAB (symbol))
 212     {
 213       obj->next = objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
 214                                 sympy_objfile_data_key);
 215
 216       if (obj->next)
 217         obj->next->prev = obj;
 218       set_objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
 219                         sympy_objfile_data_key, obj);
 220     }
 221   else
 222     obj->next = NULL;
 223 }
 224
 225 /* Create a new symbol object (gdb.Symbol) that encapsulates the struct
 226    symbol object from GDB.  */
 227 PyObject *
 228 symbol_to_symbol_object (struct symbol *sym)
 229 {
 230   symbol_object *sym_obj;
 231
 232   sym_obj = PyObject_New (symbol_object, &symbol_object_type);
 233   if (sym_obj)
 234     set_symbol (sym_obj, sym);
 235
 236   return (PyObject *) sym_obj;
 237 }
 238
 239 /* Return the symbol that is wrapped by this symbol object.  */
 240 struct symbol *
 241 symbol_object_to_symbol (PyObject *obj)
 242 {
 243   if (! PyObject_TypeCheck (obj, &symbol_object_type))
 244     return NULL;
 245   return ((symbol_object *) obj)->symbol;
 246 }
 247
 248 static void
 249 sympy_dealloc (PyObject *obj)
 250 {
 251   symbol_object *sym_obj = (symbol_object *) obj;
 252
 253   if (sym_obj->prev)
 254     sym_obj->prev->next = sym_obj->next;
 255   else if (SYMBOL_SYMTAB (sym_obj->symbol))
 256     {
 257       set_objfile_data (SYMBOL_SYMTAB (sym_obj->symbol)->objfile,
 258                         sympy_objfile_data_key, sym_obj->next);
 259     }
 260   if (sym_obj->next)
 261     sym_obj->next->prev = sym_obj->prev;
 262   sym_obj->symbol = NULL;
 263 }
 264
 265 /* Implementation of
 266    gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
 267    A tuple with 2 elements is always returned.  The first is the symbol
 268    object or None, the second is a boolean with the value of
 269    is_a_field_of_this (see comment in lookup_symbol_in_language).  */
 270
 271 PyObject *
 272 gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
 273 {
 274   int domain = VAR_DOMAIN, is_a_field_of_this = 0;
 275   const char *name;
 276   static char *keywords[] = { "name", "block", "domain", NULL };
 277   struct symbol *symbol = NULL;
 278   PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
 279   const struct block *block = NULL;
 280   volatile struct gdb_exception except;
 281
 282   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
 283                                      &block_object_type, &block_obj, &domain))
 284     return NULL;
 285
 286   if (block_obj)
 287     block = block_object_to_block (block_obj);
 288   else
 289     {
 290       struct frame_info *selected_frame;
 291       volatile struct gdb_exception except;
 292
 293       TRY_CATCH (except, RETURN_MASK_ALL)
 294         {
 295           selected_frame = get_selected_frame (_("No frame selected."));
 296           block = get_frame_block (selected_frame, NULL);
 297         }
 298       GDB_PY_HANDLE_EXCEPTION (except);
 299     }
 300
 301   TRY_CATCH (except, RETURN_MASK_ALL)
 302     {
 303       symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
 304     }
 305   GDB_PY_HANDLE_EXCEPTION (except);
 306
 307   ret_tuple = PyTuple_New (2);
 308   if (!ret_tuple)
 309     return NULL;
 310
 311   if (symbol)
 312     {
 313       sym_obj = symbol_to_symbol_object (symbol);
 314       if (!sym_obj)
 315         {
 316           Py_DECREF (ret_tuple);
 317           return NULL;
 318         }
 319     }
 320   else
 321     {
 322       sym_obj = Py_None;
 323       Py_INCREF (Py_None);
 324     }
 325   PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
 326
 327   bool_obj = is_a_field_of_this? Py_True : Py_False;
 328   Py_INCREF (bool_obj);
 329   PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
 330
 331   return ret_tuple;
 332 }
 333
 334 /* Implementation of
 335    gdb.lookup_global_symbol (name [, domain]) -> symbol or None.  */
 336
 337 PyObject *
 338 gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
 339 {
 340   int domain = VAR_DOMAIN;
 341   const char *name;
 342   static char *keywords[] = { "name", "domain", NULL };
 343   struct symbol *symbol = NULL;
 344   PyObject *sym_obj;
 345   volatile struct gdb_exception except;
 346
 347   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
 348                                      &domain))
 349     return NULL;
 350
 351   TRY_CATCH (except, RETURN_MASK_ALL)
 352     {
 353       symbol = lookup_symbol_global (name, NULL, domain);
 354     }
 355   GDB_PY_HANDLE_EXCEPTION (except);
 356
 357   if (symbol)
 358     {
 359       sym_obj = symbol_to_symbol_object (symbol);
 360       if (!sym_obj)
 361         return NULL;
 362     }
 363   else
 364     {
 365       sym_obj = Py_None;
 366       Py_INCREF (Py_None);
 367     }
 368
 369   return sym_obj;
 370 }
 371
 372 /* This function is called when an objfile is about to be freed.
 373    Invalidate the symbol as further actions on the symbol would result
 374    in bad data.  All access to obj->symbol should be gated by
 375    SYMPY_REQUIRE_VALID which will raise an exception on invalid
 376    symbols.  */
 377 static void
 378 del_objfile_symbols (struct objfile *objfile, void *datum)
 379 {
 380   symbol_object *obj = datum;
 381   while (obj)
 382     {
 383       symbol_object *next = obj->next;
 384
 385       obj->symbol = NULL;
 386       obj->next = NULL;
 387       obj->prev = NULL;
 388
 389       obj = next;
 390     }
 391 }
 392
 393 void
 394 gdbpy_initialize_symbols (void)
 395 {
 396   if (PyType_Ready (&symbol_object_type) < 0)
 397     return;
 398
 399   /* Register an objfile "free" callback so we can properly
 400      invalidate symbol when an object file that is about to be
 401      deleted.  */
 402   sympy_objfile_data_key
 403     = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
 404
 405   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
 406   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
 407   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
 408   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
 409   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
 410   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
 411   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
 412   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
 413   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
 414   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
 415   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
 416                            LOC_CONST_BYTES);
 417   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
 418                            LOC_UNRESOLVED);
 419   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
 420                            LOC_OPTIMIZED_OUT);
 421   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
 422   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
 423                            LOC_REGPARM_ADDR);
 424   PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
 425   PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
 426   PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
 427   PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
 428   PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
 429                            VARIABLES_DOMAIN);
 430   PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
 431                            FUNCTIONS_DOMAIN);
 432   PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
 433
 434   Py_INCREF (&symbol_object_type);
 435   PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
 436 }
 437
 438 \f
 439
 440 static PyGetSetDef symbol_object_getset[] = {
 441   { "type", sympy_get_type, NULL,
 442     "Type of the symbol.", NULL },
 443   { "symtab", sympy_get_symtab, NULL,
 444     "Symbol table in which the symbol appears.", NULL },
 445   { "name", sympy_get_name, NULL,
 446     "Name of the symbol, as it appears in the source code.", NULL },
 447   { "linkage_name", sympy_get_linkage_name, NULL,
 448     "Name of the symbol, as used by the linker (i.e., may be mangled).",
 449     NULL },
 450   { "print_name", sympy_get_print_name, NULL,
 451     "Name of the symbol in a form suitable for output.\n\
 452 This is either name or linkage_name, depending on whether the user asked GDB\n\
 453 to display demangled or mangled names.", NULL },
 454   { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
 455   { "is_argument", sympy_is_argument, NULL,
 456     "True if the symbol is an argument of a function." },
 457   { "is_constant", sympy_is_constant, NULL,
 458     "True if the symbol is a constant." },
 459   { "is_function", sympy_is_function, NULL,
 460     "True if the symbol is a function or method." },
 461   { "is_variable", sympy_is_variable, NULL,
 462     "True if the symbol is a variable." },
 463   { NULL }  /* Sentinel */
 464 };
 465
 466 static PyMethodDef symbol_object_methods[] = {
 467   { "is_valid", sympy_is_valid, METH_NOARGS,
 468     "is_valid () -> Boolean.\n\
 469 Return true if this symbol is valid, false if not." },
 470   {NULL}  /* Sentinel */
 471 };
 472
 473 PyTypeObject symbol_object_type = {
 474   PyObject_HEAD_INIT (NULL)
 475   0,                              /*ob_size*/
 476   "gdb.Symbol",                   /*tp_name*/
 477   sizeof (symbol_object),         /*tp_basicsize*/
 478   0,                              /*tp_itemsize*/
 479   sympy_dealloc,                  /*tp_dealloc*/
 480   0,                              /*tp_print*/
 481   0,                              /*tp_getattr*/
 482   0,                              /*tp_setattr*/
 483   0,                              /*tp_compare*/
 484   0,                              /*tp_repr*/
 485   0,                              /*tp_as_number*/
 486   0,                              /*tp_as_sequence*/
 487   0,                              /*tp_as_mapping*/
 488   0,                              /*tp_hash */
 489   0,                              /*tp_call*/
 490   sympy_str,                      /*tp_str*/
 491   0,                              /*tp_getattro*/
 492   0,                              /*tp_setattro*/
 493   0,                              /*tp_as_buffer*/
 494   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 495   "GDB symbol object",            /*tp_doc */
 496   0,                              /*tp_traverse */
 497   0,                              /*tp_clear */
 498   0,                              /*tp_richcompare */
 499   0,                              /*tp_weaklistoffset */
 500   0,                              /*tp_iter */
 501   0,                              /*tp_iternext */
 502   symbol_object_methods,          /*tp_methods */
 503   0,                              /*tp_members */
 504   symbol_object_getset            /*tp_getset */
 505 };