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