1 /* Python interface to breakpoints
3 Copyright (C) 2008-2018 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 (except
, RETURN_MASK_ALL
)
150 GDB_PY_SET_HANDLE_EXCEPTION (except
);
157 /* Python function to set the 'silent' state of a breakpoint. */
159 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
161 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
164 BPPY_SET_REQUIRE_VALID (self_bp
);
166 if (newvalue
== NULL
)
168 PyErr_SetString (PyExc_TypeError
,
169 _("Cannot delete `silent' attribute."));
172 else if (! PyBool_Check (newvalue
))
174 PyErr_SetString (PyExc_TypeError
,
175 _("The value of `silent' must be a boolean."));
179 cmp
= PyObject_IsTrue (newvalue
);
183 breakpoint_set_silent (self_bp
->bp
, cmp
);
188 /* Python function to set the thread of a breakpoint. */
190 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
192 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
195 BPPY_SET_REQUIRE_VALID (self_bp
);
197 if (newvalue
== NULL
)
199 PyErr_SetString (PyExc_TypeError
,
200 _("Cannot delete `thread' attribute."));
203 else if (PyInt_Check (newvalue
))
205 if (! gdb_py_int_as_long (newvalue
, &id
))
208 if (!valid_global_thread_id (id
))
210 PyErr_SetString (PyExc_RuntimeError
,
211 _("Invalid thread ID."));
215 else if (newvalue
== Py_None
)
219 PyErr_SetString (PyExc_TypeError
,
220 _("The value of `thread' must be an integer or None."));
224 breakpoint_set_thread (self_bp
->bp
, id
);
229 /* Python function to set the (Ada) task of a breakpoint. */
231 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
233 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
237 BPPY_SET_REQUIRE_VALID (self_bp
);
239 if (newvalue
== NULL
)
241 PyErr_SetString (PyExc_TypeError
,
242 _("Cannot delete `task' attribute."));
245 else if (PyInt_Check (newvalue
))
247 if (! gdb_py_int_as_long (newvalue
, &id
))
252 valid_id
= valid_task_id (id
);
254 CATCH (except
, RETURN_MASK_ALL
)
256 GDB_PY_SET_HANDLE_EXCEPTION (except
);
262 PyErr_SetString (PyExc_RuntimeError
,
263 _("Invalid task ID."));
267 else if (newvalue
== Py_None
)
271 PyErr_SetString (PyExc_TypeError
,
272 _("The value of `task' must be an integer or None."));
276 breakpoint_set_task (self_bp
->bp
, id
);
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
287 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
289 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
291 BPPY_REQUIRE_VALID (self_bp
);
295 delete_breakpoint (self_bp
->bp
);
297 CATCH (except
, RETURN_MASK_ALL
)
299 GDB_PY_HANDLE_EXCEPTION (except
);
307 /* Python function to set the ignore count of a breakpoint. */
309 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
311 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
314 BPPY_SET_REQUIRE_VALID (self_bp
);
316 if (newvalue
== NULL
)
318 PyErr_SetString (PyExc_TypeError
,
319 _("Cannot delete `ignore_count' attribute."));
322 else if (! PyInt_Check (newvalue
))
324 PyErr_SetString (PyExc_TypeError
,
325 _("The value of `ignore_count' must be an integer."));
329 if (! gdb_py_int_as_long (newvalue
, &value
))
337 set_ignore_count (self_bp
->number
, (int) value
, 0);
339 CATCH (except
, RETURN_MASK_ALL
)
341 GDB_PY_SET_HANDLE_EXCEPTION (except
);
348 /* Python function to set the hit count of a breakpoint. */
350 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
352 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
354 BPPY_SET_REQUIRE_VALID (self_bp
);
356 if (newvalue
== NULL
)
358 PyErr_SetString (PyExc_TypeError
,
359 _("Cannot delete `hit_count' attribute."));
366 if (! gdb_py_int_as_long (newvalue
, &value
))
371 PyErr_SetString (PyExc_AttributeError
,
372 _("The value of `hit_count' must be zero."));
377 self_bp
->bp
->hit_count
= 0;
382 /* Python function to get the location of a breakpoint. */
384 bppy_get_location (PyObject
*self
, void *closure
)
387 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
389 BPPY_REQUIRE_VALID (obj
);
391 if (obj
->bp
->type
!= bp_breakpoint
)
394 str
= event_location_to_string (obj
->bp
->location
.get ());
397 return host_string_to_python_string (str
);
400 /* Python function to get the breakpoint expression. */
402 bppy_get_expression (PyObject
*self
, void *closure
)
405 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
406 struct watchpoint
*wp
;
408 BPPY_REQUIRE_VALID (obj
);
410 if (!is_watchpoint (obj
->bp
))
413 wp
= (struct watchpoint
*) obj
->bp
;
415 str
= wp
->exp_string
;
419 return host_string_to_python_string (str
);
422 /* Python function to get the condition expression of a breakpoint. */
424 bppy_get_condition (PyObject
*self
, void *closure
)
427 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
429 BPPY_REQUIRE_VALID (obj
);
431 str
= obj
->bp
->cond_string
;
435 return host_string_to_python_string (str
);
438 /* Returns 0 on success. Returns -1 on error, with a python exception set.
442 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
444 gdb::unique_xmalloc_ptr
<char> exp_holder
;
445 const char *exp
= NULL
;
446 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
447 struct gdb_exception except
= exception_none
;
449 BPPY_SET_REQUIRE_VALID (self_bp
);
451 if (newvalue
== NULL
)
453 PyErr_SetString (PyExc_TypeError
,
454 _("Cannot delete `condition' attribute."));
457 else if (newvalue
== Py_None
)
461 exp_holder
= python_string_to_host_string (newvalue
);
462 if (exp_holder
== NULL
)
464 exp
= exp_holder
.get ();
469 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
471 CATCH (ex
, RETURN_MASK_ALL
)
477 GDB_PY_SET_HANDLE_EXCEPTION (except
);
482 /* Python function to get the commands attached to a breakpoint. */
484 bppy_get_commands (PyObject
*self
, void *closure
)
486 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
487 struct breakpoint
*bp
= self_bp
->bp
;
489 BPPY_REQUIRE_VALID (self_bp
);
491 if (! self_bp
->bp
->commands
)
496 current_uiout
->redirect (&stb
);
499 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
501 CATCH (except
, RETURN_MASK_ALL
)
503 current_uiout
->redirect (NULL
);
504 gdbpy_convert_exception (except
);
509 current_uiout
->redirect (NULL
);
510 return host_string_to_python_string (stb
.c_str ());
513 /* Set the commands attached to a breakpoint. Returns 0 on success.
514 Returns -1 on error, with a python exception set. */
516 bppy_set_commands (PyObject
*self
, PyObject
*newvalue
, void *closure
)
518 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
519 struct breakpoint
*bp
= self_bp
->bp
;
520 struct gdb_exception except
= exception_none
;
522 BPPY_SET_REQUIRE_VALID (self_bp
);
524 gdb::unique_xmalloc_ptr
<char> commands
525 (python_string_to_host_string (newvalue
));
526 if (commands
== nullptr)
532 char *save_ptr
= nullptr;
536 const char *result
= strtok_r (first
? commands
.get () : nullptr,
542 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
543 breakpoint_set_commands (self_bp
->bp
, std::move (lines
));
545 CATCH (ex
, RETURN_MASK_ALL
)
551 GDB_PY_SET_HANDLE_EXCEPTION (except
);
556 /* Python function to get the breakpoint type. */
558 bppy_get_type (PyObject
*self
, void *closure
)
560 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
562 BPPY_REQUIRE_VALID (self_bp
);
564 return PyInt_FromLong (self_bp
->bp
->type
);
567 /* Python function to get the visibility of the breakpoint. */
570 bppy_get_visibility (PyObject
*self
, void *closure
)
572 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
574 BPPY_REQUIRE_VALID (self_bp
);
576 if (user_breakpoint_p (self_bp
->bp
))
582 /* Python function to determine if the breakpoint is a temporary
586 bppy_get_temporary (PyObject
*self
, void *closure
)
588 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
590 BPPY_REQUIRE_VALID (self_bp
);
592 if (self_bp
->bp
->disposition
== disp_del
593 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
599 /* Python function to determine if the breakpoint is a pending
603 bppy_get_pending (PyObject
*self
, void *closure
)
605 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
607 BPPY_REQUIRE_VALID (self_bp
);
609 if (is_watchpoint (self_bp
->bp
))
611 if (pending_breakpoint_p (self_bp
->bp
))
617 /* Python function to get the breakpoint's number. */
619 bppy_get_number (PyObject
*self
, void *closure
)
621 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
623 BPPY_REQUIRE_VALID (self_bp
);
625 return PyInt_FromLong (self_bp
->number
);
628 /* Python function to get the breakpoint's thread ID. */
630 bppy_get_thread (PyObject
*self
, void *closure
)
632 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
634 BPPY_REQUIRE_VALID (self_bp
);
636 if (self_bp
->bp
->thread
== -1)
639 return PyInt_FromLong (self_bp
->bp
->thread
);
642 /* Python function to get the breakpoint's task ID (in Ada). */
644 bppy_get_task (PyObject
*self
, void *closure
)
646 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
648 BPPY_REQUIRE_VALID (self_bp
);
650 if (self_bp
->bp
->task
== 0)
653 return PyInt_FromLong (self_bp
->bp
->task
);
656 /* Python function to get the breakpoint's hit count. */
658 bppy_get_hit_count (PyObject
*self
, void *closure
)
660 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
662 BPPY_REQUIRE_VALID (self_bp
);
664 return PyInt_FromLong (self_bp
->bp
->hit_count
);
667 /* Python function to get the breakpoint's ignore count. */
669 bppy_get_ignore_count (PyObject
*self
, void *closure
)
671 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
673 BPPY_REQUIRE_VALID (self_bp
);
675 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
678 /* Internal function to validate the Python parameters/keywords
679 provided to bppy_init. */
682 bppy_init_validate_args (const char *spec
, char *source
,
683 char *function
, char *label
,
684 char *line
, enum bptype type
)
686 /* If spec is defined, ensure that none of the explicit location
687 keywords are also defined. */
690 if (source
!= NULL
|| function
!= NULL
|| label
!= NULL
|| line
!= NULL
)
692 PyErr_SetString (PyExc_RuntimeError
,
693 _("Breakpoints specified with spec cannot "
694 "have source, function, label or line defined."));
700 /* If spec isn't defined, ensure that the user is not trying to
701 define a watchpoint with an explicit location. */
702 if (type
== bp_watchpoint
)
704 PyErr_SetString (PyExc_RuntimeError
,
705 _("Watchpoints cannot be set by explicit "
706 "location parameters."));
711 /* Otherwise, ensure some explicit locations are defined. */
712 if (source
== NULL
&& function
== NULL
&& label
== NULL
715 PyErr_SetString (PyExc_RuntimeError
,
716 _("Neither spec nor explicit location set."));
719 /* Finally, if source is specified, ensure that line, label
720 or function are specified too. */
721 if (source
!= NULL
&& function
== NULL
&& label
== NULL
724 PyErr_SetString (PyExc_RuntimeError
,
725 _("Specifying a source must also include a "
726 "line, label or function."));
734 /* Python function to create a new breakpoint. */
736 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
738 static const char *keywords
[] = { "spec", "type", "wp_class", "internal",
739 "temporary","source", "function",
740 "label", "line", "qualified", NULL
};
741 const char *spec
= NULL
;
742 enum bptype type
= bp_breakpoint
;
743 int access_type
= hw_write
;
744 PyObject
*internal
= NULL
;
745 PyObject
*temporary
= NULL
;
746 PyObject
*lineobj
= NULL
;;
748 int temporary_bp
= 0;
749 gdb::unique_xmalloc_ptr
<char> line
;
752 char *function
= NULL
;
753 PyObject
* qualified
= NULL
;
755 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kwargs
, "|siiOOsssOO", keywords
,
756 &spec
, &type
, &access_type
,
759 &function
, &label
, &lineobj
,
766 if (PyInt_Check (lineobj
))
767 line
.reset (xstrprintf ("%ld", PyInt_AsLong (lineobj
)));
768 else if (PyString_Check (lineobj
))
769 line
= python_string_to_host_string (lineobj
);
772 PyErr_SetString (PyExc_RuntimeError
,
773 _("Line keyword should be an integer or a string. "));
780 internal_bp
= PyObject_IsTrue (internal
);
781 if (internal_bp
== -1)
785 if (temporary
!= NULL
)
787 temporary_bp
= PyObject_IsTrue (temporary
);
788 if (temporary_bp
== -1)
792 if (bppy_init_validate_args (spec
, source
, function
, label
, line
.get (),
796 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
797 bppy_pending_object
->number
= -1;
798 bppy_pending_object
->bp
= NULL
;
806 event_location_up location
;
807 symbol_name_match_type func_name_match_type
808 = (qualified
!= NULL
&& PyObject_IsTrue (qualified
)
809 ? symbol_name_match_type::FULL
810 : symbol_name_match_type::WILD
);
814 gdb::unique_xmalloc_ptr
<char>
815 copy_holder (xstrdup (skip_spaces (spec
)));
816 const char *copy
= copy_holder
.get ();
818 location
= string_to_event_location (©
,
820 func_name_match_type
);
824 struct explicit_location explicit_loc
;
826 initialize_explicit_location (&explicit_loc
);
827 explicit_loc
.source_filename
= source
;
828 explicit_loc
.function_name
= function
;
829 explicit_loc
.label_name
= label
;
832 explicit_loc
.line_offset
=
833 linespec_parse_line_offset (line
.get ());
835 explicit_loc
.func_name_match_type
= func_name_match_type
;
837 location
= new_explicit_location (&explicit_loc
);
840 create_breakpoint (python_gdbarch
,
841 location
.get (), NULL
, -1, NULL
,
843 temporary_bp
, bp_breakpoint
,
846 &bkpt_breakpoint_ops
,
847 0, 1, internal_bp
, 0);
852 gdb::unique_xmalloc_ptr
<char>
853 copy_holder (xstrdup (skip_spaces (spec
)));
854 char *copy
= copy_holder
.get ();
856 if (access_type
== hw_write
)
857 watch_command_wrapper (copy
, 0, internal_bp
);
858 else if (access_type
== hw_access
)
859 awatch_command_wrapper (copy
, 0, internal_bp
);
860 else if (access_type
== hw_read
)
861 rwatch_command_wrapper (copy
, 0, internal_bp
);
863 error(_("Cannot understand watchpoint access type."));
867 error(_("Do not understand breakpoint type to set."));
870 CATCH (except
, RETURN_MASK_ALL
)
872 bppy_pending_object
= NULL
;
873 PyErr_Format (except
.reason
== RETURN_QUIT
874 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
875 "%s", except
.message
);
880 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
887 build_bp_list (struct breakpoint
*b
, void *arg
)
889 PyObject
*list
= (PyObject
*) arg
;
890 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
893 /* Not all breakpoints will have a companion Python object.
894 Only breakpoints that were created via bppy_new, or
895 breakpoints that were created externally and are tracked by
896 the Python Scripting API. */
898 iserr
= PyList_Append (list
, bp
);
906 /* Static function to return a tuple holding all breakpoints. */
909 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
912 return PyTuple_New (0);
914 gdbpy_ref
<> list (PyList_New (0));
918 /* If iterate_over_breakpoints returns non NULL it signals an error
919 condition. In that case abandon building the list and return
921 if (iterate_over_breakpoints (build_bp_list
, list
.get ()) != NULL
)
924 return PyList_AsTuple (list
.get ());
927 /* Call the "stop" method (if implemented) in the breakpoint
928 class. If the method returns True, the inferior will be
929 stopped at the breakpoint. Otherwise the inferior will be
930 allowed to continue. */
932 enum ext_lang_bp_stop
933 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
934 struct breakpoint
*b
)
937 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
938 PyObject
*py_bp
= (PyObject
*) bp_obj
;
939 struct gdbarch
*garch
;
942 return EXT_LANG_BP_STOP_UNSET
;
945 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
947 gdbpy_enter
enter_py (garch
, current_language
);
949 if (bp_obj
->is_finish_bp
)
950 bpfinishpy_pre_stop_hook (bp_obj
);
952 if (PyObject_HasAttrString (py_bp
, stop_func
))
954 gdbpy_ref
<> result (PyObject_CallMethod (py_bp
, stop_func
, NULL
));
959 int evaluate
= PyObject_IsTrue (result
.get ());
962 gdbpy_print_stack ();
964 /* If the "stop" function returns False that means
965 the Python breakpoint wants GDB to continue. */
970 gdbpy_print_stack ();
973 if (bp_obj
->is_finish_bp
)
974 bpfinishpy_post_stop_hook (bp_obj
);
977 return EXT_LANG_BP_STOP_UNSET
;
978 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
981 /* Checks if the "stop" method exists in this breakpoint.
982 Used by condition_command to ensure mutual exclusion of breakpoint
986 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
987 struct breakpoint
*b
)
990 struct gdbarch
*garch
;
992 if (b
->py_bp_object
== NULL
)
995 py_bp
= (PyObject
*) b
->py_bp_object
;
996 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
998 gdbpy_enter
enter_py (garch
, current_language
);
999 return PyObject_HasAttrString (py_bp
, stop_func
);
1004 /* Event callback functions. */
1006 /* Callback that is used when a breakpoint is created. This function
1007 will create a new Python breakpoint object. */
1009 gdbpy_breakpoint_created (struct breakpoint
*bp
)
1011 gdbpy_breakpoint_object
*newbp
;
1012 PyGILState_STATE state
;
1014 if (!user_breakpoint_p (bp
) && bppy_pending_object
== NULL
)
1017 if (bp
->type
!= bp_breakpoint
1018 && bp
->type
!= bp_watchpoint
1019 && bp
->type
!= bp_hardware_watchpoint
1020 && bp
->type
!= bp_read_watchpoint
1021 && bp
->type
!= bp_access_watchpoint
)
1024 state
= PyGILState_Ensure ();
1026 if (bppy_pending_object
)
1028 newbp
= bppy_pending_object
;
1029 bppy_pending_object
= NULL
;
1032 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
1035 newbp
->number
= bp
->number
;
1037 newbp
->bp
->py_bp_object
= newbp
;
1038 newbp
->is_finish_bp
= 0;
1044 PyErr_SetString (PyExc_RuntimeError
,
1045 _("Error while creating breakpoint from GDB."));
1046 gdbpy_print_stack ();
1049 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_created
))
1051 if (evpy_emit_event ((PyObject
*) newbp
,
1052 gdb_py_events
.breakpoint_created
) < 0)
1053 gdbpy_print_stack ();
1056 PyGILState_Release (state
);
1059 /* Callback that is used when a breakpoint is deleted. This will
1060 invalidate the corresponding Python object. */
1062 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
1064 int num
= b
->number
;
1065 PyGILState_STATE state
;
1066 struct breakpoint
*bp
= NULL
;
1068 state
= PyGILState_Ensure ();
1069 bp
= get_breakpoint (num
);
1072 gdbpy_ref
<gdbpy_breakpoint_object
> bp_obj (bp
->py_bp_object
);
1075 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
1077 if (evpy_emit_event ((PyObject
*) bp_obj
.get (),
1078 gdb_py_events
.breakpoint_deleted
) < 0)
1079 gdbpy_print_stack ();
1086 PyGILState_Release (state
);
1089 /* Callback that is used when a breakpoint is modified. */
1092 gdbpy_breakpoint_modified (struct breakpoint
*b
)
1094 int num
= b
->number
;
1095 PyGILState_STATE state
;
1096 struct breakpoint
*bp
= NULL
;
1098 state
= PyGILState_Ensure ();
1099 bp
= get_breakpoint (num
);
1102 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
1105 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
1107 if (evpy_emit_event (bp_obj
,
1108 gdb_py_events
.breakpoint_modified
) < 0)
1109 gdbpy_print_stack ();
1113 PyGILState_Release (state
);
1118 /* Initialize the Python breakpoint code. */
1120 gdbpy_initialize_breakpoints (void)
1124 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
1125 if (PyType_Ready (&breakpoint_object_type
) < 0)
1128 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
1129 (PyObject
*) &breakpoint_object_type
) < 0)
1132 gdb::observers::breakpoint_created
.attach (gdbpy_breakpoint_created
);
1133 gdb::observers::breakpoint_deleted
.attach (gdbpy_breakpoint_deleted
);
1134 gdb::observers::breakpoint_modified
.attach (gdbpy_breakpoint_modified
);
1136 /* Add breakpoint types constants. */
1137 for (i
= 0; pybp_codes
[i
].name
; ++i
)
1139 if (PyModule_AddIntConstant (gdb_module
,
1140 /* Cast needed for Python 2.4. */
1141 (char *) pybp_codes
[i
].name
,
1142 pybp_codes
[i
].code
) < 0)
1146 /* Add watchpoint types constants. */
1147 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
1149 if (PyModule_AddIntConstant (gdb_module
,
1150 /* Cast needed for Python 2.4. */
1151 (char *) pybp_watch_types
[i
].name
,
1152 pybp_watch_types
[i
].code
) < 0)
1161 /* Helper function that overrides this Python object's
1162 PyObject_GenericSetAttr to allow extra validation of the attribute
1166 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1168 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1169 gdb::unique_xmalloc_ptr
<char> attr (python_string_to_host_string (name
));
1174 /* If the attribute trying to be set is the "stop" method,
1175 but we already have a condition set in the CLI or other extension
1176 language, disallow this operation. */
1177 if (strcmp (attr
.get (), stop_func
) == 0)
1179 const struct extension_language_defn
*extlang
= NULL
;
1181 if (obj
->bp
->cond_string
!= NULL
)
1182 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1183 if (extlang
== NULL
)
1184 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1185 if (extlang
!= NULL
)
1187 std::string error_text
1188 = string_printf (_("Only one stop condition allowed. There is"
1189 " currently a %s stop condition defined for"
1190 " this breakpoint."),
1191 ext_lang_capitalized_name (extlang
));
1192 PyErr_SetString (PyExc_RuntimeError
, error_text
.c_str ());
1197 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
1200 static gdb_PyGetSetDef breakpoint_object_getset
[] = {
1201 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1202 "Boolean telling whether the breakpoint is enabled.", NULL
},
1203 { "silent", bppy_get_silent
, bppy_set_silent
,
1204 "Boolean telling whether the breakpoint is silent.", NULL
},
1205 { "thread", bppy_get_thread
, bppy_set_thread
,
1206 "Thread ID for the breakpoint.\n\
1207 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1208 If the value is None, then this breakpoint is not thread-specific.\n\
1209 No other type of value can be used.", NULL
},
1210 { "task", bppy_get_task
, bppy_set_task
,
1211 "Thread ID for the breakpoint.\n\
1212 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1213 If the value is None, then this breakpoint is not task-specific.\n\
1214 No other type of value can be used.", NULL
},
1215 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1216 "Number of times this breakpoint should be automatically continued.",
1218 { "number", bppy_get_number
, NULL
,
1219 "Breakpoint's number assigned by GDB.", NULL
},
1220 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1221 "Number of times the breakpoint has been hit.\n\
1222 Can be set to zero to clear the count. No other value is valid\n\
1223 when setting this property.", NULL
},
1224 { "location", bppy_get_location
, NULL
,
1225 "Location of the breakpoint, as specified by the user.", NULL
},
1226 { "expression", bppy_get_expression
, NULL
,
1227 "Expression of the breakpoint, as specified by the user.", NULL
},
1228 { "condition", bppy_get_condition
, bppy_set_condition
,
1229 "Condition of the breakpoint, as specified by the user,\
1230 or None if no condition set."},
1231 { "commands", bppy_get_commands
, bppy_set_commands
,
1232 "Commands of the breakpoint, as specified by the user."},
1233 { "type", bppy_get_type
, NULL
,
1234 "Type of breakpoint."},
1235 { "visible", bppy_get_visibility
, NULL
,
1236 "Whether the breakpoint is visible to the user."},
1237 { "temporary", bppy_get_temporary
, NULL
,
1238 "Whether this breakpoint is a temporary breakpoint."},
1239 { "pending", bppy_get_pending
, NULL
,
1240 "Whether this breakpoint is a pending breakpoint."},
1241 { NULL
} /* Sentinel. */
1244 static PyMethodDef breakpoint_object_methods
[] =
1246 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1247 "Return true if this breakpoint is valid, false if not." },
1248 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1249 "Delete the underlying GDB breakpoint." },
1250 { NULL
} /* Sentinel. */
1253 PyTypeObject breakpoint_object_type
=
1255 PyVarObject_HEAD_INIT (NULL
, 0)
1256 "gdb.Breakpoint", /*tp_name*/
1257 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1266 0, /*tp_as_sequence*/
1267 0, /*tp_as_mapping*/
1272 (setattrofunc
)local_setattro
, /*tp_setattro */
1274 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1275 "GDB breakpoint object", /* tp_doc */
1276 0, /* tp_traverse */
1278 0, /* tp_richcompare */
1279 0, /* tp_weaklistoffset */
1281 0, /* tp_iternext */
1282 breakpoint_object_methods
, /* tp_methods */
1284 breakpoint_object_getset
, /* tp_getset */
1287 0, /* tp_descr_get */
1288 0, /* tp_descr_set */
1289 0, /* tp_dictoffset */
1290 bppy_init
, /* tp_init */