gdb/python/py-symtab.c

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