gdb/python/py-breakpoint.c

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