gdb.info: Jumping

Go forward to Signaling
Go backward to Assignment
Go up to Altering
Go to the top op gdb

Continuing at a different address

Ordinarily, when you continue your program, you do so at the place where
it stopped, with the `continue' command.  You can instead continue at
an address of your own choosing, with the following commands:
`jump LINESPEC'
     Resume execution at line LINESPEC.  Execution stops again
     immediately if there is a breakpoint there.  *Note Printing source
     lines: List, for a description of the different forms of LINESPEC.
     It is common practice to use the `tbreak' command in conjunction
     with `jump'.  *Note Setting breakpoints: Set Breaks.
     The `jump' command does not change the current stack frame, or the
     stack pointer, or the contents of any memory location or any
     register other than the program counter.  If line LINESPEC is in a
     different function from the one currently executing, the results
     may be bizarre if the two functions expect different patterns of
     arguments or of local variables.  For this reason, the `jump'
     command requests confirmation if the specified line is not in the
     function currently executing.  However, even bizarre results are
     predictable if you are well acquainted with the machine-language
     code of your program.
`jump *ADDRESS'
     Resume execution at the instruction at address ADDRESS.
   On many systems, you can get much the same effect as the `jump'
command by storing a new value into the register `$pc'.  The difference
is that this does not start your program running; it only changes the
address of where it _will_ run when you continue.  For example,
     set $pc = 0x485
makes the next `continue' command or stepping command execute at
address `0x485', rather than at the address where your program stopped.
*Note Continuing and stepping: Continuing and Stepping.
   The most common occasion to use the `jump' command is to back
up--perhaps with more breakpoints set--over a portion of a program that
has already executed, in order to examine its execution in more detail.