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