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