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