gdb/python/py-symtab.c

   1 /* Python interface to symbol tables.
   2
   3    Copyright (C) 2008-2013 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 "charset.h"
  22 #include "symtab.h"
  23 #include "source.h"
  24 #include "python-internal.h"
  25 #include "objfiles.h"
  26 #include "block.h"
  27
  28 typedef struct stpy_symtab_object {
  29   PyObject_HEAD
  30   /* The GDB Symbol table structure.  */
  31   struct symtab *symtab;
  32   /* A symtab object is associated with an objfile, so keep track with
  33      a doubly-linked list, rooted in the objfile.  This allows
  34      invalidation of the underlying struct symtab when the objfile is
  35      deleted.  */
  36   struct stpy_symtab_object *prev;
  37   struct stpy_symtab_object *next;
  38 } symtab_object;
  39
  40 static PyTypeObject symtab_object_type;
  41 static const struct objfile_data *stpy_objfile_data_key;
  42
  43 /* Require a valid symbol table.  All access to symtab_object->symtab
  44    should be gated by this call.  */
  45 #define STPY_REQUIRE_VALID(symtab_obj, symtab)           \
  46   do {                                                   \
  47     symtab = symtab_object_to_symtab (symtab_obj);       \
  48     if (symtab == NULL)                                  \
  49       {                                                  \
  50         PyErr_SetString (PyExc_RuntimeError,             \
  51                          _("Symbol Table is invalid.")); \
  52         return NULL;                                     \
  53       }                                                  \
  54   } while (0)
  55
  56 typedef struct salpy_sal_object {
  57   PyObject_HEAD
  58   /* The GDB Symbol table structure.  */
  59   symtab_object *symtab;
  60   /* The GDB Symbol table and line structure.  */
  61   struct symtab_and_line *sal;
  62   /* A Symtab and line object is associated with an objfile, so keep
  63      track with a doubly-linked list, rooted in the objfile.  This
  64      allows invalidation of the underlying struct symtab_and_line
  65      when the objfile is deleted.  */
  66   struct salpy_sal_object *prev;
  67   struct salpy_sal_object *next;
  68 } sal_object;
  69
  70 static PyTypeObject sal_object_type;
  71 static const struct objfile_data *salpy_objfile_data_key;
  72
  73 /* Require a valid symbol table and line object.  All access to
  74    sal_object->sal should be gated by this call.  */
  75 #define SALPY_REQUIRE_VALID(sal_obj, sal)                               \
  76   do {                                                                  \
  77     sal = sal_object_to_symtab_and_line (sal_obj);                      \
  78     if (sal == NULL)                                                    \
  79       {                                                                 \
  80           PyErr_SetString (PyExc_RuntimeError,                          \
  81                            _("Symbol Table and Line is invalid."));     \
  82           return NULL;                                                  \
  83         }                                                               \
  84   } while (0)
  85
  86 static PyObject *
  87 stpy_str (PyObject *self)
  88 {
  89   PyObject *result;
  90   struct symtab *symtab = NULL;
  91
  92   STPY_REQUIRE_VALID (self, symtab);
  93
  94   result = PyString_FromString (symtab_to_filename_for_display (symtab));
  95
  96   return result;
  97 }
  98
  99 static PyObject *
 100 stpy_get_filename (PyObject *self, void *closure)
 101 {
 102   PyObject *str_obj;
 103   struct symtab *symtab = NULL;
 104   const char *filename;
 105
 106   STPY_REQUIRE_VALID (self, symtab);
 107   filename = symtab_to_filename_for_display (symtab);
 108
 109   str_obj = PyString_Decode (filename, strlen (filename),
 110                              host_charset (), NULL);
 111   return str_obj;
 112 }
 113
 114 static PyObject *
 115 stpy_get_objfile (PyObject *self, void *closure)
 116 {
 117   struct symtab *symtab = NULL;
 118   PyObject *result;
 119
 120   STPY_REQUIRE_VALID (self, symtab);
 121
 122   result = objfile_to_objfile_object (symtab->objfile);
 123   Py_XINCREF (result);
 124   return result;
 125 }
 126
 127 static PyObject *
 128 stpy_fullname (PyObject *self, PyObject *args)
 129 {
 130   const char *fullname;
 131   struct symtab *symtab = NULL;
 132
 133   STPY_REQUIRE_VALID (self, symtab);
 134
 135   fullname = symtab_to_fullname (symtab);
 136
 137   return PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
 138 }
 139
 140 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
 141    Returns True if this Symbol table still exists in GDB.  */
 142
 143 static PyObject *
 144 stpy_is_valid (PyObject *self, PyObject *args)
 145 {
 146   struct symtab *symtab = NULL;
 147
 148   symtab = symtab_object_to_symtab (self);
 149   if (symtab == NULL)
 150     Py_RETURN_FALSE;
 151
 152   Py_RETURN_TRUE;
 153 }
 154
 155 /* Return the GLOBAL_BLOCK of the underlying symtab.  */
 156
 157 static PyObject *
 158 stpy_global_block (PyObject *self, PyObject *args)
 159 {
 160   struct symtab *symtab = NULL;
 161   struct block *block = NULL;
 162   struct blockvector *blockvector;
 163
 164   STPY_REQUIRE_VALID (self, symtab);
 165
 166   blockvector = BLOCKVECTOR (symtab);
 167   block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
 168   return block_to_block_object (block, symtab->objfile);
 169 }
 170
 171 /* Return the STATIC_BLOCK of the underlying symtab.  */
 172
 173 static PyObject *
 174 stpy_static_block (PyObject *self, PyObject *args)
 175 {
 176   struct symtab *symtab = NULL;
 177   struct block *block = NULL;
 178   struct blockvector *blockvector;
 179
 180   STPY_REQUIRE_VALID (self, symtab);
 181
 182   blockvector = BLOCKVECTOR (symtab);
 183   block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
 184   return block_to_block_object (block, symtab->objfile);
 185 }
 186
 187 static PyObject *
 188 salpy_str (PyObject *self)
 189 {
 190   char *s;
 191   const char *filename;
 192   sal_object *sal_obj;
 193   PyObject *result;
 194   struct symtab_and_line *sal = NULL;
 195
 196   SALPY_REQUIRE_VALID (self, sal);
 197
 198   sal_obj = (sal_object *) self;
 199   filename = (sal_obj->symtab == (symtab_object *) Py_None)
 200     ? "<unknown>" : symtab_to_filename_for_display (sal_obj->symtab->symtab);
 201
 202   s = xstrprintf ("symbol and line for %s, line %d", filename,
 203                   sal->line);
 204
 205   result = PyString_FromString (s);
 206   xfree (s);
 207
 208   return result;
 209 }
 210
 211 static void
 212 stpy_dealloc (PyObject *obj)
 213 {
 214   symtab_object *symtab = (symtab_object *) obj;
 215
 216   if (symtab->prev)
 217     symtab->prev->next = symtab->next;
 218   else if (symtab->symtab)
 219     {
 220       set_objfile_data (symtab->symtab->objfile,
 221                         stpy_objfile_data_key, symtab->next);
 222     }
 223   if (symtab->next)
 224     symtab->next->prev = symtab->prev;
 225   symtab->symtab = NULL;
 226 }
 227
 228
 229 static PyObject *
 230 salpy_get_pc (PyObject *self, void *closure)
 231 {
 232   struct symtab_and_line *sal = NULL;
 233
 234   SALPY_REQUIRE_VALID (self, sal);
 235
 236   return gdb_py_long_from_ulongest (sal->pc);
 237 }
 238
 239 /* Implementation of the get method for the 'last' attribute of
 240    gdb.Symtab_and_line.  */
 241
 242 static PyObject *
 243 salpy_get_last (PyObject *self, void *closure)
 244 {
 245   struct symtab_and_line *sal = NULL;
 246
 247   SALPY_REQUIRE_VALID (self, sal);
 248
 249   if (sal->end > 0)
 250     return gdb_py_long_from_ulongest (sal->end - 1);
 251   else
 252     Py_RETURN_NONE;
 253 }
 254
 255 static PyObject *
 256 salpy_get_line (PyObject *self, void *closure)
 257 {
 258   struct symtab_and_line *sal = NULL;
 259
 260   SALPY_REQUIRE_VALID (self, sal);
 261
 262   return PyInt_FromLong (sal->line);
 263 }
 264
 265 static PyObject *
 266 salpy_get_symtab (PyObject *self, void *closure)
 267 {
 268   struct symtab_and_line *sal;
 269   sal_object *self_sal = (sal_object *) self;
 270
 271   SALPY_REQUIRE_VALID (self, sal);
 272
 273   Py_INCREF (self_sal->symtab);
 274
 275   return (PyObject *) self_sal->symtab;
 276 }
 277
 278 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
 279    Returns True if this Symbol table and line object still exists GDB.  */
 280
 281 static PyObject *
 282 salpy_is_valid (PyObject *self, PyObject *args)
 283 {
 284   struct symtab_and_line *sal;
 285
 286   sal = sal_object_to_symtab_and_line (self);
 287   if (sal == NULL)
 288     Py_RETURN_FALSE;
 289
 290   Py_RETURN_TRUE;
 291 }
 292
 293 static void
 294 salpy_dealloc (PyObject *self)
 295 {
 296   sal_object *self_sal = (sal_object *) self;
 297
 298   if (self_sal->prev)
 299     self_sal->prev->next = self_sal->next;
 300   else if (self_sal->symtab != (symtab_object * ) Py_None)
 301     set_objfile_data (self_sal->symtab->symtab->objfile,
 302                       salpy_objfile_data_key, self_sal->next);
 303
 304   if (self_sal->next)
 305     self_sal->next->prev = self_sal->prev;
 306
 307   Py_DECREF (self_sal->symtab);
 308   xfree (self_sal->sal);
 309   Py_TYPE (self)->tp_free (self);
 310 }
 311
 312 /* Given a sal, and a sal_object that has previously been allocated
 313    and initialized, populate the sal_object with the struct sal data.
 314    Also, register the sal_object life-cycle with the life-cycle of the
 315    object file associated with this sal, if needed.  If a failure
 316    occurs during the sal population, this function will return
 317    NULL.  */
 318 static int
 319 set_sal (sal_object *sal_obj, struct symtab_and_line sal)
 320 {
 321   symtab_object *symtab_obj;
 322
 323   if (sal.symtab)
 324     {
 325       symtab_obj = (symtab_object *) symtab_to_symtab_object  (sal.symtab);
 326       /* If a symtab existed in the sal, but it cannot be duplicated,
 327          we exit.  */
 328       if (symtab_obj == NULL)
 329         return 0;
 330     }
 331   else
 332     {
 333       symtab_obj = (symtab_object *) Py_None;
 334       Py_INCREF (Py_None);
 335     }
 336
 337   sal_obj->sal = xmemdup (&sal, sizeof (struct symtab_and_line),
 338                           sizeof (struct symtab_and_line));
 339   sal_obj->symtab = symtab_obj;
 340   sal_obj->prev = NULL;
 341
 342   /* If the SAL does not have a symtab, we do not add it to the
 343      objfile cleanup observer linked list.  */
 344   if (sal_obj->symtab != (symtab_object *)Py_None)
 345     {
 346       sal_obj->next = objfile_data (sal_obj->symtab->symtab->objfile,
 347                                     salpy_objfile_data_key);
 348       if (sal_obj->next)
 349         sal_obj->next->prev = sal_obj;
 350
 351       set_objfile_data (sal_obj->symtab->symtab->objfile,
 352                         salpy_objfile_data_key, sal_obj);
 353     }
 354   else
 355     sal_obj->next = NULL;
 356
 357   return 1;
 358 }
 359
 360 /* Given a symtab, and a symtab_object that has previously been
 361    allocated and initialized, populate the symtab_object with the
 362    struct symtab data.  Also, register the symtab_object life-cycle
 363    with the life-cycle of the object file associated with this
 364    symtab, if needed.  */
 365 static void
 366 set_symtab (symtab_object *obj, struct symtab *symtab)
 367 {
 368   obj->symtab = symtab;
 369   obj->prev = NULL;
 370   if (symtab)
 371     {
 372       obj->next = objfile_data (symtab->objfile, stpy_objfile_data_key);
 373       if (obj->next)
 374         obj->next->prev = obj;
 375       set_objfile_data (symtab->objfile, stpy_objfile_data_key, obj);
 376     }
 377   else
 378     obj->next = NULL;
 379 }
 380
 381 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
 382    symtab structure from GDB.  */
 383 PyObject *
 384 symtab_to_symtab_object (struct symtab *symtab)
 385 {
 386   symtab_object *symtab_obj;
 387
 388   symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
 389   if (symtab_obj)
 390     set_symtab (symtab_obj, symtab);
 391
 392   return (PyObject *) symtab_obj;
 393 }
 394
 395 /* Create a new symtab and line (gdb.Symtab_and_line) object
 396    that encapsulates the symtab_and_line structure from GDB.  */
 397 PyObject *
 398 symtab_and_line_to_sal_object (struct symtab_and_line sal)
 399
 400 {
 401   sal_object *sal_obj;
 402   int success = 0;
 403
 404   sal_obj = PyObject_New (sal_object, &sal_object_type);
 405   if (sal_obj)
 406     {
 407       success = set_sal (sal_obj, sal);
 408       if (!success)
 409         {
 410           Py_DECREF (sal_obj);
 411           return NULL;
 412         }
 413     }
 414
 415   return (PyObject *) sal_obj;
 416 }
 417
 418 /* Return struct symtab_and_line reference that is wrapped by this
 419    object.  */
 420 struct symtab_and_line *
 421 sal_object_to_symtab_and_line (PyObject *obj)
 422 {
 423   if (! PyObject_TypeCheck (obj, &sal_object_type))
 424     return NULL;
 425   return ((sal_object *) obj)->sal;
 426 }
 427
 428 /* Return struct symtab reference that is wrapped by this object.  */
 429 struct symtab *
 430 symtab_object_to_symtab (PyObject *obj)
 431 {
 432   if (! PyObject_TypeCheck (obj, &symtab_object_type))
 433     return NULL;
 434   return ((symtab_object *) obj)->symtab;
 435 }
 436
 437 /* This function is called when an objfile is about to be freed.
 438    Invalidate the symbol table as further actions on the symbol table
 439    would result in bad data.  All access to obj->symtab should be
 440    gated by STPY_REQUIRE_VALID which will raise an exception on
 441    invalid symbol tables.  */
 442 static void
 443 del_objfile_symtab (struct objfile *objfile, void *datum)
 444 {
 445   symtab_object *obj = datum;
 446
 447   while (obj)
 448     {
 449       symtab_object *next = obj->next;
 450
 451       obj->symtab = NULL;
 452       obj->next = NULL;
 453       obj->prev = NULL;
 454       obj = next;
 455     }
 456 }
 457
 458 /* This function is called when an objfile is about to be freed.
 459    Invalidate the sal object as further actions on the sal
 460    would result in bad data.  All access to obj->sal should be
 461    gated by SALPY_REQUIRE_VALID which will raise an exception on
 462    invalid symbol table and line objects.  */
 463 static void
 464 del_objfile_sal (struct objfile *objfile, void *datum)
 465 {
 466   sal_object *obj = datum;
 467
 468   while (obj)
 469     {
 470       sal_object *next = obj->next;
 471
 472       Py_DECREF (obj->symtab);
 473       obj->symtab = (symtab_object *) Py_None;
 474       Py_INCREF (Py_None);
 475
 476       obj->next = NULL;
 477       obj->prev = NULL;
 478       xfree (obj->sal);
 479       obj->sal = NULL;
 480
 481       obj = next;
 482     }
 483 }
 484
 485 void
 486 gdbpy_initialize_symtabs (void)
 487 {
 488   symtab_object_type.tp_new = PyType_GenericNew;
 489   if (PyType_Ready (&symtab_object_type) < 0)
 490     return;
 491
 492   sal_object_type.tp_new = PyType_GenericNew;
 493   if (PyType_Ready (&sal_object_type) < 0)
 494     return;
 495
 496   /* Register an objfile "free" callback so we can properly
 497      invalidate symbol tables, and symbol table and line data
 498      structures when an object file that is about to be
 499      deleted.  */
 500   stpy_objfile_data_key
 501     = register_objfile_data_with_cleanup (NULL, del_objfile_symtab);
 502   salpy_objfile_data_key
 503     = register_objfile_data_with_cleanup (NULL, del_objfile_sal);
 504
 505   Py_INCREF (&symtab_object_type);
 506   PyModule_AddObject (gdb_module, "Symtab",
 507                       (PyObject *) &symtab_object_type);
 508
 509   Py_INCREF (&sal_object_type);
 510   PyModule_AddObject (gdb_module, "Symtab_and_line",
 511                       (PyObject *) &sal_object_type);
 512 }
 513
 514 \f
 515
 516 static PyGetSetDef symtab_object_getset[] = {
 517   { "filename", stpy_get_filename, NULL,
 518     "The symbol table's source filename.", NULL },
 519   { "objfile", stpy_get_objfile, NULL, "The symtab's objfile.",
 520     NULL },
 521   {NULL}  /* Sentinel */
 522 };
 523
 524 static PyMethodDef symtab_object_methods[] = {
 525   { "is_valid", stpy_is_valid, METH_NOARGS,
 526     "is_valid () -> Boolean.\n\
 527 Return true if this symbol table is valid, false if not." },
 528   { "fullname", stpy_fullname, METH_NOARGS,
 529     "fullname () -> String.\n\
 530 Return the symtab's full source filename." },
 531   { "global_block", stpy_global_block, METH_NOARGS,
 532     "global_block () -> gdb.Block.\n\
 533 Return the global block of the symbol table." },
 534   { "static_block", stpy_static_block, METH_NOARGS,
 535     "static_block () -> gdb.Block.\n\
 536 Return the static block of the symbol table." },
 537   {NULL}  /* Sentinel */
 538 };
 539
 540 static PyTypeObject symtab_object_type = {
 541   PyVarObject_HEAD_INIT (NULL, 0)
 542   "gdb.Symtab",                   /*tp_name*/
 543   sizeof (symtab_object),         /*tp_basicsize*/
 544   0,                              /*tp_itemsize*/
 545   stpy_dealloc,                   /*tp_dealloc*/
 546   0,                              /*tp_print*/
 547   0,                              /*tp_getattr*/
 548   0,                              /*tp_setattr*/
 549   0,                              /*tp_compare*/
 550   0,                              /*tp_repr*/
 551   0,                              /*tp_as_number*/
 552   0,                              /*tp_as_sequence*/
 553   0,                              /*tp_as_mapping*/
 554   0,                              /*tp_hash */
 555   0,                              /*tp_call*/
 556   stpy_str,                       /*tp_str*/
 557   0,                              /*tp_getattro*/
 558   0,                              /*tp_setattro*/
 559   0,                              /*tp_as_buffer*/
 560   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 561   "GDB symtab object",            /*tp_doc */
 562   0,                              /*tp_traverse */
 563   0,                              /*tp_clear */
 564   0,                              /*tp_richcompare */
 565   0,                              /*tp_weaklistoffset */
 566   0,                              /*tp_iter */
 567   0,                              /*tp_iternext */
 568   symtab_object_methods,          /*tp_methods */
 569   0,                              /*tp_members */
 570   symtab_object_getset            /*tp_getset */
 571 };
 572
 573 static PyGetSetDef sal_object_getset[] = {
 574   { "symtab", salpy_get_symtab, NULL, "Symtab object.", NULL },
 575   { "pc", salpy_get_pc, NULL, "Return the symtab_and_line's pc.", NULL },
 576   { "last", salpy_get_last, NULL,
 577     "Return the symtab_and_line's last address.", NULL },
 578   { "line", salpy_get_line, NULL,
 579     "Return the symtab_and_line's line.", NULL },
 580   {NULL}  /* Sentinel */
 581 };
 582
 583 static PyMethodDef sal_object_methods[] = {
 584   { "is_valid", salpy_is_valid, METH_NOARGS,
 585     "is_valid () -> Boolean.\n\
 586 Return true if this symbol table and line is valid, false if not." },
 587   {NULL}  /* Sentinel */
 588 };
 589
 590 static PyTypeObject sal_object_type = {
 591   PyVarObject_HEAD_INIT (NULL, 0)
 592   "gdb.Symtab_and_line",          /*tp_name*/
 593   sizeof (sal_object),            /*tp_basicsize*/
 594   0,                              /*tp_itemsize*/
 595   salpy_dealloc,                  /*tp_dealloc*/
 596   0,                              /*tp_print*/
 597   0,                              /*tp_getattr*/
 598   0,                              /*tp_setattr*/
 599   0,                              /*tp_compare*/
 600   0,                              /*tp_repr*/
 601   0,                              /*tp_as_number*/
 602   0,                              /*tp_as_sequence*/
 603   0,                              /*tp_as_mapping*/
 604   0,                              /*tp_hash */
 605   0,                              /*tp_call*/
 606   salpy_str,                      /*tp_str*/
 607   0,                              /*tp_getattro*/
 608   0,                              /*tp_setattro*/
 609   0,                              /*tp_as_buffer*/
 610   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 611   "GDB symtab_and_line object",   /*tp_doc */
 612   0,                              /*tp_traverse */
 613   0,                              /*tp_clear */
 614   0,                              /*tp_richcompare */
 615   0,                              /*tp_weaklistoffset */
 616   0,                              /*tp_iter */
 617   0,                              /*tp_iternext */
 618   sal_object_methods,             /*tp_methods */
 619   0,                              /*tp_members */
 620   sal_object_getset               /*tp_getset */
 621 };