How many times have you stepped through code only to find that you’ve gone too far? Maybe you overstepped a critical point in the code’s execution. Or perhaps you stepped over a function you intended to step into.
Did you know that GDB could actually step backwards through of code? That’s right. You can have GDB go back in time. This is often referred to as “reverse debugging.” But how does it work?
How It Works
Reverse debugging actually relies upon another gem in GDB’s bag-of-tricks called “process record and replay”. Rolls right off the tongue doesn’t it? I won’t spend a lot of time going into the details of PRR here, but it’s quite powerful. The only PRR command we need to be concerned with in this discussion is “record”.
The “record” command begins recording the execution of your application, making notes of things like memory and register values. When you arrive at a point in your application at which you’d like to go backwards, you can issue the “reverse” versions of all the navigation commands you’re already familiar with. This include reverse-step (rs), reverse-next (rn), reverse-continue (rc), and reverse-finish (no short version 🙁 ). As you move backwards through code, gdb reverts the state of memory and registers, effectively unexecuting lines of code.
Let’s see an example using the code snippet below.
#include <iostream> int sum(int a, int b) { int result = a + b; return result; } int main(int argc, char **argv) { int a = 12; int b = 13; int c = sum(a, b); std::cout << "The sum of " << a << " and " << b << " is " << c << "\n"; return 0; } |
Compile this (don’t forget to compile it with the ‘-g’ flag!) and fire up gdb. Then set a breakpoint at main. We can’t begin recording program execution before it’s actually running. So we issue the run command, which will execute our application and promptly break at main.
(gdb) break main Breakpoint 1 at 0x4007df: file gdbtest.cpp, line 11. (gdb) run Starting program: /home/skirk/gdbtest Breakpoint 1, main (argc=1, argv=0x7fffffffdf28) at gdbtest.cpp:11 11 int a = 12; |
At this point, we issue the “record” command to begin recording.
(gdb) record |
Now let’s start stepping through the code.
(gdb) n 12 int b = 13; (gdb) n 13 int c = sum(a, b); (gdb) n 15 std::cout << "The sum of " << a << " and " << b << " is " << c << "\n"; |
We’re now at the point just before the sum is written to stdout. What if I had intended to step into the sum function to see what it’s doing? Let’s back up to just before the sum function is called and then step into it.
(gdb) reverse-next 13 int c = sum(a, b); (gdb) s sum (a=12, b=13) at gdbtest.cpp:5 5 int result = a + b; |
Now we appear to have gone back into time. This allows us to step into the sum function. At this point, we can inspect the values of parameters a and b as we normally would.
(gdb) print a $1 = 12 (gdb) print b $2 = 13 |
If we’re satisfied with the state of things, we can allow the program to continue on.
(gdb) c Continuing. No more reverse-execution history. main (argc=1, argv=0x7fffffffdf28) at gdbtest.cpp:15 15 std::cout << "The sum of " << a << " and " << b << " is " << c << "\n"; |
An interesting thing happened here. The program execution stopped at the point at which we previously started stepping backwards. When stepping through code using recorded history, “continue” will continue program execution until the history has been exhausted, unless, of course, it has some other reason to stop such as breakpoints and the like.
Let’s now stop the recording process using the “record stop” command and allow the program to continue execution until completion.
(gdb) record stop Process record is stopped and all execution logs are deleted. (gdb) c Continuing. The sum of 12 and 13 is 25 [Inferior 1 (process 10608) exited normally] (gdb) |
Gotchas
What if we hadn’t stopped recording? Well, it depends. If your version of the runtime executes instructions that aren’t supported by PRR, then you may encounter errors such as this…
Process record does not support instruction 0xc5 at address 0x7ffff7dee8b7. Process record: failed to record execution log. Program stopped. _dl_runtime_resolve_avx () at ../sysdeps/x86_64/dl-trampoline.h:81 81 ../sysdeps/x86_64/dl-trampoline.h: No such file or directory. |
In this case, AVX instructions are being executed which aren’t supported by the record process. (In this particular case, there’s a workaround. We can export the environment variable LD_BIND_NOW=1 which resolves all symbols at load time. Doing so actually prevents the call to _dl_runtime_resolve_avx later.)
It’s also possible you might see something like…
The sum of 12 and 13 is 25 The next instruction is syscall exit_group. It will make the program exit. Do you want to stop the program?([y] or n) |
Here you’re prompted as to whether or not you want to stop the program. Regardless of what you choose, you’re still able to navigate backwards in program execution. That’s right – you can reverse debug an application that has finished running.
Caveats
There are a few caveats when performing reverse debugging.
The first is that you can’t move backwards beyond the point at which you started recording. That should make sense.
Another caveat is that recording isn’t free or cheap. There’s a non-trivial amount of overhead involved in keeping track of registers and memory. So use record where it matters.
By default, there’s an upper limit on the number of instructions the record log can contain. This is 200,000 in the default record mode. This can be tweaked however, including setting it to unlimited (which really just means it’ll record until it’s out of memory). See the GDB manual for more info on this.
You can always see what the current record instruction limit is by using the “info record” command.
Conclusion
Reverse debugging is great tool to keep in your toolbox for those tricky bits of code. In the right contexts, it can save you lots of time. Use it judiciously, however. Recording everything in your application wastes memory, memory that your application may actually need. It can also be detrimental to your program’s execution speed.