gdb/python/py-symtab.c

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