You can use the command
x (for “examine”) to examine memory in
any of several formats, independently of your program’s data types.
x command to examine memory.
n, f, and u are all optional parameters that specify how much memory to display and how to format it; addr is an expression giving the address where you want to start displaying memory. If you use defaults for nfu, you need not type the slash ‘/’. Several commands set convenient defaults for addr.
The repeat count is a decimal integer; the default is 1. It specifies how much memory (counting by units u) to display.
The display format is one of the formats used by
The unit size is any of
Halfwords (two bytes).
Words (four bytes). This is the initial default.
Giant words (eight bytes).
Each time you specify a unit size with
x, that size becomes the
default unit the next time you use
x. For the ‘i’ format,
the unit size is ignored and is normally not written. For the ‘s’ format,
the unit size defaults to ‘b’, unless it is explicitly given.
Use x /hs to display 16-bit char strings and x /ws to display
32-bit strings. The next use of x /s will again display 8-bit strings.
Note that the results depend on the programming language of the
current compilation unit. If the language is C, the ‘s’
modifier will use the UTF-16 encoding while ‘w’ will use
UTF-32. The encoding is set by the programming language and cannot
addr is the address where you want GDB to begin displaying
memory. The expression need not have a pointer value (though it may);
it is always interpreted as an integer address of a byte of memory.
See Expressions, for more information on expressions. The default for
addr is usually just after the last address examined—but several
other commands also set the default address:
info breakpoints (to
the address of the last breakpoint listed),
info line (to the
starting address of a line), and
For example, ‘x/3uh 0x54320’ is a request to display three halfwords
h) of memory, formatted as unsigned decimal integers (‘u’),
starting at address
0x54320. ‘x/4xw $sp’ prints the four
words (‘w’) of memory above the stack pointer (here, ‘$sp’;
see Registers) in hexadecimal (‘x’).
Since the letters indicating unit sizes are all distinct from the letters specifying output formats, you do not have to remember whether unit size or format comes first; either order works. The output specifications ‘4xw’ and ‘4wx’ mean exactly the same thing. (However, the count n must come first; ‘wx4’ does not work.)
Even though the unit size u is ignored for the formats ‘s’
and ‘i’, you might still want to use a count n; for example,
‘3i’ specifies that you want to see three machine instructions,
including any operands. For convenience, especially when used with
display command, the ‘i’ format also prints branch delay
slot instructions, if any, beyond the count specified, which immediately
follow the last instruction that is within the count. The command
disassemble gives an alternative way of inspecting machine
instructions; see Source and Machine Code.
All the defaults for the arguments to
x are designed to make it
easy to continue scanning memory with minimal specifications each time
x. For example, after you have inspected three machine
instructions with ‘x/3i addr’, you can inspect the next seven
with just ‘x/7’. If you use RET to repeat the
the repeat count n is used again; the other arguments default as
for successive uses of
When examining machine instructions, the instruction at current program
counter is shown with a
=> marker. For example:
(gdb) x/5i $pc-6 0x804837f <main+11>: mov %esp,%ebp 0x8048381 <main+13>: push %ecx 0x8048382 <main+14>: sub $0x4,%esp => 0x8048385 <main+17>: movl $0x8048460,(%esp) 0x804838c <main+24>: call 0x80482d4 <puts@plt>
The addresses and contents printed by the
x command are not saved
in the value history because there is often too much of them and they
would get in the way. Instead, GDB makes these values available for
subsequent use in expressions as values of the convenience variables
$__. After an
x command, the last address
examined is available for use in expressions in the convenience variable
$_. The contents of that address, as examined, are available in
the convenience variable
x command has a repeat count, the address and contents saved
are from the last memory unit printed; this is not the same as the last
address printed if several units were printed on the last line of output.
When you are debugging a program running on a remote target machine
(see Remote Debugging), you may wish to verify the program’s image
in the remote machine’s memory against the executable file you
downloaded to the target. Or, on any target, you may want to check
whether the program has corrupted its own read-only sections. The
compare-sections command is provided for such situations.
Compare the data of a loadable section section-name in the
executable file of the program being debugged with the same section in
the target machine’s memory, and report any mismatches. With no
arguments, compares all loadable sections. With an argument of
-r, compares all loadable read-only sections.
Note: for remote targets, this command can be accelerated if the target supports computing the CRC checksum of a block of memory (see qCRC packet).