gdb/python/py-breakpoint.c

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