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