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