gdb/python/py-symtab.c

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