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