1 /* Python interface to breakpoints
3 Copyright (C) 2008-2024 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"
36 #include "gdbsupport/common-utils.h"
38 extern PyTypeObject breakpoint_location_object_type
39 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_location_object");
41 struct gdbpy_breakpoint_location_object
45 /* An owning reference to the gdb breakpoint location object. */
48 /* An owning reference to the location's breakpoint owner. */
49 gdbpy_breakpoint_object
*owner
;
52 /* Require that BREAKPOINT and LOCATION->OWNER are the same; throw a Python
53 exception if they are not. */
54 #define BPLOCPY_REQUIRE_VALID(Breakpoint, Location) \
56 if ((Breakpoint)->bp != (Location)->bp_loc->owner) \
57 return PyErr_Format (PyExc_RuntimeError, \
58 _("Breakpoint location is invalid.")); \
61 /* Require that BREAKPOINT and LOCATION->OWNER are the same; throw a Python
62 exception if they are not. This macro is for use in setter functions. */
63 #define BPLOCPY_SET_REQUIRE_VALID(Breakpoint, Location) \
65 if ((Breakpoint)->bp != (Location)->bp_loc->owner) \
67 PyErr_Format (PyExc_RuntimeError, \
68 _("Breakpoint location is invalid.")); \
73 /* Debugging of Python breakpoints. */
75 static bool pybp_debug
;
77 /* Implementation of "show debug py-breakpoint". */
80 show_pybp_debug (struct ui_file
*file
, int from_tty
,
81 struct cmd_list_element
*c
, const char *value
)
83 gdb_printf (file
, _("Python breakpoint debugging is %s.\n"), value
);
86 /* Print a "py-breakpoint" debug statement. */
88 #define pybp_debug_printf(fmt, ...) \
89 debug_prefixed_printf_cond (pybp_debug, "py-breakpoint", fmt, ##__VA_ARGS__)
91 /* Print a "py-breakpoint" enter/exit debug statements. */
93 #define PYBP_SCOPED_DEBUG_ENTER_EXIT \
94 scoped_debug_enter_exit (pybp_debug, "py-breakpoint")
96 /* Number of live breakpoints. */
99 /* Variables used to pass information between the Breakpoint
100 constructor and the breakpoint-created hook function. */
101 gdbpy_breakpoint_object
*bppy_pending_object
;
103 /* Function that is called when a Python condition is evaluated. */
104 static const char stop_func
[] = "stop";
106 /* This is used to initialize various gdb.bp_* constants. */
115 /* Entries related to the type of user set breakpoints. */
116 static struct pybp_code pybp_codes
[] =
118 { "BP_NONE", bp_none
},
119 { "BP_BREAKPOINT", bp_breakpoint
},
120 { "BP_HARDWARE_BREAKPOINT", bp_hardware_breakpoint
},
121 { "BP_WATCHPOINT", bp_watchpoint
},
122 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint
},
123 { "BP_READ_WATCHPOINT", bp_read_watchpoint
},
124 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint
},
125 { "BP_CATCHPOINT", bp_catchpoint
},
126 {NULL
} /* Sentinel. */
129 /* Entries related to the type of watchpoint. */
130 static struct pybp_code pybp_watch_types
[] =
132 { "WP_READ", hw_read
},
133 { "WP_WRITE", hw_write
},
134 { "WP_ACCESS", hw_access
},
135 {NULL
} /* Sentinel. */
138 /* Python function which checks the validity of a breakpoint object. */
140 bppy_is_valid (PyObject
*self
, PyObject
*args
)
142 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
149 /* Python function to test whether or not the breakpoint is enabled. */
151 bppy_get_enabled (PyObject
*self
, void *closure
)
153 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
155 BPPY_REQUIRE_VALID (self_bp
);
158 if (self_bp
->bp
->enable_state
== bp_enabled
)
163 /* Python function to test whether or not the breakpoint is silent. */
165 bppy_get_silent (PyObject
*self
, void *closure
)
167 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
169 BPPY_REQUIRE_VALID (self_bp
);
170 if (self_bp
->bp
->silent
)
175 /* Python function to set the enabled state of a breakpoint. */
177 bppy_set_enabled (PyObject
*self
, PyObject
*newvalue
, void *closure
)
179 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
182 BPPY_SET_REQUIRE_VALID (self_bp
);
184 if (newvalue
== NULL
)
186 PyErr_SetString (PyExc_TypeError
,
187 _("Cannot delete `enabled' attribute."));
191 else if (! PyBool_Check (newvalue
))
193 PyErr_SetString (PyExc_TypeError
,
194 _("The value of `enabled' must be a boolean."));
198 cmp
= PyObject_IsTrue (newvalue
);
205 enable_breakpoint (self_bp
->bp
);
207 disable_breakpoint (self_bp
->bp
);
209 catch (const gdb_exception
&except
)
211 GDB_PY_SET_HANDLE_EXCEPTION (except
);
217 /* Python function to set the 'silent' state of a breakpoint. */
219 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
221 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
224 BPPY_SET_REQUIRE_VALID (self_bp
);
226 if (newvalue
== NULL
)
228 PyErr_SetString (PyExc_TypeError
,
229 _("Cannot delete `silent' attribute."));
232 else if (! PyBool_Check (newvalue
))
234 PyErr_SetString (PyExc_TypeError
,
235 _("The value of `silent' must be a boolean."));
239 cmp
= PyObject_IsTrue (newvalue
);
243 breakpoint_set_silent (self_bp
->bp
, cmp
);
248 /* Python function to set the thread of a breakpoint. */
250 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
252 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
255 BPPY_SET_REQUIRE_VALID (self_bp
);
257 if (newvalue
== NULL
)
259 PyErr_SetString (PyExc_TypeError
,
260 _("Cannot delete `thread' attribute."));
263 else if (PyLong_Check (newvalue
))
265 if (! gdb_py_int_as_long (newvalue
, &id
))
268 if (!valid_global_thread_id (id
))
270 PyErr_SetString (PyExc_RuntimeError
,
271 _("Invalid thread ID."));
275 if (self_bp
->bp
->task
!= -1)
277 PyErr_SetString (PyExc_RuntimeError
,
278 _("Cannot set both task and thread attributes."));
282 else if (newvalue
== Py_None
)
286 PyErr_SetString (PyExc_TypeError
,
287 _("The value of `thread' must be an integer or None."));
291 if (self_bp
->bp
->inferior
!= -1 && id
!= -1)
293 PyErr_SetString (PyExc_RuntimeError
,
294 _("Cannot have both 'thread' and 'inferior' "
295 "conditions on a breakpoint"));
299 breakpoint_set_thread (self_bp
->bp
, id
);
304 /* Python function to set the inferior of a breakpoint. */
307 bppy_set_inferior (PyObject
*self
, PyObject
*newvalue
, void *closure
)
309 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
312 BPPY_SET_REQUIRE_VALID (self_bp
);
314 if (newvalue
== NULL
)
316 PyErr_SetString (PyExc_TypeError
,
317 _("Cannot delete 'inferior' attribute."));
320 else if (PyLong_Check (newvalue
))
322 if (!gdb_py_int_as_long (newvalue
, &id
))
325 if (!valid_global_inferior_id (id
))
327 PyErr_SetString (PyExc_RuntimeError
,
328 _("Invalid inferior ID."));
332 else if (newvalue
== Py_None
)
336 PyErr_SetString (PyExc_TypeError
,
337 _("The value of 'inferior' must be an integer or None."));
341 if (self_bp
->bp
->type
!= bp_breakpoint
342 && self_bp
->bp
->type
!= bp_hardware_breakpoint
)
344 PyErr_SetString (PyExc_RuntimeError
,
345 _("Cannot set 'inferior' attribute on a gdb.Breakpoint "
350 if (self_bp
->bp
->thread
!= -1 && id
!= -1)
352 PyErr_SetString (PyExc_RuntimeError
,
353 _("Cannot have both 'thread' and 'inferior' conditions "
358 if (self_bp
->bp
->task
!= -1 && id
!= -1)
360 PyErr_SetString (PyExc_RuntimeError
,
361 _("Cannot have both 'task' and 'inferior' conditions "
366 breakpoint_set_inferior (self_bp
->bp
, id
);
371 /* Python function to set the (Ada) task of a breakpoint. */
373 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
375 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
379 BPPY_SET_REQUIRE_VALID (self_bp
);
381 if (newvalue
== NULL
)
383 PyErr_SetString (PyExc_TypeError
,
384 _("Cannot delete `task' attribute."));
387 else if (PyLong_Check (newvalue
))
389 if (! gdb_py_int_as_long (newvalue
, &id
))
394 valid_id
= valid_task_id (id
);
396 catch (const gdb_exception
&except
)
398 GDB_PY_SET_HANDLE_EXCEPTION (except
);
403 PyErr_SetString (PyExc_RuntimeError
,
404 _("Invalid task ID."));
408 if (self_bp
->bp
->thread
!= -1)
410 PyErr_SetString (PyExc_RuntimeError
,
411 _("Cannot set both task and thread attributes."));
415 else if (newvalue
== Py_None
)
419 PyErr_SetString (PyExc_TypeError
,
420 _("The value of `task' must be an integer or None."));
424 breakpoint_set_task (self_bp
->bp
, id
);
429 /* Python function which deletes the underlying GDB breakpoint. This
430 triggers the breakpoint_deleted observer which will call
431 gdbpy_breakpoint_deleted; that function cleans up the Python
435 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
437 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
439 BPPY_REQUIRE_VALID (self_bp
);
443 delete_breakpoint (self_bp
->bp
);
445 catch (const gdb_exception
&except
)
447 GDB_PY_HANDLE_EXCEPTION (except
);
454 /* Python function to set the ignore count of a breakpoint. */
456 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
458 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
461 BPPY_SET_REQUIRE_VALID (self_bp
);
463 if (newvalue
== NULL
)
465 PyErr_SetString (PyExc_TypeError
,
466 _("Cannot delete `ignore_count' attribute."));
469 else if (!PyLong_Check (newvalue
))
471 PyErr_SetString (PyExc_TypeError
,
472 _("The value of `ignore_count' must be an integer."));
476 if (! gdb_py_int_as_long (newvalue
, &value
))
484 set_ignore_count (self_bp
->number
, (int) value
, 0);
486 catch (const gdb_exception
&except
)
488 GDB_PY_SET_HANDLE_EXCEPTION (except
);
494 /* Python function to set the hit count of a breakpoint. */
496 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
498 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
500 BPPY_SET_REQUIRE_VALID (self_bp
);
502 if (newvalue
== NULL
)
504 PyErr_SetString (PyExc_TypeError
,
505 _("Cannot delete `hit_count' attribute."));
512 if (! gdb_py_int_as_long (newvalue
, &value
))
517 PyErr_SetString (PyExc_AttributeError
,
518 _("The value of `hit_count' must be zero."));
523 self_bp
->bp
->hit_count
= 0;
528 /* Python function to get the location of a breakpoint. */
530 bppy_get_location (PyObject
*self
, void *closure
)
532 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
534 BPPY_REQUIRE_VALID (obj
);
536 if (obj
->bp
->type
!= bp_breakpoint
537 && obj
->bp
->type
!= bp_hardware_breakpoint
)
540 const char *str
= obj
->bp
->locspec
->to_string ();
543 return host_string_to_python_string (str
).release ();
546 /* Python function to get the breakpoint expression. */
548 bppy_get_expression (PyObject
*self
, void *closure
)
551 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
553 BPPY_REQUIRE_VALID (obj
);
555 if (!is_watchpoint (obj
->bp
))
558 watchpoint
*wp
= gdb::checked_static_cast
<watchpoint
*> (obj
->bp
);
560 str
= wp
->exp_string
.get ();
564 return host_string_to_python_string (str
).release ();
567 /* Python function to get the condition expression of a breakpoint. */
569 bppy_get_condition (PyObject
*self
, void *closure
)
572 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
574 BPPY_REQUIRE_VALID (obj
);
576 str
= obj
->bp
->cond_string
.get ();
580 return host_string_to_python_string (str
).release ();
583 /* Returns 0 on success. Returns -1 on error, with a python exception set.
587 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
589 gdb::unique_xmalloc_ptr
<char> exp_holder
;
590 const char *exp
= NULL
;
591 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
592 struct gdb_exception except
;
594 BPPY_SET_REQUIRE_VALID (self_bp
);
596 if (newvalue
== NULL
)
598 PyErr_SetString (PyExc_TypeError
,
599 _("Cannot delete `condition' attribute."));
602 else if (newvalue
== Py_None
)
606 exp_holder
= python_string_to_host_string (newvalue
);
607 if (exp_holder
== NULL
)
609 exp
= exp_holder
.get ();
614 set_breakpoint_condition (self_bp
->bp
, exp
, 0, false);
616 catch (gdb_exception
&ex
)
618 except
= std::move (ex
);
621 GDB_PY_SET_HANDLE_EXCEPTION (except
);
626 /* Python function to get the commands attached to a breakpoint. */
628 bppy_get_commands (PyObject
*self
, void *closure
)
630 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
631 struct breakpoint
*bp
= self_bp
->bp
;
633 BPPY_REQUIRE_VALID (self_bp
);
635 if (! self_bp
->bp
->commands
)
642 ui_out_redirect_pop
redir (current_uiout
, &stb
);
643 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
645 catch (const gdb_exception
&except
)
647 gdbpy_convert_exception (except
);
651 return host_string_to_python_string (stb
.c_str ()).release ();
654 /* Set the commands attached to a breakpoint. Returns 0 on success.
655 Returns -1 on error, with a python exception set. */
657 bppy_set_commands (PyObject
*self
, PyObject
*newvalue
, void *closure
)
659 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
660 struct gdb_exception except
;
662 BPPY_SET_REQUIRE_VALID (self_bp
);
664 gdb::unique_xmalloc_ptr
<char> commands
665 (python_string_to_host_string (newvalue
));
666 if (commands
== nullptr)
672 char *save_ptr
= nullptr;
674 = [&] (std::string
&buffer
)
676 const char *result
= strtok_r (first
? commands
.get () : nullptr,
682 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
683 breakpoint_set_commands (self_bp
->bp
, std::move (lines
));
685 catch (gdb_exception
&ex
)
687 except
= std::move (ex
);
690 GDB_PY_SET_HANDLE_EXCEPTION (except
);
695 /* Python function to get the breakpoint type. */
697 bppy_get_type (PyObject
*self
, void *closure
)
699 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
701 BPPY_REQUIRE_VALID (self_bp
);
703 return gdb_py_object_from_longest (self_bp
->bp
->type
).release ();
706 /* Python function to get the visibility of the breakpoint. */
709 bppy_get_visibility (PyObject
*self
, void *closure
)
711 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
713 BPPY_REQUIRE_VALID (self_bp
);
715 if (user_breakpoint_p (self_bp
->bp
))
721 /* Python function to determine if the breakpoint is a temporary
725 bppy_get_temporary (PyObject
*self
, void *closure
)
727 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
729 BPPY_REQUIRE_VALID (self_bp
);
731 if (self_bp
->bp
->disposition
== disp_del
732 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
738 /* Python function to determine if the breakpoint is a pending
742 bppy_get_pending (PyObject
*self
, void *closure
)
744 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
746 BPPY_REQUIRE_VALID (self_bp
);
748 if (is_watchpoint (self_bp
->bp
))
750 if (pending_breakpoint_p (self_bp
->bp
))
756 /* Python function to get the breakpoint's number. */
758 bppy_get_number (PyObject
*self
, void *closure
)
760 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
762 BPPY_REQUIRE_VALID (self_bp
);
764 return gdb_py_object_from_longest (self_bp
->number
).release ();
767 /* Python function to get the breakpoint's thread ID. */
769 bppy_get_thread (PyObject
*self
, void *closure
)
771 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
773 BPPY_REQUIRE_VALID (self_bp
);
775 if (self_bp
->bp
->thread
== -1)
778 return gdb_py_object_from_longest (self_bp
->bp
->thread
).release ();
781 /* Python function to get the breakpoint's inferior ID. */
783 bppy_get_inferior (PyObject
*self
, void *closure
)
785 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
787 BPPY_REQUIRE_VALID (self_bp
);
789 if (self_bp
->bp
->inferior
== -1)
792 return gdb_py_object_from_longest (self_bp
->bp
->inferior
).release ();
795 /* Python function to get the breakpoint's task ID (in Ada). */
797 bppy_get_task (PyObject
*self
, void *closure
)
799 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
801 BPPY_REQUIRE_VALID (self_bp
);
803 if (self_bp
->bp
->task
== -1)
806 return gdb_py_object_from_longest (self_bp
->bp
->task
).release ();
809 /* Python function to get the breakpoint's hit count. */
811 bppy_get_hit_count (PyObject
*self
, void *closure
)
813 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
815 BPPY_REQUIRE_VALID (self_bp
);
817 return gdb_py_object_from_longest (self_bp
->bp
->hit_count
).release ();
820 /* Python function to get the breakpoint's ignore count. */
822 bppy_get_ignore_count (PyObject
*self
, void *closure
)
824 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
826 BPPY_REQUIRE_VALID (self_bp
);
828 return gdb_py_object_from_longest (self_bp
->bp
->ignore_count
).release ();
831 /* Python function to get the breakpoint locations of an owner breakpoint. */
834 bppy_get_locations (PyObject
*self
, void *closure
)
836 using py_bploc_t
= gdbpy_breakpoint_location_object
;
837 auto *self_bp
= (gdbpy_breakpoint_object
*) self
;
838 BPPY_REQUIRE_VALID (self_bp
);
840 gdbpy_ref
<> list (PyList_New (0));
844 for (bp_location
&loc
: self_bp
->bp
->locations ())
846 gdbpy_ref
<py_bploc_t
> py_bploc
847 (PyObject_New (py_bploc_t
, &breakpoint_location_object_type
));
848 if (py_bploc
== nullptr)
851 bp_location_ref_ptr ref
= bp_location_ref_ptr::new_reference (&loc
);
852 /* The location takes a reference to the owner breakpoint.
853 Decrements when they are de-allocated in bplocpy_dealloc */
855 py_bploc
->owner
= self_bp
;
856 py_bploc
->bp_loc
= ref
.release ();
857 if (PyList_Append (list
.get (), (PyObject
*) py_bploc
.get ()) != 0)
860 return list
.release ();
863 /* Internal function to validate the Python parameters/keywords
864 provided to bppy_init. */
867 bppy_init_validate_args (const char *spec
, char *source
,
868 char *function
, char *label
,
869 char *line
, enum bptype type
)
871 /* If spec is defined, ensure that none of the explicit location
872 keywords are also defined. */
875 if (source
!= NULL
|| function
!= NULL
|| label
!= NULL
|| line
!= NULL
)
877 PyErr_SetString (PyExc_RuntimeError
,
878 _("Breakpoints specified with spec cannot "
879 "have source, function, label or line defined."));
885 /* If spec isn't defined, ensure that the user is not trying to
886 define a watchpoint with an explicit location. */
887 if (type
== bp_watchpoint
)
889 PyErr_SetString (PyExc_RuntimeError
,
890 _("Watchpoints cannot be set by explicit "
891 "location parameters."));
896 /* Otherwise, ensure some explicit locations are defined. */
897 if (source
== NULL
&& function
== NULL
&& label
== NULL
900 PyErr_SetString (PyExc_RuntimeError
,
901 _("Neither spec nor explicit location set."));
904 /* Finally, if source is specified, ensure that line, label
905 or function are specified too. */
906 if (source
!= NULL
&& function
== NULL
&& label
== NULL
909 PyErr_SetString (PyExc_RuntimeError
,
910 _("Specifying a source must also include a "
911 "line, label or function."));
919 /* Python function to create a new breakpoint. */
921 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
923 static const char *keywords
[] = { "spec", "type", "wp_class", "internal",
924 "temporary","source", "function",
925 "label", "line", "qualified", NULL
};
926 const char *spec
= NULL
;
927 enum bptype type
= bp_breakpoint
;
928 int access_type
= hw_write
;
929 PyObject
*internal
= NULL
;
930 PyObject
*temporary
= NULL
;
931 PyObject
*lineobj
= NULL
;;
933 int temporary_bp
= 0;
934 gdb::unique_xmalloc_ptr
<char> line
;
937 char *function
= NULL
;
938 PyObject
* qualified
= NULL
;
940 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kwargs
, "|siiOOsssOO", keywords
,
941 &spec
, &type
, &access_type
,
944 &function
, &label
, &lineobj
,
951 if (PyLong_Check (lineobj
))
952 line
= xstrprintf ("%ld", PyLong_AsLong (lineobj
));
953 else if (PyUnicode_Check (lineobj
))
954 line
= python_string_to_host_string (lineobj
);
957 PyErr_SetString (PyExc_RuntimeError
,
958 _("Line keyword should be an integer or a string. "));
965 internal_bp
= PyObject_IsTrue (internal
);
966 if (internal_bp
== -1)
970 if (temporary
!= NULL
)
972 temporary_bp
= PyObject_IsTrue (temporary
);
973 if (temporary_bp
== -1)
977 if (bppy_init_validate_args (spec
, source
, function
, label
, line
.get (),
981 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
982 bppy_pending_object
->number
= -1;
983 bppy_pending_object
->bp
= NULL
;
990 case bp_hardware_breakpoint
:
992 location_spec_up locspec
;
993 symbol_name_match_type func_name_match_type
994 = (qualified
!= NULL
&& PyObject_IsTrue (qualified
)
995 ? symbol_name_match_type::FULL
996 : symbol_name_match_type::WILD
);
1000 gdb::unique_xmalloc_ptr
<char>
1001 copy_holder (xstrdup (skip_spaces (spec
)));
1002 const char *copy
= copy_holder
.get ();
1004 locspec
= string_to_location_spec (©
,
1006 func_name_match_type
);
1010 std::unique_ptr
<explicit_location_spec
> explicit_loc
1011 (new explicit_location_spec ());
1013 if (source
!= nullptr)
1014 explicit_loc
->source_filename
= make_unique_xstrdup (source
);
1015 if (function
!= nullptr)
1016 explicit_loc
->function_name
= make_unique_xstrdup (function
);
1017 if (label
!= nullptr)
1018 explicit_loc
->label_name
= make_unique_xstrdup (label
);
1021 explicit_loc
->line_offset
1022 = linespec_parse_line_offset (line
.get ());
1024 explicit_loc
->func_name_match_type
= func_name_match_type
;
1026 locspec
.reset (explicit_loc
.release ());
1029 const struct breakpoint_ops
*ops
1030 = breakpoint_ops_for_location_spec (locspec
.get (), false);
1032 create_breakpoint (gdbpy_enter::get_gdbarch (),
1033 locspec
.get (), NULL
, -1, -1, NULL
, false,
1039 0, 1, internal_bp
, 0);
1044 spec
= skip_spaces (spec
);
1046 if (access_type
== hw_write
)
1047 watch_command_wrapper (spec
, 0, internal_bp
);
1048 else if (access_type
== hw_access
)
1049 awatch_command_wrapper (spec
, 0, internal_bp
);
1050 else if (access_type
== hw_read
)
1051 rwatch_command_wrapper (spec
, 0, internal_bp
);
1053 error(_("Cannot understand watchpoint access type."));
1057 error (_("BP_CATCHPOINT not supported"));
1059 error(_("Do not understand breakpoint type to set."));
1062 catch (const gdb_exception
&except
)
1064 bppy_pending_object
= NULL
;
1065 gdbpy_convert_exception (except
);
1069 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
1073 /* __repr__ implementation for gdb.Breakpoint. */
1076 bppy_repr (PyObject
*self
)
1078 const auto bp
= (struct gdbpy_breakpoint_object
*) self
;
1079 if (bp
->bp
== nullptr)
1080 return PyUnicode_FromFormat ("<%s (invalid)>", Py_TYPE (self
)->tp_name
);
1082 std::string str
= " ";
1083 if (bp
->bp
->thread
!= -1)
1084 str
+= string_printf ("thread=%d ", bp
->bp
->thread
);
1085 if (bp
->bp
->task
> 0)
1086 str
+= string_printf ("task=%d ", bp
->bp
->task
);
1087 if (bp
->bp
->enable_count
> 0)
1088 str
+= string_printf ("enable_count=%d ", bp
->bp
->enable_count
);
1091 return PyUnicode_FromFormat ("<%s%s number=%d hits=%d%s>",
1092 Py_TYPE (self
)->tp_name
,
1093 (bp
->bp
->enable_state
== bp_enabled
1094 ? "" : " disabled"), bp
->bp
->number
,
1095 bp
->bp
->hit_count
, str
.c_str ());
1098 /* Append to LIST the breakpoint Python object associated to B.
1100 Return true on success. Return false on failure, with the Python error
1104 build_bp_list (struct breakpoint
*b
, PyObject
*list
)
1106 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
1108 /* Not all breakpoints will have a companion Python object.
1109 Only breakpoints that were created via bppy_new, or
1110 breakpoints that were created externally and are tracked by
1111 the Python Scripting API. */
1115 return PyList_Append (list
, bp
) == 0;
1118 /* See python-internal.h. */
1121 gdbpy_breakpoint_init_breakpoint_type ()
1123 if (breakpoint_object_type
.tp_new
== nullptr)
1125 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
1126 if (PyType_Ready (&breakpoint_object_type
) < 0)
1128 /* Reset tp_new back to nullptr so future calls to this function
1129 will try calling PyType_Ready again. */
1130 breakpoint_object_type
.tp_new
= nullptr;
1138 /* Static function to return a tuple holding all breakpoints. */
1141 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
1144 return PyTuple_New (0);
1146 gdbpy_ref
<> list (PyList_New (0));
1150 /* If build_bp_list returns false, it signals an error condition. In that
1151 case abandon building the list and return nullptr. */
1152 for (breakpoint
&bp
: all_breakpoints ())
1153 if (!build_bp_list (&bp
, list
.get ()))
1156 return PyList_AsTuple (list
.get ());
1159 /* Call the "stop" method (if implemented) in the breakpoint
1160 class. If the method returns True, the inferior will be
1161 stopped at the breakpoint. Otherwise the inferior will be
1162 allowed to continue. */
1164 enum ext_lang_bp_stop
1165 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
1166 struct breakpoint
*b
)
1169 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
1170 PyObject
*py_bp
= (PyObject
*) bp_obj
;
1173 return EXT_LANG_BP_STOP_UNSET
;
1177 gdbpy_enter
enter_py (b
->gdbarch
);
1179 if (bp_obj
->is_finish_bp
)
1180 bpfinishpy_pre_stop_hook (bp_obj
);
1182 if (PyObject_HasAttrString (py_bp
, stop_func
))
1184 gdbpy_ref
<> result (PyObject_CallMethod (py_bp
, stop_func
, NULL
));
1189 int evaluate
= PyObject_IsTrue (result
.get ());
1192 gdbpy_print_stack ();
1194 /* If the "stop" function returns False that means
1195 the Python breakpoint wants GDB to continue. */
1200 gdbpy_print_stack ();
1203 if (bp_obj
->is_finish_bp
)
1204 bpfinishpy_post_stop_hook (bp_obj
);
1207 return EXT_LANG_BP_STOP_UNSET
;
1208 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
1211 /* Checks if the "stop" method exists in this breakpoint.
1212 Used by condition_command to ensure mutual exclusion of breakpoint
1216 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
1217 struct breakpoint
*b
)
1221 if (b
->py_bp_object
== NULL
)
1224 py_bp
= (PyObject
*) b
->py_bp_object
;
1226 gdbpy_enter
enter_py (b
->gdbarch
);
1227 return PyObject_HasAttrString (py_bp
, stop_func
);
1232 /* Event callback functions. */
1234 /* Callback that is used when a breakpoint is created. This function
1235 will create a new Python breakpoint object. */
1237 gdbpy_breakpoint_created (struct breakpoint
*bp
)
1239 PYBP_SCOPED_DEBUG_ENTER_EXIT
;
1241 gdbpy_breakpoint_object
*newbp
;
1243 if (!user_breakpoint_p (bp
) && bppy_pending_object
== NULL
)
1245 pybp_debug_printf ("not attaching python object to this breakpoint");
1249 if (bp
->type
!= bp_breakpoint
1250 && bp
->type
!= bp_hardware_breakpoint
1251 && bp
->type
!= bp_watchpoint
1252 && bp
->type
!= bp_hardware_watchpoint
1253 && bp
->type
!= bp_read_watchpoint
1254 && bp
->type
!= bp_access_watchpoint
1255 && bp
->type
!= bp_catchpoint
)
1257 pybp_debug_printf ("is not a breakpoint or watchpoint");
1261 gdbpy_enter
enter_py (bp
->gdbarch
);
1263 if (bppy_pending_object
)
1265 newbp
= bppy_pending_object
;
1267 bppy_pending_object
= NULL
;
1268 pybp_debug_printf ("attaching existing breakpoint object");
1272 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
1273 pybp_debug_printf ("attaching new breakpoint object");
1277 newbp
->number
= bp
->number
;
1279 newbp
->bp
->py_bp_object
= newbp
;
1280 newbp
->is_finish_bp
= 0;
1285 PyErr_SetString (PyExc_RuntimeError
,
1286 _("Error while creating breakpoint from GDB."));
1287 gdbpy_print_stack ();
1290 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_created
))
1292 if (evpy_emit_event ((PyObject
*) newbp
,
1293 gdb_py_events
.breakpoint_created
) < 0)
1294 gdbpy_print_stack ();
1298 /* Callback that is used when a breakpoint is deleted. This will
1299 invalidate the corresponding Python object. */
1301 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
1303 PYBP_SCOPED_DEBUG_ENTER_EXIT
;
1305 int num
= b
->number
;
1306 struct breakpoint
*bp
= NULL
;
1308 bp
= get_breakpoint (num
);
1311 gdbpy_enter
enter_py (b
->gdbarch
);
1313 gdbpy_ref
<gdbpy_breakpoint_object
> bp_obj (bp
->py_bp_object
);
1316 if (bp_obj
->is_finish_bp
)
1317 bpfinishpy_pre_delete_hook (bp_obj
.get ());
1319 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
1321 if (evpy_emit_event ((PyObject
*) bp_obj
.get (),
1322 gdb_py_events
.breakpoint_deleted
) < 0)
1323 gdbpy_print_stack ();
1332 /* Callback that is used when a breakpoint is modified. */
1335 gdbpy_breakpoint_modified (struct breakpoint
*b
)
1337 PYBP_SCOPED_DEBUG_ENTER_EXIT
;
1339 int num
= b
->number
;
1340 struct breakpoint
*bp
= NULL
;
1342 bp
= get_breakpoint (num
);
1345 gdbpy_enter
enter_py (b
->gdbarch
);
1347 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
1350 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
1352 if (evpy_emit_event (bp_obj
,
1353 gdb_py_events
.breakpoint_modified
) < 0)
1354 gdbpy_print_stack ();
1362 /* Initialize the Python breakpoint code. */
1363 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
1364 gdbpy_initialize_breakpoints (void)
1368 if (!gdbpy_breakpoint_init_breakpoint_type ())
1371 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
1372 (PyObject
*) &breakpoint_object_type
) < 0)
1375 gdb::observers::breakpoint_created
.attach (gdbpy_breakpoint_created
,
1377 gdb::observers::breakpoint_deleted
.attach (gdbpy_breakpoint_deleted
,
1379 gdb::observers::breakpoint_modified
.attach (gdbpy_breakpoint_modified
,
1382 /* Add breakpoint types constants. */
1383 for (i
= 0; pybp_codes
[i
].name
; ++i
)
1385 if (PyModule_AddIntConstant (gdb_module
, pybp_codes
[i
].name
,
1386 pybp_codes
[i
].code
) < 0)
1390 /* Add watchpoint types constants. */
1391 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
1393 if (PyModule_AddIntConstant (gdb_module
, pybp_watch_types
[i
].name
,
1394 pybp_watch_types
[i
].code
) < 0)
1401 /* Initialize the Python BreakpointLocation code. */
1403 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
1404 gdbpy_initialize_breakpoint_locations ()
1406 if (PyType_Ready (&breakpoint_location_object_type
) < 0)
1409 if (gdb_pymodule_addobject (gdb_module
, "BreakpointLocation",
1410 (PyObject
*) &breakpoint_location_object_type
)
1418 /* Helper function that overrides this Python object's
1419 PyObject_GenericSetAttr to allow extra validation of the attribute
1423 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1425 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1426 gdb::unique_xmalloc_ptr
<char> attr (python_string_to_host_string (name
));
1431 /* If the attribute trying to be set is the "stop" method,
1432 but we already have a condition set in the CLI or other extension
1433 language, disallow this operation. */
1434 if (strcmp (attr
.get (), stop_func
) == 0)
1436 const struct extension_language_defn
*extlang
= NULL
;
1438 if (obj
->bp
->cond_string
!= NULL
)
1439 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1440 if (extlang
== NULL
)
1441 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1442 if (extlang
!= NULL
)
1444 std::string error_text
1445 = string_printf (_("Only one stop condition allowed. There is"
1446 " currently a %s stop condition defined for"
1447 " this breakpoint."),
1448 ext_lang_capitalized_name (extlang
));
1449 PyErr_SetString (PyExc_RuntimeError
, error_text
.c_str ());
1454 return PyObject_GenericSetAttr (self
, name
, v
);
1457 static gdb_PyGetSetDef breakpoint_object_getset
[] = {
1458 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1459 "Boolean telling whether the breakpoint is enabled.", NULL
},
1460 { "silent", bppy_get_silent
, bppy_set_silent
,
1461 "Boolean telling whether the breakpoint is silent.", NULL
},
1462 { "thread", bppy_get_thread
, bppy_set_thread
,
1463 "Thread ID for the breakpoint.\n\
1464 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1465 If the value is None, then this breakpoint is not thread-specific.\n\
1466 No other type of value can be used.", NULL
},
1467 { "inferior", bppy_get_inferior
, bppy_set_inferior
,
1468 "Inferior ID for the breakpoint.\n\
1469 If the value is an inferior ID (integer), then this is an inferior-specific\n\
1470 breakpoint. If the value is None, then this breakpoint is not\n\
1471 inferior-specific. No other type of value can be used.", NULL
},
1472 { "task", bppy_get_task
, bppy_set_task
,
1473 "Thread ID for the breakpoint.\n\
1474 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1475 If the value is None, then this breakpoint is not task-specific.\n\
1476 No other type of value can be used.", NULL
},
1477 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1478 "Number of times this breakpoint should be automatically continued.",
1480 { "number", bppy_get_number
, NULL
,
1481 "Breakpoint's number assigned by GDB.", NULL
},
1482 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1483 "Number of times the breakpoint has been hit.\n\
1484 Can be set to zero to clear the count. No other value is valid\n\
1485 when setting this property.", NULL
},
1486 { "location", bppy_get_location
, NULL
,
1487 "Location of the breakpoint, as specified by the user.", NULL
},
1488 { "expression", bppy_get_expression
, NULL
,
1489 "Expression of the breakpoint, as specified by the user.", NULL
},
1490 { "condition", bppy_get_condition
, bppy_set_condition
,
1491 "Condition of the breakpoint, as specified by the user,\
1492 or None if no condition set."},
1493 { "commands", bppy_get_commands
, bppy_set_commands
,
1494 "Commands of the breakpoint, as specified by the user."},
1495 { "type", bppy_get_type
, NULL
,
1496 "Type of breakpoint."},
1497 { "visible", bppy_get_visibility
, NULL
,
1498 "Whether the breakpoint is visible to the user."},
1499 { "temporary", bppy_get_temporary
, NULL
,
1500 "Whether this breakpoint is a temporary breakpoint."},
1501 { "pending", bppy_get_pending
, NULL
,
1502 "Whether this breakpoint is a pending breakpoint."},
1503 { "locations", bppy_get_locations
, NULL
,
1504 "Get locations where this breakpoint was set"},
1505 { NULL
} /* Sentinel. */
1508 static PyMethodDef breakpoint_object_methods
[] =
1510 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1511 "Return true if this breakpoint is valid, false if not." },
1512 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1513 "Delete the underlying GDB breakpoint." },
1514 { NULL
} /* Sentinel. */
1517 PyTypeObject breakpoint_object_type
=
1519 PyVarObject_HEAD_INIT (NULL
, 0)
1520 "gdb.Breakpoint", /*tp_name*/
1521 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1528 bppy_repr
, /*tp_repr*/
1530 0, /*tp_as_sequence*/
1531 0, /*tp_as_mapping*/
1536 (setattrofunc
)local_setattro
, /*tp_setattro */
1538 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1539 "GDB breakpoint object", /* tp_doc */
1540 0, /* tp_traverse */
1542 0, /* tp_richcompare */
1543 0, /* tp_weaklistoffset */
1545 0, /* tp_iternext */
1546 breakpoint_object_methods
, /* tp_methods */
1548 breakpoint_object_getset
, /* tp_getset */
1551 0, /* tp_descr_get */
1552 0, /* tp_descr_set */
1553 0, /* tp_dictoffset */
1554 bppy_init
, /* tp_init */
1558 void _initialize_py_breakpoint ();
1560 _initialize_py_breakpoint ()
1562 add_setshow_boolean_cmd
1563 ("py-breakpoint", class_maintenance
, &pybp_debug
,
1564 _("Set Python breakpoint debugging."),
1565 _("Show Python breakpoint debugging."),
1566 _("When on, Python breakpoint debugging is enabled."),
1569 &setdebuglist
, &showdebuglist
);
1572 GDBPY_INITIALIZE_FILE (gdbpy_initialize_breakpoints
);
1573 GDBPY_INITIALIZE_FILE (gdbpy_initialize_breakpoint_locations
);
1575 /* Python function to set the enabled state of a breakpoint location. */
1578 bplocpy_set_enabled (PyObject
*py_self
, PyObject
*newvalue
, void *closure
)
1580 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1581 BPPY_SET_REQUIRE_VALID (self
->owner
);
1582 BPLOCPY_SET_REQUIRE_VALID (self
->owner
, self
);
1584 if (newvalue
== nullptr)
1586 PyErr_SetString (PyExc_TypeError
,
1587 _("Cannot delete 'enabled' attribute."));
1590 else if (!PyBool_Check (newvalue
))
1592 PyErr_SetString (PyExc_TypeError
,
1593 _("The value of 'enabled' must be a boolean."));
1597 int cmp
= PyObject_IsTrue (newvalue
);
1603 enable_disable_bp_location (self
->bp_loc
, cmp
== 1);
1605 catch (const gdb_exception
&except
)
1607 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1612 /* Python function to test whether or not the breakpoint location is enabled. */
1615 bplocpy_get_enabled (PyObject
*py_self
, void *closure
)
1617 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1618 BPPY_REQUIRE_VALID (self
->owner
);
1619 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1621 if (self
->bp_loc
->enabled
)
1627 /* Python function to get address of breakpoint location. */
1630 bplocpy_get_address (PyObject
*py_self
, void *closure
)
1632 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1633 BPPY_REQUIRE_VALID (self
->owner
);
1634 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1635 return gdb_py_object_from_ulongest (self
->bp_loc
->address
).release ();
1638 /* Python function to get owner of breakpoint location, which
1639 is of type gdb.Breakpoint. */
1642 bplocpy_get_owner (PyObject
*py_self
, void *closure
)
1644 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1645 BPPY_REQUIRE_VALID (self
->owner
);
1646 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1647 Py_INCREF (self
->owner
);
1648 return (PyObject
*) self
->owner
;
1651 /* Python function to get the source file name path and line number
1652 where this breakpoint location was set. */
1655 bplocpy_get_source_location (PyObject
*py_self
, void *closure
)
1657 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1658 BPPY_REQUIRE_VALID (self
->owner
);
1659 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1660 if (self
->bp_loc
->symtab
)
1662 gdbpy_ref
<> tup (PyTuple_New (2));
1665 /* symtab->filename is never NULL. */
1666 gdbpy_ref
<> filename
1667 = host_string_to_python_string (self
->bp_loc
->symtab
->filename
);
1668 if (filename
== nullptr)
1670 auto line
= gdb_py_object_from_ulongest (self
->bp_loc
->line_number
);
1671 if (line
== nullptr)
1673 if (PyTuple_SetItem (tup
.get (), 0, filename
.release ()) == -1
1674 || PyTuple_SetItem (tup
.get (), 1, line
.release ()) == -1)
1676 return tup
.release ();
1682 /* Python function to get the function name of where this location was set. */
1685 bplocpy_get_function (PyObject
*py_self
, void *closure
)
1687 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1688 BPPY_REQUIRE_VALID (self
->owner
);
1689 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1690 const auto fn_name
= self
->bp_loc
->function_name
.get ();
1691 if (fn_name
!= nullptr)
1692 return host_string_to_python_string (fn_name
).release ();
1697 bplocpy_get_thread_groups (PyObject
*py_self
, void *closure
)
1699 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1700 BPPY_REQUIRE_VALID (self
->owner
);
1701 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1702 gdbpy_ref
<> list (PyList_New (0));
1703 if (list
== nullptr)
1705 for (inferior
*inf
: all_inferiors ())
1707 if (inf
->pspace
== self
->bp_loc
->pspace
)
1709 gdbpy_ref
<> num
= gdb_py_object_from_ulongest (inf
->num
);
1712 if (PyList_Append (list
.get (), num
.release ()) != 0)
1716 return list
.release ();
1720 bplocpy_get_fullname (PyObject
*py_self
, void *closure
)
1722 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1723 BPPY_REQUIRE_VALID (self
->owner
);
1724 BPLOCPY_REQUIRE_VALID (self
->owner
, self
);
1725 const auto symtab
= self
->bp_loc
->symtab
;
1726 if (symtab
!= nullptr && symtab
->fullname
!= nullptr)
1728 gdbpy_ref
<> fullname
1729 = host_string_to_python_string (symtab
->fullname
);
1730 return fullname
.release ();
1735 /* De-allocation function to be called for the Python object. */
1738 bplocpy_dealloc (PyObject
*py_self
)
1740 auto *self
= (gdbpy_breakpoint_location_object
*) py_self
;
1741 bp_location_ref_ptr decrementing_ref
{self
->bp_loc
};
1742 Py_XDECREF (self
->owner
);
1743 Py_TYPE (py_self
)->tp_free (py_self
);
1746 /* __repr__ implementation for gdb.BreakpointLocation. */
1749 bplocpy_repr (PyObject
*py_self
)
1751 const auto self
= (gdbpy_breakpoint_location_object
*) py_self
;
1752 if (self
->owner
== nullptr || self
->owner
->bp
== nullptr
1753 || self
->owner
->bp
!= self
->bp_loc
->owner
)
1754 return gdb_py_invalid_object_repr (py_self
);
1756 const auto enabled
= self
->bp_loc
->enabled
? "enabled" : "disabled";
1758 std::string
str (enabled
);
1760 str
+= string_printf (" address=%s",
1761 paddress (self
->bp_loc
->owner
->gdbarch
,
1762 self
->bp_loc
->address
));
1764 if (self
->bp_loc
->requested_address
!= self
->bp_loc
->address
)
1765 str
+= string_printf (" requested_address=%s",
1766 paddress (self
->bp_loc
->owner
->gdbarch
,
1767 self
->bp_loc
->requested_address
));
1768 if (self
->bp_loc
->symtab
!= nullptr)
1769 str
+= string_printf (" source=%s:%d", self
->bp_loc
->symtab
->filename
,
1770 self
->bp_loc
->line_number
);
1772 const auto fn_name
= self
->bp_loc
->function_name
.get ();
1773 if (fn_name
!= nullptr)
1779 return PyUnicode_FromFormat ("<%s %s>", Py_TYPE (self
)->tp_name
,
1783 /* Attribute get/set Python definitions. */
1785 static gdb_PyGetSetDef bp_location_object_getset
[] = {
1786 { "enabled", bplocpy_get_enabled
, bplocpy_set_enabled
,
1787 "Boolean telling whether the breakpoint is enabled.", NULL
},
1788 { "owner", bplocpy_get_owner
, NULL
,
1789 "Get the breakpoint owner object", NULL
},
1790 { "address", bplocpy_get_address
, NULL
,
1791 "Get address of where this location was set", NULL
},
1792 { "source", bplocpy_get_source_location
, NULL
,
1793 "Get file and line number of where this location was set", NULL
},
1794 { "function", bplocpy_get_function
, NULL
,
1795 "Get function of where this location was set", NULL
},
1796 { "fullname", bplocpy_get_fullname
, NULL
,
1797 "Get fullname of where this location was set", NULL
},
1798 { "thread_groups", bplocpy_get_thread_groups
, NULL
,
1799 "Get thread groups where this location is in", NULL
},
1800 { NULL
} /* Sentinel. */
1803 PyTypeObject breakpoint_location_object_type
=
1805 PyVarObject_HEAD_INIT (NULL
, 0)
1806 "gdb.BreakpointLocation", /*tp_name*/
1807 sizeof (gdbpy_breakpoint_location_object
), /*tp_basicsize*/
1809 bplocpy_dealloc
, /*tp_dealloc*/
1814 bplocpy_repr
, /*tp_repr*/
1816 0, /*tp_as_sequence*/
1817 0, /*tp_as_mapping*/
1824 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1825 "GDB breakpoint location object", /* tp_doc */
1826 0, /* tp_traverse */
1828 0, /* tp_richcompare */
1829 0, /* tp_weaklistoffset */
1831 0, /* tp_iternext */
1834 bp_location_object_getset
, /* tp_getset */
1837 0, /* tp_descr_get */
1838 0, /* tp_descr_set */
1839 0, /* tp_dictoffset */