Next: Floating Point Hardware, Previous: Convenience Vars, Up: Data
You can refer to machine register contents, in expressions, as variables
with names starting with `$'. The names of registers are different
for each machine; use info registers
to see the names used on
your machine.
info registers
info all-registers
info registers
regname ...
gdb has four “standard” register names that are available (in
expressions) on most machines—whenever they do not conflict with an
architecture's canonical mnemonics for registers. The register names
$pc
and $sp
are used for the program counter register and
the stack pointer. $fp
is used for a register that contains a
pointer to the current stack frame, and $ps
is used for a
register that contains the processor status. For example,
you could print the program counter in hex with
p/x $pc
or print the instruction to be executed next with
x/i $pc
or add four to the stack pointer1 with
set $sp += 4
Whenever possible, these four standard register names are available on
your machine even though the machine has different canonical mnemonics,
so long as there is no conflict. The info registers
command
shows the canonical names. For example, on the SPARC, info
registers
displays the processor status register as $psr
but you
can also refer to it as $ps
; and on x86-based machines $ps
is an alias for the eflags register.
gdb always considers the contents of an ordinary register as an integer when the register is examined in this way. Some machines have special registers which can hold nothing but floating point; these registers are considered to have floating point values. There is no way to refer to the contents of an ordinary register as floating point value (although you can print it as a floating point value with `print/f $regname').
Some registers have distinct “raw” and “virtual” data formats. This
means that the data format in which the register contents are saved by
the operating system is not the same one that your program normally
sees. For example, the registers of the 68881 floating point
coprocessor are always saved in “extended” (raw) format, but all C
programs expect to work with “double” (virtual) format. In such
cases, gdb normally works with the virtual format only (the format
that makes sense for your program), but the info registers
command
prints the data in both formats.
Some machines have special registers whose contents can be interpreted
in several different ways. For example, modern x86-based machines
have SSE and MMX registers that can hold several values packed
together in several different formats. gdb refers to such
registers in struct
notation:
(gdb) print $xmm1 $1 = { v4_float = {0, 3.43859137e-038, 1.54142831e-044, 1.821688e-044}, v2_double = {9.92129282474342e-303, 2.7585945287983262e-313}, v16_int8 = "\000\000\000\000\3706;\001\v\000\000\000\r\000\000", v8_int16 = {0, 0, 14072, 315, 11, 0, 13, 0}, v4_int32 = {0, 20657912, 11, 13}, v2_int64 = {88725056443645952, 55834574859}, uint128 = 0x0000000d0000000b013b36f800000000 }
To set values of such registers, you need to tell gdb which
view of the register you wish to change, as if you were assigning
value to a struct
member:
(gdb) set $xmm1.uint128 = 0x000000000000000000000000FFFFFFFF
Normally, register values are relative to the selected stack frame (see Selecting a Frame). This means that you get the value that the register would contain if all stack frames farther in were exited and their saved registers restored. In order to see the true contents of hardware registers, you must select the innermost frame (with `frame 0').
However, gdb must deduce where registers are saved, from the machine code generated by your compiler. If some registers are not saved, or if gdb is unable to locate the saved registers, the selected stack frame makes no difference.
[1] This is a way of removing
one word from the stack, on machines where stacks grow downward in
memory (most machines, nowadays). This assumes that the innermost
stack frame is selected; setting $sp
is not allowed when other
stack frames are selected. To pop entire frames off the stack,
regardless of machine architecture, use return
;
see Returning from a Function.