GDB fallback debugging

To join the debugger that you are using GDB7.0 and above and run on a platform that supports reverse debugging, you can debug the program with the following commands:

Reverse-continue

The reverse runner knows that it encounters an event (such as a breakpoint, observer, exception) that can cause the program to break.

Reverse-step

Reverse-run the program to the last source line that was executed.

Reverse-stepi

Reverse running the program to the previous machine instruction

Reverse-next

The reverse runs to the last line of source code that was executed, but does not enter the function.

Reverse-nexti

Run backwards to the previous machine instruction, unless the instruction is used to return a function call, and the entire function will be executed in reverse.

Reverse-finish

The reverse runner returns to the place where the current function is called.

Set exec-direction [forward | reverse]

Set the direction of the program, you can use the usual command step and continue, etc. to perform reverse debugging commands.

The inverse of the above can also be understood to undo the effect of the statement that is run later, back to the previous state.

OK, then let's try to debug backwards.

First, confirm that your platform supports process record playback (processes records and Replay), and when the debugger enables the process record playback function, the debugger records the daemon, which is the difference between the running state of each step of the debug process and the previous run state. It is convenient to go back to the previous step when you need to undo it.

Suppose we have the following C program:

[CPP]View PlainCopyprint?

1. int main (int argc, const Char *argv[])
2. {
3. int a = 0;
4. A = 1;
5. A = 2;
6. return 0;
7. }

Compile it and add the debug symbols:

[Python]View PlainCopy print?

1. $ gcc-wall-g A.C

To start Debugging:

[Python]View PlainCopyprint?

1. $ gdb a.out

Take a look at the source code:

[Python]View PlainCopy  print?

1. (GDB) L
2. 1 int main (int argc, const char *argv[])
3. 2 {
4. 3 int a = 0;
5. 4 A = 1;
6. 5 A = 2;
7. 6 return 0;
8. 7}

Next, set a breakpoint on the third line:

[Python]View PlainCopyprint?

1. (GDB) b 3
2. Breakpoint 1 at 0x804839a:file A.C, line 3.

Run, the program will stop at the third line:

[Python]View PlainCopy print?

1. (GDB) R
2. Starting program:/home/cheryl/a.out
3. Breakpoint 1, Main (argc=1, argv=0xbffff3e4) at A.C:3
4. 3 int a = 0;

Setting a monitoring point for variable a allows us to observe:

[Python]View PlainCopyprint?

1. (GDB) Watch a
2. Hardware watchpoint 2:a

Start process record playback:

[Python]View PlainCopyprint?

1. (GDB) record

Now each step of the debugger will record the changes for backtracking. We execute 3 consecutive statements.

[Python]View PlainCopyprint?

2. (GDB) n
4. 4 A = 1;
6. (GDB)
8. Hardware watchpoint 2:a
10. Old value = 0
12. New value = 1
14. Main (argc=1, argv=0xbffff3e4) at A.C:5
16. 5 A = 2;
18. (GDB)
20. Hardware watchpoint 2:a
22. Old value = 1
24. New value = 2
26. Main (argc=1, argv=0xbffff3e4) at A.C:6
28. 6 return 0;

As you can see, the value of a is changed from 0 to 1, then to 2, what if you want the program to revert back to its previous state? You can use the Reverse-next command:

[Python]View PlainCopyprint?

2. (GDB) Reverse-next
4. Hardware watchpoint 2:a
6. Old value = 2
8. New value = 1
10. Main (argc=1, argv=0xbffff3e4) at A.C:5
12. 5 A = 2;
14. (GDB)
16. Hardware watchpoint 2:a
18. Old value = 1
20. New value = 0
22. Main (argc=1, argv=0xbffff3e4) at A.C:4
24. 4 A = 1;
26. (GDB)
28. No more reverse-execution history.
30. Main (argc=1, argv=0xbffff3e4) at A.C:3
32. 3 int a = 0;
34. (GDB)

So the program goes back to where we started the process of recording playback, and the value of a is returned to its original state in two steps.

If you need to turn off process record playback, you can use the record stop:

[Python]View PlainCopyprint?

1. (GDB) Record stop
2. Process record is stoped and all execution logs is deleted.

Reference: "Reverse debugging with GDB"---http://sourceware.org/gdb/wiki/ReverseDebug

GDB fallback debugging