This is the mail archive of the mailing list for the GDB project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFA] Submit process record and replay fourth time, 8/8

Change the name of record command.
 doc/gdb.texinfo |  107 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

--- a/doc/gdb.texinfo
+++ b/doc/gdb.texinfo
@@ -134,6 +134,7 @@ software in general.  We will miss him.
 * Running::                     Running programs under @value{GDBN}
 * Stopping::                    Stopping and continuing
 * Reverse Execution::           Running programs backward
+* Process record and replay::   Recording inferior's execution and replaying it
 * Stack::                       Examining the stack
 * Source::                      Examining source files
 * Data::                        Examining data
@@ -5002,6 +5003,112 @@ This is the default.
 @end table

+@node Process record and replay
+@chapter Recording inferior's execution and replaying it
+@cindex process record and replay
+@cindex recording inferior's execution and replaying it
+In a architecture environment that supports process record and replay,
+process record and replay target can record a log of the process execution,
+and replay it with both forward and reverse execute commands.
+When this target is in use, if the execution log includes the record for
+the next instruction, @value{GDBN} will debug in replay mode.  So inferior
+will not really execute and all the execution events are taken from the
+execution log.  Just the values of registers (include pc register) and
+memory of the inferior will be changed.
+Otherwise, @value{GDBN} will debug in record mode.  So inferior will
+execute normally and @value{GDBN} will record the execution log.
+If you are debugging in a architecture environment that supports
+process record and replay, @value{GDBN} provides the following commands.
+@table @code
+@kindex target record
+@kindex record
+@kindex rec
+@item target record
+This a standard command to start process record and replay target.
+Process record and replay target can only debug a process that already
+running.  Therefore you need to first start the process @code{run},
+and then start the recording @code{target record}.
+Both @code{record} and @code{rec} are the aliases of @code{target record}.
+Displaced stepping function will disable when process record and replay
+target is opened.  Because process record and replay target doesn't
+support displaced stepping function.
+If inferior in non-stop mode (non-stop) or in asynchronous mode
+(target-async), process record and replay target can't be open because
+it doesn't support these two modes.
+@kindex record stop
+@kindex rec s
+@item record stop
+Stop process record and replay target at once.  When Process record and
+replay target stops, all the execution log will be deleted and the inferior
+will either be terminated, or remain in its final state.
+When you stop the process record and replay target in record mode (at the
+end of the execution log), the inferior will be stopped at the next
+instruction that would have been recorded.  In other words, if you record
+for a while and then stop recording, the inferior process will be left in
+the same state as if recording never happened.
+On the other hand, if the process record and replay target is stopped while
+in replay mode (that is, not at the end of the execution log but at some
+earlier point), the inferior process will become ``live'' at that
earlier state,
+and it will then be possible to continue debugging the process ``live'' from
+that state.
+When the inferior process exits, or @value{GDBN} detaches from it, process
+record and replay target will automatically stop itself.
+@kindex set record insn-number-max
+@item set record insn-number-max @var{limit}
+Set the limit of instructions to be recorded.  Default value is 200000.
+In this case, if record instructions number is bigger than @var{limit},
+@value{GDBN} will auto delete the earliest recorded instruction execute
+If set to 0, @value{GDBN} will not delete the earliest recorded instruction
+execute log.  Record instructions number limit function will disable.
+@kindex show record insn-number-max
+@item show record insn-number-max
+Show the value of recorded instructions limit.
+@kindex set record stop-at-limit
+@item set record stop-at-limit on
+Set the behavior when record instructions limit is reached.
+This is the default mode.  Meaning that @value{GDBN} will stop ask user
+want close @code{record stop-at-limit} or stop inferior.
+@item set record stop-at-limit off
+This mean that @value{GDBN} will auto delete the oldest record to make
+room for each new one.
+@kindex show record stop-at-limit
+@item show record stop-at-limit
+Show the value of record stop-at-limit.
+@kindex info record insn-number
+@item info record insn-number
+Show the current number of recorded instructions.
+@kindex record delete
+@kindex rec del
+@item record delete
+When record target running in replay mode (``in the past''), delete the
+subsequent execution log and begin to record a new execution log starting
+from the current address.  It means you will abandon the previously
+recorded ``future'' and begin recording a new ``future''.
+@end table
 @node Stack
 @chapter Examining the Stack

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]