1 /* Python interface to symbols. 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 "block.h" 22 #include "frame.h" 23 #include "symtab.h" 24 #include "python-internal.h" 25 #include "objfiles.h" 26 27 typedef struct sympy_symbol_object { 28 PyObject_HEAD 29 /* The GDB symbol structure this object is wrapping. */ 30 struct symbol *symbol; 31 /* A symbol object is associated with an objfile, so keep track with 32 doubly-linked list, rooted in the objfile. This lets us 33 invalidate the underlying struct symbol when the objfile is 34 deleted. */ 35 struct sympy_symbol_object *prev; 36 struct sympy_symbol_object *next; 37 } symbol_object; 38 39 /* Require a valid symbol. All access to symbol_object->symbol should be 40 gated by this call. */ 41 #define SYMPY_REQUIRE_VALID(symbol_obj, symbol) \ 42 do { \ 43 symbol = symbol_object_to_symbol (symbol_obj); \ 44 if (symbol == NULL) \ 45 { \ 46 PyErr_SetString (PyExc_RuntimeError, \ 47 _("Symbol is invalid.")); \ 48 return NULL; \ 49 } \ 50 } while (0) 51 52 static const struct objfile_data *sympy_objfile_data_key; 53 54 static PyObject * 55 sympy_str (PyObject *self) 56 { 57 PyObject *result; 58 struct symbol *symbol = NULL; 59 60 SYMPY_REQUIRE_VALID (self, symbol); 61 62 result = PyString_FromString (SYMBOL_PRINT_NAME (symbol)); 63 64 return result; 65 } 66 67 static PyObject * 68 sympy_get_type (PyObject *self, void *closure) 69 { 70 struct symbol *symbol = NULL; 71 72 SYMPY_REQUIRE_VALID (self, symbol); 73 74 if (SYMBOL_TYPE (symbol) == NULL) 75 { 76 Py_INCREF (Py_None); 77 return Py_None; 78 } 79 80 return type_to_type_object (SYMBOL_TYPE (symbol)); 81 } 82 83 static PyObject * 84 sympy_get_symtab (PyObject *self, void *closure) 85 { 86 struct symbol *symbol = NULL; 87 88 SYMPY_REQUIRE_VALID (self, symbol); 89 90 if (!SYMBOL_OBJFILE_OWNED (symbol)) 91 Py_RETURN_NONE; 92 93 return symtab_to_symtab_object (symbol_symtab (symbol)); 94 } 95 96 static PyObject * 97 sympy_get_name (PyObject *self, void *closure) 98 { 99 struct symbol *symbol = NULL; 100 101 SYMPY_REQUIRE_VALID (self, symbol); 102 103 return PyString_FromString (SYMBOL_NATURAL_NAME (symbol)); 104 } 105 106 static PyObject * 107 sympy_get_linkage_name (PyObject *self, void *closure) 108 { 109 struct symbol *symbol = NULL; 110 111 SYMPY_REQUIRE_VALID (self, symbol); 112 113 return PyString_FromString (SYMBOL_LINKAGE_NAME (symbol)); 114 } 115 116 static PyObject * 117 sympy_get_print_name (PyObject *self, void *closure) 118 { 119 struct symbol *symbol = NULL; 120 121 SYMPY_REQUIRE_VALID (self, symbol); 122 123 return sympy_str (self); 124 } 125 126 static PyObject * 127 sympy_get_addr_class (PyObject *self, void *closure) 128 { 129 struct symbol *symbol = NULL; 130 131 SYMPY_REQUIRE_VALID (self, symbol); 132 133 return PyInt_FromLong (SYMBOL_CLASS (symbol)); 134 } 135 136 static PyObject * 137 sympy_is_argument (PyObject *self, void *closure) 138 { 139 struct symbol *symbol = NULL; 140 141 SYMPY_REQUIRE_VALID (self, symbol); 142 143 return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol)); 144 } 145 146 static PyObject * 147 sympy_is_constant (PyObject *self, void *closure) 148 { 149 struct symbol *symbol = NULL; 150 enum address_class theclass; 151 152 SYMPY_REQUIRE_VALID (self, symbol); 153 154 theclass = SYMBOL_CLASS (symbol); 155 156 return PyBool_FromLong (theclass == LOC_CONST || theclass == LOC_CONST_BYTES); 157 } 158 159 static PyObject * 160 sympy_is_function (PyObject *self, void *closure) 161 { 162 struct symbol *symbol = NULL; 163 enum address_class theclass; 164 165 SYMPY_REQUIRE_VALID (self, symbol); 166 167 theclass = SYMBOL_CLASS (symbol); 168 169 return PyBool_FromLong (theclass == LOC_BLOCK); 170 } 171 172 static PyObject * 173 sympy_is_variable (PyObject *self, void *closure) 174 { 175 struct symbol *symbol = NULL; 176 enum address_class theclass; 177 178 SYMPY_REQUIRE_VALID (self, symbol); 179 180 theclass = SYMBOL_CLASS (symbol); 181 182 return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol) 183 && (theclass == LOC_LOCAL || theclass == LOC_REGISTER 184 || theclass == LOC_STATIC || theclass == LOC_COMPUTED 185 || theclass == LOC_OPTIMIZED_OUT)); 186 } 187 188 /* Implementation of gdb.Symbol.needs_frame -> Boolean. 189 Returns true iff the symbol needs a frame for evaluation. */ 190 191 static PyObject * 192 sympy_needs_frame (PyObject *self, void *closure) 193 { 194 struct symbol *symbol = NULL; 195 int result = 0; 196 197 SYMPY_REQUIRE_VALID (self, symbol); 198 199 TRY 200 { 201 result = symbol_read_needs_frame (symbol); 202 } 203 CATCH (except, RETURN_MASK_ALL) 204 { 205 GDB_PY_HANDLE_EXCEPTION (except); 206 } 207 END_CATCH 208 209 if (result) 210 Py_RETURN_TRUE; 211 Py_RETURN_FALSE; 212 } 213 214 /* Implementation of gdb.Symbol.line -> int. 215 Returns the line number at which the symbol was defined. */ 216 217 static PyObject * 218 sympy_line (PyObject *self, void *closure) 219 { 220 struct symbol *symbol = NULL; 221 222 SYMPY_REQUIRE_VALID (self, symbol); 223 224 return PyInt_FromLong (SYMBOL_LINE (symbol)); 225 } 226 227 /* Implementation of gdb.Symbol.is_valid (self) -> Boolean. 228 Returns True if this Symbol still exists in GDB. */ 229 230 static PyObject * 231 sympy_is_valid (PyObject *self, PyObject *args) 232 { 233 struct symbol *symbol = NULL; 234 235 symbol = symbol_object_to_symbol (self); 236 if (symbol == NULL) 237 Py_RETURN_FALSE; 238 239 Py_RETURN_TRUE; 240 } 241 242 /* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value. Returns 243 the value of the symbol, or an error in various circumstances. */ 244 245 static PyObject * 246 sympy_value (PyObject *self, PyObject *args) 247 { 248 struct symbol *symbol = NULL; 249 struct frame_info *frame_info = NULL; 250 PyObject *frame_obj = NULL; 251 struct value *value = NULL; 252 253 if (!PyArg_ParseTuple (args, "|O", &frame_obj)) 254 return NULL; 255 256 if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type)) 257 { 258 PyErr_SetString (PyExc_TypeError, "argument is not a frame"); 259 return NULL; 260 } 261 262 SYMPY_REQUIRE_VALID (self, symbol); 263 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF) 264 { 265 PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef"); 266 return NULL; 267 } 268 269 TRY 270 { 271 if (frame_obj != NULL) 272 { 273 frame_info = frame_object_to_frame_info (frame_obj); 274 if (frame_info == NULL) 275 error (_("invalid frame")); 276 } 277 278 if (symbol_read_needs_frame (symbol) && frame_info == NULL) 279 error (_("symbol requires a frame to compute its value")); 280 281 value = read_var_value (symbol, frame_info); 282 } 283 CATCH (except, RETURN_MASK_ALL) 284 { 285 GDB_PY_HANDLE_EXCEPTION (except); 286 } 287 END_CATCH 288 289 return value_to_value_object (value); 290 } 291 292 /* Given a symbol, and a symbol_object that has previously been 293 allocated and initialized, populate the symbol_object with the 294 struct symbol data. Also, register the symbol_object life-cycle 295 with the life-cycle of the object file associated with this 296 symbol, if needed. */ 297 static void 298 set_symbol (symbol_object *obj, struct symbol *symbol) 299 { 300 obj->symbol = symbol; 301 obj->prev = NULL; 302 if (SYMBOL_OBJFILE_OWNED (symbol) 303 && symbol_symtab (symbol) != NULL) 304 { 305 struct objfile *objfile = symbol_objfile (symbol); 306 307 obj->next = objfile_data (objfile, sympy_objfile_data_key); 308 if (obj->next) 309 obj->next->prev = obj; 310 set_objfile_data (objfile, sympy_objfile_data_key, obj); 311 } 312 else 313 obj->next = NULL; 314 } 315 316 /* Create a new symbol object (gdb.Symbol) that encapsulates the struct 317 symbol object from GDB. */ 318 PyObject * 319 symbol_to_symbol_object (struct symbol *sym) 320 { 321 symbol_object *sym_obj; 322 323 sym_obj = PyObject_New (symbol_object, &symbol_object_type); 324 if (sym_obj) 325 set_symbol (sym_obj, sym); 326 327 return (PyObject *) sym_obj; 328 } 329 330 /* Return the symbol that is wrapped by this symbol object. */ 331 struct symbol * 332 symbol_object_to_symbol (PyObject *obj) 333 { 334 if (! PyObject_TypeCheck (obj, &symbol_object_type)) 335 return NULL; 336 return ((symbol_object *) obj)->symbol; 337 } 338 339 static void 340 sympy_dealloc (PyObject *obj) 341 { 342 symbol_object *sym_obj = (symbol_object *) obj; 343 344 if (sym_obj->prev) 345 sym_obj->prev->next = sym_obj->next; 346 else if (sym_obj->symbol != NULL 347 && SYMBOL_OBJFILE_OWNED (sym_obj->symbol) 348 && symbol_symtab (sym_obj->symbol) != NULL) 349 { 350 set_objfile_data (symbol_objfile (sym_obj->symbol), 351 sympy_objfile_data_key, sym_obj->next); 352 } 353 if (sym_obj->next) 354 sym_obj->next->prev = sym_obj->prev; 355 sym_obj->symbol = NULL; 356 } 357 358 /* Implementation of 359 gdb.lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this) 360 A tuple with 2 elements is always returned. The first is the symbol 361 object or None, the second is a boolean with the value of 362 is_a_field_of_this (see comment in lookup_symbol_in_language). */ 363 364 PyObject * 365 gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw) 366 { 367 int domain = VAR_DOMAIN; 368 struct field_of_this_result is_a_field_of_this; 369 const char *name; 370 static char *keywords[] = { "name", "block", "domain", NULL }; 371 struct symbol *symbol = NULL; 372 PyObject *block_obj = NULL, *ret_tuple, *sym_obj, *bool_obj; 373 const struct block *block = NULL; 374 375 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!i", keywords, &name, 376 &block_object_type, &block_obj, &domain)) 377 return NULL; 378 379 if (block_obj) 380 block = block_object_to_block (block_obj); 381 else 382 { 383 struct frame_info *selected_frame; 384 385 TRY 386 { 387 selected_frame = get_selected_frame (_("No frame selected.")); 388 block = get_frame_block (selected_frame, NULL); 389 } 390 CATCH (except, RETURN_MASK_ALL) 391 { 392 GDB_PY_HANDLE_EXCEPTION (except); 393 } 394 END_CATCH 395 } 396 397 TRY 398 { 399 symbol = lookup_symbol (name, block, domain, &is_a_field_of_this); 400 } 401 CATCH (except, RETURN_MASK_ALL) 402 { 403 GDB_PY_HANDLE_EXCEPTION (except); 404 } 405 END_CATCH 406 407 ret_tuple = PyTuple_New (2); 408 if (!ret_tuple) 409 return NULL; 410 411 if (symbol) 412 { 413 sym_obj = symbol_to_symbol_object (symbol); 414 if (!sym_obj) 415 { 416 Py_DECREF (ret_tuple); 417 return NULL; 418 } 419 } 420 else 421 { 422 sym_obj = Py_None; 423 Py_INCREF (Py_None); 424 } 425 PyTuple_SET_ITEM (ret_tuple, 0, sym_obj); 426 427 bool_obj = (is_a_field_of_this.type != NULL) ? Py_True : Py_False; 428 Py_INCREF (bool_obj); 429 PyTuple_SET_ITEM (ret_tuple, 1, bool_obj); 430 431 return ret_tuple; 432 } 433 434 /* Implementation of 435 gdb.lookup_global_symbol (name [, domain]) -> symbol or None. */ 436 437 PyObject * 438 gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw) 439 { 440 int domain = VAR_DOMAIN; 441 const char *name; 442 static char *keywords[] = { "name", "domain", NULL }; 443 struct symbol *symbol = NULL; 444 PyObject *sym_obj; 445 446 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &name, 447 &domain)) 448 return NULL; 449 450 TRY 451 { 452 symbol = lookup_global_symbol (name, NULL, domain); 453 } 454 CATCH (except, RETURN_MASK_ALL) 455 { 456 GDB_PY_HANDLE_EXCEPTION (except); 457 } 458 END_CATCH 459 460 if (symbol) 461 { 462 sym_obj = symbol_to_symbol_object (symbol); 463 if (!sym_obj) 464 return NULL; 465 } 466 else 467 { 468 sym_obj = Py_None; 469 Py_INCREF (Py_None); 470 } 471 472 return sym_obj; 473 } 474 475 /* This function is called when an objfile is about to be freed. 476 Invalidate the symbol as further actions on the symbol would result 477 in bad data. All access to obj->symbol should be gated by 478 SYMPY_REQUIRE_VALID which will raise an exception on invalid 479 symbols. */ 480 static void 481 del_objfile_symbols (struct objfile *objfile, void *datum) 482 { 483 symbol_object *obj = datum; 484 while (obj) 485 { 486 symbol_object *next = obj->next; 487 488 obj->symbol = NULL; 489 obj->next = NULL; 490 obj->prev = NULL; 491 492 obj = next; 493 } 494 } 495 496 int 497 gdbpy_initialize_symbols (void) 498 { 499 if (PyType_Ready (&symbol_object_type) < 0) 500 return -1; 501 502 /* Register an objfile "free" callback so we can properly 503 invalidate symbol when an object file that is about to be 504 deleted. */ 505 sympy_objfile_data_key 506 = register_objfile_data_with_cleanup (NULL, del_objfile_symbols); 507 508 if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0 509 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", 510 LOC_CONST) < 0 511 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", 512 LOC_STATIC) < 0 513 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", 514 LOC_REGISTER) < 0 515 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", 516 LOC_ARG) < 0 517 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", 518 LOC_REF_ARG) < 0 519 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", 520 LOC_LOCAL) < 0 521 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", 522 LOC_TYPEDEF) < 0 523 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", 524 LOC_LABEL) < 0 525 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", 526 LOC_BLOCK) < 0 527 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES", 528 LOC_CONST_BYTES) < 0 529 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED", 530 LOC_UNRESOLVED) < 0 531 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT", 532 LOC_OPTIMIZED_OUT) < 0 533 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", 534 LOC_COMPUTED) < 0 535 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR", 536 LOC_REGPARM_ADDR) < 0 537 || PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", 538 UNDEF_DOMAIN) < 0 539 || PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", 540 VAR_DOMAIN) < 0 541 || PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", 542 STRUCT_DOMAIN) < 0 543 || PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", 544 LABEL_DOMAIN) < 0 545 || PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN", 546 VARIABLES_DOMAIN) < 0 547 || PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN", 548 FUNCTIONS_DOMAIN) < 0 549 || PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", 550 TYPES_DOMAIN) < 0) 551 return -1; 552 553 return gdb_pymodule_addobject (gdb_module, "Symbol", 554 (PyObject *) &symbol_object_type); 555 } 556 557 558 559 static PyGetSetDef symbol_object_getset[] = { 560 { "type", sympy_get_type, NULL, 561 "Type of the symbol.", NULL }, 562 { "symtab", sympy_get_symtab, NULL, 563 "Symbol table in which the symbol appears.", NULL }, 564 { "name", sympy_get_name, NULL, 565 "Name of the symbol, as it appears in the source code.", NULL }, 566 { "linkage_name", sympy_get_linkage_name, NULL, 567 "Name of the symbol, as used by the linker (i.e., may be mangled).", 568 NULL }, 569 { "print_name", sympy_get_print_name, NULL, 570 "Name of the symbol in a form suitable for output.\n\ 571 This is either name or linkage_name, depending on whether the user asked GDB\n\ 572 to display demangled or mangled names.", NULL }, 573 { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." }, 574 { "is_argument", sympy_is_argument, NULL, 575 "True if the symbol is an argument of a function." }, 576 { "is_constant", sympy_is_constant, NULL, 577 "True if the symbol is a constant." }, 578 { "is_function", sympy_is_function, NULL, 579 "True if the symbol is a function or method." }, 580 { "is_variable", sympy_is_variable, NULL, 581 "True if the symbol is a variable." }, 582 { "needs_frame", sympy_needs_frame, NULL, 583 "True if the symbol requires a frame for evaluation." }, 584 { "line", sympy_line, NULL, 585 "The source line number at which the symbol was defined." }, 586 { NULL } /* Sentinel */ 587 }; 588 589 static PyMethodDef symbol_object_methods[] = { 590 { "is_valid", sympy_is_valid, METH_NOARGS, 591 "is_valid () -> Boolean.\n\ 592 Return true if this symbol is valid, false if not." }, 593 { "value", sympy_value, METH_VARARGS, 594 "value ([frame]) -> gdb.Value\n\ 595 Return the value of the symbol." }, 596 {NULL} /* Sentinel */ 597 }; 598 599 PyTypeObject symbol_object_type = { 600 PyVarObject_HEAD_INIT (NULL, 0) 601 "gdb.Symbol", /*tp_name*/ 602 sizeof (symbol_object), /*tp_basicsize*/ 603 0, /*tp_itemsize*/ 604 sympy_dealloc, /*tp_dealloc*/ 605 0, /*tp_print*/ 606 0, /*tp_getattr*/ 607 0, /*tp_setattr*/ 608 0, /*tp_compare*/ 609 0, /*tp_repr*/ 610 0, /*tp_as_number*/ 611 0, /*tp_as_sequence*/ 612 0, /*tp_as_mapping*/ 613 0, /*tp_hash */ 614 0, /*tp_call*/ 615 sympy_str, /*tp_str*/ 616 0, /*tp_getattro*/ 617 0, /*tp_setattro*/ 618 0, /*tp_as_buffer*/ 619 Py_TPFLAGS_DEFAULT, /*tp_flags*/ 620 "GDB symbol object", /*tp_doc */ 621 0, /*tp_traverse */ 622 0, /*tp_clear */ 623 0, /*tp_richcompare */ 624 0, /*tp_weaklistoffset */ 625 0, /*tp_iter */ 626 0, /*tp_iternext */ 627 symbol_object_methods, /*tp_methods */ 628 0, /*tp_members */ 629 symbol_object_getset /*tp_getset */ 630 }; 631