1 /* Python interface to breakpoints
3 Copyright (C) 2008-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "python-internal.h"
25 #include "breakpoint.h"
27 #include "gdbthread.h"
28 #include "observable.h"
29 #include "cli/cli-script.h"
31 #include "arch-utils.h"
37 /* Number of live breakpoints. */
40 /* Variables used to pass information between the Breakpoint
41 constructor and the breakpoint-created hook function. */
42 gdbpy_breakpoint_object
*bppy_pending_object
;
44 /* Function that is called when a Python condition is evaluated. */
45 static const char stop_func
[] = "stop";
47 /* This is used to initialize various gdb.bp_* constants. */
56 /* Entries related to the type of user set breakpoints. */
57 static struct pybp_code pybp_codes
[] =
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. */
68 /* Entries related to the type of watchpoint. */
69 static struct pybp_code pybp_watch_types
[] =
71 { "WP_READ", hw_read
},
72 { "WP_WRITE", hw_write
},
73 { "WP_ACCESS", hw_access
},
74 {NULL
} /* Sentinel. */
77 /* Python function which checks the validity of a breakpoint object. */
79 bppy_is_valid (PyObject
*self
, PyObject
*args
)
81 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
88 /* Python function to test whether or not the breakpoint is enabled. */
90 bppy_get_enabled (PyObject
*self
, void *closure
)
92 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
94 BPPY_REQUIRE_VALID (self_bp
);
97 if (self_bp
->bp
->enable_state
== bp_enabled
)
102 /* Python function to test whether or not the breakpoint is silent. */
104 bppy_get_silent (PyObject
*self
, void *closure
)
106 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
108 BPPY_REQUIRE_VALID (self_bp
);
109 if (self_bp
->bp
->silent
)
114 /* Python function to set the enabled state of a breakpoint. */
116 bppy_set_enabled (PyObject
*self
, PyObject
*newvalue
, void *closure
)
118 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
121 BPPY_SET_REQUIRE_VALID (self_bp
);
123 if (newvalue
== NULL
)
125 PyErr_SetString (PyExc_TypeError
,
126 _("Cannot delete `enabled' attribute."));
130 else if (! PyBool_Check (newvalue
))
132 PyErr_SetString (PyExc_TypeError
,
133 _("The value of `enabled' must be a boolean."));
137 cmp
= PyObject_IsTrue (newvalue
);
144 enable_breakpoint (self_bp
->bp
);
146 disable_breakpoint (self_bp
->bp
);
148 catch (const gdb_exception
&except
)
150 GDB_PY_SET_HANDLE_EXCEPTION (except
);
156 /* Python function to set the 'silent' state of a breakpoint. */
158 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
160 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
163 BPPY_SET_REQUIRE_VALID (self_bp
);
165 if (newvalue
== NULL
)
167 PyErr_SetString (PyExc_TypeError
,
168 _("Cannot delete `silent' attribute."));
171 else if (! PyBool_Check (newvalue
))
173 PyErr_SetString (PyExc_TypeError
,
174 _("The value of `silent' must be a boolean."));
178 cmp
= PyObject_IsTrue (newvalue
);
182 breakpoint_set_silent (self_bp
->bp
, cmp
);
187 /* Python function to set the thread of a breakpoint. */
189 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
191 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
194 BPPY_SET_REQUIRE_VALID (self_bp
);
196 if (newvalue
== NULL
)
198 PyErr_SetString (PyExc_TypeError
,
199 _("Cannot delete `thread' attribute."));
202 else if (PyInt_Check (newvalue
))
204 if (! gdb_py_int_as_long (newvalue
, &id
))
207 if (!valid_global_thread_id (id
))
209 PyErr_SetString (PyExc_RuntimeError
,
210 _("Invalid thread ID."));
214 else if (newvalue
== Py_None
)
218 PyErr_SetString (PyExc_TypeError
,
219 _("The value of `thread' must be an integer or None."));
223 breakpoint_set_thread (self_bp
->bp
, id
);
228 /* Python function to set the (Ada) task of a breakpoint. */
230 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
232 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
236 BPPY_SET_REQUIRE_VALID (self_bp
);
238 if (newvalue
== NULL
)
240 PyErr_SetString (PyExc_TypeError
,
241 _("Cannot delete `task' attribute."));
244 else if (PyInt_Check (newvalue
))
246 if (! gdb_py_int_as_long (newvalue
, &id
))
251 valid_id
= valid_task_id (id
);
253 catch (const gdb_exception
&except
)
255 GDB_PY_SET_HANDLE_EXCEPTION (except
);
260 PyErr_SetString (PyExc_RuntimeError
,
261 _("Invalid task ID."));
265 else if (newvalue
== Py_None
)
269 PyErr_SetString (PyExc_TypeError
,
270 _("The value of `task' must be an integer or None."));
274 breakpoint_set_task (self_bp
->bp
, id
);
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
285 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
287 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
289 BPPY_REQUIRE_VALID (self_bp
);
293 delete_breakpoint (self_bp
->bp
);
295 catch (const gdb_exception
&except
)
297 GDB_PY_HANDLE_EXCEPTION (except
);
304 /* Python function to set the ignore count of a breakpoint. */
306 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
308 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
311 BPPY_SET_REQUIRE_VALID (self_bp
);
313 if (newvalue
== NULL
)
315 PyErr_SetString (PyExc_TypeError
,
316 _("Cannot delete `ignore_count' attribute."));
319 else if (! PyInt_Check (newvalue
))
321 PyErr_SetString (PyExc_TypeError
,
322 _("The value of `ignore_count' must be an integer."));
326 if (! gdb_py_int_as_long (newvalue
, &value
))
334 set_ignore_count (self_bp
->number
, (int) value
, 0);
336 catch (const gdb_exception
&except
)
338 GDB_PY_SET_HANDLE_EXCEPTION (except
);
344 /* Python function to set the hit count of a breakpoint. */
346 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
348 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
350 BPPY_SET_REQUIRE_VALID (self_bp
);
352 if (newvalue
== NULL
)
354 PyErr_SetString (PyExc_TypeError
,
355 _("Cannot delete `hit_count' attribute."));
362 if (! gdb_py_int_as_long (newvalue
, &value
))
367 PyErr_SetString (PyExc_AttributeError
,
368 _("The value of `hit_count' must be zero."));
373 self_bp
->bp
->hit_count
= 0;
378 /* Python function to get the location of a breakpoint. */
380 bppy_get_location (PyObject
*self
, void *closure
)
382 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
384 BPPY_REQUIRE_VALID (obj
);
386 if (obj
->bp
->type
!= bp_breakpoint
)
389 const char *str
= event_location_to_string (obj
->bp
->location
.get ());
392 return host_string_to_python_string (str
).release ();
395 /* Python function to get the breakpoint expression. */
397 bppy_get_expression (PyObject
*self
, void *closure
)
400 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
401 struct watchpoint
*wp
;
403 BPPY_REQUIRE_VALID (obj
);
405 if (!is_watchpoint (obj
->bp
))
408 wp
= (struct watchpoint
*) obj
->bp
;
410 str
= wp
->exp_string
;
414 return host_string_to_python_string (str
).release ();
417 /* Python function to get the condition expression of a breakpoint. */
419 bppy_get_condition (PyObject
*self
, void *closure
)
422 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
424 BPPY_REQUIRE_VALID (obj
);
426 str
= obj
->bp
->cond_string
;
430 return host_string_to_python_string (str
).release ();
433 /* Returns 0 on success. Returns -1 on error, with a python exception set.
437 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
439 gdb::unique_xmalloc_ptr
<char> exp_holder
;
440 const char *exp
= NULL
;
441 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
442 struct gdb_exception except
;
444 BPPY_SET_REQUIRE_VALID (self_bp
);
446 if (newvalue
== NULL
)
448 PyErr_SetString (PyExc_TypeError
,
449 _("Cannot delete `condition' attribute."));
452 else if (newvalue
== Py_None
)
456 exp_holder
= python_string_to_host_string (newvalue
);
457 if (exp_holder
== NULL
)
459 exp
= exp_holder
.get ();
464 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
466 catch (gdb_exception
&ex
)
468 except
= std::move (ex
);
471 GDB_PY_SET_HANDLE_EXCEPTION (except
);
476 /* Python function to get the commands attached to a breakpoint. */
478 bppy_get_commands (PyObject
*self
, void *closure
)
480 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
481 struct breakpoint
*bp
= self_bp
->bp
;
483 BPPY_REQUIRE_VALID (self_bp
);
485 if (! self_bp
->bp
->commands
)
490 current_uiout
->redirect (&stb
);
493 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
495 catch (const gdb_exception
&except
)
497 current_uiout
->redirect (NULL
);
498 gdbpy_convert_exception (except
);
502 current_uiout
->redirect (NULL
);
503 return host_string_to_python_string (stb
.c_str ()).release ();
506 /* Set the commands attached to a breakpoint. Returns 0 on success.
507 Returns -1 on error, with a python exception set. */
509 bppy_set_commands (PyObject
*self
, PyObject
*newvalue
, void *closure
)
511 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
512 struct gdb_exception except
;
514 BPPY_SET_REQUIRE_VALID (self_bp
);
516 gdb::unique_xmalloc_ptr
<char> commands
517 (python_string_to_host_string (newvalue
));
518 if (commands
== nullptr)
524 char *save_ptr
= nullptr;
528 const char *result
= strtok_r (first
? commands
.get () : nullptr,
534 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
535 breakpoint_set_commands (self_bp
->bp
, std::move (lines
));
537 catch (gdb_exception
&ex
)
539 except
= std::move (ex
);
542 GDB_PY_SET_HANDLE_EXCEPTION (except
);
547 /* Python function to get the breakpoint type. */
549 bppy_get_type (PyObject
*self
, void *closure
)
551 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
553 BPPY_REQUIRE_VALID (self_bp
);
555 return PyInt_FromLong (self_bp
->bp
->type
);
558 /* Python function to get the visibility of the breakpoint. */
561 bppy_get_visibility (PyObject
*self
, void *closure
)
563 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
565 BPPY_REQUIRE_VALID (self_bp
);
567 if (user_breakpoint_p (self_bp
->bp
))
573 /* Python function to determine if the breakpoint is a temporary
577 bppy_get_temporary (PyObject
*self
, void *closure
)
579 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
581 BPPY_REQUIRE_VALID (self_bp
);
583 if (self_bp
->bp
->disposition
== disp_del
584 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
590 /* Python function to determine if the breakpoint is a pending
594 bppy_get_pending (PyObject
*self
, void *closure
)
596 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
598 BPPY_REQUIRE_VALID (self_bp
);
600 if (is_watchpoint (self_bp
->bp
))
602 if (pending_breakpoint_p (self_bp
->bp
))
608 /* Python function to get the breakpoint's number. */
610 bppy_get_number (PyObject
*self
, void *closure
)
612 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
614 BPPY_REQUIRE_VALID (self_bp
);
616 return PyInt_FromLong (self_bp
->number
);
619 /* Python function to get the breakpoint's thread ID. */
621 bppy_get_thread (PyObject
*self
, void *closure
)
623 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
625 BPPY_REQUIRE_VALID (self_bp
);
627 if (self_bp
->bp
->thread
== -1)
630 return PyInt_FromLong (self_bp
->bp
->thread
);
633 /* Python function to get the breakpoint's task ID (in Ada). */
635 bppy_get_task (PyObject
*self
, void *closure
)
637 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
639 BPPY_REQUIRE_VALID (self_bp
);
641 if (self_bp
->bp
->task
== 0)
644 return PyInt_FromLong (self_bp
->bp
->task
);
647 /* Python function to get the breakpoint's hit count. */
649 bppy_get_hit_count (PyObject
*self
, void *closure
)
651 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
653 BPPY_REQUIRE_VALID (self_bp
);
655 return PyInt_FromLong (self_bp
->bp
->hit_count
);
658 /* Python function to get the breakpoint's ignore count. */
660 bppy_get_ignore_count (PyObject
*self
, void *closure
)
662 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
664 BPPY_REQUIRE_VALID (self_bp
);
666 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
669 /* Internal function to validate the Python parameters/keywords
670 provided to bppy_init. */
673 bppy_init_validate_args (const char *spec
, char *source
,
674 char *function
, char *label
,
675 char *line
, enum bptype type
)
677 /* If spec is defined, ensure that none of the explicit location
678 keywords are also defined. */
681 if (source
!= NULL
|| function
!= NULL
|| label
!= NULL
|| line
!= NULL
)
683 PyErr_SetString (PyExc_RuntimeError
,
684 _("Breakpoints specified with spec cannot "
685 "have source, function, label or line defined."));
691 /* If spec isn't defined, ensure that the user is not trying to
692 define a watchpoint with an explicit location. */
693 if (type
== bp_watchpoint
)
695 PyErr_SetString (PyExc_RuntimeError
,
696 _("Watchpoints cannot be set by explicit "
697 "location parameters."));
702 /* Otherwise, ensure some explicit locations are defined. */
703 if (source
== NULL
&& function
== NULL
&& label
== NULL
706 PyErr_SetString (PyExc_RuntimeError
,
707 _("Neither spec nor explicit location set."));
710 /* Finally, if source is specified, ensure that line, label
711 or function are specified too. */
712 if (source
!= NULL
&& function
== NULL
&& label
== NULL
715 PyErr_SetString (PyExc_RuntimeError
,
716 _("Specifying a source must also include a "
717 "line, label or function."));
725 /* Python function to create a new breakpoint. */
727 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
729 static const char *keywords
[] = { "spec", "type", "wp_class", "internal",
730 "temporary","source", "function",
731 "label", "line", "qualified", NULL
};
732 const char *spec
= NULL
;
733 enum bptype type
= bp_breakpoint
;
734 int access_type
= hw_write
;
735 PyObject
*internal
= NULL
;
736 PyObject
*temporary
= NULL
;
737 PyObject
*lineobj
= NULL
;;
739 int temporary_bp
= 0;
740 gdb::unique_xmalloc_ptr
<char> line
;
743 char *function
= NULL
;
744 PyObject
* qualified
= NULL
;
746 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kwargs
, "|siiOOsssOO", keywords
,
747 &spec
, &type
, &access_type
,
750 &function
, &label
, &lineobj
,
757 if (PyInt_Check (lineobj
))
758 line
.reset (xstrprintf ("%ld", PyInt_AsLong (lineobj
)));
759 else if (PyString_Check (lineobj
))
760 line
= python_string_to_host_string (lineobj
);
763 PyErr_SetString (PyExc_RuntimeError
,
764 _("Line keyword should be an integer or a string. "));
771 internal_bp
= PyObject_IsTrue (internal
);
772 if (internal_bp
== -1)
776 if (temporary
!= NULL
)
778 temporary_bp
= PyObject_IsTrue (temporary
);
779 if (temporary_bp
== -1)
783 if (bppy_init_validate_args (spec
, source
, function
, label
, line
.get (),
787 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
788 bppy_pending_object
->number
= -1;
789 bppy_pending_object
->bp
= NULL
;
797 event_location_up location
;
798 symbol_name_match_type func_name_match_type
799 = (qualified
!= NULL
&& PyObject_IsTrue (qualified
)
800 ? symbol_name_match_type::FULL
801 : symbol_name_match_type::WILD
);
805 gdb::unique_xmalloc_ptr
<char>
806 copy_holder (xstrdup (skip_spaces (spec
)));
807 const char *copy
= copy_holder
.get ();
809 location
= string_to_event_location (©
,
811 func_name_match_type
);
815 struct explicit_location explicit_loc
;
817 initialize_explicit_location (&explicit_loc
);
818 explicit_loc
.source_filename
= source
;
819 explicit_loc
.function_name
= function
;
820 explicit_loc
.label_name
= label
;
823 explicit_loc
.line_offset
=
824 linespec_parse_line_offset (line
.get ());
826 explicit_loc
.func_name_match_type
= func_name_match_type
;
828 location
= new_explicit_location (&explicit_loc
);
831 create_breakpoint (python_gdbarch
,
832 location
.get (), NULL
, -1, NULL
,
834 temporary_bp
, bp_breakpoint
,
837 &bkpt_breakpoint_ops
,
838 0, 1, internal_bp
, 0);
843 gdb::unique_xmalloc_ptr
<char>
844 copy_holder (xstrdup (skip_spaces (spec
)));
845 char *copy
= copy_holder
.get ();
847 if (access_type
== hw_write
)
848 watch_command_wrapper (copy
, 0, internal_bp
);
849 else if (access_type
== hw_access
)
850 awatch_command_wrapper (copy
, 0, internal_bp
);
851 else if (access_type
== hw_read
)
852 rwatch_command_wrapper (copy
, 0, internal_bp
);
854 error(_("Cannot understand watchpoint access type."));
858 error(_("Do not understand breakpoint type to set."));
861 catch (const gdb_exception
&except
)
863 bppy_pending_object
= NULL
;
864 gdbpy_convert_exception (except
);
868 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
875 build_bp_list (struct breakpoint
*b
, PyObject
*list
)
877 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
880 /* Not all breakpoints will have a companion Python object.
881 Only breakpoints that were created via bppy_new, or
882 breakpoints that were created externally and are tracked by
883 the Python Scripting API. */
885 iserr
= PyList_Append (list
, bp
);
893 /* Static function to return a tuple holding all breakpoints. */
896 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
899 return PyTuple_New (0);
901 gdbpy_ref
<> list (PyList_New (0));
905 /* If iterate_over_breakpoints returns non NULL it signals an error
906 condition. In that case abandon building the list and return
908 auto callback
= [&] (breakpoint
*bp
)
910 return build_bp_list(bp
, list
.get ());
912 if (iterate_over_breakpoints (callback
) != NULL
)
915 return PyList_AsTuple (list
.get ());
918 /* Call the "stop" method (if implemented) in the breakpoint
919 class. If the method returns True, the inferior will be
920 stopped at the breakpoint. Otherwise the inferior will be
921 allowed to continue. */
923 enum ext_lang_bp_stop
924 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
925 struct breakpoint
*b
)
928 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
929 PyObject
*py_bp
= (PyObject
*) bp_obj
;
930 struct gdbarch
*garch
;
933 return EXT_LANG_BP_STOP_UNSET
;
936 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
938 gdbpy_enter
enter_py (garch
, current_language
);
940 if (bp_obj
->is_finish_bp
)
941 bpfinishpy_pre_stop_hook (bp_obj
);
943 if (PyObject_HasAttrString (py_bp
, stop_func
))
945 gdbpy_ref
<> result (PyObject_CallMethod (py_bp
, stop_func
, NULL
));
950 int evaluate
= PyObject_IsTrue (result
.get ());
953 gdbpy_print_stack ();
955 /* If the "stop" function returns False that means
956 the Python breakpoint wants GDB to continue. */
961 gdbpy_print_stack ();
964 if (bp_obj
->is_finish_bp
)
965 bpfinishpy_post_stop_hook (bp_obj
);
968 return EXT_LANG_BP_STOP_UNSET
;
969 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
972 /* Checks if the "stop" method exists in this breakpoint.
973 Used by condition_command to ensure mutual exclusion of breakpoint
977 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
978 struct breakpoint
*b
)
981 struct gdbarch
*garch
;
983 if (b
->py_bp_object
== NULL
)
986 py_bp
= (PyObject
*) b
->py_bp_object
;
987 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
989 gdbpy_enter
enter_py (garch
, current_language
);
990 return PyObject_HasAttrString (py_bp
, stop_func
);
995 /* Event callback functions. */
997 /* Callback that is used when a breakpoint is created. This function
998 will create a new Python breakpoint object. */
1000 gdbpy_breakpoint_created (struct breakpoint
*bp
)
1002 gdbpy_breakpoint_object
*newbp
;
1004 if (!user_breakpoint_p (bp
) && bppy_pending_object
== NULL
)
1007 if (bp
->type
!= bp_breakpoint
1008 && bp
->type
!= bp_watchpoint
1009 && bp
->type
!= bp_hardware_watchpoint
1010 && bp
->type
!= bp_read_watchpoint
1011 && bp
->type
!= bp_access_watchpoint
)
1014 struct gdbarch
*garch
= bp
->gdbarch
? bp
->gdbarch
: get_current_arch ();
1015 gdbpy_enter
enter_py (garch
, current_language
);
1017 if (bppy_pending_object
)
1019 newbp
= bppy_pending_object
;
1021 bppy_pending_object
= NULL
;
1024 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
1027 newbp
->number
= bp
->number
;
1029 newbp
->bp
->py_bp_object
= newbp
;
1030 newbp
->is_finish_bp
= 0;
1035 PyErr_SetString (PyExc_RuntimeError
,
1036 _("Error while creating breakpoint from GDB."));
1037 gdbpy_print_stack ();
1040 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_created
))
1042 if (evpy_emit_event ((PyObject
*) newbp
,
1043 gdb_py_events
.breakpoint_created
) < 0)
1044 gdbpy_print_stack ();
1048 /* Callback that is used when a breakpoint is deleted. This will
1049 invalidate the corresponding Python object. */
1051 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
1053 int num
= b
->number
;
1054 struct breakpoint
*bp
= NULL
;
1056 bp
= get_breakpoint (num
);
1059 struct gdbarch
*garch
= bp
->gdbarch
? bp
->gdbarch
: get_current_arch ();
1060 gdbpy_enter
enter_py (garch
, current_language
);
1062 gdbpy_ref
<gdbpy_breakpoint_object
> bp_obj (bp
->py_bp_object
);
1065 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
1067 if (evpy_emit_event ((PyObject
*) bp_obj
.get (),
1068 gdb_py_events
.breakpoint_deleted
) < 0)
1069 gdbpy_print_stack ();
1078 /* Callback that is used when a breakpoint is modified. */
1081 gdbpy_breakpoint_modified (struct breakpoint
*b
)
1083 int num
= b
->number
;
1084 struct breakpoint
*bp
= NULL
;
1086 bp
= get_breakpoint (num
);
1089 struct gdbarch
*garch
= bp
->gdbarch
? bp
->gdbarch
: get_current_arch ();
1090 gdbpy_enter
enter_py (garch
, current_language
);
1092 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
1095 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
1097 if (evpy_emit_event (bp_obj
,
1098 gdb_py_events
.breakpoint_modified
) < 0)
1099 gdbpy_print_stack ();
1107 /* Initialize the Python breakpoint code. */
1109 gdbpy_initialize_breakpoints (void)
1113 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
1114 if (PyType_Ready (&breakpoint_object_type
) < 0)
1117 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
1118 (PyObject
*) &breakpoint_object_type
) < 0)
1121 gdb::observers::breakpoint_created
.attach (gdbpy_breakpoint_created
);
1122 gdb::observers::breakpoint_deleted
.attach (gdbpy_breakpoint_deleted
);
1123 gdb::observers::breakpoint_modified
.attach (gdbpy_breakpoint_modified
);
1125 /* Add breakpoint types constants. */
1126 for (i
= 0; pybp_codes
[i
].name
; ++i
)
1128 if (PyModule_AddIntConstant (gdb_module
, pybp_codes
[i
].name
,
1129 pybp_codes
[i
].code
) < 0)
1133 /* Add watchpoint types constants. */
1134 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
1136 if (PyModule_AddIntConstant (gdb_module
, pybp_watch_types
[i
].name
,
1137 pybp_watch_types
[i
].code
) < 0)
1146 /* Helper function that overrides this Python object's
1147 PyObject_GenericSetAttr to allow extra validation of the attribute
1151 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1153 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1154 gdb::unique_xmalloc_ptr
<char> attr (python_string_to_host_string (name
));
1159 /* If the attribute trying to be set is the "stop" method,
1160 but we already have a condition set in the CLI or other extension
1161 language, disallow this operation. */
1162 if (strcmp (attr
.get (), stop_func
) == 0)
1164 const struct extension_language_defn
*extlang
= NULL
;
1166 if (obj
->bp
->cond_string
!= NULL
)
1167 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1168 if (extlang
== NULL
)
1169 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1170 if (extlang
!= NULL
)
1172 std::string error_text
1173 = string_printf (_("Only one stop condition allowed. There is"
1174 " currently a %s stop condition defined for"
1175 " this breakpoint."),
1176 ext_lang_capitalized_name (extlang
));
1177 PyErr_SetString (PyExc_RuntimeError
, error_text
.c_str ());
1182 return PyObject_GenericSetAttr (self
, name
, v
);
1185 static gdb_PyGetSetDef breakpoint_object_getset
[] = {
1186 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1187 "Boolean telling whether the breakpoint is enabled.", NULL
},
1188 { "silent", bppy_get_silent
, bppy_set_silent
,
1189 "Boolean telling whether the breakpoint is silent.", NULL
},
1190 { "thread", bppy_get_thread
, bppy_set_thread
,
1191 "Thread ID for the breakpoint.\n\
1192 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1193 If the value is None, then this breakpoint is not thread-specific.\n\
1194 No other type of value can be used.", NULL
},
1195 { "task", bppy_get_task
, bppy_set_task
,
1196 "Thread ID for the breakpoint.\n\
1197 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1198 If the value is None, then this breakpoint is not task-specific.\n\
1199 No other type of value can be used.", NULL
},
1200 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1201 "Number of times this breakpoint should be automatically continued.",
1203 { "number", bppy_get_number
, NULL
,
1204 "Breakpoint's number assigned by GDB.", NULL
},
1205 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1206 "Number of times the breakpoint has been hit.\n\
1207 Can be set to zero to clear the count. No other value is valid\n\
1208 when setting this property.", NULL
},
1209 { "location", bppy_get_location
, NULL
,
1210 "Location of the breakpoint, as specified by the user.", NULL
},
1211 { "expression", bppy_get_expression
, NULL
,
1212 "Expression of the breakpoint, as specified by the user.", NULL
},
1213 { "condition", bppy_get_condition
, bppy_set_condition
,
1214 "Condition of the breakpoint, as specified by the user,\
1215 or None if no condition set."},
1216 { "commands", bppy_get_commands
, bppy_set_commands
,
1217 "Commands of the breakpoint, as specified by the user."},
1218 { "type", bppy_get_type
, NULL
,
1219 "Type of breakpoint."},
1220 { "visible", bppy_get_visibility
, NULL
,
1221 "Whether the breakpoint is visible to the user."},
1222 { "temporary", bppy_get_temporary
, NULL
,
1223 "Whether this breakpoint is a temporary breakpoint."},
1224 { "pending", bppy_get_pending
, NULL
,
1225 "Whether this breakpoint is a pending breakpoint."},
1226 { NULL
} /* Sentinel. */
1229 static PyMethodDef breakpoint_object_methods
[] =
1231 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1232 "Return true if this breakpoint is valid, false if not." },
1233 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1234 "Delete the underlying GDB breakpoint." },
1235 { NULL
} /* Sentinel. */
1238 PyTypeObject breakpoint_object_type
=
1240 PyVarObject_HEAD_INIT (NULL
, 0)
1241 "gdb.Breakpoint", /*tp_name*/
1242 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1251 0, /*tp_as_sequence*/
1252 0, /*tp_as_mapping*/
1257 (setattrofunc
)local_setattro
, /*tp_setattro */
1259 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1260 "GDB breakpoint object", /* tp_doc */
1261 0, /* tp_traverse */
1263 0, /* tp_richcompare */
1264 0, /* tp_weaklistoffset */
1266 0, /* tp_iternext */
1267 breakpoint_object_methods
, /* tp_methods */
1269 breakpoint_object_getset
, /* tp_getset */
1272 0, /* tp_descr_get */
1273 0, /* tp_descr_set */
1274 0, /* tp_dictoffset */
1275 bppy_init
, /* tp_init */