]>
Commit | Line | Data |
---|---|---|
1 | /* Reverse execution and reverse debugging. | |
2 | ||
3 | Copyright (C) 2006-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 "target.h" | |
22 | #include "top.h" | |
23 | #include "cli/cli-cmds.h" | |
24 | #include "cli/cli-decode.h" | |
25 | #include "cli/cli-utils.h" | |
26 | #include "inferior.h" | |
27 | #include "infrun.h" | |
28 | #include "regcache.h" | |
29 | ||
30 | /* User interface: | |
31 | reverse-step, reverse-next etc. */ | |
32 | ||
33 | /* exec_reverse_once -- accepts an arbitrary gdb command (string), | |
34 | and executes it with exec-direction set to 'reverse'. | |
35 | ||
36 | Used to implement reverse-next etc. commands. */ | |
37 | ||
38 | static void | |
39 | exec_reverse_once (const char *cmd, const char *args, int from_tty) | |
40 | { | |
41 | enum exec_direction_kind dir = execution_direction; | |
42 | ||
43 | if (dir == EXEC_REVERSE) | |
44 | error (_("Already in reverse mode. Use '%s' or 'set exec-dir forward'."), | |
45 | cmd); | |
46 | ||
47 | if (!target_can_execute_reverse) | |
48 | error (_("Target %s does not support this command."), target_shortname); | |
49 | ||
50 | std::string reverse_command = string_printf ("%s %s", cmd, args ? args : ""); | |
51 | scoped_restore restore_exec_dir | |
52 | = make_scoped_restore (&execution_direction, EXEC_REVERSE); | |
53 | execute_command (reverse_command.c_str (), from_tty); | |
54 | } | |
55 | ||
56 | static void | |
57 | reverse_step (const char *args, int from_tty) | |
58 | { | |
59 | exec_reverse_once ("step", args, from_tty); | |
60 | } | |
61 | ||
62 | static void | |
63 | reverse_stepi (const char *args, int from_tty) | |
64 | { | |
65 | exec_reverse_once ("stepi", args, from_tty); | |
66 | } | |
67 | ||
68 | static void | |
69 | reverse_next (const char *args, int from_tty) | |
70 | { | |
71 | exec_reverse_once ("next", args, from_tty); | |
72 | } | |
73 | ||
74 | static void | |
75 | reverse_nexti (const char *args, int from_tty) | |
76 | { | |
77 | exec_reverse_once ("nexti", args, from_tty); | |
78 | } | |
79 | ||
80 | static void | |
81 | reverse_continue (const char *args, int from_tty) | |
82 | { | |
83 | exec_reverse_once ("continue", args, from_tty); | |
84 | } | |
85 | ||
86 | static void | |
87 | reverse_finish (const char *args, int from_tty) | |
88 | { | |
89 | exec_reverse_once ("finish", args, from_tty); | |
90 | } | |
91 | ||
92 | /* Data structures for a bookmark list. */ | |
93 | ||
94 | struct bookmark { | |
95 | struct bookmark *next; | |
96 | int number; | |
97 | CORE_ADDR pc; | |
98 | struct symtab_and_line sal; | |
99 | gdb_byte *opaque_data; | |
100 | }; | |
101 | ||
102 | static struct bookmark *bookmark_chain; | |
103 | static int bookmark_count; | |
104 | ||
105 | #define ALL_BOOKMARKS(B) for ((B) = bookmark_chain; (B); (B) = (B)->next) | |
106 | ||
107 | #define ALL_BOOKMARKS_SAFE(B,TMP) \ | |
108 | for ((B) = bookmark_chain; \ | |
109 | (B) ? ((TMP) = (B)->next, 1) : 0; \ | |
110 | (B) = (TMP)) | |
111 | ||
112 | /* save_bookmark_command -- implement "bookmark" command. | |
113 | Call target method to get a bookmark identifier. | |
114 | Insert bookmark identifier into list. | |
115 | ||
116 | Identifier will be a malloc string (gdb_byte *). | |
117 | Up to us to free it as required. */ | |
118 | ||
119 | static void | |
120 | save_bookmark_command (const char *args, int from_tty) | |
121 | { | |
122 | /* Get target's idea of a bookmark. */ | |
123 | gdb_byte *bookmark_id = target_get_bookmark (args, from_tty); | |
124 | struct gdbarch *gdbarch = get_current_regcache ()->arch (); | |
125 | ||
126 | /* CR should not cause another identical bookmark. */ | |
127 | dont_repeat (); | |
128 | ||
129 | if (bookmark_id == NULL) | |
130 | error (_("target_get_bookmark failed.")); | |
131 | ||
132 | /* Set up a bookmark struct. */ | |
133 | bookmark *b = new bookmark (); | |
134 | b->number = ++bookmark_count; | |
135 | b->pc = regcache_read_pc (get_current_regcache ()); | |
136 | b->sal = find_pc_line (b->pc, 0); | |
137 | b->sal.pspace = get_frame_program_space (get_current_frame ()); | |
138 | b->opaque_data = bookmark_id; | |
139 | b->next = NULL; | |
140 | ||
141 | /* Add this bookmark to the end of the chain, so that a list | |
142 | of bookmarks will come out in order of increasing numbers. */ | |
143 | ||
144 | bookmark *b1 = bookmark_chain; | |
145 | if (b1 == 0) | |
146 | bookmark_chain = b; | |
147 | else | |
148 | { | |
149 | while (b1->next) | |
150 | b1 = b1->next; | |
151 | b1->next = b; | |
152 | } | |
153 | printf_filtered (_("Saved bookmark %d at %s\n"), b->number, | |
154 | paddress (gdbarch, b->sal.pc)); | |
155 | } | |
156 | ||
157 | /* Implement "delete bookmark" command. */ | |
158 | ||
159 | static int | |
160 | delete_one_bookmark (int num) | |
161 | { | |
162 | struct bookmark *b1, *b; | |
163 | ||
164 | /* Find bookmark with corresponding number. */ | |
165 | ALL_BOOKMARKS (b) | |
166 | if (b->number == num) | |
167 | break; | |
168 | ||
169 | /* Special case, first item in list. */ | |
170 | if (b == bookmark_chain) | |
171 | bookmark_chain = b->next; | |
172 | ||
173 | /* Find bookmark preceding "marked" one, so we can unlink. */ | |
174 | if (b) | |
175 | { | |
176 | ALL_BOOKMARKS (b1) | |
177 | if (b1->next == b) | |
178 | { | |
179 | /* Found designated bookmark. Unlink and delete. */ | |
180 | b1->next = b->next; | |
181 | break; | |
182 | } | |
183 | xfree (b->opaque_data); | |
184 | delete b; | |
185 | return 1; /* success */ | |
186 | } | |
187 | return 0; /* failure */ | |
188 | } | |
189 | ||
190 | static void | |
191 | delete_all_bookmarks (void) | |
192 | { | |
193 | struct bookmark *b, *b1; | |
194 | ||
195 | ALL_BOOKMARKS_SAFE (b, b1) | |
196 | { | |
197 | xfree (b->opaque_data); | |
198 | xfree (b); | |
199 | } | |
200 | bookmark_chain = NULL; | |
201 | } | |
202 | ||
203 | static void | |
204 | delete_bookmark_command (const char *args, int from_tty) | |
205 | { | |
206 | if (bookmark_chain == NULL) | |
207 | { | |
208 | warning (_("No bookmarks.")); | |
209 | return; | |
210 | } | |
211 | ||
212 | if (args == NULL || args[0] == '\0') | |
213 | { | |
214 | if (from_tty && !query (_("Delete all bookmarks? "))) | |
215 | return; | |
216 | delete_all_bookmarks (); | |
217 | return; | |
218 | } | |
219 | ||
220 | number_or_range_parser parser (args); | |
221 | while (!parser.finished ()) | |
222 | { | |
223 | int num = parser.get_number (); | |
224 | if (!delete_one_bookmark (num)) | |
225 | /* Not found. */ | |
226 | warning (_("No bookmark #%d."), num); | |
227 | } | |
228 | } | |
229 | ||
230 | /* Implement "goto-bookmark" command. */ | |
231 | ||
232 | static void | |
233 | goto_bookmark_command (const char *args, int from_tty) | |
234 | { | |
235 | struct bookmark *b; | |
236 | unsigned long num; | |
237 | const char *p = args; | |
238 | ||
239 | if (args == NULL || args[0] == '\0') | |
240 | error (_("Command requires an argument.")); | |
241 | ||
242 | if (startswith (args, "start") | |
243 | || startswith (args, "begin") | |
244 | || startswith (args, "end")) | |
245 | { | |
246 | /* Special case. Give target opportunity to handle. */ | |
247 | target_goto_bookmark ((gdb_byte *) args, from_tty); | |
248 | return; | |
249 | } | |
250 | ||
251 | if (args[0] == '\'' || args[0] == '\"') | |
252 | { | |
253 | /* Special case -- quoted string. Pass on to target. */ | |
254 | if (args[strlen (args) - 1] != args[0]) | |
255 | error (_("Unbalanced quotes: %s"), args); | |
256 | target_goto_bookmark ((gdb_byte *) args, from_tty); | |
257 | return; | |
258 | } | |
259 | ||
260 | /* General case. Bookmark identified by bookmark number. */ | |
261 | num = get_number (&args); | |
262 | ||
263 | if (num == 0) | |
264 | error (_("goto-bookmark: invalid bookmark number '%s'."), p); | |
265 | ||
266 | ALL_BOOKMARKS (b) | |
267 | if (b->number == num) | |
268 | break; | |
269 | ||
270 | if (b) | |
271 | { | |
272 | /* Found. Send to target method. */ | |
273 | target_goto_bookmark (b->opaque_data, from_tty); | |
274 | return; | |
275 | } | |
276 | /* Not found. */ | |
277 | error (_("goto-bookmark: no bookmark found for '%s'."), p); | |
278 | } | |
279 | ||
280 | static int | |
281 | bookmark_1 (int bnum) | |
282 | { | |
283 | struct gdbarch *gdbarch = get_current_regcache ()->arch (); | |
284 | struct bookmark *b; | |
285 | int matched = 0; | |
286 | ||
287 | ALL_BOOKMARKS (b) | |
288 | { | |
289 | if (bnum == -1 || bnum == b->number) | |
290 | { | |
291 | printf_filtered (" %d %s '%s'\n", | |
292 | b->number, | |
293 | paddress (gdbarch, b->pc), | |
294 | b->opaque_data); | |
295 | matched++; | |
296 | } | |
297 | } | |
298 | ||
299 | if (bnum > 0 && matched == 0) | |
300 | printf_filtered ("No bookmark #%d\n", bnum); | |
301 | ||
302 | return matched; | |
303 | } | |
304 | ||
305 | /* Implement "info bookmarks" command. */ | |
306 | ||
307 | static void | |
308 | info_bookmarks_command (const char *args, int from_tty) | |
309 | { | |
310 | if (!bookmark_chain) | |
311 | printf_filtered (_("No bookmarks.\n")); | |
312 | else if (args == NULL || *args == '\0') | |
313 | bookmark_1 (-1); | |
314 | else | |
315 | { | |
316 | number_or_range_parser parser (args); | |
317 | while (!parser.finished ()) | |
318 | { | |
319 | int bnum = parser.get_number (); | |
320 | bookmark_1 (bnum); | |
321 | } | |
322 | } | |
323 | } | |
324 | ||
325 | void _initialize_reverse (); | |
326 | void | |
327 | _initialize_reverse () | |
328 | { | |
329 | add_com ("reverse-step", class_run, reverse_step, _("\ | |
330 | Step program backward until it reaches the beginning of another source line.\n\ | |
331 | Argument N means do this N times (or till program stops for another reason).") | |
332 | ); | |
333 | add_com_alias ("rs", "reverse-step", class_run, 1); | |
334 | ||
335 | add_com ("reverse-next", class_run, reverse_next, _("\ | |
336 | Step program backward, proceeding through subroutine calls.\n\ | |
337 | Like the \"reverse-step\" command as long as subroutine calls do not happen;\n\ | |
338 | when they do, the call is treated as one instruction.\n\ | |
339 | Argument N means do this N times (or till program stops for another reason).") | |
340 | ); | |
341 | add_com_alias ("rn", "reverse-next", class_run, 1); | |
342 | ||
343 | add_com ("reverse-stepi", class_run, reverse_stepi, _("\ | |
344 | Step backward exactly one instruction.\n\ | |
345 | Argument N means do this N times (or till program stops for another reason).") | |
346 | ); | |
347 | add_com_alias ("rsi", "reverse-stepi", class_run, 0); | |
348 | ||
349 | add_com ("reverse-nexti", class_run, reverse_nexti, _("\ | |
350 | Step backward one instruction, but proceed through called subroutines.\n\ | |
351 | Argument N means do this N times (or till program stops for another reason).") | |
352 | ); | |
353 | add_com_alias ("rni", "reverse-nexti", class_run, 0); | |
354 | ||
355 | add_com ("reverse-continue", class_run, reverse_continue, _("\ | |
356 | Continue program being debugged but run it in reverse.\n\ | |
357 | If proceeding from breakpoint, a number N may be used as an argument,\n\ | |
358 | which means to set the ignore count of that breakpoint to N - 1 (so that\n\ | |
359 | the breakpoint won't break until the Nth time it is reached).")); | |
360 | add_com_alias ("rc", "reverse-continue", class_run, 0); | |
361 | ||
362 | add_com ("reverse-finish", class_run, reverse_finish, _("\ | |
363 | Execute backward until just before selected stack frame is called.")); | |
364 | ||
365 | add_com ("bookmark", class_bookmark, save_bookmark_command, _("\ | |
366 | Set a bookmark in the program's execution history.\n\ | |
367 | A bookmark represents a point in the execution history \n\ | |
368 | that can be returned to at a later point in the debug session.")); | |
369 | add_info ("bookmarks", info_bookmarks_command, _("\ | |
370 | Status of user-settable bookmarks.\n\ | |
371 | Bookmarks are user-settable markers representing a point in the \n\ | |
372 | execution history that can be returned to later in the same debug \n\ | |
373 | session.")); | |
374 | add_cmd ("bookmark", class_bookmark, delete_bookmark_command, _("\ | |
375 | Delete a bookmark from the bookmark list.\n\ | |
376 | Argument is a bookmark number or numbers,\n\ | |
377 | or no argument to delete all bookmarks."), | |
378 | &deletelist); | |
379 | add_com ("goto-bookmark", class_bookmark, goto_bookmark_command, _("\ | |
380 | Go to an earlier-bookmarked point in the program's execution history.\n\ | |
381 | Argument is the bookmark number of a bookmark saved earlier by using \n\ | |
382 | the 'bookmark' command, or the special arguments:\n\ | |
383 | start (beginning of recording)\n\ | |
384 | end (end of recording)")); | |
385 | } |