from gdb.texinfo on 11 July 1994 -->
Go to the previous, next section.
Continuing means resuming program execution until your program
completes normally. In contrast, stepping means executing just
one more "step" of your program, where "step" may mean either one
line of source code, or one machine instruction (depending on what
particular command you use). Either when continuing
or when stepping, your program may stop even sooner, due to
a breakpoint or a signal. (If due to a signal, you may want to use
handle
, or use `signal 0' to resume execution.
See section Signals.)
continue [ignore-count]
c [ignore-count]
fg [ignore-count]
ignore
(see section Break conditions).
The argument ignore-count is meaningful only when your program
stopped due to a breakpoint. At other times, the argument to
continue
is ignored.
The synonyms c
and fg
are provided purely for convenience,
and have exactly the same behavior as continue
.
To resume execution at a different place, you can use return
(see section Returning from a function) to go back to the
calling function; or jump
(see section Continuing at a different address) to go to an arbitrary location in your program.
A typical technique for using stepping is to set a breakpoint (see section Breakpoints, watchpoints, and exceptions) at the beginning of the function or the section of your program where a problem is believed to lie, run your program until it stops at that breakpoint, and then step through the suspect area, examining the variables that are interesting, until you see the problem happen.
step
s
.
Warning: If you use the step
command while control is
within a function that was compiled without debugging information,
execution proceeds until control reaches a function that does have
debugging information.
step count
step
, but do so count times. If a
breakpoint is reached,
or a signal not related to stepping occurs before count steps,
stepping stops right away.
next [count]
step
, but any function calls appearing within the line
of code are executed without stopping. Execution stops when control
reaches a different line of code at the stack level which was executing
when the next
command was given. This command is abbreviated
n
.
An argument count is a repeat count, as for step
.
next
within a function that lacks debugging information acts like
step
, but any function calls appearing within the code of the
function are executed without stopping.
finish
Contrast this with the return
command (see section Returning from a function).
until
u
next
command, except that when until
encounters a jump, it
automatically continues execution until the program counter is greater
than the address of the jump.
This means that when you reach the end of a loop after single stepping
though it, until
makes your program continue execution until it
exits the loop. In contrast, a next
command at the end of a loop
simply steps back to the beginning of the loop, which forces you to step
through the next iteration.
until
always stops your program if it attempts to exit the current
stack frame.
until
may produce somewhat counterintuitive results if the order
of machine code does not match the order of the source lines. For
example, in the following excerpt from a debugging session, the f
(frame
) command shows that execution is stopped at line
206
; yet when we use until
, we get to line 195
:
(gdb) f #0 main (argc=4, argv=0xf7fffae8) at m4.c:206 206 expand_input(); (gdb) until 195 for ( ; argc > 0; NEXTARG) {
This happened because, for execution efficiency, the compiler had
generated code for the loop closure test at the end, rather than the
start, of the loop--even though the test in a C for
-loop is
written before the body of the loop. The until
command appeared
to step back to the beginning of the loop when it advanced to this
expression; however, it has not really gone to an earlier
statement--not in terms of the actual machine code.
until
with no argument works by means of single
instruction stepping, and hence is slower than until
with an
argument.
until location
u location
break
(see section Setting breakpoints). This form of the command uses breakpoints,
and hence is quicker than until
without an argument.
stepi
si
It is often useful to do `display/i $pc' when stepping by machine instructions. This makes GDB automatically display the next instruction to be executed, each time your program stops. See section Automatic display.
An argument is a repeat count, as in step
.
nexti
ni
An argument is a repeat count, as in next
.
Go to the previous, next section.