1 /* Python interface to breakpoints 2 3 Copyright (C) 2008-2012 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 "value.h" 22 #include "exceptions.h" 23 #include "python-internal.h" 24 #include "charset.h" 25 #include "breakpoint.h" 26 #include "gdbcmd.h" 27 #include "gdbthread.h" 28 #include "observer.h" 29 #include "cli/cli-script.h" 30 #include "ada-lang.h" 31 #include "arch-utils.h" 32 #include "language.h" 33 34 /* Number of live breakpoints. */ 35 static int bppy_live; 36 37 /* Variables used to pass information between the Breakpoint 38 constructor and the breakpoint-created hook function. */ 39 breakpoint_object *bppy_pending_object; 40 41 /* Function that is called when a Python condition is evaluated. */ 42 static char * const stop_func = "stop"; 43 44 /* This is used to initialize various gdb.bp_* constants. */ 45 struct pybp_code 46 { 47 /* The name. */ 48 const char *name; 49 /* The code. */ 50 enum type_code code; 51 }; 52 53 /* Entries related to the type of user set breakpoints. */ 54 static struct pybp_code pybp_codes[] = 55 { 56 { "BP_NONE", bp_none}, 57 { "BP_BREAKPOINT", bp_breakpoint}, 58 { "BP_WATCHPOINT", bp_watchpoint}, 59 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint}, 60 { "BP_READ_WATCHPOINT", bp_read_watchpoint}, 61 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint}, 62 {NULL} /* Sentinel. */ 63 }; 64 65 /* Entries related to the type of watchpoint. */ 66 static struct pybp_code pybp_watch_types[] = 67 { 68 { "WP_READ", hw_read}, 69 { "WP_WRITE", hw_write}, 70 { "WP_ACCESS", hw_access}, 71 {NULL} /* Sentinel. */ 72 }; 73 74 /* Python function which checks the validity of a breakpoint object. */ 75 static PyObject * 76 bppy_is_valid (PyObject *self, PyObject *args) 77 { 78 breakpoint_object *self_bp = (breakpoint_object *) self; 79 80 if (self_bp->bp) 81 Py_RETURN_TRUE; 82 Py_RETURN_FALSE; 83 } 84 85 /* Python function to test whether or not the breakpoint is enabled. */ 86 static PyObject * 87 bppy_get_enabled (PyObject *self, void *closure) 88 { 89 breakpoint_object *self_bp = (breakpoint_object *) self; 90 91 BPPY_REQUIRE_VALID (self_bp); 92 if (! self_bp->bp) 93 Py_RETURN_FALSE; 94 if (self_bp->bp->enable_state == bp_enabled) 95 Py_RETURN_TRUE; 96 Py_RETURN_FALSE; 97 } 98 99 /* Python function to test whether or not the breakpoint is silent. */ 100 static PyObject * 101 bppy_get_silent (PyObject *self, void *closure) 102 { 103 breakpoint_object *self_bp = (breakpoint_object *) self; 104 105 BPPY_REQUIRE_VALID (self_bp); 106 if (self_bp->bp->silent) 107 Py_RETURN_TRUE; 108 Py_RETURN_FALSE; 109 } 110 111 /* Python function to set the enabled state of a breakpoint. */ 112 static int 113 bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure) 114 { 115 breakpoint_object *self_bp = (breakpoint_object *) self; 116 int cmp; 117 volatile struct gdb_exception except; 118 119 BPPY_SET_REQUIRE_VALID (self_bp); 120 121 if (newvalue == NULL) 122 { 123 PyErr_SetString (PyExc_TypeError, 124 _("Cannot delete `enabled' attribute.")); 125 126 return -1; 127 } 128 else if (! PyBool_Check (newvalue)) 129 { 130 PyErr_SetString (PyExc_TypeError, 131 _("The value of `enabled' must be a boolean.")); 132 return -1; 133 } 134 135 cmp = PyObject_IsTrue (newvalue); 136 if (cmp < 0) 137 return -1; 138 139 TRY_CATCH (except, RETURN_MASK_ALL) 140 { 141 if (cmp == 1) 142 enable_breakpoint (self_bp->bp); 143 else 144 disable_breakpoint (self_bp->bp); 145 } 146 GDB_PY_SET_HANDLE_EXCEPTION (except); 147 148 return 0; 149 } 150 151 /* Python function to set the 'silent' state of a breakpoint. */ 152 static int 153 bppy_set_silent (PyObject *self, PyObject *newvalue, void *closure) 154 { 155 breakpoint_object *self_bp = (breakpoint_object *) self; 156 int cmp; 157 158 BPPY_SET_REQUIRE_VALID (self_bp); 159 160 if (newvalue == NULL) 161 { 162 PyErr_SetString (PyExc_TypeError, 163 _("Cannot delete `silent' attribute.")); 164 return -1; 165 } 166 else if (! PyBool_Check (newvalue)) 167 { 168 PyErr_SetString (PyExc_TypeError, 169 _("The value of `silent' must be a boolean.")); 170 return -1; 171 } 172 173 cmp = PyObject_IsTrue (newvalue); 174 if (cmp < 0) 175 return -1; 176 else 177 breakpoint_set_silent (self_bp->bp, cmp); 178 179 return 0; 180 } 181 182 /* Python function to set the thread of a breakpoint. */ 183 static int 184 bppy_set_thread (PyObject *self, PyObject *newvalue, void *closure) 185 { 186 breakpoint_object *self_bp = (breakpoint_object *) self; 187 long id; 188 189 BPPY_SET_REQUIRE_VALID (self_bp); 190 191 if (newvalue == NULL) 192 { 193 PyErr_SetString (PyExc_TypeError, 194 _("Cannot delete `thread' attribute.")); 195 return -1; 196 } 197 else if (PyInt_Check (newvalue)) 198 { 199 if (! gdb_py_int_as_long (newvalue, &id)) 200 return -1; 201 202 if (! valid_thread_id (id)) 203 { 204 PyErr_SetString (PyExc_RuntimeError, 205 _("Invalid thread ID.")); 206 return -1; 207 } 208 } 209 else if (newvalue == Py_None) 210 id = -1; 211 else 212 { 213 PyErr_SetString (PyExc_TypeError, 214 _("The value of `thread' must be an integer or None.")); 215 return -1; 216 } 217 218 breakpoint_set_thread (self_bp->bp, id); 219 220 return 0; 221 } 222 223 /* Python function to set the (Ada) task of a breakpoint. */ 224 static int 225 bppy_set_task (PyObject *self, PyObject *newvalue, void *closure) 226 { 227 breakpoint_object *self_bp = (breakpoint_object *) self; 228 long id; 229 int valid_id = 0; 230 volatile struct gdb_exception except; 231 232 BPPY_SET_REQUIRE_VALID (self_bp); 233 234 if (newvalue == NULL) 235 { 236 PyErr_SetString (PyExc_TypeError, 237 _("Cannot delete `task' attribute.")); 238 return -1; 239 } 240 else if (PyInt_Check (newvalue)) 241 { 242 if (! gdb_py_int_as_long (newvalue, &id)) 243 return -1; 244 245 TRY_CATCH (except, RETURN_MASK_ALL) 246 { 247 valid_id = valid_task_id (id); 248 } 249 GDB_PY_SET_HANDLE_EXCEPTION (except); 250 251 if (! valid_id) 252 { 253 PyErr_SetString (PyExc_RuntimeError, 254 _("Invalid task ID.")); 255 return -1; 256 } 257 } 258 else if (newvalue == Py_None) 259 id = 0; 260 else 261 { 262 PyErr_SetString (PyExc_TypeError, 263 _("The value of `task' must be an integer or None.")); 264 return -1; 265 } 266 267 breakpoint_set_task (self_bp->bp, id); 268 269 return 0; 270 } 271 272 /* Python function which deletes the underlying GDB breakpoint. This 273 triggers the breakpoint_deleted observer which will call 274 gdbpy_breakpoint_deleted; that function cleans up the Python 275 sections. */ 276 277 static PyObject * 278 bppy_delete_breakpoint (PyObject *self, PyObject *args) 279 { 280 breakpoint_object *self_bp = (breakpoint_object *) self; 281 volatile struct gdb_exception except; 282 283 BPPY_REQUIRE_VALID (self_bp); 284 285 TRY_CATCH (except, RETURN_MASK_ALL) 286 { 287 delete_breakpoint (self_bp->bp); 288 } 289 GDB_PY_HANDLE_EXCEPTION (except); 290 291 Py_RETURN_NONE; 292 } 293 294 295 /* Python function to set the ignore count of a breakpoint. */ 296 static int 297 bppy_set_ignore_count (PyObject *self, PyObject *newvalue, void *closure) 298 { 299 breakpoint_object *self_bp = (breakpoint_object *) self; 300 long value; 301 volatile struct gdb_exception except; 302 303 BPPY_SET_REQUIRE_VALID (self_bp); 304 305 if (newvalue == NULL) 306 { 307 PyErr_SetString (PyExc_TypeError, 308 _("Cannot delete `ignore_count' attribute.")); 309 return -1; 310 } 311 else if (! PyInt_Check (newvalue)) 312 { 313 PyErr_SetString (PyExc_TypeError, 314 _("The value of `ignore_count' must be an integer.")); 315 return -1; 316 } 317 318 if (! gdb_py_int_as_long (newvalue, &value)) 319 return -1; 320 321 if (value < 0) 322 value = 0; 323 324 TRY_CATCH (except, RETURN_MASK_ALL) 325 { 326 set_ignore_count (self_bp->number, (int) value, 0); 327 } 328 GDB_PY_SET_HANDLE_EXCEPTION (except); 329 330 return 0; 331 } 332 333 /* Python function to set the hit count of a breakpoint. */ 334 static int 335 bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure) 336 { 337 breakpoint_object *self_bp = (breakpoint_object *) self; 338 339 BPPY_SET_REQUIRE_VALID (self_bp); 340 341 if (newvalue == NULL) 342 { 343 PyErr_SetString (PyExc_TypeError, 344 _("Cannot delete `hit_count' attribute.")); 345 return -1; 346 } 347 else 348 { 349 long value; 350 351 if (! gdb_py_int_as_long (newvalue, &value)) 352 return -1; 353 354 if (value != 0) 355 { 356 PyErr_SetString (PyExc_AttributeError, 357 _("The value of `hit_count' must be zero.")); 358 return -1; 359 } 360 } 361 362 self_bp->bp->hit_count = 0; 363 364 return 0; 365 } 366 367 /* Python function to get the location of a breakpoint. */ 368 static PyObject * 369 bppy_get_location (PyObject *self, void *closure) 370 { 371 char *str; 372 breakpoint_object *obj = (breakpoint_object *) self; 373 374 BPPY_REQUIRE_VALID (obj); 375 376 if (obj->bp->type != bp_breakpoint) 377 Py_RETURN_NONE; 378 379 str = obj->bp->addr_string; 380 381 if (! str) 382 str = ""; 383 return PyString_Decode (str, strlen (str), host_charset (), NULL); 384 } 385 386 /* Python function to get the breakpoint expression. */ 387 static PyObject * 388 bppy_get_expression (PyObject *self, void *closure) 389 { 390 char *str; 391 breakpoint_object *obj = (breakpoint_object *) self; 392 struct watchpoint *wp; 393 394 BPPY_REQUIRE_VALID (obj); 395 396 if (!is_watchpoint (obj->bp)) 397 Py_RETURN_NONE; 398 399 wp = (struct watchpoint *) obj->bp; 400 401 str = wp->exp_string; 402 if (! str) 403 str = ""; 404 405 return PyString_Decode (str, strlen (str), host_charset (), NULL); 406 } 407 408 /* Python function to get the condition expression of a breakpoint. */ 409 static PyObject * 410 bppy_get_condition (PyObject *self, void *closure) 411 { 412 char *str; 413 breakpoint_object *obj = (breakpoint_object *) self; 414 415 BPPY_REQUIRE_VALID (obj); 416 417 str = obj->bp->cond_string; 418 if (! str) 419 Py_RETURN_NONE; 420 421 return PyString_Decode (str, strlen (str), host_charset (), NULL); 422 } 423 424 /* Returns 0 on success. Returns -1 on error, with a python exception set. 425 */ 426 427 static int 428 bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure) 429 { 430 char *exp; 431 breakpoint_object *self_bp = (breakpoint_object *) self; 432 volatile struct gdb_exception except; 433 434 BPPY_SET_REQUIRE_VALID (self_bp); 435 436 if (newvalue == NULL) 437 { 438 PyErr_SetString (PyExc_TypeError, 439 _("Cannot delete `condition' attribute.")); 440 return -1; 441 } 442 else if (newvalue == Py_None) 443 exp = ""; 444 else 445 { 446 exp = python_string_to_host_string (newvalue); 447 if (exp == NULL) 448 return -1; 449 } 450 451 TRY_CATCH (except, RETURN_MASK_ALL) 452 { 453 set_breakpoint_condition (self_bp->bp, exp, 0); 454 } 455 456 if (newvalue != Py_None) 457 xfree (exp); 458 459 GDB_PY_SET_HANDLE_EXCEPTION (except); 460 461 return 0; 462 } 463 464 /* Python function to get the commands attached to a breakpoint. */ 465 static PyObject * 466 bppy_get_commands (PyObject *self, void *closure) 467 { 468 breakpoint_object *self_bp = (breakpoint_object *) self; 469 struct breakpoint *bp = self_bp->bp; 470 long length; 471 volatile struct gdb_exception except; 472 struct ui_file *string_file; 473 struct cleanup *chain; 474 PyObject *result; 475 char *cmdstr; 476 477 BPPY_REQUIRE_VALID (self_bp); 478 479 if (! self_bp->bp->commands) 480 Py_RETURN_NONE; 481 482 string_file = mem_fileopen (); 483 chain = make_cleanup_ui_file_delete (string_file); 484 485 ui_out_redirect (current_uiout, string_file); 486 TRY_CATCH (except, RETURN_MASK_ALL) 487 { 488 print_command_lines (current_uiout, breakpoint_commands (bp), 0); 489 } 490 ui_out_redirect (current_uiout, NULL); 491 GDB_PY_HANDLE_EXCEPTION (except); 492 493 cmdstr = ui_file_xstrdup (string_file, &length); 494 make_cleanup (xfree, cmdstr); 495 result = PyString_Decode (cmdstr, strlen (cmdstr), host_charset (), NULL); 496 do_cleanups (chain); 497 return result; 498 } 499 500 /* Python function to get the breakpoint type. */ 501 static PyObject * 502 bppy_get_type (PyObject *self, void *closure) 503 { 504 breakpoint_object *self_bp = (breakpoint_object *) self; 505 506 BPPY_REQUIRE_VALID (self_bp); 507 508 return PyInt_FromLong (self_bp->bp->type); 509 } 510 511 /* Python function to get the visibility of the breakpoint. */ 512 513 static PyObject * 514 bppy_get_visibility (PyObject *self, void *closure) 515 { 516 breakpoint_object *self_bp = (breakpoint_object *) self; 517 518 BPPY_REQUIRE_VALID (self_bp); 519 520 if (self_bp->bp->number < 0) 521 Py_RETURN_FALSE; 522 523 Py_RETURN_TRUE; 524 } 525 526 /* Python function to get the breakpoint's number. */ 527 static PyObject * 528 bppy_get_number (PyObject *self, void *closure) 529 { 530 breakpoint_object *self_bp = (breakpoint_object *) self; 531 532 BPPY_REQUIRE_VALID (self_bp); 533 534 return PyInt_FromLong (self_bp->number); 535 } 536 537 /* Python function to get the breakpoint's thread ID. */ 538 static PyObject * 539 bppy_get_thread (PyObject *self, void *closure) 540 { 541 breakpoint_object *self_bp = (breakpoint_object *) self; 542 543 BPPY_REQUIRE_VALID (self_bp); 544 545 if (self_bp->bp->thread == -1) 546 Py_RETURN_NONE; 547 548 return PyInt_FromLong (self_bp->bp->thread); 549 } 550 551 /* Python function to get the breakpoint's task ID (in Ada). */ 552 static PyObject * 553 bppy_get_task (PyObject *self, void *closure) 554 { 555 breakpoint_object *self_bp = (breakpoint_object *) self; 556 557 BPPY_REQUIRE_VALID (self_bp); 558 559 if (self_bp->bp->task == 0) 560 Py_RETURN_NONE; 561 562 return PyInt_FromLong (self_bp->bp->task); 563 } 564 565 /* Python function to get the breakpoint's hit count. */ 566 static PyObject * 567 bppy_get_hit_count (PyObject *self, void *closure) 568 { 569 breakpoint_object *self_bp = (breakpoint_object *) self; 570 571 BPPY_REQUIRE_VALID (self_bp); 572 573 return PyInt_FromLong (self_bp->bp->hit_count); 574 } 575 576 /* Python function to get the breakpoint's ignore count. */ 577 static PyObject * 578 bppy_get_ignore_count (PyObject *self, void *closure) 579 { 580 breakpoint_object *self_bp = (breakpoint_object *) self; 581 582 BPPY_REQUIRE_VALID (self_bp); 583 584 return PyInt_FromLong (self_bp->bp->ignore_count); 585 } 586 587 /* Python function to create a new breakpoint. */ 588 static int 589 bppy_init (PyObject *self, PyObject *args, PyObject *kwargs) 590 { 591 static char *keywords[] = { "spec", "type", "wp_class", "internal", NULL }; 592 const char *spec; 593 int type = bp_breakpoint; 594 int access_type = hw_write; 595 PyObject *internal = NULL; 596 int internal_bp = 0; 597 volatile struct gdb_exception except; 598 599 if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiO", keywords, 600 &spec, &type, &access_type, &internal)) 601 return -1; 602 603 if (internal) 604 { 605 internal_bp = PyObject_IsTrue (internal); 606 if (internal_bp == -1) 607 return -1; 608 } 609 610 bppy_pending_object = (breakpoint_object *) self; 611 bppy_pending_object->number = -1; 612 bppy_pending_object->bp = NULL; 613 614 TRY_CATCH (except, RETURN_MASK_ALL) 615 { 616 char *copy = xstrdup (spec); 617 struct cleanup *cleanup = make_cleanup (xfree, copy); 618 619 switch (type) 620 { 621 case bp_breakpoint: 622 { 623 create_breakpoint (python_gdbarch, 624 copy, NULL, -1, 625 0, 626 0, bp_breakpoint, 627 0, 628 AUTO_BOOLEAN_TRUE, 629 &bkpt_breakpoint_ops, 630 0, 1, internal_bp, 0); 631 break; 632 } 633 case bp_watchpoint: 634 { 635 if (access_type == hw_write) 636 watch_command_wrapper (copy, 0, internal_bp); 637 else if (access_type == hw_access) 638 awatch_command_wrapper (copy, 0, internal_bp); 639 else if (access_type == hw_read) 640 rwatch_command_wrapper (copy, 0, internal_bp); 641 else 642 error(_("Cannot understand watchpoint access type.")); 643 break; 644 } 645 default: 646 error(_("Do not understand breakpoint type to set.")); 647 } 648 649 do_cleanups (cleanup); 650 } 651 if (except.reason < 0) 652 { 653 PyErr_Format (except.reason == RETURN_QUIT 654 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, 655 "%s", except.message); 656 return -1; 657 } 658 659 BPPY_SET_REQUIRE_VALID ((breakpoint_object *) self); 660 return 0; 661 } 662 663 664 665 static int 666 build_bp_list (struct breakpoint *b, void *arg) 667 { 668 PyObject *list = arg; 669 PyObject *bp = (PyObject *) b->py_bp_object; 670 int iserr = 0; 671 672 /* Not all breakpoints will have a companion Python object. 673 Only breakpoints that were created via bppy_new, or 674 breakpoints that were created externally and are tracked by 675 the Python Scripting API. */ 676 if (bp) 677 iserr = PyList_Append (list, bp); 678 679 if (iserr == -1) 680 return 1; 681 682 return 0; 683 } 684 685 /* Static function to return a tuple holding all breakpoints. */ 686 687 PyObject * 688 gdbpy_breakpoints (PyObject *self, PyObject *args) 689 { 690 PyObject *list, *tuple; 691 692 if (bppy_live == 0) 693 Py_RETURN_NONE; 694 695 list = PyList_New (0); 696 if (!list) 697 return NULL; 698 699 /* If iteratre_over_breakpoints returns non NULL it signals an error 700 condition. In that case abandon building the list and return 701 NULL. */ 702 if (iterate_over_breakpoints (build_bp_list, list) != NULL) 703 { 704 Py_DECREF (list); 705 return NULL; 706 } 707 708 tuple = PyList_AsTuple (list); 709 Py_DECREF (list); 710 711 return tuple; 712 } 713 714 /* Call the "stop" method (if implemented) in the breakpoint 715 class. If the method returns True, the inferior will be 716 stopped at the breakpoint. Otherwise the inferior will be 717 allowed to continue. */ 718 719 int 720 gdbpy_should_stop (struct breakpoint_object *bp_obj) 721 { 722 int stop = 1; 723 724 PyObject *py_bp = (PyObject *) bp_obj; 725 struct breakpoint *b = bp_obj->bp; 726 struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch (); 727 struct cleanup *cleanup = ensure_python_env (garch, current_language); 728 729 if (bp_obj->is_finish_bp) 730 bpfinishpy_pre_stop_hook (bp_obj); 731 732 if (PyObject_HasAttrString (py_bp, stop_func)) 733 { 734 PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL); 735 736 if (result) 737 { 738 int evaluate = PyObject_IsTrue (result); 739 740 if (evaluate == -1) 741 gdbpy_print_stack (); 742 743 /* If the "stop" function returns False that means 744 the Python breakpoint wants GDB to continue. */ 745 if (! evaluate) 746 stop = 0; 747 748 Py_DECREF (result); 749 } 750 else 751 gdbpy_print_stack (); 752 } 753 754 if (bp_obj->is_finish_bp) 755 bpfinishpy_post_stop_hook (bp_obj); 756 757 do_cleanups (cleanup); 758 759 return stop; 760 } 761 762 /* Checks if the "stop" method exists in this breakpoint. 763 Used by condition_command to ensure mutual exclusion of breakpoint 764 conditions. */ 765 766 int 767 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj) 768 { 769 int has_func = 0; 770 PyObject *py_bp = (PyObject *) bp_obj; 771 struct gdbarch *garch = bp_obj->bp->gdbarch ? bp_obj->bp->gdbarch : 772 get_current_arch (); 773 struct cleanup *cleanup = ensure_python_env (garch, current_language); 774 775 if (py_bp != NULL) 776 has_func = PyObject_HasAttrString (py_bp, stop_func); 777 778 do_cleanups (cleanup); 779 780 return has_func; 781 } 782 783 784 785 /* Event callback functions. */ 786 787 /* Callback that is used when a breakpoint is created. This function 788 will create a new Python breakpoint object. */ 789 static void 790 gdbpy_breakpoint_created (struct breakpoint *bp) 791 { 792 breakpoint_object *newbp; 793 PyGILState_STATE state; 794 795 if (bp->number < 0 && bppy_pending_object == NULL) 796 return; 797 798 if (bp->type != bp_breakpoint 799 && bp->type != bp_watchpoint 800 && bp->type != bp_hardware_watchpoint 801 && bp->type != bp_read_watchpoint 802 && bp->type != bp_access_watchpoint) 803 return; 804 805 state = PyGILState_Ensure (); 806 807 if (bppy_pending_object) 808 { 809 newbp = bppy_pending_object; 810 bppy_pending_object = NULL; 811 } 812 else 813 newbp = PyObject_New (breakpoint_object, &breakpoint_object_type); 814 if (newbp) 815 { 816 newbp->number = bp->number; 817 newbp->bp = bp; 818 newbp->bp->py_bp_object = newbp; 819 newbp->is_finish_bp = 0; 820 Py_INCREF (newbp); 821 ++bppy_live; 822 } 823 else 824 { 825 PyErr_SetString (PyExc_RuntimeError, 826 _("Error while creating breakpoint from GDB.")); 827 gdbpy_print_stack (); 828 } 829 830 PyGILState_Release (state); 831 } 832 833 /* Callback that is used when a breakpoint is deleted. This will 834 invalidate the corresponding Python object. */ 835 static void 836 gdbpy_breakpoint_deleted (struct breakpoint *b) 837 { 838 int num = b->number; 839 PyGILState_STATE state; 840 struct breakpoint *bp = NULL; 841 breakpoint_object *bp_obj; 842 843 state = PyGILState_Ensure (); 844 bp = get_breakpoint (num); 845 if (bp) 846 { 847 bp_obj = bp->py_bp_object; 848 if (bp_obj) 849 { 850 bp_obj->bp = NULL; 851 --bppy_live; 852 Py_DECREF (bp_obj); 853 } 854 } 855 PyGILState_Release (state); 856 } 857 858 859 860 /* Initialize the Python breakpoint code. */ 861 void 862 gdbpy_initialize_breakpoints (void) 863 { 864 int i; 865 866 breakpoint_object_type.tp_new = PyType_GenericNew; 867 if (PyType_Ready (&breakpoint_object_type) < 0) 868 return; 869 870 Py_INCREF (&breakpoint_object_type); 871 PyModule_AddObject (gdb_module, "Breakpoint", 872 (PyObject *) &breakpoint_object_type); 873 874 observer_attach_breakpoint_created (gdbpy_breakpoint_created); 875 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted); 876 877 /* Add breakpoint types constants. */ 878 for (i = 0; pybp_codes[i].name; ++i) 879 { 880 if (PyModule_AddIntConstant (gdb_module, 881 /* Cast needed for Python 2.4. */ 882 (char *) pybp_codes[i].name, 883 pybp_codes[i].code) < 0) 884 return; 885 } 886 887 /* Add watchpoint types constants. */ 888 for (i = 0; pybp_watch_types[i].name; ++i) 889 { 890 if (PyModule_AddIntConstant (gdb_module, 891 /* Cast needed for Python 2.4. */ 892 (char *) pybp_watch_types[i].name, 893 pybp_watch_types[i].code) < 0) 894 return; 895 } 896 897 } 898 899 900 901 /* Helper function that overrides this Python object's 902 PyObject_GenericSetAttr to allow extra validation of the attribute 903 being set. */ 904 905 static int 906 local_setattro (PyObject *self, PyObject *name, PyObject *v) 907 { 908 breakpoint_object *obj = (breakpoint_object *) self; 909 char *attr = python_string_to_host_string (name); 910 911 if (attr == NULL) 912 return -1; 913 914 /* If the attribute trying to be set is the "stop" method, 915 but we already have a condition set in the CLI, disallow this 916 operation. */ 917 if (strcmp (attr, stop_func) == 0 && obj->bp->cond_string) 918 { 919 xfree (attr); 920 PyErr_SetString (PyExc_RuntimeError, 921 _("Cannot set 'stop' method. There is an " \ 922 "existing GDB condition attached to the " \ 923 "breakpoint.")); 924 return -1; 925 } 926 927 xfree (attr); 928 929 return PyObject_GenericSetAttr ((PyObject *)self, name, v); 930 } 931 932 static PyGetSetDef breakpoint_object_getset[] = { 933 { "enabled", bppy_get_enabled, bppy_set_enabled, 934 "Boolean telling whether the breakpoint is enabled.", NULL }, 935 { "silent", bppy_get_silent, bppy_set_silent, 936 "Boolean telling whether the breakpoint is silent.", NULL }, 937 { "thread", bppy_get_thread, bppy_set_thread, 938 "Thread ID for the breakpoint.\n\ 939 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\ 940 If the value is None, then this breakpoint is not thread-specific.\n\ 941 No other type of value can be used.", NULL }, 942 { "task", bppy_get_task, bppy_set_task, 943 "Thread ID for the breakpoint.\n\ 944 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\ 945 If the value is None, then this breakpoint is not task-specific.\n\ 946 No other type of value can be used.", NULL }, 947 { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count, 948 "Number of times this breakpoint should be automatically continued.", 949 NULL }, 950 { "number", bppy_get_number, NULL, 951 "Breakpoint's number assigned by GDB.", NULL }, 952 { "hit_count", bppy_get_hit_count, bppy_set_hit_count, 953 "Number of times the breakpoint has been hit.\n\ 954 Can be set to zero to clear the count. No other value is valid\n\ 955 when setting this property.", NULL }, 956 { "location", bppy_get_location, NULL, 957 "Location of the breakpoint, as specified by the user.", NULL}, 958 { "expression", bppy_get_expression, NULL, 959 "Expression of the breakpoint, as specified by the user.", NULL}, 960 { "condition", bppy_get_condition, bppy_set_condition, 961 "Condition of the breakpoint, as specified by the user,\ 962 or None if no condition set."}, 963 { "commands", bppy_get_commands, NULL, 964 "Commands of the breakpoint, as specified by the user."}, 965 { "type", bppy_get_type, NULL, 966 "Type of breakpoint."}, 967 { "visible", bppy_get_visibility, NULL, 968 "Whether the breakpoint is visible to the user."}, 969 { NULL } /* Sentinel. */ 970 }; 971 972 static PyMethodDef breakpoint_object_methods[] = 973 { 974 { "is_valid", bppy_is_valid, METH_NOARGS, 975 "Return true if this breakpoint is valid, false if not." }, 976 { "delete", bppy_delete_breakpoint, METH_NOARGS, 977 "Delete the underlying GDB breakpoint." }, 978 { NULL } /* Sentinel. */ 979 }; 980 981 PyTypeObject breakpoint_object_type = 982 { 983 PyObject_HEAD_INIT (NULL) 984 0, /*ob_size*/ 985 "gdb.Breakpoint", /*tp_name*/ 986 sizeof (breakpoint_object), /*tp_basicsize*/ 987 0, /*tp_itemsize*/ 988 0, /*tp_dealloc*/ 989 0, /*tp_print*/ 990 0, /*tp_getattr*/ 991 0, /*tp_setattr*/ 992 0, /*tp_compare*/ 993 0, /*tp_repr*/ 994 0, /*tp_as_number*/ 995 0, /*tp_as_sequence*/ 996 0, /*tp_as_mapping*/ 997 0, /*tp_hash */ 998 0, /*tp_call*/ 999 0, /*tp_str*/ 1000 0, /*tp_getattro*/ 1001 (setattrofunc)local_setattro, /*tp_setattro */ 1002 0, /*tp_as_buffer*/ 1003 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 1004 "GDB breakpoint object", /* tp_doc */ 1005 0, /* tp_traverse */ 1006 0, /* tp_clear */ 1007 0, /* tp_richcompare */ 1008 0, /* tp_weaklistoffset */ 1009 0, /* tp_iter */ 1010 0, /* tp_iternext */ 1011 breakpoint_object_methods, /* tp_methods */ 1012 0, /* tp_members */ 1013 breakpoint_object_getset, /* tp_getset */ 1014 0, /* tp_base */ 1015 0, /* tp_dict */ 1016 0, /* tp_descr_get */ 1017 0, /* tp_descr_set */ 1018 0, /* tp_dictoffset */ 1019 bppy_init, /* tp_init */ 1020 0, /* tp_alloc */ 1021 }; 1022