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