When you are debugging a program, it is not unusual to realize that you have gone too far, and some event of interest has already happened. If the target environment supports it, gdb can allow you to “rewind” the program by running it backward.
A target environment that supports reverse execution should be able to “undo” the changes in machine state that have taken place as the program was executing normally. Variables, registers etc. should revert to their previous values. Obviously this requires a great deal of sophistication on the part of the target environment; not all target environments can support reverse execution.
When a program is executed in reverse, the instructions that have most recently been executed are “un-executed”, in reverse order. The program counter runs backward, following the previous thread of execution in reverse. As each instruction is “un-executed”, the values of memory and/or registers that were changed by that instruction are reverted to their previous states. After executing a piece of source code in reverse, all side effects of that code should be “undone”, and all variables should be returned to their prior values1.
If you are debugging in a target environment that supports reverse execution, gdb provides the following commands.
reverse-step will only stop
at the beginning of a source line. It “un-executes” the previously
executed source line. If the previous source line included calls to
reverse-step will step (backward) into
the called function, stopping at the beginning of the last
statement in the called function (typically a return statement).
Also, as with the
step command, if non-debuggable functions are
reverse-step will run thru them backward without stopping.
reverse-stepiwill take you back from the destination of the jump to the jump instruction itself.
reverse-nextwill take you back to the caller of that function, before the function was called, just as the normal
nextcommand would take you from the last line of a function back to its return to its caller 2.
reverse-nextiexecutes a single instruction in reverse, except that called functions are “un-executed” atomically. That is, if the previously executed instruction was a return from another function,
reverse-nextiwill continue to execute in reverse until the call to that function (from the current stack frame) is reached.
finishcommand takes you to the point where the current function returns,
reverse-finishtakes you to the point where it was called. Instead of ending up at the end of the current function invocation, you end up at the beginning.
set exec-direction reverse
step, stepi, next, nexti, continue, and finish. The
returncommand cannot be used in reverse mode.
set exec-direction forward
 Note that some side effects are easier to undo than others. For instance, memory and registers are relatively easy, but device I/O is hard. Some targets may be able undo things like device I/O, and some may not.
The contract between gdb and the reverse executing target requires only that the target do something reasonable when gdb tells it to execute backwards, and then report the results back to gdb. Whatever the target reports back to gdb, gdb will report back to the user. gdb assumes that the memory and registers that the target reports are in a consistant state, but gdb accepts whatever it is given.
 Unless the code is too heavily optimized.