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     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symtab_object");
  42 static const struct objfile_data *stpy_objfile_data_key;
  43
  44 /* Require a valid symbol table.  All access to symtab_object->symtab
  45    should be gated by this call.  */
  46 #define STPY_REQUIRE_VALID(symtab_obj, symtab)           \
  47   do {                                                   \
  48     symtab = symtab_object_to_symtab (symtab_obj);       \
  49     if (symtab == NULL)                                  \
  50       {                                                  \
  51         PyErr_SetString (PyExc_RuntimeError,             \
  52                          _("Symbol Table is invalid.")); \
  53         return NULL;                                     \
  54       }                                                  \
  55   } while (0)
  56
  57 typedef struct salpy_sal_object {
  58   PyObject_HEAD
  59   /* The GDB Symbol table structure.  */
  60   symtab_object *symtab;
  61   /* The GDB Symbol table and line structure.  */
  62   struct symtab_and_line *sal;
  63   /* A Symtab and line object is associated with an objfile, so keep
  64      track with a doubly-linked list, rooted in the objfile.  This
  65      allows invalidation of the underlying struct symtab_and_line
  66      when the objfile is deleted.  */
  67   struct salpy_sal_object *prev;
  68   struct salpy_sal_object *next;
  69 } sal_object;
  70
  71 static PyTypeObject sal_object_type
  72     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("sal_object");
  73 static const struct objfile_data *salpy_objfile_data_key;
  74
  75 /* Require a valid symbol table and line object.  All access to
  76    sal_object->sal should be gated by this call.  */
  77 #define SALPY_REQUIRE_VALID(sal_obj, sal)                               \
  78   do {                                                                  \
  79     sal = sal_object_to_symtab_and_line (sal_obj);                      \
  80     if (sal == NULL)                                                    \
  81       {                                                                 \
  82           PyErr_SetString (PyExc_RuntimeError,                          \
  83                            _("Symbol Table and Line is invalid."));     \
  84           return NULL;                                                  \
  85         }                                                               \
  86   } while (0)
  87
  88 static PyObject *
  89 stpy_str (PyObject *self)
  90 {
  91   PyObject *result;
  92   struct symtab *symtab = NULL;
  93
  94   STPY_REQUIRE_VALID (self, symtab);
  95
  96   result = PyString_FromString (symtab_to_filename_for_display (symtab));
  97
  98   return result;
  99 }
 100
 101 static PyObject *
 102 stpy_get_filename (PyObject *self, void *closure)
 103 {
 104   PyObject *str_obj;
 105   struct symtab *symtab = NULL;
 106   const char *filename;
 107
 108   STPY_REQUIRE_VALID (self, symtab);
 109   filename = symtab_to_filename_for_display (symtab);
 110
 111   str_obj = PyString_Decode (filename, strlen (filename),
 112                              host_charset (), NULL);
 113   return str_obj;
 114 }
 115
 116 static PyObject *
 117 stpy_get_objfile (PyObject *self, void *closure)
 118 {
 119   struct symtab *symtab = NULL;
 120   PyObject *result;
 121
 122   STPY_REQUIRE_VALID (self, symtab);
 123
 124   result = objfile_to_objfile_object (symtab->objfile);
 125   Py_XINCREF (result);
 126   return result;
 127 }
 128
 129 static PyObject *
 130 stpy_fullname (PyObject *self, PyObject *args)
 131 {
 132   const char *fullname;
 133   struct symtab *symtab = NULL;
 134
 135   STPY_REQUIRE_VALID (self, symtab);
 136
 137   fullname = symtab_to_fullname (symtab);
 138
 139   return PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
 140 }
 141
 142 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
 143    Returns True if this Symbol table still exists in GDB.  */
 144
 145 static PyObject *
 146 stpy_is_valid (PyObject *self, PyObject *args)
 147 {
 148   struct symtab *symtab = NULL;
 149
 150   symtab = symtab_object_to_symtab (self);
 151   if (symtab == NULL)
 152     Py_RETURN_FALSE;
 153
 154   Py_RETURN_TRUE;
 155 }
 156
 157 /* Return the GLOBAL_BLOCK of the underlying symtab.  */
 158
 159 static PyObject *
 160 stpy_global_block (PyObject *self, PyObject *args)
 161 {
 162   struct symtab *symtab = NULL;
 163   struct block *block = NULL;
 164   struct blockvector *blockvector;
 165
 166   STPY_REQUIRE_VALID (self, symtab);
 167
 168   blockvector = BLOCKVECTOR (symtab);
 169   block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
 170   return block_to_block_object (block, symtab->objfile);
 171 }
 172
 173 /* Return the STATIC_BLOCK of the underlying symtab.  */
 174
 175 static PyObject *
 176 stpy_static_block (PyObject *self, PyObject *args)
 177 {
 178   struct symtab *symtab = NULL;
 179   struct block *block = NULL;
 180   struct blockvector *blockvector;
 181
 182   STPY_REQUIRE_VALID (self, symtab);
 183
 184   blockvector = BLOCKVECTOR (symtab);
 185   block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
 186   return block_to_block_object (block, symtab->objfile);
 187 }
 188
 189 static PyObject *
 190 salpy_str (PyObject *self)
 191 {
 192   char *s;
 193   const char *filename;
 194   sal_object *sal_obj;
 195   PyObject *result;
 196   struct symtab_and_line *sal = NULL;
 197
 198   SALPY_REQUIRE_VALID (self, sal);
 199
 200   sal_obj = (sal_object *) self;
 201   filename = (sal_obj->symtab == (symtab_object *) Py_None)
 202     ? "<unknown>" : symtab_to_filename_for_display (sal_obj->symtab->symtab);
 203
 204   s = xstrprintf ("symbol and line for %s, line %d", filename,
 205                   sal->line);
 206
 207   result = PyString_FromString (s);
 208   xfree (s);
 209
 210   return result;
 211 }
 212
 213 static void
 214 stpy_dealloc (PyObject *obj)
 215 {
 216   symtab_object *symtab = (symtab_object *) obj;
 217
 218   if (symtab->prev)
 219     symtab->prev->next = symtab->next;
 220   else if (symtab->symtab)
 221     {
 222       set_objfile_data (symtab->symtab->objfile,
 223                         stpy_objfile_data_key, symtab->next);
 224     }
 225   if (symtab->next)
 226     symtab->next->prev = symtab->prev;
 227   symtab->symtab = NULL;
 228 }
 229
 230
 231 static PyObject *
 232 salpy_get_pc (PyObject *self, void *closure)
 233 {
 234   struct symtab_and_line *sal = NULL;
 235
 236   SALPY_REQUIRE_VALID (self, sal);
 237
 238   return gdb_py_long_from_ulongest (sal->pc);
 239 }
 240
 241 /* Implementation of the get method for the 'last' attribute of
 242    gdb.Symtab_and_line.  */
 243
 244 static PyObject *
 245 salpy_get_last (PyObject *self, void *closure)
 246 {
 247   struct symtab_and_line *sal = NULL;
 248
 249   SALPY_REQUIRE_VALID (self, sal);
 250
 251   if (sal->end > 0)
 252     return gdb_py_long_from_ulongest (sal->end - 1);
 253   else
 254     Py_RETURN_NONE;
 255 }
 256
 257 static PyObject *
 258 salpy_get_line (PyObject *self, void *closure)
 259 {
 260   struct symtab_and_line *sal = NULL;
 261
 262   SALPY_REQUIRE_VALID (self, sal);
 263
 264   return PyInt_FromLong (sal->line);
 265 }
 266
 267 static PyObject *
 268 salpy_get_symtab (PyObject *self, void *closure)
 269 {
 270   struct symtab_and_line *sal;
 271   sal_object *self_sal = (sal_object *) self;
 272
 273   SALPY_REQUIRE_VALID (self, sal);
 274
 275   Py_INCREF (self_sal->symtab);
 276
 277   return (PyObject *) self_sal->symtab;
 278 }
 279
 280 /* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
 281    Returns True if this Symbol table and line object still exists GDB.  */
 282
 283 static PyObject *
 284 salpy_is_valid (PyObject *self, PyObject *args)
 285 {
 286   struct symtab_and_line *sal;
 287
 288   sal = sal_object_to_symtab_and_line (self);
 289   if (sal == NULL)
 290     Py_RETURN_FALSE;
 291
 292   Py_RETURN_TRUE;
 293 }
 294
 295 static void
 296 salpy_dealloc (PyObject *self)
 297 {
 298   sal_object *self_sal = (sal_object *) self;
 299
 300   if (self_sal->prev)
 301     self_sal->prev->next = self_sal->next;
 302   else if (self_sal->symtab != (symtab_object * ) Py_None)
 303     set_objfile_data (self_sal->symtab->symtab->objfile,
 304                       salpy_objfile_data_key, self_sal->next);
 305
 306   if (self_sal->next)
 307     self_sal->next->prev = self_sal->prev;
 308
 309   Py_DECREF (self_sal->symtab);
 310   xfree (self_sal->sal);
 311   Py_TYPE (self)->tp_free (self);
 312 }
 313
 314 /* Given a sal, and a sal_object that has previously been allocated
 315    and initialized, populate the sal_object with the struct sal data.
 316    Also, register the sal_object life-cycle with the life-cycle of the
 317    object file associated with this sal, if needed.  If a failure
 318    occurs during the sal population, this function will return -1.  */
 319 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
 320 set_sal (sal_object *sal_obj, struct symtab_and_line sal)
 321 {
 322   symtab_object *symtab_obj;
 323
 324   if (sal.symtab)
 325     {
 326       symtab_obj = (symtab_object *) symtab_to_symtab_object  (sal.symtab);
 327       /* If a symtab existed in the sal, but it cannot be duplicated,
 328          we exit.  */
 329       if (symtab_obj == NULL)
 330         return -1;
 331     }
 332   else
 333     {
 334       symtab_obj = (symtab_object *) Py_None;
 335       Py_INCREF (Py_None);
 336     }
 337
 338   sal_obj->sal = xmemdup (&sal, sizeof (struct symtab_and_line),
 339                           sizeof (struct symtab_and_line));
 340   sal_obj->symtab = symtab_obj;
 341   sal_obj->prev = NULL;
 342
 343   /* If the SAL does not have a symtab, we do not add it to the
 344      objfile cleanup observer linked list.  */
 345   if (sal_obj->symtab != (symtab_object *)Py_None)
 346     {
 347       sal_obj->next = objfile_data (sal_obj->symtab->symtab->objfile,
 348                                     salpy_objfile_data_key);
 349       if (sal_obj->next)
 350         sal_obj->next->prev = sal_obj;
 351
 352       set_objfile_data (sal_obj->symtab->symtab->objfile,
 353                         salpy_objfile_data_key, sal_obj);
 354     }
 355   else
 356     sal_obj->next = NULL;
 357
 358   return 0;
 359 }
 360
 361 /* Given a symtab, and a symtab_object that has previously been
 362    allocated and initialized, populate the symtab_object with the
 363    struct symtab data.  Also, register the symtab_object life-cycle
 364    with the life-cycle of the object file associated with this
 365    symtab, if needed.  */
 366 static void
 367 set_symtab (symtab_object *obj, struct symtab *symtab)
 368 {
 369   obj->symtab = symtab;
 370   obj->prev = NULL;
 371   if (symtab)
 372     {
 373       obj->next = objfile_data (symtab->objfile, stpy_objfile_data_key);
 374       if (obj->next)
 375         obj->next->prev = obj;
 376       set_objfile_data (symtab->objfile, stpy_objfile_data_key, obj);
 377     }
 378   else
 379     obj->next = NULL;
 380 }
 381
 382 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
 383    symtab structure from GDB.  */
 384 PyObject *
 385 symtab_to_symtab_object (struct symtab *symtab)
 386 {
 387   symtab_object *symtab_obj;
 388
 389   symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
 390   if (symtab_obj)
 391     set_symtab (symtab_obj, symtab);
 392
 393   return (PyObject *) symtab_obj;
 394 }
 395
 396 /* Create a new symtab and line (gdb.Symtab_and_line) object
 397    that encapsulates the symtab_and_line structure from GDB.  */
 398 PyObject *
 399 symtab_and_line_to_sal_object (struct symtab_and_line sal)
 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       if (set_sal (sal_obj, sal) < 0)
 408         {
 409           Py_DECREF (sal_obj);
 410           return NULL;
 411         }
 412     }
 413
 414   return (PyObject *) sal_obj;
 415 }
 416
 417 /* Return struct symtab_and_line reference that is wrapped by this
 418    object.  */
 419 struct symtab_and_line *
 420 sal_object_to_symtab_and_line (PyObject *obj)
 421 {
 422   if (! PyObject_TypeCheck (obj, &sal_object_type))
 423     return NULL;
 424   return ((sal_object *) obj)->sal;
 425 }
 426
 427 /* Return struct symtab reference that is wrapped by this object.  */
 428 struct symtab *
 429 symtab_object_to_symtab (PyObject *obj)
 430 {
 431   if (! PyObject_TypeCheck (obj, &symtab_object_type))
 432     return NULL;
 433   return ((symtab_object *) obj)->symtab;
 434 }
 435
 436 /* This function is called when an objfile is about to be freed.
 437    Invalidate the symbol table as further actions on the symbol table
 438    would result in bad data.  All access to obj->symtab should be
 439    gated by STPY_REQUIRE_VALID which will raise an exception on
 440    invalid symbol tables.  */
 441 static void
 442 del_objfile_symtab (struct objfile *objfile, void *datum)
 443 {
 444   symtab_object *obj = datum;
 445
 446   while (obj)
 447     {
 448       symtab_object *next = obj->next;
 449
 450       obj->symtab = NULL;
 451       obj->next = NULL;
 452       obj->prev = NULL;
 453       obj = next;
 454     }
 455 }
 456
 457 /* This function is called when an objfile is about to be freed.
 458    Invalidate the sal object as further actions on the sal
 459    would result in bad data.  All access to obj->sal should be
 460    gated by SALPY_REQUIRE_VALID which will raise an exception on
 461    invalid symbol table and line objects.  */
 462 static void
 463 del_objfile_sal (struct objfile *objfile, void *datum)
 464 {
 465   sal_object *obj = datum;
 466
 467   while (obj)
 468     {
 469       sal_object *next = obj->next;
 470
 471       Py_DECREF (obj->symtab);
 472       obj->symtab = (symtab_object *) Py_None;
 473       Py_INCREF (Py_None);
 474
 475       obj->next = NULL;
 476       obj->prev = NULL;
 477       xfree (obj->sal);
 478       obj->sal = NULL;
 479
 480       obj = next;
 481     }
 482 }
 483
 484 int
 485 gdbpy_initialize_symtabs (void)
 486 {
 487   symtab_object_type.tp_new = PyType_GenericNew;
 488   if (PyType_Ready (&symtab_object_type) < 0)
 489     return -1;
 490
 491   sal_object_type.tp_new = PyType_GenericNew;
 492   if (PyType_Ready (&sal_object_type) < 0)
 493     return -1;
 494
 495   /* Register an objfile "free" callback so we can properly
 496      invalidate symbol tables, and symbol table and line data
 497      structures when an object file that is about to be
 498      deleted.  */
 499   stpy_objfile_data_key
 500     = register_objfile_data_with_cleanup (NULL, del_objfile_symtab);
 501   salpy_objfile_data_key
 502     = register_objfile_data_with_cleanup (NULL, del_objfile_sal);
 503
 504   Py_INCREF (&symtab_object_type);
 505   if (PyModule_AddObject (gdb_module, "Symtab",
 506                           (PyObject *) &symtab_object_type) < 0)
 507     return -1;
 508
 509   Py_INCREF (&sal_object_type);
 510   return 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 };