]> CyberLeo.Net >> Repos - FreeBSD/releng/10.0.git/blob - contrib/gdb/gdb/mi/mi-cmd-break.c
- Copy stable/10 (r259064) to releng/10.0 as part of the
[FreeBSD/releng/10.0.git] / contrib / gdb / gdb / mi / mi-cmd-break.c
1 /* MI Command Set - breakpoint and watchpoint commands.
2    Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
3    Contributed by Cygnus Solutions (a Red Hat company).
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 2 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, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 #include "defs.h"
23 #include "mi-cmds.h"
24 #include "ui-out.h"
25 #include "mi-out.h"
26 #include "breakpoint.h"
27 #include "gdb_string.h"
28 #include "mi-getopt.h"
29 #include "gdb-events.h"
30 #include "gdb.h"
31
32 enum
33   {
34     FROM_TTY = 0
35   };
36
37 /* Output a single breakpoint. */
38
39 static void
40 breakpoint_notify (int b)
41 {
42   gdb_breakpoint_query (uiout, b);
43 }
44
45
46 struct gdb_events breakpoint_hooks =
47 {
48   breakpoint_notify,
49   breakpoint_notify,
50   breakpoint_notify,
51 };
52
53
54 enum bp_type
55   {
56     REG_BP,
57     HW_BP,
58     REGEXP_BP
59   };
60
61 /* Insert a breakpoint. The type of breakpoint is specified by the
62    first argument: -break-insert <location> --> insert a regular
63    breakpoint.  -break-insert -t <location> --> insert a temporary
64    breakpoint.  -break-insert -h <location> --> insert an hardware
65    breakpoint.  -break-insert -t -h <location> --> insert a temporary
66    hw bp.  
67    -break-insert -r <regexp> --> insert a bp at functions matching
68    <regexp> */
69
70 enum mi_cmd_result
71 mi_cmd_break_insert (char *command, char **argv, int argc)
72 {
73   char *address = NULL;
74   enum bp_type type = REG_BP;
75   int temp_p = 0;
76   int thread = -1;
77   int ignore_count = 0;
78   char *condition = NULL;
79   enum gdb_rc rc;
80   struct gdb_events *old_hooks;
81   enum opt
82     {
83       HARDWARE_OPT, TEMP_OPT /*, REGEXP_OPT */ , CONDITION_OPT,
84       IGNORE_COUNT_OPT, THREAD_OPT
85     };
86   static struct mi_opt opts[] =
87   {
88     {"h", HARDWARE_OPT, 0},
89     {"t", TEMP_OPT, 0},
90     {"c", CONDITION_OPT, 1},
91     {"i", IGNORE_COUNT_OPT, 1},
92     {"p", THREAD_OPT, 1},
93     0
94   };
95
96   /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
97      to denote the end of the option list. */
98   int optind = 0;
99   char *optarg;
100   while (1)
101     {
102       int opt = mi_getopt ("mi_cmd_break_insert", argc, argv, opts, &optind, &optarg);
103       if (opt < 0)
104         break;
105       switch ((enum opt) opt)
106         {
107         case TEMP_OPT:
108           temp_p = 1;
109           break;
110         case HARDWARE_OPT:
111           type = HW_BP;
112           break;
113 #if 0
114         case REGEXP_OPT:
115           type = REGEXP_BP;
116           break;
117 #endif
118         case CONDITION_OPT:
119           condition = optarg;
120           break;
121         case IGNORE_COUNT_OPT:
122           ignore_count = atol (optarg);
123           break;
124         case THREAD_OPT:
125           thread = atol (optarg);
126           break;
127         }
128     }
129
130   if (optind >= argc)
131     error ("mi_cmd_break_insert: Missing <location>");
132   if (optind < argc - 1)
133     error ("mi_cmd_break_insert: Garbage following <location>");
134   address = argv[optind];
135
136   /* Now we have what we need, let's insert the breakpoint! */
137   old_hooks = set_gdb_event_hooks (&breakpoint_hooks);
138   switch (type)
139     {
140     case REG_BP:
141       rc = gdb_breakpoint (address, condition,
142                            0 /*hardwareflag */ , temp_p,
143                            thread, ignore_count);
144       break;
145     case HW_BP:
146       rc = gdb_breakpoint (address, condition,
147                            1 /*hardwareflag */ , temp_p,
148                            thread, ignore_count);
149       break;
150 #if 0
151     case REGEXP_BP:
152       if (temp_p)
153         error ("mi_cmd_break_insert: Unsupported tempoary regexp breakpoint");
154       else
155         rbreak_command_wrapper (address, FROM_TTY);
156       return MI_CMD_DONE;
157       break;
158 #endif
159     default:
160       internal_error (__FILE__, __LINE__,
161                       "mi_cmd_break_insert: Bad switch.");
162     }
163   set_gdb_event_hooks (old_hooks);
164
165   if (rc == GDB_RC_FAIL)
166     return MI_CMD_CAUGHT_ERROR;
167   else
168     return MI_CMD_DONE;
169 }
170
171 enum wp_type
172 {
173   REG_WP,
174   READ_WP,
175   ACCESS_WP
176 };
177
178 /* Insert a watchpoint. The type of watchpoint is specified by the
179    first argument: 
180    -break-watch <expr> --> insert a regular wp.  
181    -break-watch -r <expr> --> insert a read watchpoint.
182    -break-watch -a <expr> --> insert an access wp. */
183
184 enum mi_cmd_result
185 mi_cmd_break_watch (char *command, char **argv, int argc)
186 {
187   char *expr = NULL;
188   enum wp_type type = REG_WP;
189   enum opt
190     {
191       READ_OPT, ACCESS_OPT
192     };
193   static struct mi_opt opts[] =
194   {
195     {"r", READ_OPT, 0},
196     {"a", ACCESS_OPT, 0},
197     0
198   };
199
200   /* Parse arguments. */
201   int optind = 0;
202   char *optarg;
203   while (1)
204     {
205       int opt = mi_getopt ("mi_cmd_break_watch", argc, argv, opts, &optind, &optarg);
206       if (opt < 0)
207         break;
208       switch ((enum opt) opt)
209         {
210         case READ_OPT:
211           type = READ_WP;
212           break;
213         case ACCESS_OPT:
214           type = ACCESS_WP;
215           break;
216         }
217     }
218   if (optind >= argc)
219     error ("mi_cmd_break_watch: Missing <expression>");
220   if (optind < argc - 1)
221     error ("mi_cmd_break_watch: Garbage following <expression>");
222   expr = argv[optind];
223
224   /* Now we have what we need, let's insert the watchpoint! */
225   switch (type)
226     {
227     case REG_WP:
228       watch_command_wrapper (expr, FROM_TTY);
229       break;
230     case READ_WP:
231       rwatch_command_wrapper (expr, FROM_TTY);
232       break;
233     case ACCESS_WP:
234       awatch_command_wrapper (expr, FROM_TTY);
235       break;
236     default:
237       error ("mi_cmd_break_watch: Unknown watchpoint type.");
238     }
239   return MI_CMD_DONE;
240 }