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_symtab (PyObject *self, void *closure)
  70 {
  71   struct symbol *symbol = NULL;
  72
  73   SYMPY_REQUIRE_VALID (self, symbol);
  74
  75   return symtab_to_symtab_object (SYMBOL_SYMTAB (symbol));
  76 }
  77
  78 static PyObject *
  79 sympy_get_name (PyObject *self, void *closure)
  80 {
  81   struct symbol *symbol = NULL;
  82
  83   SYMPY_REQUIRE_VALID (self, symbol);
  84
  85   return PyString_FromString (SYMBOL_NATURAL_NAME (symbol));
  86 }
  87
  88 static PyObject *
  89 sympy_get_linkage_name (PyObject *self, void *closure)
  90 {
  91   struct symbol *symbol = NULL;
  92
  93   SYMPY_REQUIRE_VALID (self, symbol);
  94
  95   return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol));
  96 }
  97
  98 static PyObject *
  99 sympy_get_print_name (PyObject *self, void *closure)
 100 {
 101   struct symbol *symbol = NULL;
 102
 103   SYMPY_REQUIRE_VALID (self, symbol);
 104
 105   return sympy_str (self);
 106 }
 107
 108 static PyObject *
 109 sympy_get_addr_class (PyObject *self, void *closure)
 110 {
 111   struct symbol *symbol = NULL;
 112
 113   SYMPY_REQUIRE_VALID (self, symbol);
 114
 115   return PyInt_FromLong (SYMBOL_CLASS (symbol));
 116 }
 117
 118 static PyObject *
 119 sympy_is_argument (PyObject *self, void *closure)
 120 {
 121   struct symbol *symbol = NULL;
 122
 123   SYMPY_REQUIRE_VALID (self, symbol);
 124
 125   return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol));
 126 }
 127
 128 static PyObject *
 129 sympy_is_constant (PyObject *self, void *closure)
 130 {
 131   struct symbol *symbol = NULL;
 132   enum address_class class;
 133
 134   SYMPY_REQUIRE_VALID (self, symbol);
 135
 136   class = SYMBOL_CLASS (symbol);
 137
 138   return PyBool_FromLong (class == LOC_CONST || class == LOC_CONST_BYTES);
 139 }
 140
 141 static PyObject *
 142 sympy_is_function (PyObject *self, void *closure)
 143 {
 144   struct symbol *symbol = NULL;
 145   enum address_class class;
 146
 147   SYMPY_REQUIRE_VALID (self, symbol);
 148
 149   class = SYMBOL_CLASS (symbol);
 150
 151   return PyBool_FromLong (class == LOC_BLOCK);
 152 }
 153
 154 static PyObject *
 155 sympy_is_variable (PyObject *self, void *closure)
 156 {
 157   struct symbol *symbol = NULL;
 158   enum address_class class;
 159
 160   SYMPY_REQUIRE_VALID (self, symbol);
 161
 162   class = SYMBOL_CLASS (symbol);
 163
 164   return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
 165                           && (class == LOC_LOCAL || class == LOC_REGISTER
 166                               || class == LOC_STATIC || class == LOC_COMPUTED
 167                               || class == LOC_OPTIMIZED_OUT));
 168 }
 169
 170 /* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
 171    Returns True if this Symbol still exists in GDB.  */
 172
 173 static PyObject *
 174 sympy_is_valid (PyObject *self, PyObject *args)
 175 {
 176   struct symbol *symbol = NULL;
 177
 178   symbol = symbol_object_to_symbol (self);
 179   if (symbol == NULL)
 180     Py_RETURN_FALSE;
 181
 182   Py_RETURN_TRUE;
 183 }
 184
 185 /* Given a symbol, and a symbol_object that has previously been
 186    allocated and initialized, populate the symbol_object with the
 187    struct symbol data.  Also, register the symbol_object life-cycle
 188    with the life-cycle of the object file associated with this
 189    symbol, if needed.  */
 190 static void
 191 set_symbol (symbol_object *obj, struct symbol *symbol)
 192 {
 193   obj->symbol = symbol;
 194   obj->prev = NULL;
 195   if (SYMBOL_SYMTAB (symbol))
 196     {
 197       obj->next = objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
 198                                 sympy_objfile_data_key);
 199
 200       if (obj->next)
 201         obj->next->prev = obj;
 202       set_objfile_data (SYMBOL_SYMTAB (symbol)->objfile,
 203                         sympy_objfile_data_key, obj);
 204     }
 205   else
 206     obj->next = NULL;
 207 }
 208
 209 /* Create a new symbol object (gdb.Symbol) that encapsulates the struct
 210    symbol object from GDB.  */
 211 PyObject *
 212 symbol_to_symbol_object (struct symbol *sym)
 213 {
 214   symbol_object *sym_obj;
 215
 216   sym_obj = PyObject_New (symbol_object, &symbol_object_type);
 217   if (sym_obj)
 218     set_symbol (sym_obj, sym);
 219
 220   return (PyObject *) sym_obj;
 221 }
 222
 223 /* Return the symbol that is wrapped by this symbol object.  */
 224 struct symbol *
 225 symbol_object_to_symbol (PyObject *obj)
 226 {
 227   if (! PyObject_TypeCheck (obj, &symbol_object_type))
 228     return NULL;
 229   return ((symbol_object *) obj)->symbol;
 230 }
 231
 232 static void
 233 sympy_dealloc (PyObject *obj)
 234 {
 235   symbol_object *sym_obj = (symbol_object *) obj;
 236
 237   if (sym_obj->prev)
 238     sym_obj->prev->next = sym_obj->next;
 239   else if (SYMBOL_SYMTAB (sym_obj->symbol))
 240     {
 241       set_objfile_data (SYMBOL_SYMTAB (sym_obj->symbol)->objfile,
 242                         sympy_objfile_data_key, sym_obj->next);
 243     }
 244   if (sym_obj->next)
 245     sym_obj->next->prev = sym_obj->prev;
 246   sym_obj->symbol = NULL;
 247 }
 248
 249 /* Implementation of
 250    gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)
 251    A tuple with 2 elements is always returned.  The first is the symbol
 252    object or None, the second is a boolean with the value of
 253    is_a_field_of_this (see comment in lookup_symbol_in_language).  */
 254
 255 PyObject *
 256 gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw)
 257 {
 258   int domain = VAR_DOMAIN, is_a_field_of_this = 0;
 259   const char *name;
 260   static char *keywords[] = { "name", "block", "domain", NULL };
 261   struct symbol *symbol;
 262   PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj;
 263   struct block *block = NULL;
 264
 265   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name,
 266                                      &block_object_type, &block_obj, &domain))
 267     return NULL;
 268
 269   if (block_obj)
 270     block = block_object_to_block (block_obj);
 271   else
 272     {
 273       struct frame_info *selected_frame;
 274       volatile struct gdb_exception except;
 275
 276       TRY_CATCH (except, RETURN_MASK_ALL)
 277         {
 278           selected_frame = get_selected_frame (_("No frame selected."));
 279           block = get_frame_block (selected_frame, NULL);
 280         }
 281       GDB_PY_HANDLE_EXCEPTION (except);
 282     }
 283
 284   symbol = lookup_symbol (name, block, domain, &is_a_field_of_this);
 285
 286   ret_tuple = PyTuple_New (2);
 287   if (!ret_tuple)
 288     return NULL;
 289
 290   if (symbol)
 291     {
 292       sym_obj = symbol_to_symbol_object (symbol);
 293       if (!sym_obj)
 294         {
 295           Py_DECREF (ret_tuple);
 296           return NULL;
 297         }
 298     }
 299   else
 300     {
 301       sym_obj = Py_None;
 302       Py_INCREF (Py_None);
 303     }
 304   PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
 305
 306   bool_obj = is_a_field_of_this? Py_True : Py_False;
 307   Py_INCREF (bool_obj);
 308   PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
 309
 310   return ret_tuple;
 311 }
 312
 313 /* Implementation of
 314    gdb.lookup_global_symbol (name [, domain]) -> symbol or None.  */
 315
 316 PyObject *
 317 gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
 318 {
 319   int domain = VAR_DOMAIN;
 320   const char *name;
 321   static char *keywords[] = { "name", "domain", NULL };
 322   struct symbol *symbol;
 323   PyObject *sym_obj;
 324
 325   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name,
 326                                      &domain))
 327     return NULL;
 328
 329   symbol = lookup_symbol_global (name, NULL, domain);
 330
 331   if (symbol)
 332     {
 333       sym_obj = symbol_to_symbol_object (symbol);
 334       if (!sym_obj)
 335         return NULL;
 336     }
 337   else
 338     {
 339       sym_obj = Py_None;
 340       Py_INCREF (Py_None);
 341     }
 342
 343   return sym_obj;
 344 }
 345
 346 /* This function is called when an objfile is about to be freed.
 347    Invalidate the symbol as further actions on the symbol would result
 348    in bad data.  All access to obj->symbol should be gated by
 349    SYMPY_REQUIRE_VALID which will raise an exception on invalid
 350    symbols.  */
 351 static void
 352 del_objfile_symbols (struct objfile *objfile, void *datum)
 353 {
 354   symbol_object *obj = datum;
 355   while (obj)
 356     {
 357       symbol_object *next = obj->next;
 358
 359       obj->symbol = NULL;
 360       obj->next = NULL;
 361       obj->prev = NULL;
 362
 363       obj = next;
 364     }
 365 }
 366
 367 void
 368 gdbpy_initialize_symbols (void)
 369 {
 370   if (PyType_Ready (&symbol_object_type) < 0)
 371     return;
 372
 373   /* Register an objfile "free" callback so we can properly
 374      invalidate symbol when an object file that is about to be
 375      deleted.  */
 376   sympy_objfile_data_key
 377     = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
 378
 379   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
 380   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
 381   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
 382   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
 383   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
 384   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
 385   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
 386   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
 387   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
 388   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
 389   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
 390                            LOC_CONST_BYTES);
 391   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
 392                            LOC_UNRESOLVED);
 393   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
 394                            LOC_OPTIMIZED_OUT);
 395   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
 396   PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
 397                            LOC_REGPARM_ADDR);
 398   PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
 399   PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
 400   PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
 401   PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
 402   PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
 403                            VARIABLES_DOMAIN);
 404   PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
 405                            FUNCTIONS_DOMAIN);
 406   PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
 407
 408   Py_INCREF (&symbol_object_type);
 409   PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
 410 }
 411
 412 \f
 413
 414 static PyGetSetDef symbol_object_getset[] = {
 415   { "symtab", sympy_get_symtab, NULL,
 416     "Symbol table in which the symbol appears.", NULL },
 417   { "name", sympy_get_name, NULL,
 418     "Name of the symbol, as it appears in the source code.", NULL },
 419   { "linkage_name", sympy_get_linkage_name, NULL,
 420     "Name of the symbol, as used by the linker (i.e., may be mangled).",
 421     NULL },
 422   { "print_name", sympy_get_print_name, NULL,
 423     "Name of the symbol in a form suitable for output.\n\
 424 This is either name or linkage_name, depending on whether the user asked GDB\n\
 425 to display demangled or mangled names.", NULL },
 426   { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
 427   { "is_argument", sympy_is_argument, NULL,
 428     "True if the symbol is an argument of a function." },
 429   { "is_constant", sympy_is_constant, NULL,
 430     "True if the symbol is a constant." },
 431   { "is_function", sympy_is_function, NULL,
 432     "True if the symbol is a function or method." },
 433   { "is_variable", sympy_is_variable, NULL,
 434     "True if the symbol is a variable." },
 435   { NULL }  /* Sentinel */
 436 };
 437
 438 static PyMethodDef symbol_object_methods[] = {
 439   { "is_valid", sympy_is_valid, METH_NOARGS,
 440     "is_valid () -> Boolean.\n\
 441 Return true if this symbol is valid, false if not." },
 442   {NULL}  /* Sentinel */
 443 };
 444
 445 PyTypeObject symbol_object_type = {
 446   PyObject_HEAD_INIT (NULL)
 447   0,                              /*ob_size*/
 448   "gdb.Symbol",                   /*tp_name*/
 449   sizeof (symbol_object),         /*tp_basicsize*/
 450   0,                              /*tp_itemsize*/
 451   sympy_dealloc,                  /*tp_dealloc*/
 452   0,                              /*tp_print*/
 453   0,                              /*tp_getattr*/
 454   0,                              /*tp_setattr*/
 455   0,                              /*tp_compare*/
 456   0,                              /*tp_repr*/
 457   0,                              /*tp_as_number*/
 458   0,                              /*tp_as_sequence*/
 459   0,                              /*tp_as_mapping*/
 460   0,                              /*tp_hash */
 461   0,                              /*tp_call*/
 462   sympy_str,                      /*tp_str*/
 463   0,                              /*tp_getattro*/
 464   0,                              /*tp_setattro*/
 465   0,                              /*tp_as_buffer*/
 466   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 467   "GDB symbol object",            /*tp_doc */
 468   0,                              /*tp_traverse */
 469   0,                              /*tp_clear */
 470   0,                              /*tp_richcompare */
 471   0,                              /*tp_weaklistoffset */
 472   0,                              /*tp_iter */
 473   0,                              /*tp_iternext */
 474   symbol_object_methods,          /*tp_methods */
 475   0,                              /*tp_members */
 476   symbol_object_getset            /*tp_getset */
 477 };