gdb/python/py-symbol.c

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