gdb/python/py-symtab.c

   1 /* Python interface to symbol tables.
   2
   3    Copyright (C) 2008-2020 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   PyObject *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).release ();
 112   return str_obj;
 113 }
 114
 115 static PyObject *
 116 stpy_get_objfile (PyObject *self, void *closure)
 117 {
 118   struct symtab *symtab = NULL;
 119
 120   STPY_REQUIRE_VALID (self, symtab);
 121
 122   return objfile_to_objfile_object (SYMTAB_OBJFILE (symtab)).release ();
 123 }
 124
 125 /* Getter function for symtab.producer.  */
 126
 127 static PyObject *
 128 stpy_get_producer (PyObject *self, void *closure)
 129 {
 130   struct symtab *symtab = NULL;
 131   struct compunit_symtab *cust;
 132
 133   STPY_REQUIRE_VALID (self, symtab);
 134   cust = SYMTAB_COMPUNIT (symtab);
 135   if (COMPUNIT_PRODUCER (cust) != NULL)
 136     {
 137       const char *producer = COMPUNIT_PRODUCER (cust);
 138
 139       return host_string_to_python_string (producer).release ();
 140     }
 141
 142   Py_RETURN_NONE;
 143 }
 144
 145 static PyObject *
 146 stpy_fullname (PyObject *self, PyObject *args)
 147 {
 148   const char *fullname;
 149   struct symtab *symtab = NULL;
 150
 151   STPY_REQUIRE_VALID (self, symtab);
 152
 153   fullname = symtab_to_fullname (symtab);
 154
 155   return host_string_to_python_string (fullname).release ();
 156 }
 157
 158 /* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
 159    Returns True if this Symbol table still exists in GDB.  */
 160
 161 static PyObject *
 162 stpy_is_valid (PyObject *self, PyObject *args)
 163 {
 164   struct symtab *symtab = NULL;
 165
 166   symtab = symtab_object_to_symtab (self);
 167   if (symtab == NULL)
 168     Py_RETURN_FALSE;
 169
 170   Py_RETURN_TRUE;
 171 }
 172
 173 /* Return the GLOBAL_BLOCK of the underlying symtab.  */
 174
 175 static PyObject *
 176 stpy_global_block (PyObject *self, PyObject *args)
 177 {
 178   struct symtab *symtab = NULL;
 179   const struct block *block = NULL;
 180   const struct blockvector *blockvector;
 181
 182   STPY_REQUIRE_VALID (self, symtab);
 183
 184   blockvector = SYMTAB_BLOCKVECTOR (symtab);
 185   block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
 186   return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
 187 }
 188
 189 /* Return the STATIC_BLOCK of the underlying symtab.  */
 190
 191 static PyObject *
 192 stpy_static_block (PyObject *self, PyObject *args)
 193 {
 194   struct symtab *symtab = NULL;
 195   const struct block *block = NULL;
 196   const struct blockvector *blockvector;
 197
 198   STPY_REQUIRE_VALID (self, symtab);
 199
 200   blockvector = SYMTAB_BLOCKVECTOR (symtab);
 201   block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
 202   return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
 203 }
 204
 205 /* Implementation of gdb.Symtab.linetable (self) -> gdb.LineTable.
 206    Returns a gdb.LineTable object corresponding to this symbol
 207    table.  */
 208
 209 static PyObject *
 210 stpy_get_linetable (PyObject *self, PyObject *args)
 211 {
 212   struct symtab *symtab = NULL;
 213
 214   STPY_REQUIRE_VALID (self, symtab);
 215
 216   return symtab_to_linetable_object (self);
 217 }
 218
 219 static PyObject *
 220 salpy_str (PyObject *self)
 221 {
 222   const char *filename;
 223   sal_object *sal_obj;
 224   struct symtab_and_line *sal = NULL;
 225
 226   SALPY_REQUIRE_VALID (self, sal);
 227
 228   sal_obj = (sal_object *) self;
 229   if (sal_obj->symtab == Py_None)
 230     filename = "<unknown>";
 231   else
 232     {
 233       symtab *symtab = symtab_object_to_symtab (sal_obj->symtab);
 234       filename = symtab_to_filename_for_display (symtab);
 235     }
 236
 237   return PyString_FromFormat ("symbol and line for %s, line %d", filename,
 238                               sal->line);
 239 }
 240
 241 static void
 242 stpy_dealloc (PyObject *obj)
 243 {
 244   symtab_object *symtab = (symtab_object *) obj;
 245
 246   if (symtab->prev)
 247     symtab->prev->next = symtab->next;
 248   else if (symtab->symtab)
 249     {
 250       set_objfile_data (SYMTAB_OBJFILE (symtab->symtab),
 251                         stpy_objfile_data_key, symtab->next);
 252     }
 253   if (symtab->next)
 254     symtab->next->prev = symtab->prev;
 255   symtab->symtab = NULL;
 256   Py_TYPE (obj)->tp_free (obj);
 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 };