gdb/python/py-symtab.c

   1 /* Python interface to symbol tables.
   2
   3    Copyright (C) 2008-2017 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 = host_string_to_python_string (filename);
 112   return str_obj;
 113 }
 114
 115 static PyObject *
 116 stpy_get_objfile (PyObject *self, void *closure)
 117 {
 118   struct symtab *symtab = NULL;
 119   PyObject *result;
 120
 121   STPY_REQUIRE_VALID (self, symtab);
 122
 123   result = objfile_to_objfile_object (SYMTAB_OBJFILE (symtab));
 124   Py_XINCREF (result);
 125   return result;
 126 }
 127
 128 /* Getter function for symtab.producer.  */
 129
 130 static PyObject *
 131 stpy_get_producer (PyObject *self, void *closure)
 132 {
 133   struct symtab *symtab = NULL;
 134   struct compunit_symtab *cust;
 135
 136   STPY_REQUIRE_VALID (self, symtab);
 137   cust = SYMTAB_COMPUNIT (symtab);
 138   if (COMPUNIT_PRODUCER (cust) != NULL)
 139     {
 140       const char *producer = COMPUNIT_PRODUCER (cust);
 141
 142       return host_string_to_python_string (producer);
 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 host_string_to_python_string (fullname);
 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 = SYMTAB_BLOCKVECTOR (symtab);
 188   block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
 189   return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
 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 = SYMTAB_BLOCKVECTOR (symtab);
 204   block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
 205   return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
 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_OBJFILE (symtab->symtab),
 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 (SYMTAB_OBJFILE (self_sal->symtab->symtab),
 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 = ((struct symtab_and_line *)
 372                   xmemdup (&sal, sizeof (struct symtab_and_line),
 373                            sizeof (struct symtab_and_line)));
 374   sal_obj->symtab = symtab_obj;
 375   sal_obj->prev = NULL;
 376
 377   /* If the SAL does not have a symtab, we do not add it to the
 378      objfile cleanup observer linked list.  */
 379   if (sal_obj->symtab != (symtab_object *)Py_None)
 380     {
 381       sal_obj->next
 382         = ((struct salpy_sal_object *)
 383            objfile_data (SYMTAB_OBJFILE (sal_obj->symtab->symtab),
 384                          salpy_objfile_data_key));
 385       if (sal_obj->next)
 386         sal_obj->next->prev = sal_obj;
 387
 388       set_objfile_data (SYMTAB_OBJFILE (sal_obj->symtab->symtab),
 389                         salpy_objfile_data_key, sal_obj);
 390     }
 391   else
 392     sal_obj->next = NULL;
 393
 394   return 0;
 395 }
 396
 397 /* Given a symtab, and a symtab_object that has previously been
 398    allocated and initialized, populate the symtab_object with the
 399    struct symtab data.  Also, register the symtab_object life-cycle
 400    with the life-cycle of the object file associated with this
 401    symtab, if needed.  */
 402 static void
 403 set_symtab (symtab_object *obj, struct symtab *symtab)
 404 {
 405   obj->symtab = symtab;
 406   obj->prev = NULL;
 407   if (symtab)
 408     {
 409       obj->next
 410         = ((struct stpy_symtab_object *)
 411            objfile_data (SYMTAB_OBJFILE (symtab), stpy_objfile_data_key));
 412       if (obj->next)
 413         obj->next->prev = obj;
 414       set_objfile_data (SYMTAB_OBJFILE (symtab), stpy_objfile_data_key, obj);
 415     }
 416   else
 417     obj->next = NULL;
 418 }
 419
 420 /* Create a new symbol table (gdb.Symtab) object that encapsulates the
 421    symtab structure from GDB.  */
 422 PyObject *
 423 symtab_to_symtab_object (struct symtab *symtab)
 424 {
 425   symtab_object *symtab_obj;
 426
 427   symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
 428   if (symtab_obj)
 429     set_symtab (symtab_obj, symtab);
 430
 431   return (PyObject *) symtab_obj;
 432 }
 433
 434 /* Create a new symtab and line (gdb.Symtab_and_line) object
 435    that encapsulates the symtab_and_line structure from GDB.  */
 436 PyObject *
 437 symtab_and_line_to_sal_object (struct symtab_and_line sal)
 438 {
 439   sal_object *sal_obj;
 440
 441   sal_obj = PyObject_New (sal_object, &sal_object_type);
 442   if (sal_obj)
 443     {
 444       if (set_sal (sal_obj, sal) < 0)
 445         {
 446           Py_DECREF (sal_obj);
 447           return NULL;
 448         }
 449     }
 450
 451   return (PyObject *) sal_obj;
 452 }
 453
 454 /* Return struct symtab_and_line reference that is wrapped by this
 455    object.  */
 456 struct symtab_and_line *
 457 sal_object_to_symtab_and_line (PyObject *obj)
 458 {
 459   if (! PyObject_TypeCheck (obj, &sal_object_type))
 460     return NULL;
 461   return ((sal_object *) obj)->sal;
 462 }
 463
 464 /* Return struct symtab reference that is wrapped by this object.  */
 465 struct symtab *
 466 symtab_object_to_symtab (PyObject *obj)
 467 {
 468   if (! PyObject_TypeCheck (obj, &symtab_object_type))
 469     return NULL;
 470   return ((symtab_object *) obj)->symtab;
 471 }
 472
 473 /* This function is called when an objfile is about to be freed.
 474    Invalidate the symbol table as further actions on the symbol table
 475    would result in bad data.  All access to obj->symtab should be
 476    gated by STPY_REQUIRE_VALID which will raise an exception on
 477    invalid symbol tables.  */
 478 static void
 479 del_objfile_symtab (struct objfile *objfile, void *datum)
 480 {
 481   symtab_object *obj = (symtab_object *) datum;
 482
 483   while (obj)
 484     {
 485       symtab_object *next = obj->next;
 486
 487       obj->symtab = NULL;
 488       obj->next = NULL;
 489       obj->prev = NULL;
 490       obj = next;
 491     }
 492 }
 493
 494 /* This function is called when an objfile is about to be freed.
 495    Invalidate the sal object as further actions on the sal
 496    would result in bad data.  All access to obj->sal should be
 497    gated by SALPY_REQUIRE_VALID which will raise an exception on
 498    invalid symbol table and line objects.  */
 499 static void
 500 del_objfile_sal (struct objfile *objfile, void *datum)
 501 {
 502   sal_object *obj = (sal_object *) datum;
 503
 504   while (obj)
 505     {
 506       sal_object *next = obj->next;
 507
 508       Py_DECREF (obj->symtab);
 509       obj->symtab = (symtab_object *) Py_None;
 510       Py_INCREF (Py_None);
 511
 512       obj->next = NULL;
 513       obj->prev = NULL;
 514       xfree (obj->sal);
 515       obj->sal = NULL;
 516
 517       obj = next;
 518     }
 519 }
 520
 521 int
 522 gdbpy_initialize_symtabs (void)
 523 {
 524   symtab_object_type.tp_new = PyType_GenericNew;
 525   if (PyType_Ready (&symtab_object_type) < 0)
 526     return -1;
 527
 528   sal_object_type.tp_new = PyType_GenericNew;
 529   if (PyType_Ready (&sal_object_type) < 0)
 530     return -1;
 531
 532   /* Register an objfile "free" callback so we can properly
 533      invalidate symbol tables, and symbol table and line data
 534      structures when an object file that is about to be
 535      deleted.  */
 536   stpy_objfile_data_key
 537     = register_objfile_data_with_cleanup (NULL, del_objfile_symtab);
 538   salpy_objfile_data_key
 539     = register_objfile_data_with_cleanup (NULL, del_objfile_sal);
 540
 541   if (gdb_pymodule_addobject (gdb_module, "Symtab",
 542                               (PyObject *) &symtab_object_type) < 0)
 543     return -1;
 544
 545   return gdb_pymodule_addobject (gdb_module, "Symtab_and_line",
 546                                  (PyObject *) &sal_object_type);
 547 }
 548
 549 \f
 550
 551 static PyGetSetDef symtab_object_getset[] = {
 552   { "filename", stpy_get_filename, NULL,
 553     "The symbol table's source filename.", NULL },
 554   { "objfile", stpy_get_objfile, NULL, "The symtab's objfile.",
 555     NULL },
 556   { "producer", stpy_get_producer, NULL,
 557     "The name/version of the program that compiled this symtab.", NULL },
 558   {NULL}  /* Sentinel */
 559 };
 560
 561 static PyMethodDef symtab_object_methods[] = {
 562   { "is_valid", stpy_is_valid, METH_NOARGS,
 563     "is_valid () -> Boolean.\n\
 564 Return true if this symbol table is valid, false if not." },
 565   { "fullname", stpy_fullname, METH_NOARGS,
 566     "fullname () -> String.\n\
 567 Return the symtab's full source filename." },
 568   { "global_block", stpy_global_block, METH_NOARGS,
 569     "global_block () -> gdb.Block.\n\
 570 Return the global block of the symbol table." },
 571   { "static_block", stpy_static_block, METH_NOARGS,
 572     "static_block () -> gdb.Block.\n\
 573 Return the static block of the symbol table." },
 574     { "linetable", stpy_get_linetable, METH_NOARGS,
 575     "linetable () -> gdb.LineTable.\n\
 576 Return the LineTable associated with this symbol table" },
 577   {NULL}  /* Sentinel */
 578 };
 579
 580 PyTypeObject symtab_object_type = {
 581   PyVarObject_HEAD_INIT (NULL, 0)
 582   "gdb.Symtab",                   /*tp_name*/
 583   sizeof (symtab_object),         /*tp_basicsize*/
 584   0,                              /*tp_itemsize*/
 585   stpy_dealloc,                   /*tp_dealloc*/
 586   0,                              /*tp_print*/
 587   0,                              /*tp_getattr*/
 588   0,                              /*tp_setattr*/
 589   0,                              /*tp_compare*/
 590   0,                              /*tp_repr*/
 591   0,                              /*tp_as_number*/
 592   0,                              /*tp_as_sequence*/
 593   0,                              /*tp_as_mapping*/
 594   0,                              /*tp_hash */
 595   0,                              /*tp_call*/
 596   stpy_str,                       /*tp_str*/
 597   0,                              /*tp_getattro*/
 598   0,                              /*tp_setattro*/
 599   0,                              /*tp_as_buffer*/
 600   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 601   "GDB symtab object",            /*tp_doc */
 602   0,                              /*tp_traverse */
 603   0,                              /*tp_clear */
 604   0,                              /*tp_richcompare */
 605   0,                              /*tp_weaklistoffset */
 606   0,                              /*tp_iter */
 607   0,                              /*tp_iternext */
 608   symtab_object_methods,          /*tp_methods */
 609   0,                              /*tp_members */
 610   symtab_object_getset            /*tp_getset */
 611 };
 612
 613 static PyGetSetDef sal_object_getset[] = {
 614   { "symtab", salpy_get_symtab, NULL, "Symtab object.", NULL },
 615   { "pc", salpy_get_pc, NULL, "Return the symtab_and_line's pc.", NULL },
 616   { "last", salpy_get_last, NULL,
 617     "Return the symtab_and_line's last address.", NULL },
 618   { "line", salpy_get_line, NULL,
 619     "Return the symtab_and_line's line.", NULL },
 620   {NULL}  /* Sentinel */
 621 };
 622
 623 static PyMethodDef sal_object_methods[] = {
 624   { "is_valid", salpy_is_valid, METH_NOARGS,
 625     "is_valid () -> Boolean.\n\
 626 Return true if this symbol table and line is valid, false if not." },
 627   {NULL}  /* Sentinel */
 628 };
 629
 630 PyTypeObject sal_object_type = {
 631   PyVarObject_HEAD_INIT (NULL, 0)
 632   "gdb.Symtab_and_line",          /*tp_name*/
 633   sizeof (sal_object),            /*tp_basicsize*/
 634   0,                              /*tp_itemsize*/
 635   salpy_dealloc,                  /*tp_dealloc*/
 636   0,                              /*tp_print*/
 637   0,                              /*tp_getattr*/
 638   0,                              /*tp_setattr*/
 639   0,                              /*tp_compare*/
 640   0,                              /*tp_repr*/
 641   0,                              /*tp_as_number*/
 642   0,                              /*tp_as_sequence*/
 643   0,                              /*tp_as_mapping*/
 644   0,                              /*tp_hash */
 645   0,                              /*tp_call*/
 646   salpy_str,                      /*tp_str*/
 647   0,                              /*tp_getattro*/
 648   0,                              /*tp_setattro*/
 649   0,                              /*tp_as_buffer*/
 650   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 651   "GDB symtab_and_line object",   /*tp_doc */
 652   0,                              /*tp_traverse */
 653   0,                              /*tp_clear */
 654   0,                              /*tp_richcompare */
 655   0,                              /*tp_weaklistoffset */
 656   0,                              /*tp_iter */
 657   0,                              /*tp_iternext */
 658   sal_object_methods,             /*tp_methods */
 659   0,                              /*tp_members */
 660   sal_object_getset               /*tp_getset */
 661 };