linux下gdb单步调试
用 GDB调试程序
GDB 概述
————
GDB 是 GNU开源组织发布的一个强大的 UNIX下的程序调试工具。或许，各位比较喜欢那种图形界面方式的，像 VC、 BCB等 IDE的调试，但如果你是在 UNIX平台下做软件，你会发现 GDB这个调试工具有比 VC、 BCB的图形化调试器更强大的功能。所谓 “寸有所长，尺有所短 ”就是这个道理。
一般来说， GDB主要帮忙你完成下面四个方面的功能：
1 、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。
2 、可让被调试的程序在你所指定的调置的断点处停住。（断点可以是条件表达式）
3 、当程序被停住时，可以检查此时你的程序中所发生的事。
4 、动态的改变你程序的执行环境。
从上面看来， GDB和一般的调试工具没有什么两样，基本上也是完成这些功能，不过在细节上，你会发现 GDB这个调试工具的强大，大家可能比较习惯了图形化的调试工具，但有时候，命令行的调试工具却有着图形化工具所不能完成的功能。让我们一一看来。
一个调试示例
——————
源程序： tst.c
1 #include
2
3 int func(int n)
4 {
5 int sum=0,i;
6 for(i=0; i
8 sum+=i;
9 }
10 return sum;
11 }
12
13
14 main()
15 {
16 int i;
17 long result = 0;
18 for(i=1; i<=100; i++)
19 {
20 result += i;
21 }
22
23 printf("result[1-100] = %d /n", result );
24 printf("result[1-250] = %d /n", func(250) );
25 }
编译生成执行文件：（ Linux下）
hchen/test> cc -g tst.c -o tst
使用 GDB调试：
hchen/test> gdb tst <----------启动 GDB
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-suse-linux"...
(gdb) l <-------------------- l 命令相当于 list，从第一行开始例出原码。
1 #include
2
3 int func(int n)
4 {
5 int sum=0,i;
6 for(i=0; i
8 sum+=i;
9 }
10 return sum;
(gdb) <--------------------
11 }
12
13
14 main()
15 {
16 int i;
17 long result = 0;
18 for(i=1; i<=100; i++)
19 {
20 result += i;
(gdb) break 16 <-------------------- 设置断点，在源程序第 16行处。
Breakpoint 1 at 0x8048496: file tst.c, line 16.
(gdb) break func <-------------------- 设置断点，在函数 func()入口处。
Breakpoint 2 at 0x8048456: file tst.c, line 5.
(gdb) info break <-------------------- 查看断点信息。
Num Type Disp Enb Address What
1 breakpoint keep y 0x08048496 in main at tst.c:16
2 breakpoint keep y 0x08048456 in func at tst.c:5
(gdb) r <--------------------- 运行程序， run命令简写
Starting program: /home/hchen/test/tst
Breakpoint 1, main () at tst.c:17 <----------在断点处停住。
17 long result = 0;
(gdb) n <--------------------- 单条语句执行， next命令简写。
18 for(i=1; i<=100; i++)
(gdb) n
20 result += i;
(gdb) n
18 for(i=1; i<=100; i++)
(gdb) n
20 result += i;
(gdb) c <--------------------- 继续运行程序， continue命令简写。
Continuing.
result[1-100] = 5050 <---------- 程序输出。
Breakpoint 2, func (n=250) at tst.c:5
5 int sum=0,i;
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p i <--------------------- 打印变量 i的值， print命令简写。
$1 = 134513808
(gdb) n
8 sum+=i;
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p sum
$2 = 1
(gdb) n
8 sum+=i;
(gdb) p i
$3 = 2
(gdb) n
6 for(i=1; i<=n; i++)
(gdb) p sum
$4 = 3
(gdb) bt <--------------------- 查看函数堆栈。
#0 func (n=250) at tst.c:5
#1 0x080484e4 in main () at tst.c:24
#2 0x400409ed in __libc_start_main () from /lib/libc.so.6
(gdb) finish <--------------------- 退出函数。
Run till exit from #0 func (n=250) at tst.c:5
0x080484e4 in main () at tst.c:24
24 printf("result[1-250] = %d /n", func(250) );
Value returned is $6 = 31375
(gdb) c <--------------------- 继续运行。
Continuing.
result[1-250] = 31375 <---------- 程序输出。
Program exited with code 027. <--------程序退出，调试结束。
(gdb) q <--------------------- 退出 gdb。
hchen/test>
好了，有了以上的感性认识，还是让我们来系统地认识一下 gdb吧。
使用 GDB
————
一般来说 GDB主要调试的是 C/C++的程序。要调试C/C++ 的程序，首先在编译时，我们必须要把调试信息加到可执行文件中。使用编译器（ cc/gcc/g++）的 -g参数可以做到这一点。如：
> cc -g hello.c -o hello
> g++ -g hello.cpp -o hello
如果没有 -g，你将看不见程序的函数名、变量名，所代替的全是运行时的内存地址。当你用 -g把调试信息加入之后，并成功编译目标代码以后，让我们来看看如何用 gdb来调试他。
启动 GDB的方法有以下几种：
1 、 gdb
program
2 、 gdb
3 、 gdb
GDB 启动时，可以加上一些 GDB的启动开关，详细的开关可以用 gdb -help查看。我在下面只例举一些比较常用的参数：
-symbols
-s
-se file
从指定文件中读取符号表信息，并把他用在可执行文件中。
-core
-c
-directory
-d
GDB 的命令概貌
———————
启动 gdb后，就你被带入 gdb的调试环境中，就可以使用 gdb的命令开始调试程序了， gdb的命令可以使用 help命令来查看，如下所示：
/home/hchen> gdb
GNU gdb 5.1.1
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-suse-linux".
(gdb) help
List of classes of commands:
aliases -- Aliases of other commands
breakpoints -- Making program stop at certain points
data -- Examining data
files -- Specifying and examining files
internals -- Maintenance commands
obscure -- Obscure features
running -- Running the program
stack -- Examining the stack
status -- Status inquiries
support -- Support facilities
tracepoints -- Tracing of program execution without stopping the program
user-defined -- User-defined commands
Type "help" followed by a class name for a list of commands in that class.
Type "help" followed by command name for full documentation.
Command name abbreviations are allowed if unambiguous.
(gdb)
gdb 的命令很多， gdb把之分成许多个种类。 help命令只是例出 gdb的命令种类，如果要看种类中的命令，可以使用 help
gdb 中，输入命令时，可以不用打全命令，只用打命令的前几个字符就可以了，当然，命令的前几个字符应该要标志着一个唯一的命令，在 Linux下，你可以敲击两次 TAB键来补齐命令的全称，如果有重复的，那么 gdb会把其例出来。
示例一：在进入函数 func时，设置一个断点。可以敲入 break func，或是直接就是 b func
(gdb) b func
Breakpoint 1 at 0x8048458: file hello.c, line 10.
示例二：敲入 b按两次 TAB键，你会看到所有 b打头的命令：
(gdb) b
backtrace break bt
(gdb)
示例三：只记得函数的前缀，可以这样：
(gdb) b make_ < 按 TAB键 >
（再按下一次 TAB键，你会看到 :）
make_a_section_from_file make_environ
make_abs_section make_function_type
make_blockvector make_pointer_type
make_cleanup make_reference_type
make_command make_symbol_completion_list
(gdb) b make_
GDB 把所有 make开头的函数全部例出来给你查看。
示例四：调试 C++的程序时，有可以函数名一样。如：
(gdb) b 'bubble( M-?
bubble(double,double) bubble(int,int)
(gdb) b 'bubble(
你可以查看到 C++中的所有的重载函数及参数。（注： M-?和 “按两次 TAB键 ”是一个意思）
要退出 gdb时，只用发 quit或命令简称 q就行了。
GDB 中运行 UNIX的 shell程序
————————————
在 gdb环境中，你可以执行 UNIX的 shell的命令，使用 gdb的 shell命令来完成：
shell
还有一个 gdb命令是 make：
make
在 GDB中运行程序
————————
当以 gdb
在 gdb中，运行程序使用 r或是 run命令。程序的运行，你有可能需要设置下面四方面的事。
1 、程序运行参数。
set args 可指定运行时参数。（如： set args 10 20 30 40 50）
show args 命令可以查看设置好的运行参数。
2 、运行环境。
path
show paths 查看程序的运行路径。
set environment varname [=value] 设置环境变量。如： set env USER=hchen
show environment [varname] 查看环境变量。
3 、工作目录。
cd
pwd 显示当前的所在目录。
4 、程序的输入输出。
info terminal 显示你程序用到的终端的模式。
使用重定向控制程序输出。如： run > outfile
tty 命令可以指写输入输出的终端设备。如： tty /dev/ttyb
调试已运行的程序
————————
两种方法：
1 、在 UNIX下用 ps查看正在运行的程序的 PID（进程 ID），然后用 gdb
2 、先用 gdb
暂停 /恢复程序运行
—————————
调试程序中，暂停程序运行是必须的， GDB可以方便地暂停程序的运行。你可以设置程序的在哪行停住，在什么条件下停住，在收到什么信号时停往等等。以便于你查看运行时的变量，以及运行时的流程。
当进程被 gdb停住时，你可以使用 info program来查看程序的是否在运行，进程号，被暂停的原因。
在 gdb中，我们可以有以下几种暂停方式：断点（ BreakPoint）、观察点（ WatchPoint）、捕捉点（ CatchPoint）、信号（ Signals）、线程停止（ Thread Stops）。如果要恢复程序运行，可以使用 c或是 continue命令。
一、设置断点（ BreakPoint）
我们用 break命令来设置断点。正面有几点设置断点的方法：
break
break
break +offset
break -offset
在当前行号的前面或后面的 offset行停住。 offiset为自然数。
break filename:linenum
在源文件 filename的 linenum行处停住。
break filename:function
在源文件 filename的 function函数的入口处停住。
break *address
在程序运行的内存地址处停住。
break
break 命令没有参数时，表示在下一条指令处停住。
break ... if
...
查看断点时，可使用 info命令，如下所示：（注： n表示断点号）
info breakpoints [n]
info break [n]
二、设置观察点（ WatchPoint）
观察点一般来观察某个表达式（变量也是一种表达式）的值是否有变化了，如果有变化，马上停住程序。我们有下面的几种方法来设置观察点：
watch
rwatch
awatch
info watchpoints
列出当前所设置了的所有观察点。
三、设置捕捉点（ CatchPoint）
你可设置捕捉点来补捉程序运行时的一些事件。如：载入共享库（动态链接库）或是 C++的异常。设置捕捉点的格式为：
catch
1 、 throw一个 C++抛出的异常。（ throw为关键字）
2 、 catch一个 C++捕捉到的异常。（ catch为关键字）
3 、 exec调用系统调用 exec时。（ exec为关键字，目前此功能只在 HP-UX下有用）
4 、 fork调用系统调用 fork时。（ fork为关键字，目前此功能只在 HP-UX下有用）
5 、 vfork调用系统调用 vfork时。（ vfork为关键字，目前此功能只在 HP-UX下有用）
6 、 load或 load
7 、 unload或 unload
tcatch
四、维护停止点
上面说了如何设置程序的停止点， GDB中的停止点也就是上述的三类。在 GDB中，如果你觉得已定义好的停止点没有用了，你可以使用 delete、 clear、 disable、 enable这几个命令来进行维护。
clear
清除所有的已定义的停止点。
clear
clear
clear
clear
delete [breakpoints] [range...]
删除指定的断点， breakpoints为断点号。如果不指定断点号，则表示删除所有的断点。 range表示断点号的范围（如： 3-7）。其简写命令为 d。
比删除更好的一种方法是 disable停止点， disable了的停止点， GDB不会删除，当你还需要时， enable即可，就好像回收站一样。
disable [breakpoints] [range...]
disable 所指定的停止点， breakpoints为停止点号。如果什么都不指定，表示 disable所有的停止点。简写命令是 dis.
enable [breakpoints] [range...]
enable 所指定的停止点， breakpoints为停止点号。
enable [breakpoints] once range...
enable 所指定的停止点一次，当程序停止后，该停止点马上被 GDB自动 disable。
enable [breakpoints] delete range...
enable 所指定的停止点一次，当程序停止后，该停止点马上被 GDB自动删除。
五、停止条件维护
前面在说到设置断点时，我们提到过可以设置一个条件，当条件成立时，程序自动停止，这是一个非常强大的功能，这里，我想专门说说这个条件的相关维护命令。一般来说，为断点设置一个条件，我们使用 if关键词，后面跟其断点条件。并且，条件设置好后，我们可以用 condition命令来修改断点的条件。（只有 break和 watch命令支持 if， catch目前暂不支持 if）
condition
condition
还有一个比较特殊的维护命令 ignore，你可以指定程序运行时，忽略停止条件几次。
ignore
六、为停止点设定运行命令
我们可以使用 GDB提供的 command命令来设置停止点的运行命令。也就是说，当运行的程序在被停止住时，我们可以让其自动运行一些别的命令，这很有利行自动化调试。对基于 GDB的自动化调试是一个强大的支持。
commands [bnum]
... command-list ...
end
为断点号 bnum指写一个命令列表。当程序被该断点停住时， gdb会依次运行命令列表中的命令。
例如：
break foo if x>0
commands
printf "x is %d/n",x
continue
end
断点设置在函数 foo中，断点条件是 x>0，如果程序被断住后，也就是，一旦 x的值在 foo函数中大于 0， GDB会自动打印出 x的值，并继续运行程序。
如果你要清除断点上的命令序列，那么只要简单的执行一下 commands命令，并直接在打个 end就行了。
七、断点菜单
在 C++中，可能会重复出现同一个名字的函数若干次（函数重载），在这种情况下， break
(gdb) b String::after
[0] cancel
[1] all
[2] file:String.cc; line number:867
[3] file:String.cc; line number:860
[4] file:String.cc; line number:875
[5] file:String.cc; line number:853
[6] file:String.cc; line number:846
[7] file:String.cc; line number:735
> 2 4 6
Breakpoint 1 at 0xb26c: file String.cc, line 867.
Breakpoint 2 at 0xb344: file String.cc, line 875.
Breakpoint 3 at 0xafcc: file String.cc, line 846.
Multiple breakpoints were set.
Use the "delete" command to delete unwanted
breakpoints.
(gdb)
可见， GDB列出了所有 after的重载函数，你可以选一下列表编号就行了。 0表示放弃设置断点， 1表示所有函数都设置断点。
八、恢复程序运行和单步调试
当程序被停住了，你可以用 continue命令恢复程序的运行直到程序结束，或下一个断点到来。也可以使用 step或 next命令单步跟踪程序。
continue [ignore-count]
c [ignore-count]
fg [ignore-count]
恢复程序运行，直到程序结束，或是下一个断点到来。 ignore-count表示忽略其后的断点次数。 continue， c， fg三个命令都是一样的意思。
step
next
set step-mode
set step-mode on
打开 step-mode模式，于是，在进行单步跟踪时，程序不会因为没有 debug信息而不停住。这个参数有很利于查看机器码。
set step-mod off
关闭 step-mode模式。
finish
运行程序，直到当前函数完成返回。并打印函数返回时的堆栈地址和返回值及参数值等信息。
until 或 u
当你厌倦了在一个循环体内单步跟踪时，这个命令可以运行程序直到退出循环体。
stepi 或 si
nexti 或 ni
单步跟踪一条机器指令！一条程序代码有可能由数条机器指令完成， stepi和 nexti可以单步执行机器指令。与之一样有相同功能的命令是 “ display/i $pc ”，当运行完这个命令后，单步跟踪会在打出程序代码的同时打出机器指令（也就是汇编代码）
九、信号（ Signals）
信号是一种软中断，是一种处理异步事件的方法。一般来说，操作系统都支持许多信号。尤其是 UNIX，比较重要应用程序一般都会处理信号。 UNIX定义了许多信号，比如 SIGINT表示中断字符信号，也就是 Ctrl+C的信号， SIGBUS表示硬件故障的信号； SIGCHLD表示子进程状态改变信号； SIGKILL表示终止程序运行的信号，等等。信号量编程是 UNIX下非常重要的一种技术。
GDB 有能力在你调试程序的时候处理任何一种信号，你可以告诉 GDB需要处理哪一种信号。你可以要求 GDB收到你所指定的信号时，马上停住正在运行的程序，以供你进行调试。你可以用 GDB的 handle命令来完成这一功能。
handle
nostop
当被调试的程序收到信号时， GDB不会停住程序的运行，但会打出消息告诉你收到这种信号。
stop
当被调试的程序收到信号时， GDB会停住你的程序。
print
当被调试的程序收到信号时， GDB会显示出一条信息。
noprint
当被调试的程序收到信号时， GDB不会告诉你收到信号的信息。
pass
noignore
当被调试的程序收到信号时， GDB不处理信号。这表示， GDB会把这个信号交给被调试程序会处理。
nopass
ignore
当被调试的程序收到信号时， GDB不会让被调试程序来处理这个信号。
info signals
info handle
查看有哪些信号在被 GDB检测中。
十、线程（ Thread Stops）
如果你程序是多线程的话，你可以定义你的断点是否在所有的线程上，或是在某个特定的线程。 GDB很容易帮你完成这一工作。
break
break
linespec
(gdb) break frik.c:13 thread 28 if bartab > lim
当你的程序被 GDB停住时，所有的运行线程都会被停住。这方便你你查看运行程序的总体情况。而在你恢复程序运行时，所有的线程也会被恢复运行。那怕是主进程在被单步调试时。
查看栈信息
—————
当程序被停住了，你需要做的第一件事就是查看程序是在哪里停住的。当你的程序调用了一个函数，函数的地址，函数参数，函数内的局部变量都会被压入 “栈 ”（ Stack）中。你可以用 GDB命令来查看当前的栈中的信息。
下面是一些查看函数调用栈信息的 GDB命令：
backtrace
bt
打印当前的函数调用栈的所有信息。如：
(gdb) bt
#0 func (n=250) at tst.c:6
#1 0x08048524 in main (argc=1, argv=0xbffff674) at tst.c:30
#2 0x400409ed in __libc_start_main () from /lib/libc.so.6
从上可以看出函数的调用栈信息： __libc_start_main --> main() --> func()
backtrace
bt
n
backtrace <-n>
bt <-n>
-n 表一个负整数，表示只打印栈底下 n层的栈信息。
如果你要查看某一层的信息，你需要在切换当前的栈，一般来说，程序停止时，最顶层的栈就是当前栈，如果你要查看栈下面层的详细信息，首先要做的是切换当前栈。
frame
f
n
up
down
上面的命令，都会打印出移动到的栈层的信息。如果你不想让其打出信息。你可以使用这三个命令：
select-frame
up-silently
down-silently
查看当前栈层的信息，你可以用以下 GDB命令：
frame 或 f
会打印出这些信息：栈的层编号，当前的函数名，函数参数值，函数所在文件及行号，函数执行到的语句。
info frame
info f
这个命令会打印出更为详细的当前栈层的信息，只不过，大多数都是运行时的内内地址。比如：函数地址，调用函数的地址，被调用函数的地址，目前的函数是由什么样的程序语言写成的、函数参数地址及值、局部变量的地址等等。如：
(gdb) info f
Stack level 0, frame at 0xbffff5d4:
eip = 0x804845d in func (tst.c:6); saved eip 0x8048524
called by frame at 0xbffff60c
source language c.
Arglist at 0xbffff5d4, args: n=250
Locals at 0xbffff5d4, Previous frame's sp is 0x0
Saved registers:
ebp at 0xbffff5d4, eip at 0xbffff5d8
info args
打印出当前函数的参数名及其值。
info locals
打印出当前函数中所有局部变量及其值。
info catch
打印出当前的函数中的异常处理信息。
查看源程序
—————
一、显示源代码
GDB 可以打印出所调试程序的源代码，当然，在程序编译时一定要加上 -g的参数，把源程序信息编译到执行文件中。不然就看不到源程序了。当程序停下来以后， GDB会报告程序停在了那个文件的第几行上。你可以用 list命令来打印程序的源代码。还是来看一看查看源代码的 GDB命令吧。
list
list
list
显示当前行后面的源程序。
list -
显示当前行前面的源程序。
一般是打印当前行的上 5行和下 5行，如果显示函数是是上 2行下8 行，默认是 10行，当然，你也可以定制显示的范围，使用下面命令可以设置一次显示源程序的行数。
set listsize
show listsize
查看当前 listsize的设置。
list 命令还有下面的用法：
list
list ,
list +
往后显示源代码。
一般来说在 list后面可以跟以下这们的参数：
<+offset> 当前行号的正偏移量。
<-offset> 当前行号的负偏移量。
<*address> 程序运行时的语句在内存中的地址。
二、搜索源代码
不仅如此， GDB还提供了源代码搜索的命令：
forward-search
search
reverse-search
其中，
三、指定源文件的路径
某些时候，用 -g编译过后的执行程序中只是包括了源文件的名字，没有路径名。 GDB提供了可以让你指定源文件的路径的命令，以便 GDB进行搜索。
directory
dir
directory
清除所有的自定义的源文件搜索路径信息。
show directories
显示定义了的源文件搜索路径。
四、源代码的内存
你可以使用 info line命令来查看源代码在内存中的地址。 info line后面可以跟 “行号 ”， “函数名 ”， “文件名 :行号 ”， “文件名 :函数名 ”，这个命令会打印出所指定的源码在运行时的内存地址，如：
(gdb) info line tst.c:func
Line 5 of "tst.c" starts at address 0x8048456
还有一个命令（ disassemble）你可以查看源程序的当前执行时的机器码，这个命令会把目前内存中的指令 dump出来。如下面的示例表示查看函数 func的汇编代码。
(gdb) disassemble func
Dump of assembler code for function func:
0x8048450
0x8048451
0x8048453
0x8048456
0x804845d
0x8048464
0x8048467
0x804846a
0x804846c
0x804846e
0x8048470
0x8048473
0x8048476
0x8048479
0x804847b
0x804847c
0x8048480
0x8048483
0x8048485
0x8048487
0x8048489
0x804848a
End of assembler dump.
查看运行时数据
———————
在你调试程序时，当程序被停住时，你可以使用 print命令（简写命令为 p），或是同义命令 inspect来查看当前程序的运行数据。 print命令的格式是：
print
print /
一、表达式
print 和许多 GDB的命令一样，可以接受一个表达式， GDB会根据当前的程序运行的数据来计算这个表达式，既然是表达式，那么就可以是当前程序运行中的 const常量、变量、函数等内容。可惜的是 GDB不能使用你在程序中所定义的宏。
表达式的语法应该是当前所调试的语言的语法，由于 C/C++是一种大众型的语言，所以，本文中的例子都是关于 C/C++的。（而关于用 GDB调试其它语言的章节，我将在后面介绍）
在表达式中，有几种 GDB所支持的操作符，它们可以用在任何一种语言中。
@
是一个和数组有关的操作符，在后面会有更详细的说明。
::
指定一个在文件或是一个函数中的变量。
{
二、程序变量
在 GDB中，你可以随时查看以下三种变量的值：
1 、全局变量（所有文件可见的）
2 、静态全局变量（当前文件可见的）
3 、局部变量（当前 Scope可见的）
如果你的局部变量和全局变量发生冲突（也就是重名），一般情况下是局部变量会隐藏全局变量，也就是说，如果一个全局变量和一个函数中的局部变量同名时，如果当前停止点在函数中，用 print显示出的变量的值会是函数中的局部变量的值。如果此时你想查看全局变量的值时，你可以使用 “ :: ”操作符：
file::variable
function::variable
可以通过这种形式指定你所想查看的变量，是哪个文件中的或是哪个函数中的。例如，查看文件 f2.c中的全局变量 x的值：
gdb) p 'f2.c'::x
当然， “ :: ”操作符会和 C++中的发生冲突， GDB能自动识别 “ :: ”是否 C++的操作符，所以你不必担心在调试 C++程序时会出现异常。
另外，需要注意的是，如果你的程序编译时开启了优化选项，那么在用 GDB调试被优化过的程序时，可能会发生某些变量不能访问，或是取值错误码的情况。这个是很正常的，因为优化程序会删改你的程序，整理你程序的语句顺序，剔除一些无意义的变量等，所以在 GDB调试这种程序时，运行时的指令和你所编写指令就有不一样，也就会出现你所想象不到的结果。对付这种情况时，需要在编译程序时关闭编译优化。一般来说，几乎所有的编译器都支持编译优化的开关，例如， GNU的 C/C++编译器 GCC，你可以使用 “ -gstabs ”选项来解决这个问题。关于编译器的参数，还请查看编译器的使用说明文档。
三、数组
有时候，你需要查看一段连续的内存空间的值。比如数组的一段，或是动态分配的数据的大小。你可以使用 GDB的 “ @ ”操作符， “ @ ”的左边是第一个内存的地址的值， “ @ ”的右边则你你想查看内存的长度。例如，你的程序中有这样的语句：
int *array = (int *) malloc (len * sizeof (int));
于是，在 GDB调试过程中，你可以以如下命令显示出这个动态数组的取值：
p *array@len
@ 的左边是数组的首地址的值，也就是变量 array所指向的内容，右边则是数据的长度，其保存在变量 len中，其输出结果，大约是下面这个样子的：
(gdb) p *array@len
$1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}
如果是静态数组的话，可以直接用 print数组名，就可以显示数组中所有数据的内容了。
四、输出格式
一般来说， GDB会根据变量的类型输出变量的值。但你也可以自定义 GDB的输出的格式。例如，你想输出一个整数的十六进制，或是二进制来查看这个整型变量的中的位的情况。要做到这样，你可以使用 GDB的数据显示格式：
x 按十六进制格式显示变量。
d 按十进制格式显示变量。
u 按十六进制格式显示无符号整型。
o 按八进制格式显示变量。
t 按二进制格式显示变量。
a 按十六进制格式显示变量。
c 按字符格式显示变量。
f 按浮点数格式显示变量。
(gdb) p i
$21 = 101
(gdb) p/a i
$22 = 0x65
(gdb) p/c i
$23 = 101 'e'
(gdb) p/f i
$24 = 1.41531145e-43
(gdb) p/x i
$25 = 0x65
(gdb) p/t i
$26 = 1100101
五、查看内存
你可以使用 examine命令（简写是 x）来查看内存地址中的值。 x命令的语法如下所示：
x/
n
n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。
f 表示显示的格式，参见上面。如果地址所指的是字符串，那么格式可以是 s，如果地十是指令地址，那么格式可以是 i。
u 表示从当前地址往后请求的字节数，如果不指定的话， GDB默认是 4个 bytes。 u参数可以用下面的字符来代替， b表示单字节， h表示双字节， w表示四字节， g表示八字节。当我们指定了字节长度后， GDB会从指内存定的内存地址开始，读写指定字节，并把其当作一个值取出来。
n/f/u 三个参数可以一起使用。例如：
命令： x/3uh 0x54320表示，从内存地址 0x54320读取内容， h表示以双字节为一个单位， 3表示三个单位， u表示按十六进制显示。
六、自动显示
你可以设置一些自动显示的变量，当程序停住时，或是在你单步跟踪时，这些变量会自动显示。相关的 GDB命令是 display。
display
display/
display/
expr
格式 i和 s同样被 display支持，一个非常有用的命令是：
display/i $pc
$pc 是 GDB的环境变量，表示着指令的地址， /i则表示输出格式为机器指令码，也就是汇编。于是当程序停下后，就会出现源代码和机器指令码相对应的情形，这是一个很有意思的功能。
下面是一些和 display相关的 GDB命令：
undisplay
delete display
disable display
enable display
disable
info display
查看 display设置的自动显示的信息。 GDB会打出一张表格，向你报告当然调试中设置了多少个自动显示设置，其中包括，设置的编号，表达式，是否 enable。
七、设置显示选项
GDB 中关于显示的选项比较多，这里我只例举大多数常用的选项。
set print address
set print address on
打开地址输出，当程序显示函数信息时， GDB会显出函数的参数地址。系统默认为打开的，如：
(gdb) f
#0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
at input.c:530
530 if (lquote != def_lquote)
set print address off
关闭函数的参数地址显示，如：
(gdb) set print addr off
(gdb) f
#0 set_quotes (lq="<<", rq=">>") at input.c:530
530 if (lquote != def_lquote)
show print address
查看当前地址显示选项是否打开。
set print array
set print array on
打开数组显示，打开后当数组显示时，每个元素占一行，如果不打开的话，每个元素则以逗号分隔。这个选项默认是关闭的。与之相关的两个命令如下，我就不再多说了。
set print array off
show print array
set print elements
show print elements
查看 print elements的选项信息。
set print null-stop
set print pretty on
如果打开 printf pretty这个选项，那么当 GDB显示结构体时会比较漂亮。如：
$1 = {
next = 0x0,
flags = {
sweet = 1,
sour = 1
},
meat = 0x54 "Pork"
}
set print pretty off
关闭 printf pretty这个选项， GDB显示结构体时会如下显示：
$1 = {next = 0x0, flags = {sweet = 1, sour = 1}, meat = 0x54 "Pork"}
show print pretty
查看 GDB是如何显示结构体的。
set print sevenbit-strings
show print sevenbit-strings
查看字符显示开关是否打开。
set print union
typedef enum {Tree, Bug} Species;
typedef enum {Big_tree, Acorn, Seedling} Tree_forms;
typedef enum {Caterpillar, Cocoon, Butterfly}
Bug_forms;
struct thing {
Species it;
union {
Tree_forms tree;
Bug_forms bug;
} form;
};
struct thing foo = {Tree, {Acorn}};
当打开这个开关时，执行 p foo命令后，会如下显示：
$1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}}
当关闭这个开关时，执行 p foo命令后，会如下显示：
$1 = {it = Tree, form = {...}}
show print union
查看联合体数据的显示方式
set print object
show print object
查看对象选项的设置。
set print static-members
show print static-members
查看静态数据成员选项设置。
set print vtbl
show print vtbl
查看虚函数显示格式的选项。
八、历史记录
当你用 GDB的 print查看程序运行时的数据时，你每一个 print都会被 GDB记录下来。 GDB会以 $1, $2, $3 .....这样的方式为你每一个 print命令编上号。于是，你可以使用这个编号访问以前的表达式，如 $1。这个功能所带来的好处是，如果你先前输入了一个比较长的表达式，如果你还想查看这个表达式的值，你可以使用历史记录来访问，省去了重复输入。
九、 GDB环境变量
你可以在 GDB的调试环境中定义自己的变量，用来保存一些调试程序中的运行数据。要定义一个 GDB的变量很简单只需。使用 GDB的 set命令。 GDB的环境变量和 UNIX一样，也是以 $起头。如：
set $foo = *object_ptr
使用环境变量时， GDB会在你第一次使用时创建这个变量，而在以后的使用中，则直接对其賦值。环境变量没有类型，你可以给环境变量定义任一的类型。包括结构体和数组。
show convenience
该命令查看当前所设置的所有的环境变量。
这是一个比较强大的功能，环境变量和程序变量的交互使用，将使得程序调试更为灵活便捷。例如：
set $i = 0
print bar[$i++]->contents
于是，当你就不必， print bar[0]->contents, print bar[1]->contents地输入命令了。输入这样的命令后，只用敲回车，重复执行上一条语句，环境变量会自动累加，从而完成逐个输出的功能。
十、查看寄存器
要查看寄存器的值，很简单，可以使用如下命令：
info registers
查看寄存器的情况。（除了浮点寄存器）
info all-registers
查看所有寄存器的情况。（包括浮点寄存器）
info registers
寄存器中放置了程序运行时的数据，比如程序当前运行的指令地址（ ip），程序的当前堆栈地址（ sp）等等。你同样可以使用 print命令来访问寄存器的情况，只需要在寄存器名字前加一个 $符号就可以了。如： p $eip。
改变程序的执行
———————
一旦使用 GDB挂上被调试程序，当程序运行起来后，你可以根据自己的调试思路来动态地在 GDB中更改当前被调试程序的运行线路或是其变量的值，这个强大的功能能够让你更好的调试你的程序，比如，你可以在程序的一次运行中走遍程序的所有分支。
一、修改变量值
修改被调试程序运行时的变量值，在 GDB中很容易实现，使用 GDB的 print命令即可完成。如：
(gdb) print x=4
x=4 这个表达式是 C/C++的语法，意为把变量 x的值修改为 4，如果你当前调试的语言是 Pascal，那么你可以使用 Pascal的语法： x:=4。
在某些时候，很有可能你的变量和 GDB中的参数冲突，如：
(gdb) whatis width
type = double
(gdb) p width
$4 = 13
(gdb) set width=47
Invalid syntax in expression.
因为， set width是 GDB的命令，所以，出现了 “ Invalid syntax in expression ”的设置错误，此时，你可以使用 set var命令来告诉 GDB， width不是你 GDB的参数，而是程序的变量名，如：
(gdb) set var width=47
另外，还可能有些情况， GDB并不报告这种错误，所以保险起见，在你改变程序变量取值时，最好都使用 set var格式的 GDB命令。
二、跳转执行
一般来说，被调试程序会按照程序代码的运行顺序依次执行。 GDB提供了乱序执行的功能，也就是说， GDB可以修改程序的执行顺序，可以让程序执行随意跳跃。这个功能可以由 GDB的 jump命令来完：
jump
jump
这里的 是代码行的内存地址。
注意， jump命令不会改变当前的程序栈中的内容，所以，当你从一个函数跳到另一个函数时，当函数运行完返回时进行弹栈操作时必然会发生错误，可能结果还是非常奇怪的，甚至于产生程序 Core Dump。所以最好是同一个函数中进行跳转。
熟悉汇编的人都知道，程序运行时，有一个寄存器用于保存当前代码所在的内存地址。所以， jump命令也就是改变了这个寄存器中的值。于是，你可以使用 “ set $pc ”来更改跳转执行的地址。如：
set $pc = 0x485
三、产生信号量
使用 singal命令，可以产生一个信号量给被调试的程序。如：中断信号 Ctrl+C。这非常方便于程序的调试，可以在程序运行的任意位置设置断点，并在该断点用 GDB产生一个信号量，这种精确地在某处产生信号非常有利程序的调试。
语法是： signal
single 命令和 shell的 kill命令不同，系统的 kill命令发信号给被调试程序时，是由 GDB截获的，而 single命令所发出一信号则是直接发给被调试程序的。
四、强制函数返回
如果你的调试断点在某个函数中，并还有语句没有执行完。你可以使用 return命令强制函数忽略还没有执行的语句并返回。
return
return
五、强制调用函数
call
另一个相似的命令也可以完成这一功能 —— print， print后面可以跟表达式，所以也可以用他来调用函数， print和 call的不同是，如果函数返回 void， call则不显示， print则显示函数返回值，并把该值存入历史数据中。
在不同语言中使用 GDB
——————————
GDB 支持下列语言： C, C++, Fortran, PASCAL, Java, Chill, assembly,和 Modula-2。一般说来， GDB会根据你所调试的程序来确定当然的调试语言，比如：发现文件名后缀为 “ .c ”的， GDB会认为是 C程序。文件名后缀为 “ .C, .cc, .cp, .cpp, .cxx, .c++ ”的， GDB会认为是 C++程序。而后缀是 “ .f, .F ”的， GDB会认为是 Fortran程序，还有，后缀为如果是 “ .s, .S ”的会认为是汇编语言。
也就是说， GDB会根据你所调试的程序的语言，来设置自己的语言环境，并让 GDB的命令跟着语言环境的改变而改变。比如一些 GDB命令需要用到表达式或变量时，这些表达式或变量的语法，完全是根据当前的语言环境而改变的。例如 C/C++中对指针的语法是 *p，而在 Modula-2中则是 p^。并且，如果你当前的程序是由几种不同语言一同编译成的，那到在调试过程中， GDB也能根据不同的语言自动地切换语言环境。这种跟着语言环境而改变的功能，真是体贴开发人员的一种设计。
下面是几个相关于 GDB语言环境的命令：
show language
查看当前的语言环境。如果 GDB不能识为你所调试的编程语言，那么， C语言被认为是默认的环境。
info frame
查看当前函数的程序语言。
info source
查看当前文件的程序语言。
如果 GDB没有检测出当前的程序语言，那么你也可以手动设置当前的程序语言。使用 set language命令即可做到。
当 set language命令后什么也不跟的话，你可以查看 GDB所支持的语言种类：
(gdb) set language
The currently understood settings are:
local or auto Automatic setting based on source file
c Use the C language
c++ Use the C++ language
asm Use the Asm language
chill Use the Chill language
fortran Use the Fortran language
java Use the Java language
modula-2 Use the Modula-2 language
pascal Use the Pascal language
scheme Use the Scheme language
于是你可以在 set language后跟上被列出来的程序语言名，来设置当前的语言环境。
后记
——
GDB 是一个强大的命令行调试工具。大家知道命令行的强大就是在于，其可以形成执行序列，形成脚本。 UNIX下的软件全是命令行的，这给程序开发提代供了极大的便利，命令行软件的优势在于，它们可以非常容易的集成在一起，使用几个简单的已有工具的命令，就可以做出一个非常强大的功能。
GDB手册1:一个GDB会话样例
GDB:第一章
第一章：一个GDB会话样例
1 一个GDB会话样例
你可以随意用这部手册来了解有关GDB的一切。然而，一些趁手的命令就足以开始使用调试器。这一章介绍了这些命令。
在这个简单的会话里，我们强调用户输入用黑体来显示，这样可以和环境输出明确的区分开来。
GNU m4（通用宏处理器）的以前版本有以下的一个bug:有时候，在我们改变了宏默认的引号字符串的时候，用来在别的宏里捕获
宏定义的命令就失效了。在接下来简短的m4例子里，我们定义了一个展开是“0000”的宏foo；我们接着用m4内建的defn来定义宏bar，bar的
值也是“0000”。然而，在我们用来替代开引号字符和用
baz:
$ cd gnu/m4
$ ./m4
define(foo,0000)
foo
0000
define(bar,defn(‘foo’))
bar
0000
changequote(,
define(baz,defn(foo
baz
Ctrl-d
m4: End of input: 0: fatal error: EOF in string
让我们试着用GDB来看看发生了什么。
$ gdb m4
gdb is free software and you are welcome to distribute copies
of it under certain conditions; type “show copying” to see
the conditions.
There is absolutely no warranty for gdb; type “show warranty”
for details.
gdb 6.8.50.20080307, Copyright 1999 Free Software Foundation, Inc…
(gdb)
GDB只是读入仅够在有需要的时候用来发现哪里能够找到后续内容的数据；这将是GDB的第一个提示很开出现。现在我们
让GDB用一个比通常窄的显示区域，这样可以让本书的例子显示的更好。
(gdb) set width 70
我们需要探查m4内建函数changequote是如何工作的。因为已经看过了源代码，我们知道相关的子函数是m4_changequote，所以我们
用GDB break命令在这个函数上设置一个断点。
(gdb) break m4 changequote
Breakpoint 1 at 0x62f4: file builtin.c, line 879.
用run 命令，m4就在GDB的控制下运行了。只要还没有运行到m4_changequote子函数，程序就如同往常一样运行：
(gdb) run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)
foo
0000
为了出发断点，我们要调用changequote.GDB挂起m4，显示出在它停止执行处的上下文信息。
changequote(,
Breakpoint 1, m4_changequote (argc=3, argv=0x33c70)
at builtin.c:879
879 if (bad_argc(TOKEN_DATA_TEXT(argv[0]),argc,1,3))
现在我们可以用命令n接着运行当前函数的下一行指令。
(gdb) n
882 set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\
: nil,
set_quotes看上去像有可能失败的子函数。为了进入子函数，我们可以用命令s(step)而不是用next。step进入被调用的
子函数的第一行，所以step进入set_qoutes.
(gdb) s
set_quotes (lq=0x34c78 “”, rq=0x34c88 “
at input.c:530
530 if (lquote != def_lquote)
这些输出显示了在m4挂起时的调用函数栈。它显示了栈的概要。我们可以用命令backtrace(也可以用缩写bt)来看当前在哪里：
backtrace命令显示了每一个活动子程序的栈。
gdb) bt
#0 set_quotes (lq=0x34c78 “”, rq=0x34c88 “
at input.c:530
#1 0×6344 in m4_changequote (argc=3, argv=0x33c70)
at builtin.c:882
#2 0×8174 in expand_macro (sym=0×33320) at macro.c:242
#3 0x7a88 in expand_token (obs=0×0, t=209696, td=0xf7fffa30)
at macro.c:71
#4 0x79dc in expand_input () at macro.c:40
#5 0×2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
我们step几行来观察会发生什么。在开始的两次为了避免进入xstrdup子程序，我们用’s';接下来的两次我们用’n'。
(gdb) s
0x3b5c 532 if (rquote != def_rquote)
(gdb) s
0x3b80 535 lquote = (lq == nil || *lq == ’\0’) ? \
def_lquote : xstrdup(lq);
(gdb) n
536 rquote = (rq == nil || *rq == ’\0’) ? def_rquote\
: xstrdup(rq);
(gdb) n
538 len_lquote = strlen(rquote);
最后一行输出看上去有点怪异；我们可以检查变量lquote和rquote的值来看看它们是否是真的是我们所期待的新的
左右引号。我们用命令p(print)
(gdb) p lquote
$1 = 0x35d40 “”
(gdb) p rquote
$2 = 0x35d50 “
lquote和rquote确实是新的左右引号。为了查看一些相关的信息，我们可以用命令l(list)显示当前代码附近的10行代码。
(gdb) l
533 xfree(rquote);
534
535 lquote = (lq == nil || *lq == ’\0’) ? def_lquote\
: xstrdup (lq);
536 rquote = (rq == nil || *rq == ’\0’) ? def_rquote\
: xstrdup (rq);
537
538 len_lquote = strlen(rquote);
539 len_rquote = strlen(lquote);
540 }
541
542 void
让我们step两行（设置len_lquote和len_rquote），然后检查这两个变量的值。
(gdb) n
539 len_rquote = strlen(lquote);
(gdb) n
540 }
(gdb) p len lquote
$3 = 9
(gdb) p len rquote
$4 = 7
假设len_lqoute和len_rquote分别代表lqoute和rquote的长度，很显然这个结果是错误的，我们可以用命令p来设置
较合理的值，p命令不仅可以打印表达式的值，而且表达式也可以调用子函数，也可以给表达式赋值。
(gdb) p len lquote=strlen(lquote)
$5 = 7
(gdb) p len rquote=strlen(rquote)
$6 = 9
是不是这样就足以修正m4内建的defn关于使用新的引号的错误了呢？我们可以用命令c让m4继续执行,接着试这个刚刚过引起问题的例子：
(gdb) c
Continuing.
define(baz,defn(foo
baz
0000
成功了！这个新的引用现在和默认的一样正确了。这个问题看来是两个形参搞错了。我们输入一个EOF让m4退出：
Ctrl-d
Program exited normally.
消息’Program exited normally.’是GDB输出的；它显示了m4已经执行完了。我们可以用quit命令来结束GDB会话。
GDB手册2:进入和离开GDB
这章讨论了如何开始和离开GDB。
提要：
1. 输入’gdb’开始GDB
2. 输入 quit or Ctrl-d来退出
2.1 调用GDB
运行gdb程序调用GDB。一旦开始执行，GDB会一直从终端读入命令，直到你告诉它结束为止。
在需要制定一些调试环境的时候，你也可以在开始的时候就用可变长参数和选项来运行GDB。
命令行参数描述了GDB可以适合多种情况；在某些环境下，某些选项不可以用。
最常用的启动GDB的方式是使用一个制定要调试程序的参数：
gdb program
你也可以用可执行程序和core文件来启动:
gdb program core
如果你要调试一个进程，你可以用用进程ID来替代第二个参数：
gdb program 1234
这样可以attach GDB到进程 1234（除非你同时有一个文件叫“1234”，GDB首先会检查是否有一个core文件）。
要利用第二个命令行参数需要操作系统的支持；当你用GDB作为远程调试器去attach到一个裸机上时，很有可能
得不到任何有关进程的信息，也不大可能得到core dump文件。如果不能attach到进程或读入core dump文件，GDB会
给出警告。 你可以用参数–args来让gdb传递参数给被调试的可执行程序.这个选项可以停止参数的执行。
gdb –args gcc -O2 -c foo.c
这将让gdb调试gcc, 设置gcc的命令行参数(参见4.3节[参数]，27页)为‘-O2 -c foo.c’.
你可以运行gdb而不输出开头信息，开头信息描述了GDB的非保障性，用-silent参数指定：
gdb -silent
你可以用命令行参数来进一步控制GDB的启动。GDB本身可以提示参数信息。
输入
gdb -help
来显示所有可选项和简短参数用法描述（’gdb -h’是对等的缩写）。
所有的选项和命令行参数将以先后顺序处理。’-x’选项将会改变一规则。
2.1.1 选择文件
当 GDB启动时它读入选项和参数，参数是固定指定为可执行程序和core文件的（或者进程ID）。这和分别用选项
‘-se’和’-c’(‘-p’)指定的参数一样。（GDB读入的第一个没有选项相联系的参数将和用’-se’选项相关的参数一样；如果有，
第二个没有选项相关的参数和用’-c’/'p’选项相关的参数一样）如果第二个参数用十进制数表示，GDB首先会尝试着
attach到一个进程，如果失败了，GDB会尝试着将它作为core文件打开。如果你有一个用十进制数字命名的core文件，
你可以用前缀’./’(例如‘./12345′)来防止GDB将它误作为进程ID.
如果GDB没有配置为支持core文件，就像大多数嵌入式目标一样，那么GDB将会视第二个参数为多余而忽略它。
很多选项都有长短形式；长短形式都将在下表中列出。如果你截断了长选项，只要这个选项参数足以明确的表达，
GDB也可以认识。(如果你喜欢，你可以用’–’标记选项参数而不是我们更都使用的’-')
-symbols file
-s file 从file读入符号表.
-exec file
-e file 用文件file作为可执行文件来执行，或者在和core dump连接的时候用来检查出数据.
-se file 从文件中读入符号表，而且将文件作为可执行程序.
-core file
-c 文件file将作为core dump来检查.
-pid number
-p number 连接到以pid为number的进程，作为命令attach的参数.
-command file
-x file 从文件file里执行GDB命令.参见20.3节[命令文件，221页]
-eval-command command
-ex command 执行单一的GDB命令。这个选项可以多次调用来执行多个命令。它也可以用’-command’交叉.
gdb -ex ’target sim’ -ex ’load’ \
-x setbreakpoints -ex ’run’ a.out
-directory directory
-d directory
加入路径directory作为源代码和脚本文件的搜索路径.
-r
-readnow 立即读入每一个符号文件的符号表，而不是默认的那种在需要时才渐次读入的方式。这将是初始阶段慢一点，
而以后执行将更快。
2.1.2 选择模式
你可以用多种模式运行GDB–例如，批处理模式和安静模式。
-nx
-n 不执行任何初始化文件里的命令。通常，在处理完所有的命令选项和参数之后，GDB会执行这些文件里的命令。
-quiet
-silent
-q “安静”。不打印介绍和版权信息。在批处理模式下这些信息也不打印。
-batch 以批处理模式运行。处理完所有命令文件（用’-x’指定）后以0状态退出（如果没有用‘-x’选项，需要执行完在
初始化文件里的所有命令）。批处理模式在将GDB作为过滤器运行的时候很有用，例如下载和运行一个远程计算机
上的程序；为了使这个模式更有用，信息‘Program exited normally.’将不输出（通常在GDB控制下会输出的）
-batch-silent
类似于批处理模式运行，但是完全的安静。GDB所有的输出到stdout的信息都将禁止（stderr不受影响）。这个模式
比’-silent’更安静而将是交互式的会话失效。这个模式在使用给出‘Loading section’信息的目标是特别有用。
注意，通过GDB输出的那些目标也将变哑。
-return-child-result
GDB的返回值是子进程（别调试的进程）的返回值，但是有以下的例外：
1. GDB异常退出。例如，由于不正确的参数或者内部错误。在此情况退出码和没有‘-return-child-result’一样。
2. 用户用明确的值退出。例如,’quit 1′
3. 子进程没有运行，或者不可结束，这种情况下推出码是-1.
这个选项在和’-batch’/'-batch-silent’联用，GDB作为远程程序加载器或者仿真接口时很有用。
-nowindows
-nw
“无窗口”。如果GDB内建图形用户接口，那么这个选项将让GDB只以命令行接口运行。如果GUI不可用，这个选项将
不起效。
-cd directory
GDB用directory作为它的工作目录，而不是当前目录
-fullname
-f GNU Emacs在把GDB运行为子进程的时候设置这个选项。这个选项告诉GDB在每次栈显示的时候以标准且可识别
的方式输出完整的文件名和行号（包括每次程序中断的时候）。可识别的形式看上去像两个’\032′字符开始，接下来是
文件名，行号和字符位置和新行，他们用冒号分隔。Emacs-to-gdb接口程序用两个’\032′字符作为信号来在一帧上显示源
代码。
-epoch Epoch在运行GDB作为子进程时Epoch Emacs-GDB接口设置这个选项.它让GDB修改打印例程以此来让Epoch在单
独的窗口里显示表达式的值。
-annotate level
这个选项设置GDB的注释级别。这个选项和‘set annotate level’命令相同（参见25张[注释]，291页）。注释级别控制着
GDB打印多少信息，提示，表达式的值，代码行和其它种类的输出。通常是0级，1级为GNU Emacs运行GDB而用，3级
是给控制GDB的程序的最高可用级别，2级已经不再使用了。GDB/MI可以极大的取代注释机制（参见第24章[GDB/MI],
235页）。
–args 改变命令行的转译，一边把可执行文件参数后面的参数传递给它。这个选项将阻止选项的处理。
-baud bps
-b bps 设置被GDB用来远程调试的串口行速率（波特率或者bits/每秒）。
-l timeout
设置被GDB用来远程调试的链接超时（秒）。
-tty device
-t device
将设备作为你的程序的标准输入输出。
-tui 在启动时激活文本用户接口。文本用户接口在终端上管理多种文本窗口，用来显示代码，汇编，寄存器和GDB命令的
输出（参见第22章[GDB文本用户接口]，227页）。作为选择，文本用户接口可以用程序’gdbtui’激活。如果你在Emacs时不要
使用这个选项（参见第23张[在GNU Emacs里使用GDB]）。
-interpreter interp
把解释器interp作为控制程序或设备的接口。这个选项由和GDB通讯的程序设置，并以此作为后台的。参见第21张[命令解
释器]，225页。
从GDB6.0版以后’–interpreter=mi’(或者’–interpreter=mi2′)导致GDB使用GDB/MI接口（参见第24章[GDB/MI接口]，235页）。
以前的GDB/MI接口，包括GDB5.3版本和选择了‘–interpreter=mi1’都已经废止了。更早的GDB?MI接口也不再支持了。
-write 以可读可写的方式打开可执行程序和core文件。和‘set write on’命令相同。（参见14.6节[补丁]，152页）
-statistics
在每次完成命令和回到提示符的时候，此选项可让GDB打印时间和内存使用统计信息。
-version
此选项可让GDB打印版本号和非保障性声明然后退出。
2.1.3 GDB在启动阶段的活动
下文描述了GDB在启动阶段时的活动：
1. 启动命令行解释器（由命令行制定）（参见2.1.2节[模式选项]，13页）
2. 读入在你的home目录下的初始化文件（如果有的话）然后执行里面的所有命令。
3. 处理命令行选项和参数。
4 读入和执行在当前工作目录下的初始话文件（如果有的话）里的命令。只有在当前目录和你的home目录不同时才会执行。
因此，在你启动GDB的目录下你可以有不止一个的初始化文件。
5. 读入命令文件（用’-x’选项指定）。更多详细信息请请参见20.3节[命令文件]，221页。
6. 读入记录在历史文件里的命令历史。更多详细信息请参见19.3节[命令历史]。
初始化文件和命令文件使用相同的语法，并且GDB用相同的方式处理它们。你的home目录下初始化文件可以设置选项(
像’set complaints’), 这样可以影响此后的命令行选项和参数的处理。如果你用了’-nx’选项，初始化文件将不会被执行（参见2.1.2节
[选择模式],13页）。
GDB初始化文件通常称为’.gdbinit’. 由于DOS 文件系统的文件名限制，GDB DJGPP口使用’gdb.ini’这个名字。GDB的Windows
口使用标准名称，但是如果发现’gdb.ini’文件，它会警告你并建议你重命名为标准名称。
2.2 退出GDB
quit [expression]
q 要退出GDB,可以用quit命令（缩写为q),或者敲入文件结束符(通常是Ctrl-d).如果你不提供表达式，GDB会正常结束；否则GDB
会用表达式的结果作为错误码结束。
中断（常常是Ctrl-c)并不从GDB里退出，而是结束正在处理中的GDB命令然后回到GDB命令级。任何时候敲入中断都是安全的，
因为GDB知道安全的时候才会让这个中断起效。
如果你用GDB attach过一个进程，你可以用detach命令释放进程（参见4.7节[调试已经运行的进程]，30页）。
2.3 Shell命令
在调试期间，如果你需要偶尔执行shell命令，不需要离开或者刮起GDB;你可以直接使用shell命令。
shell command string
启动标准shell执行command string.如果环境变量SHELL存在，环境变量SHELL决定哪一个shell来运行。否则GDB将用默认的shell(
Unix系统’/bin/sh’，MS-DOS用’COMMAND.COM’).
在编译环境里make工具通常都是必需的。在GDB里你不需要用shell命令调用make:
make make-args
用指定参数执行make程序。和’shell make make-args’相同。
2.4 日志输出
你可能想要保存GDB命令的输出到一个文件里。有多个命令可以控制GDB的日志。
set logging on
激活日志功能.
set logging off
关闭日志功能.
set logging file file
改变当前的logfile名字l. 默认的logfile是‘gdb.txt’.
set logging overwrite [on|off]
默认的，gdb会以附加的方式保存日志。如果你想改为覆盖方式保存的话，可以设置为覆盖方式。
set logging redirect [on|off]
默认的，gdb输出会打印到终端和logfile。可以将终端重定向到logfile里，如果你只要它输出到logfile里。
show logging
显示当前日志设置
GDB手册3:GDB命令
第三章 GDB 命令
假如缩写是无歧义的话，你可以将一个GDB命令缩写为开头的几个字母；你也可以用回车键来重复一些GDB命令。你也可以
用TAP键来让GDB补全一个命令的剩余部分（或者告诉你可供选择的命令，假如不止一个命令可选的话）。
3.1 命令语法
一个GDB命令是单独的输入行。没有长度限制。命令由一个命令名开始，接着是提供给命令的参数。例如，命令step接收
一个代表步长的参数，就像”step 5″.你也可以用不带参数的step命令。某些命令不允许参数。
GDB命令名总是在没有歧义的情况下允许截短。在某些情况下，即使是有歧义的缩写也是允许的；比如，s是特别为step而定义的缩写，即使有其他的命令也是以s开头。你可以用这些缩写作为help命令的参数测试他们。
一个空白行的输入（敲入回车键）对GDB而言意味着重复此前的命令。有些命令（例如run)不能用这种方式重复；这些命令不经意的重复可能导致麻烦或者你不大希望重复他们。用户定义命令可以关闭这些feature;参见20.1.1节[定义],227页。
list和x命令，在你用回车键重复他们的时候，会建构新的而不是重复此前输入的参数。这个特性可以很便捷扫描代码和内存。
GDB也可以以另外一种方式使用回车键：和通用工具more相似的方式来区分长输出（参见19.4节[屏幕大小],219页）。因为在这种情况下很容易按下过多的回车键，在产生长输出时GDB关闭命令重复的功能。
从#开始到行结束的文本都是注释；这些文本什么也不干。他们主要是在命令文件里起帮助理解的作用（参见20.1.3节[命令文件],229页）。
Ctrl-o绑定对于重复复杂的命令序列很有帮助。这个命令接受一个当前行，例如一个回车，接着从命令历史里取得相对于当前行的下一行来编辑。
3.2 命令补全
GDB可以为你补全命令的剩余部分，如果有且只有一个可能的命令；它也可以在任何时间为你显示一个命令里的下一个词的有效可能值。命令补全功能对GDB命令，子命令和你的程序里的符号都有效。
无论何时你想要GDB补全一个单词的时候，按下TAB键就可以了。如果只有一个可能，GDB会补全这个词，接着等待你去完成这个命令（按下回车键）。例如，如果你敲入
(gdb) info bre
GDB补全’breakpoints’的剩余部分，因为只有info子命令以’bre’开头：
(gdb) info breakpoints
现 在你可以敲入回车键来运行info breakpoints命令；假如’breakpoints’看上去不像你期待的，你可以用回退键删除之，然后敲入别的。，假如 ‘breakpoints’看上去不像你期待的。（如果在开头你就确信你要的就是info breakpoints，你就可以用缩写的形式来立即回车运行’info bre’，而不必等命令补全再回车）。
如果在你按下TAB键的时候有过个候选项的话，GDB会发出一个铃声。你可以多敲入几个字符后再试一下，或者再按一次TAB键
；GDB会为你显示所有可能补全的候选项。例如，你可能想要在一个名字开头是’make_’子函数里设置一个断点,而在你敲入b make_
(gdb) b make_
gdb sounds bell; press hTABi again, to see:
make_a_section_from_file make_environ
make_abs_section make_function_type
make_blockvector make_pointer_type
make_cleanup make_reference_type
make_command make_symbol_completion_list
(gdb) b make_
显示完所有可能的候选项之后，GDB会复制你刚才的输入（在这个例子里是’b make_’）以便你完成这个命令。
如果你只是想要在开始的时候看看候选列表，你可以按下M-?而不是按下
键（假如键盘上有这个键的话），假如没有这个键，你可以按下
有时候你需要的字符串可能含有圆括号，或者GDB认为这个字符串是不一个字。为了让补全功能在这种情况下生效，你可以用’
(单括号)封起来。
这种情况最有可能出现在你敲入一个C++函数名的时候。这是因为C++允许函数重载（同一个函数名多次定义，以参数类型来区分）。例如，在一个名为 name的函数设置断点的时候，你需要区分是在参数为int的函数name上还是参数为float的函数name设置断点的。为了在这时用词补全功能，在 函数名之前敲入一个单引号’。这样GDB就可以知道需要考虑比通常只按下
(gdb) b ?ˉbubble( M-?
bubble(double,double) bubble(int,int)
(gdb) b ?ˉbubble(
在某些需要补全的情况下，GDB可以提示你需要引号。这时，如果你开始的时候没有敲入引号，GDB会为你插入一个引号：
(gdb) b bub
GDB会以下面的输出提醒你，然后响一声：
(gdb) b ’bubble(
通常的，在有重载符号情况下，在你还没有开始敲入参数列表的时候就用补全功能的时候，GDB提示需要一个引号然后插入它。
更多有关重载函数信息，参见12.4.1.3节[C++表达式],126页。你可以用set overload-resolution off命令关闭重载解决方案，参见12.4.1.7节，[GDB的C++功能],128页。
3.3 帮助
用help功能，你可以获得GDB的命令信息。
help
h 你可以用help(缩写h)不带参数来显示一个命令分类的简短列表。
(gdb) help
List of classes of commands:
aliases — Aliases of other commands
breakpoints — Making program stop at certain points
data — Examining data
files — Specifying and examining files
internals — Maintenance commands
obscure — Obscure features
running — Running the program
stack — Examining the stack
status — Status inquiries
support — Support facilities
tracepoints — Tracing of program execution without
stopping the program
user-defined — User-defined commands
Type “help” followed by a class name for a list of
commands in that class.
Type “help” followed by command name for full
documentation.
Command name abbreviations are allowed if unambiguous.
(gdb)
help class
用help分类作为参数，你可以得到这个分类里命令列表。比如，下面是status分类的帮助显示：
(gdb) help status
Status inquiries.
List of commands:
info — Generic command for showing things
about the program being debugged
show — Generic command for showing things
about the debugger
Type “help” followed by command name for full
documentation.
Command name abbreviations are allowed if unambiguous.
(gdb)
help command
用命令名作参数，GDB会显示一段如何使用这个命令的信息。
apropos args
apropos命令会在命令和文档里文档搜索这个args指定的正则表达式。这个命令会打印所有符合的结果。例如：
apropos reload
结果：
set symbol-reloading — Set dynamic symbol table reloading
multiple times in one run
show symbol-reloading — Show dynamic symbol table reloading
multiple times in one run
complete args
complete args命令列出所有可能的补全结果。用args指定你想要的命令的开头字母。例如：
complete i
结果：
if
ignore
info
inspect
这个是为GNU Emacs设计的。
更进一步的，你可以用GDB命令info和show来查询你程序的状态或者GDB本身的状态。这两个命令都支持多个主题的查询；这本手册会在恰当的时候介绍这两个命令。索引里的info和show下的列表列出了所有的子命令。参见[索引]，407页。
info 这个命令（缩写i）可以描述程序的状态。例如，你可以用info args显示传递给函数的参数,用info registers来列出
寄存器数据，用info breakpoints列出你设置的断点。你可以用help info来取得info的所有子命令。
set 你可以用set命令把一个表达式的值来设置一个环境变量。例如，你可以用set prompt $来设置GDB提示符。
show 和info不同，show描述的GDB本身的状态。你可以用set命令改变大多数你可以用show显示的内容。例如，你可以用set
radix来设置显示的数值进制系统，或者用show radix来显示数值进制。
你可以用不带参数的show命令来显示所有可以设置的参数和它们的值；你也可以用info set。这两个命令是一样的。
还有其余3种show子命令，这3中命令缺乏对应的set命令：
show version
显示当前GDB的版本。你应该在GDB bug报告中包含版本信息。如果你的机器上有多个版本的GDB,你可能需要知道哪个版
本是你正在运行的；随着GDB的发展，新的命令会引入，而一些旧的将废弃。同时，许多系统供应商移植了不同版本的
GDB,在GNU/Linux发行版也存在着多种版本的GDB.版本号和你启动时显示一样。
show copying
info copying
显示GDB版权信息。
show warranty
info warranty
显示GNU免责声明，或者保证（如果你的GDB版本有的话）。
GDB手册4:在GDB里运行程序
第四章 在GDB里运行程序
在你开始在GDB里运行程序前，你需要在编译的时候产生调试信息。
你可以在你选定的环境里带参数（如果有的话）的启动GDB。如果你是在本地调试，你可以重定向输入输出，调试一个已运行
的进程，或者结束一个进程。
4.1 为调试而编译
为了有效的调试程序，你需要在编译的时候产生调试信息。调试信息存储在目标文件里；调试信息描述了数据和函数的类型，
源代码和可执行代码的对应关系。
编译时指定编译器的’-g’选项可以产生调试信息。
在编译给你的客户发布的程序时，可以用’-O’选项指定编译器进行优化。然而，许多编译器不能同时处理’-g’和’-o’选项。如果用的
是这些编译器，你得不到带有调试信息的优化过的可执行程序。
GCC,GNU C/C++编译器，带有或不带’-O’选项都可以用’-g’选项，因此可以让GDB调试优化过的代码。我们推荐你在编译程序时总
是用’-g’。也许你认为你的程序是正确的，但决不要去碰运气。
请记住在你调试一个用’-g -o’编译的程序时，优化器已经重排了你的代码；调试器显示的是真正编译成的代码。在执行路径和你
的源代码不一致时，不要太惊讶！一个极端例子：如果定义了一个变量，但从来也没用过，GDB发现不了它—-因为优化器已经把
它优化掉了。
用’-g -o’和只用’-g’编译的程序有时候不大一样，特别是在有些具有指令调度的机器上。如有疑问，再用只带’-g’编译，如果这个版
本修正了问题，请给我们发送一个报告（包含一个测试用例）。更多调试优化过的代码，参见8.2节[变量],76页。
较早前的GNU C编译器允许一个’-gg’变体选项来产生调试信息。GDB不再支持这个格式；如果你的GNU C编译器有这个选项，别
再用了。
GDB知道预编译宏，可以显示宏的展开式（参见第九章[宏],101页）。由于’-g’选项产生的调试信息过多，大多数编译器不会产生
与编译宏的信息。GCC3.1版本以及此后的可以提供宏信息，如果在编译的时候指定了’-gdwarf-2′和’-g3′选项;前一个选项产生Dwarf
2格式的调试信息，后者产生”额外信息”。我们希望在将来能够找到一个精简的方式来表示宏信息，这样只要一个’-g’选项就可以了
。
4.2 开始程序
run
r 在GDB里用run命令开始你的程序。你在启动GDB时指定要调试的程序名（VxWorks例外）（参见第二章[进入和离开GDB]），
或者用file或者exec-file命令（参见15.1节[指定文件的命令]，155页）。
如果你是在一个支持多进程的环境里运行GDB的话，run命令创建一个子进程来运行你的程序。在某系不支持多进程的环境下，
run跳到被调试程序的开头。其他的目标，比如’remote’,总是在运行的。如果你的到一个类似如下的错误信息：
The “remote” target does not support “run”.
Try “help target” or “continue”.
接着用’continue’继续运行你的程序。你可能需要先load（参见[加载]，169页）。
程序的执行总会受某些从它的上级那里得到的信息的影响。GDB可以指定那些虚啊哟你在启动程序之前就要设置的信息（你
可以在启动程序之后改变，但是只有在下一次运行的时候才起效）。这些信息可以划分为4类：
The arguments.
将你的程序的参数作为run命令的参数。如果在你的环境里有shell，shell可以用来传递参数，那样的话你就可以用普通的方式
（比如wildcard展开和变量替换）来描述参数了。在Unix系统里，你可以用环境变量SHELL来控制使用那个shell。参见4.3节[程序
参数]，27页。
The environment.
你的程序会从GDB里继承环境变量，而你也可以用GDB命令set environment和unset environment改变某些影响你的程序的
环境变量。参见4.4节[程序的环境]，28页。
The working directory.
你的程序从GDB里继承工作目录。你可以用GDB命令cd来改变工作目录。参见4.5节[程序的工作目录]，29页。
The standard input and output.
你的程序使用和GDB一样的标准输入输出。你可以在run命令行里重定向输入和输出，或者你可以用tty命令来为你的程序
设置不同的设备。参见4.6节[程序的输入输出]，29页。
警告：输入输出重定向起效之后，你不能再用管道将程序的产生的输出传递到另外一个程序里去；如果你要这样试的话，
GDB 很有可能结束调试这个错误的程序。
在你执行run命令后，你的程序马上就开始执行。参见第五章[停止和继续]，39页，那里讨论了如何筹划中断你的程序。一
旦你的程序中断下来，你就可以在你的程序里调用函数，用print或者call命令。参见第八章[检验数据]，75页。
如果在最近一次GDB读入符号表之后符号文件的修改时间发生了改变，GDB会丢弃现有的符号表然后重新读入。重新读入
符号表的时候，GDB会试图保留你当前的断点设置。
start 不同的语言可能有不同的主函数的名称。对于C/C++来说，主函数的名称一直都是”main”,而有些语言例如Ada就不需
要为他们的主函数指定一个特定的名称。依赖于编程语言，调试器可以方便的开始执行程序并且在主函数的入口点中
断。
‘start’命令的功能和在主函数入口点里设置一个临时断点后执行’run’命令相当。有些程序包含一个在主程序之前执
行的加工期，加工期会执行一些启动代码。这依赖于你使用哪种语言写程序。例如，C++,构造函数会在main之前为静
态和全局变量调用。因此调试器有可能在主函数之前就中断程序。而临时断点还会保留来中断程序的执行。
‘start’的参数将会传递给你的程序。这些参数会以字符形式给’run’命令。注意要是下次不带参数调用’start’或
‘run’的时候，这些参数将会被重用。
有些时候必须在加工期调试程序。这样的话，start命令在主函数入口点的中断就太迟了，唯一此时已经过了加工期
。在这种情况下，在运行情在加工期代码上设置断点就可以了。
4.3 程序参数
参数可以藉由run命令的参数来指定。参数由shell传递给你的程序，shell会扩展通配符和执行重定向。你的SHELL环境变量
（如果有的话）会决定GDB使用哪种shell.如果你没有定义SHELL的话，GDB使用默认的shell(Unix下’bin/sh’)。
在非Unix系统里，程序通常都是由GDB直接调用的，GDB会用相应的系统调用来模拟I/O重定向，通配符的宽展由程序的加
工期代码完成，不是由shell来做的。
不带参数的run命令使用前一次的run命令的参数，或者由set args命令设置的参数。
set args
为你的下一次执行程序设置参数。如果set args不带参数的话，run就不带参数的执行程序。一旦你带参数的run程序
的话，要想下一次不带参数的执行程序就只有用不带参数的set args命令了。
show args
显示在启动的时候传递给程序的参数。
4.4 程序的环境
环境由一系列的环境变量和环境变量的值的组合组成。环境变量可以很方便地记录一些东西，例如你的用户名，
home目录，终端类型，程序执行的搜索路径等等。通常通过shell来设置环境变量，这些变量就可以被别的程序继
承了。这在调试的时候很有用，GDB就不必重新启动来试验一个改变了的环境。
path directory
在PATH环境变量的前头加上diretory(可执行程序的搜索路径)。GDB用的PATH将不会改变。你可以指定多个路径名
称，用空格符或者系统依赖（Unix’:',MS_DOS、MS-Windows’;'）的分隔符类分割如果directory已经在PATH里了，
这个directory会移到PATH的前面以加快搜索。
在GDB搜索路径的时候，你可以用’$cwd’来代指当前工作目录。如果你用’.'代替，它代表在你执行path命令时的目
录。GDB在把路径加入PATH前用当前路径替代’.’.
show paths
显示可执行程序的搜索路径列表（PATH环境变量）。
show environment [varname]
打印名为varname的环境变量的值。如果你没提供varname，打印所有的环境变量的名称和值。你可以缩写
environment为env.
set environment varname [=value]
设置环境变量varname的为value.这个值只为你的程序改变，GDB本身不改变。value可以使任意字符串；环境变量
都是字符串，你的程序负责转译；如果被删除了，变量的值就被设置为null值。例如，命令：
set env USER = foo
告诉被调试的程序，下一次执行run的时候，它的用户是’foo’.(‘=’附近的空格是为了清楚些；空格不是必须的)
unset environment varname
删除传递给程序的环境变量。和‘set env varname =’不同，unset environment是从环境变量里删除变量，而不是
为它设置一个空值。
警告：在Unix系统，GDB用shell执行程序，shell由SHELL决定（如果有的话，否则用’/bin/sh’）。如果SHELL环境变
量指定的shell有初始化文件的话–例如C-shell的’.cshrc’，BASH的’.bashrc’—这些文件里定义的变量都将影响你的程序。
你也可以将那些只在登录时用到的变量移到别的文件里，例如’.login’或者’.profile’。
4.5 程序的工作目录
每次你用run启动程序时，程序都从GDB的当前工作目录继承工作目录。GDB从它的父进程（通常是shell）那里继承工作
目录,而你可以用cd在GDB里指定一个新的工作目录。
GDB的工作目录是GDB操作文件时的默认目录。参加按15.1节[文件命令]，155页。
cd directory
指定GDB的工作目录为directory
pwd 打印GDB的工作目录
通常很难找到被调试程序的当前工作路径（因为它可以在运行的时候改变）。如果你是在支持’/proc’文件系统的系统下
运行GDB的，你可以用info proc命令来查找当前被调试程序的工作目录。（参见18.1.3节，[SVR4进程信息]，183页）
4.6 程序的输入输出
缺省情况下，GDB里运行的程序在与GDB相同的终端上输入输出。GDB会在和你交互的时候切换到它自己的终端模式，
不过它会记住你的程序的终端模式然后在继续运行程序切换到那个模式上。
info terminal
显示GDB记录的你的程序使用的终端模式。
你可以用run命令重定向程序的输入/输出。例如：
run > outfile
开始运行程序，将打印输出到文件’outfile’。
另外一个指定程序输入输出的命令是tty命令。这个命令接受一个文件名作为参数，然后将这个文件作为接下来的
run命令的缺省值。它也可以为子进程重置控制终端。例如：
tty /dev/ttyb
将接下来run命令运行的进程的输入输出定向到’/dev/ttyb’,并将此作为控制终端。
run命令将改变tty命令对于输入输出的设备的设置，但不改变其控制终端。
用tty命令或者在run命令里重定向输入只会影响你调试的程序。GDB的输入仍然来自于你的终端。tty是set inferior-tty的别名。
你可以用show inferior-tty命令来趟GDB显示程序将要使用终端名。
set inferior-tty /dev/ttyb
将被调试程序的tty设备设置为/dev/ttyb
show inferior-tty
显示被调试程序目前的tty设备名
4.7 调试一个已经在运行的进程
attach process-id
这个命令attach到一个从GDB外启动的进程上。（info files显示你当前活跃的目标）这个命令需要一个进
程id作为参数。通常用ps工具来找到一个Unix进程的ID,或者用’jobs -l’shell命令。
在你执行attach命令之后，按下回车键attach将不会再次执行。
只有在支持进程的环境下，attach命令才有效；例如，attach在没有操作系统的裸机上市无效的。你必须有发给
进程送信号的权限。
在你执行attach命令的时候，调试器首先在当前工作目录下查找进程的可执行程序，如果没有找到，接着会用源
代码文件搜索路径（参见7.5节[指定源代码目录]，70页）。你也可以用file命令来加载可执行文件。参见15.1节[
指定文件的命令]，155页。
GDB在准备好要调试的进程后第一件事就是中断这个进程。可以在run启动的进程上的使用的命令也可以用在你
attach的进程上，你可以检查，修改这个进程。你可以插入一个断点；你可以step和continue;你可以修改存储器。
如果你希望进程继续执行，你可以在attach之后用continue命令来继续。
detach
在完成了调试之后，可以用detach来释放GDB对进程的控制。detach进程后，进程继续执行。detach命令之
后，进程和GDB就没有关系了，你还可以attach到另外一个进程或者用run启动一个程序。detach执行之后
，按下回车键不会再重复。
如果你attach过一个进程，退出GDB会detach这个进程。如果你是用run命令启动的话，你将kill这个进程。缺省
的，GDB会要求得到你的确认；你可以用set confirm命令来控制是否需要确认（参见19.7节[可选的警告和消息]，213页）。
4.8 杀死子进程
kill 杀死在GDB里运行的子进程
在你希望调试一个core dump而不是进程的时候，这个命令很有用。在程序运行期间的时候，GDB会忽略core dump
。
在某系操作系统，如果你在GDB里为这个程序设置了断点，这个程序就不能在GDB外运行了。你可以用kill命令来
让程序在GDB外运行。
在你运行程序的时候，kill命令也有助于重编和重新连接程序，而有些系统是不可能做到这个的。在这种情况下
，在下次执行run命令的时候，GDB可以知道程序已经发生变化了，就会重新读取符号表（同时也会保留你目前的
断点设置）。
4.9 调试多线程进程
在某些操作系统里，例如HP-UX和Solaris，一个程序可能有多个线程。线程精确概念随着各个操作系统而不一样
，但大体上，一个有多个线程的进程和多进程相似，除了多线程共享一个地址空间（就是说，他们可以检查和修改
同一个变量）。另一方面，每个线程有它自己的寄存器和执行栈，也可能有自己私有的存储空间。
GDB提供了多个调试多线程的工具：
新线程的自动通知
‘thread threadno’，切换线程
‘info threads’，查询线程
‘thread apply [threadno] [all] args’，对线程列表执行命令
线程特定断点
‘set print thread-events’，控制线程开始和结束时打印消息
警告：在各个支持线程的操作系统里，不是所有的GDB配置都支持这些工具的。如果你的GDB不支持线程，这个命
令就无效。例如，不支持线程的系统里’info threads’命令就不能输出信息，也会拒绝thread命令，如下：
(gdb) info threads
(gdb) thread 1
Thread ID 1 not known. Use the “info threads” command to
see the IDs of currently known threads.
GDB线程调试工具可以观察进程的所有线程，而一旦GDB控制线程的话，这个线程就总是调试的焦点了。这个线程
称为当前线程。调试命令从当前线程的角度来显示进程的信息。
一旦GDB察觉到进程的新线程，GDB就会用‘[New systag]’的方式显示目标系统的标识。systag是线程的标识，各
个系统不一样。例如，当GDB发现一个新线程的时候，在GNU/Linux你可能看到
[New Thread 46912507313328 (LWP 25582)]。
而在SGI系统里，systag就简单的形如‘process 368’，没有更多信息。
出于调试的目的，GDB自己会给线程一个编号–总是一个整数。
info threads
显示当前进程里的线程的总概要。GDB显示每个线程（以此为序）：
1.GDB分配的线程号
2.目标系统的线程标识（systag）
3.线程当前栈的概要
线程号左边的星号’*'代表此线程是当前线程。例如：
(gdb) info threads
3 process 35 thread 27 0x34e5 in sigpause ()
2 process 35 thread 23 0x34e5 in sigpause ()
* 1 process 35 thread 13 main (argc=1, argv=0x7ffffff8)
at threadtest.c:68
在HP-UX系统里：
出于调试目的， GDB为进程里每个线程分配一个线程号（以线程创建顺序分配小整数）。
无论何时GDB察觉到一个新线程，它会用‘[New systag]’的形式显示GDB自己的线程号和目标系统的线程标志 。
systag是线程标识，各个系统下可能不同。例如，GDB察觉到新线程，在HP-UX，你能看到
[New thread 2 (system thread 26594)]。
info threads
显示所有线程的概要。GDB显示每一个线程（以此为序）：
1.GDB分配的线程 号
2.目标系统的线程标识（systag)
3.线程当前栈的概要
线程号左边的星号’*'代表此线程是当前线程。例如：
(gdb) info threads
* 3 system thread 26607 worker (wptr=0x7b09c318 “@”) \
at quicksort.c:137
2 system thread 26606 0x7b0030d8 in __ksleep () \
from /usr/lib/libc.2
1 system thread 27905 0x7b003498 in _brk () \
from /usr/lib/libc.2
在Solaris系统，那你可以用一个Solaris特有的命令来显示更多的信息：
maint info sol-threads
显示Solaris用户线程的信息。
thread threadno
将threadno指向的线程设置为当前线程。这个命令的参数threadno是GDB内部的线程号，就是’info threads’
命令显示第一列。
GDB会显示你选择的线程的系统标识和它当前栈的概要：
(gdb) thread 2
[Switching to process 35 thread 23]
0x34e5 in sigpause ()
伴随着’[New...]‘消息，’Switching to’之后的文本形式由你的系统线程标识表示方式决定。
thread apply [threadno] [all] command
thread apply命令可以让你在一个或多个线程上执行名为command命令。用参数threadno指定你希望操作的
线程数目。可以是单个线程号，’info threads’显示的第一列；或者可以是线程范围，像2-4.要操作所有
线程，敲入thread apply all command。
set print thread-events
set print thread-events on
set print thread-events off
GDB察觉到新线程启动或线程结束的时候，set print thread-events命令可以开启或关闭打印信息。缺省
下，如果目标系统支持的话，这些事件发生的时候，这些信息会打印出来。注意，这些信息不一定在所有目
标系统里都可以关闭的。
show print thread-events
显示是否在GDB察觉线程启动或结束时打印信息。
由断点或者信号决定，无论何时GDB停止程序，它都会选择断点或信号发生的线程。GDB会用‘[Switching to syst
ag]’形式标识线程提示线程上下文的切换。
更多关于GDB在停止启动多线程程序的行为的信息，参见5.4节[停止核启动多线程程序]，59页。
更多多线程程序观察点的信息，参见5.1.2[设置观察点]，44页。
4.10 调试多个程序
在多数系统下，GDB没有为能用fork调用创建附加进程的程序提供特殊的支持。程序创建子进程时，GDB会继续调试
父进程，而子进程则不受影响。如果你此前在子进程的代码上设置了一个断点，则子进程会被SIGTRAP信号结束。
不过，如果你想调试子进程的话，有一个不那么麻烦的替代方案。在fork调用之后的子进程代码里调用sleep调
用。如果sleep代码的调用由某些环境变量或者某个文件的存在与否来决定，那就很方便了：如果你不想调试子进
程，不设置这些变量或者删除文件就可以了。在子进程休眠的时候，用ps程序来得到进程id.接着用GDB attach到这
个子进程上，如果你正在调试父进程，你需要新启动一个GDB实例，参见4.7[Attach]，30页。你就可以如同attach到别的
进程那样开始调试子进程了。
在某些系统上，GDB提供调试用fork或vfork调用创建子进程的程序的支持。目前，只有HP-UX(11.x和以后版本)和
GNU/Linux（2.5.60内核版本及后续）提供这个功能的支持。
缺省的，在创建子进程的时候，GDB会继续调试父进程，而子进程不受影响。
如果你要调试子进程，用命令
set follow-fork-mode.
set follow-fork-mode mode
设置调试器对于fork或vfork调用的反应。fork或vfork创建一个子进程。mode参数可以是：
parent fork之后调试原进程。子进程不受影响。这是缺省方式。
child fork之后调试新的进程。父进程不受影响。
show follow-fork-mode
显示当前调试器对于fork/vfork调用的反应。
在Linux下，如果你要调试父进程和子进程，用命令
set detach-on-fork.
set detach-on-fork mode
设置GDB在fork之后是否detach进程中的其中一个，或者继续保留控制这两个进程。
on 子进程（或者父进程，依赖于follow-fork-mode的值）会被detach然后独立运行。这是缺省mode。
off 两个进程都由GDB控制。一个进程（子进程或者父进程，依赖于follow-fork-mode）被调试，另外
一个则被挂起。
show detach-on-fork
显示detach-on-fork mode
如果你选择了设置‘detach-on-fork’为off,那么GDB会保持控制所有被创建的子程序（包括被嵌套创建的）。你
可以用info forks命令来显示在GDB里创建的子进程，然后用fork命令来从一个进程切换到另一个。
info forks
打印在GDB控制下被创建的子进程列表。这个表包括fork id, 进程id和当前进程的位置（程序计数器）。
fork fork-id
切换到fork-id指定的进程。参数fork-id是GDB内部为fork分配的，如命令’info forks’所显示列表的第一
列。
process process-id
切换到process-id指定的进程。参数process-id必须是’info forks’输出的。
要想结束调试一个被创建的进程，可以用detach fork命令（允许这个进程独立的运行），或者用删除（也杀死）
的方法delete fork命令。
detach fork fork-id
detach一个由GDB标识的fork-id指定的进程，然后从fork列表里删除。这个进程会被允许继续独立运行。
delete fork fork-id
杀死一个由GDB标识的fork-id指定的进程，然后从fork列表里删除。
如果你要调试一个vfork创建接着exec的进程的话，GDB会在这个新的目标上执行到底一个断点。如果你在原来程序
的主函数上设置了一个断点，子进程上的主函数上也有一个同样的断点。
如果子进程正在执行vfork调用，你不能调试子进程或者父进程。
如果你在exec调用执行之后运行GDB的run命令，新目标会重新启动。要重启父进程，运行file命令，父进程可执行程序
名作参数。
你可以用catch命令来在fork,vfork或者exec调用的时候让GDB中断。
4.11 为跳转设置书签
在某些操作系统（目前只在GNU/Linux上），GDB可以保存一个程序状态的快照，称为检查点，以后可以跳回。
跳回到检查点会撤销所有在检查点之后的变化。这些变化包括内存，寄存器，甚至系统状态（有些限制）。这样可以
有效的及时回到在检查点设置的状态。
因此，如果你单步调试到你认为你接近到快要发生错误的地方，你就可以保存一个检查点。接着，如果你不经意的走的
太远错过了关键的状态，你可以回到检查点后再从那里开始，而不需要从头启动程序。
检查点对于需要很长时间或者单步调试里bug发生地方很远的情况下很有帮助。
用checkpoint/restart方法调试：
checkpoint
保存被调试程序当前执行状态的快照。checkpoint命令不需要参数，但每个检查点都分配一个小整数标识，如同
breakpoint标识一样。
info checkpoints
列出在当前被调试会话的检查点。对于每个检查点，信息显示如下：
Checkpoint ID
Process ID
Code Address
Source line, or label
restart checkpoint-id
在检查点号的状态上重新启动。所有程序变量，寄存器，栈帧等等都恢复到检查点上保存的状态。本质上将，gdb会
把时钟回拨到检查点所记录的时间。
注意，断点，GDB变量，命令历史等不受检查点重置的影响。通常，检查点只重置被调试程序内部的状态，不影响调试器
本省的状态。
delete checkpoint checkpoint-id
删除以前保存的检查点
回到以前保存的检查点，会重置程序的用户状态，加上相当数量的系统状态，包括文件指针。重置不会撤销已写入文件的数据，但
是会把文件指针指向以前的文职，因此以前写入的数据就可以被覆盖。对于以只读模式打开的文件，指针也会回到以前的位置，因此
可以重新读取数据。
当然，送到打印机（或者其它外设）的字符不能收回，而从别的设备（比如串口设备）里读取的数据可以从内部程序缓冲里撤销，
但是不能被塞回到串行管道里去，然后再读取他们。相似的是文件的内如如果被改变了，也不能被重置。
然而，在这些约束条件下，你可以重新回到以前保存的程序状态去，重新调试–然后你可以改变事件的过程来执行一个不同的路径
调试。
最后，在你回到检查点的时候，有些内部程序状态会不一样—程序的进程id。每个检查点会有一个独立的进程id(pid),每个都和原
来的pid不一样。如果你的程序保存了一个进程id的本地副本，这会有一个潜在的问题。
4.11.1 使用检查点的隐含好处
在某些系统里（例如GNU/Linux）,出于安全考虑，每个新进程的地址空间都要随机确定。这就很难或者说不可能在一个绝对地址上
设置一个断点或者观察点，因为一个符号的绝对位置每次执行都不一样。
然而，一个检查点是一个进程的相同的副本。因此如果你在主函数的入口点创建了一个检查点，你可以避开地址空间的随机化的影
响，而且符号也会呆在相同的位置。
GDB手册5:中断和继续
第五章 中断和继续
使用调试器的主要目的是在程序结束之前可以中断它；或者是在程序出现问题的时候，你可以调查为什么出问题。
在GDB里，有多个原因可以让程序中断，例如信号，断点或者一个GDB命令之后（例如step）执行新一行代码前。你可以检查和改变变量，设置一个新的断 点，或者删除一个旧的断点，再接着执行。通常GDB提供的消息可以显示程序大量的状态—但你也可以在任何时候显式的请求这些信息。
info program
显示程序状态信息：是否在执行，是什么进程，为什么中断。
5.1 断点，监视点，捕获点
断点可以让程序在执行到某个点上停止下来。对于每个断点，你可以加上条件来更详细地控制程序是否中断。你可以用break命令（带变量）来设置断点（参见 5.1.1节[设置断点]，40页），变量用来指定程序在什么地方中断（以行号，函数名或者程序的绝对地址的方式）。
在某些系统里，你可以在可执行程序运行前，在共享库里设置断点。在HP-UX系统里有些小小的限制：你必须等到程序运行才能在那些被程序间接调用的共享库例程上设置断点，例如，例程是pthread_create调用的参数。
监视点是特殊的断点，在表达式的值改变的时候中断程序。表达式可以是是一个变量的值，或者是由操作符绑定的一个或多个变量，例如’a+b’.有时这种断点 也称为数据断点。你必须用一个不同的命令来设置监视点（参见5.1.2节[设置监视点]，44页），除此之外，你看原因两断点一样管理监视点：用相同的命 令激活，禁用，删除断点和监视点。
在任何GDB中断程序的时候，你可以安排自动显示程序的数值。参见8.6节[自动显示]，81页。
捕获点是另一种特殊类型的断点，用来在某些事件发生时中断程序，例如在抛出C++异常或者加载库的时候。和监视点一样，你需要用不同的命令来设置捕获点 （参见5.1.3节[设置捕获点]，47页），除此之外，你可以类似断点来管理捕获点。（在程序接到一个信号时停止程序，用handle命令；参见5.3 节[信号]，57页）
GDB会在你创建断点，监视点，捕获点的时候分配一个数字给它们；这些数字是从1开始的连续整数。在很多用来控制断点多种功能的命令里，你可以用断点号来指明是操作哪一个断点。每个断点可以激活或者禁用；如果被禁用了，他就不再影响程序的运行，除非你再激活它。
5.1.1 设置断点
断点设置用break命令（缩写b). 调试器用’$bpnum’变量记录你最近设置的断点号；关于便利变量用途的讨论，参见8.9节[便利变量]，89页。
break location
在给定的位置(location)设置断点，位置可以是函数名，行号，或者是一个指令的地址。(参见7.2节[指定位置]，68页，所有可能指定
位置的方式)。断点可能在程序执行指定位置前的代码前中断程序。
在可以重载符号的源代码语言里，例如C++，一个函数名可以涉及到多于一个可能中断的位置。参见5.1.8节[断点菜单]，52页，讨论
了这种情况。
break
在不带参数的情况下，break命令在当前栈里的下一条指令里设置断点（参见第六章[检查栈]，61页）。在当前栈的最低端，这可以让
程序在控制返回到帧的时候立即中断。这和一个栈帧里的finish命令的效果相似–除了finish不留下一个有效的断点。如果你在栈帧的最
低端用break而不带参数，GDB在下次到达当前位置时中断程序；这在循环内很有帮助。
GDB通常在继续执行时忽略断点，直到最少一条指令执行为止。如果没有这样做，你不禁用断点，你将不能通过断点。这个股则在程
序中断的时候，不论断点是否存在，都可以生效。
break … if cond
带参数设置断点；在每次断点到达时计算cond表达式，并且当且仅当表达式的值不为零的时候中断—就是说，如果cond表达式为真。
‘…’代表可能的指定中断位置的参数（上面描述过的）。更多中断条件的信息，参见5.1.6节[中断条件，50页]。
tbreak args
设置一个只中断一次的断点。args和break命令里的参数一样，断点设置也一样，但断点在第一次程序中断后自动删除。参见5.1.5节[关
闭断点]，49页。
hbreak args
设置一个硬件支持的断点。args和break命令的一样，设置也一样，但断点需要硬件支持，某些目标硬件可能不支持。这个命令的主
要目的是为了调试EPROM/ROM代码，所以你可以不改变指令而在这个指令上设置一个断点。这个指令可以用在SPARClite DSU支持的新
的陷阱-产生和多数基于X86的目标。这些目标可以在程序访问某些数据或指令地址的时候产生陷阱，这些陷阱是设计用来调试寄存器
的。然而硬件断点寄存器有断点数的限制。例如，在DSU上，一次只可以设置两个数据断点，如果多于两个的话GDB会拒绝的。在设置
新的断点前删除或禁用不用的硬件断点（参见5.1.5节[禁用断点]，49页）。参见5.1.6节[中断条件]，50页。更多远程目标，你可以
限制硬件断点的数量，见[设置远程硬件断点限制]，177页。
thbreak args
设置一个只中断一次的硬件支持断点。args和hbreak的参数一样，设置方式也一样。不过，和tbreak命令相似，断点会在程序第一次
中断后自动删除。和hbreak命令相似，断点需要硬件支持，某些硬件可能不支持。参见5.1.5[禁用断点]，49页。参见5.1.6节[中断
条件]，50页。
rbreak regex
在所有匹配正则表达式regex的函数上设置断点。这个命令会在所有匹配的函数上设置无条件的断点，也打印设置的断点列表。一旦
这些断点被设置上，它们就和用break命令设置的一样了。你可以删除，禁用它们，或者可以和别的断点一样为他们设置条件。
正则表达式的语法是标准的，就如’grep’工具用的一样。注意，和shells用的不一样，例如foo*匹配开头是fo，接下来有0或者多个
o的函数。在你的正则表达式的开头和结尾有个隐含的.*,所以要想只匹配foo开头的函数，用^foo.
在调试C++程序，在非特定类的成员函数的重载函数的设置断点上，rbreak很有用。
可以用rbreak命令在一个程序里的所有函数上设置断点，如下：
(gdb) rbreak .
info breakpoints [n]
info break [n]
info watchpoints [n]
打印断点，监视点和捕获点表。可选参数n代表打印特定断点的信息（或者监视点，捕获点）。对于每个断点，打印下列信息：
Breakpoint Numbers
Type 断点，监视点，或捕获点
Disposition
断点是否标记为禁用或删除
Enabled or Disabled
用’y'标记激活断点，用’n'标记断点禁用。
Address
程序里的断点位置，内存里的位置。对于一个挂起的断点，它的位置是未
知的，这个域会包含’
起作用的。详细说明见下面。一个断点对应多个位置的话，这个域会包含
‘
What
断点位置在程序源代码，文件和行号。对于一个挂起的断点，由于在对应
的共享库未被加载前不能解释，此时断点命令会显示一个初始的字符串。
如果断点是有条件的，info break会显示被断点影响的行上的条件；断点命令，如果有的话，
会在这行后显示。一个挂起的断点可以有条件的指定。这个条件会在共享库加载后分析有效性，
以此来确定一个有效的位置。
info break带有一个断点号n的参数将只显示此断点。变量$_和x命令缺省的检查地址用来显示
最近位置的断点（参见8.5节[查看内存]，79页）。
info break断点被执行过的次数。这个命令在和ignore命令和用的时候特别有用。你可以忽略
大部分的断点执行，查看断点信息来看断点总共有多少次执行，然后再次运行，忽略这个总数
少一次的端点执行。这将可以让你快速的到达断点的最后一次执行。
GDB可以在程序的同一位置设置任意数量的断点。这不是愚蠢或毫无意义的。特别是在断点是条件性的
情况下，更为有用（参见5.1.6节[断点条件]，50页）。
一个断点可能对应于多个位置。这种情况的例子如下：
对于C++构造函数，GCC编译器产生函数体多个的实例，用于不同的重载场景。
对于C++模板函数，函数里一个给定的行可以对应于任意数量的实例。
对于内联函数，一个给定的源代码行可以对应于多个内联的地址。
在这些情况下，GDB会在这些相关的位置插入断点。
一个对应于多个位置的断点可能会用多行来显示断点信息表–一个表头行，接下来是每一行对应于每一
断点位置。表头行在地址列里有’
个位置对应的函数名。断点号列的形式是断点号.位置号。
例如：
Num Type Disp Enb Address What
1 breakpoint keep y
stop only if i==1
breakpoint already hit 1 time
1.1 y 0x080486a2 in void foo
1.2 y 0x080486ca in void foo
将断点号.位置号作为参数传递给enable何disable命令，每个位置就可以被单独的激活或者禁用。注意，不能
从列表里删除一个单独的位置，只能删除从属于父断点的整个位置列表（用delete num命令，num是父断点的编号
，上面例子里是1）.禁用或者激活父断点（参见5.1.5[禁用]，49页）影响所有属于这个断点的位置。
在共享库里设置断点是很平常的事。程序运行的时候共享库可以显式加载/卸载，还可以多次重复。为了支持这
个用例，GDB会在共享库加载/卸载的时候更新断点位置。典型地，在库尚未加载或库的符号还不可用的时候，你可
以在调试会话的开始在库里设置一个断点。在设置此类断点的时，GDB会问你是否想要设置一个所谓的挂起断点–
断点的地址还不能解释。
程序运行后，当一个新共享库加载以后，GDB会重新计算所有断点。当一个新加载的共享库包含挂起断点引用到
的符号或者行时，这个断点就变为已解析和普通断点了。在共享库卸载时，所有引用到它的符号或行的断点都成为
挂起断点。
这个逻辑也适用于对应于多个位置的断点。例如，如果你在一个C++模板函数里设置了一个断点，一个新加载的
共享库有此模板的一个实例，一个新的位置会加到断点的位置列表里。
除了位置未解析外，挂起断点和常规断点没有区别。你可以设置条件或者命令，激活或者禁用和执行别的断点操
作。
在’break’命令不能解析断点地址时，GDB提供了附加的命令来控制解析此地址：
set breakpoint pending auto
这个命令是缺省行为。GDB不能找到断点位置时，它会向你询问是否该创建一个刮起断点。
set breakpoint pending on
设置未识别断点位置应该自动的创建一个刮起断点。
set breakpoint pending off
挂起断点不创建。任何未识别断点位置都将导致一个错误。这个设置不影响此前创建的挂
起断点。
show breakpoint pending
显示目前关于创建挂起断点的行为模式。
上面的设置只影响break命令和它的参数。一旦断点被设置了，共享库加载/卸载时会被自动的更新。
上面的设置只影响break命令和它的参数。一旦断点被设置了，共享库加载/卸载时会被自动的更新。
对于某些目标，断点所在的位置可以在只读或是可读写的，GDB可以根据断点位置来自行决定用硬件或者软件断点。这
个规则应用于用break命令来设置的断点，也用于那些用next和finish之类的命令设置的内部断点。对于用hbreak命令设置
的断点，GDB总会用硬件断点。
用下列命令控制这个自动行为：
set breakpoint auto-hw on
这是缺省行为。GDB设置断点时，它会尝试用目标内存映射来决定是用软件还是用硬件断点。
set breakpoint auto-hw off
设置GDB不自动选择断点类型。如果目标提供了内存映射，GDB会在试图在只读地址上设置软件断点的时候警告。
GDB本身会在程序里为某些特殊目的设置断点，例如为了恰当的处理longjmp（在C程序里）。这些内部断点分配负值编号，
从-1开始；’info breakpoints’不显示它们。可以用GDB维持命令’maint info breakpoints’来查看它们（参见[maint info
breakpoints],331页）。
5.1.2 设置监视点
在一个表达式改变时，可以用监视点来中断程序运行，而不需要预先知道表达式在哪里发生变化。（这类断点有时称为数
据断点）。表达式可以简单如单个变量的值，也可以复杂如多个变量用操作符结合起来。例如：
1.单个变量值的引用
2.一个地址转换为一个恰当的数据类型。比如，‘*(int *)0×12345678’会在指定的地址监视一个4字节长的区域（认为是一个
整形）。
3.任意复杂的表达式，例如‘a*b + c/d’。表达式可以程序语言的任何正确的操作符（参见12章[语言]，119页）。
可以在一个表达式上设置一个断点，即使这个表达式尚不能解析。例如，可以在‘*global_ptr’初始化前设置一个监视点。
在程序设置了‘*global_ptr’和表达式用一个有效值时，GDB会中断程序。如果表达式通过其他方式变有效，而不是通过改变
变量的方式的话（例如，malloc调用而使‘*global_ptr’指向的内存可用），GDB会在下次表达式改变时中断程序。
监视点可以用硬件或硬件的方式实现，这依赖于你的系统。如果是软件断点的话，GDB单步跟踪程序并且每一次都测试变量的
值，这将使得比普通的执行慢几百倍。（但这是值得的，在你没有线索去哪里找bug的时候）
在某些系统里，比如HP-UX, PowerPC, gnu/Linux和大多数基于x86的系统里，GDB支持硬件监视点，而这不会降低程序执行速度。
watch expr [thread threadnum
设置一个表达式监视点。在表达式expr被被改写和值改变时GDB会中断程序。最简单（也是最常用的）的用法是监视一个变
量：
(gdb) watch foo
如果命令包含[thread threadnum]参数，GDB只会在threadnum标识的线程改变表达式expr的值时中断。注意，只在硬件
监视点上GDB才起作用。
rwatch expr [thread threadnum]
程序读表达式的值时中断。
awatch expr [thread threadnum]
读或写表达式时中断。
info watchpoints
打印监视点，断点和捕获点列表；和info break相同（参见5.1.1节[设置断点]，40页）
如果可能，GDB就设置一个硬件监视点。硬件监视点执行的非常快，调试器会在指令产生监视值改变的时候报告这个变化。如果GDB
不能设置一个硬件监视点，那么它会设置一个软件监视点，软件监视点会相对慢得多，而且是在变化发生之后的下一个指令才报告，
并不是在发生改变的时候就报告。
用set can-use-hw-watchpoints 0命令可以迫使GDB只设置软件监视点。由于参数设置为0了，GDB就再也不会试图去
设置硬件监视点了，即使这个系统支持硬件监视点（注意，此前设置的硬件-协助的监视点仍将使用硬件机制来监视
表达式的值）。
set can-use-hw-watchpoints
设置是否用硬件监视点。
show can-use-hw-watchpoints
显示硬件监视点的当前模式。
对于远程系统，你可是限制硬件监视点的数量，参见[设置远程 硬件-断点-限制]，177页。
在执行watch命令时，GDB报告：
Hardware watchpoint num: expr
如果成功设置了一个硬件监视点的话。
目前，awatch和rwatch命令只能设置硬件监视点，因为不改变被监视的表达式的值的数据的访问不在每个执行到它
的指令上都加以检查的话，就没法探测到；目前GDB也没有那样做。如果GDB发现用awatch或者rwatch不能设置硬件监视
点的话，会打印类似如下信息：
Expression cannot be implemented with read/access watchpoint.
有时候，由于被监视的表达式的数据类型长度超出目标系统上支持的硬件监视点，GDB可能不能设置硬件监视点。例
如,某些系统只能监视最多4个字节宽的硬件监视点；在这些系统里，不能为带有双精度的浮点指针数据（通常是8字节
长）的表达式设置一个硬件断点。一个可能的替代方案是，把一个长区域分成一系列小的监视点。
如果设置了太多的硬件监视点，GDB有可能不能再继续执行程序时插入所有的监视点。由于准确的有效监视点的数量
在程序重新执行后才能知道，GDB可能不能在设置监视点的时候给出警告，警告信息会在程序重新执行后发出：
Hardware watchpoint num: Could not insert watchpoint
如果发出了这个警告，需要删除或禁用一些监视点。
监视复杂的引用了大量的变量的表达式可能会消耗光硬件断点可用的资源。这是因为GDB需要分别为监视表达式里
引用的每个变量分配资源。
如果调用了一个交互使用打印或者调用的函数，任何监视点都只能等到GDB遇到另一种断点或调用结束之后才有效。
GDB会在离开生存区的时候，自动删除监视本地（自动）变量的监视点，或者是引用到这种变量的表达式的监视点；
也就是说在离开这些变量定义区的时候。尤其是，在调试程序要结束时，所有的本地变量都要离开生存区的时候，只
有全局变量的监视点才保留。如果重新执行程序，需要重设这些监视点。一个方法是在main函数的入口点设置代码断
点，在执行断点的时候设置这些监视点。
在多线程程序里，监视点会从每个线程里发现被监视的表达式值的变化。
警告：多线程程序里，软件监视点只有有限的用处。如果GDB创建了一个软件监视点，它只能在一个线程里监
视这个表达式的值。如果你你确信只有当前的线程活动会导致表达式的值的改变的话（并且你确信没有别的线程会变成当前线程的话），那么你可以像通常那样使用软件监视点。然而，GDB不能察觉非当前线程改变表达式值。（于此相反
，硬件监视点能从所有线程中监视断点）
参见[设置远程硬件-监视点-限制]，177页。
5.1.3 设置捕获点
用捕获点可以让调试器为某些程序事件中断程序执行，例如C++异常或者是共享库的加载。用catch命令来设置
一个捕获点。
catch event
在event发生时中断。事件可以是下列的：
throw C++异常的抛出。
catch C++异常的捕获。
execption
Ada异常。如果在命令的结尾指定了异常名（比如catch execption Program_Error）,调试器
就只会在这个异常发生时中断。否则，调试器会在任意的Ada异常发生时中断。
exception unhandled
没有被程序处理的异常。
assert 一个失败的Ada断言。
exec exec调用。目前只在HP-UX和GNU/Linux上可用。
fork fork调用。目前只在HP-UX和GNU/Linux上可用。
vfork vfork调用。目前只在HP-UX和GNU/Linux上可用。
load
load libname
动态加载共享库，或者加载库libname。目前只在HP-UX上可用。
unload
unload libname
卸载动态加载的共享库，或者卸载库libname。目前只在HP-UX上可用。
tcatch event
设置只中断一次的捕获点。捕获点会在事件第一次捕获之后自动删除。
用info break命令列出目前的捕获点。
目前GDB对C++异常处理有一些限制（catch throw和catch catch）:
1.如果交互调用函数，GDB通常会在这个函数结束时将控制权交还给你。如果这个调用产生
了一个异常，这个调用可能越过交还控制权的机制，让程序结束或仅仅只是继续执行，直到
它碰到一断点，捕获到一个GDB检测的信号，或者退出。即使你为异常设置了捕获点也是一
样的；异常的捕获点在交互式的调用里是禁用的。
2.不能交互的产生一个异常。
3.不能交互的注册异常处理函数。
某些时候catch并不是最好的异常处理调试技术：如果你需要异常发生的精确位置的话，在
异常处理函数前中断是更好的选择，因为那样的话可以看到还未退绕的栈。相反，在异常处理
函数里设置断点的话，就不太容易找出在哪里发生了异常。
要在异常处理函数调用前中断程序，你需要了解一些实现的知识。就GNU C++而言，异常是调
用一个名为__raise_exception的库函数而引发的，这个函数有下面的ANSI C接口：
void __raise_exception (void **addr, void *id);
要让调试器在栈没有退绕前捕获异常，在函数__raise_exception上设置断点就可以了（参见5.1
节[断点；监视点；和异常]，39页）。
用一个条件断点（参见5.1.6节[断点条件]，50页），可以在一个指定异常发生时中断。可以用
多个条件断点来在任何一个异常发生的时候中断程序。
5.1.4 删除断点
常常有必要在断点完成任务之后删除断点，监视点或者捕获点，因为不再需要它们再次中断了。这
就是删除断点。一个断点删除之后就不存在了；它被遗忘了。
用clear命令可以从程序中删除所有断点。用delete命令指定断点号可以删除单独的断点，监视点或
者捕获点。
用删除断点来继续执行并不是必须的。只要不改变执行地址的执行程序，GDB 会自动忽略在将要执行
的第一个指令上的断点。
clear 在选定的栈帧上的下一个指令上删除所有的断点（参见6.3节[选择一个帧]，64页）。只要选择
最内层的帧的话，这是一个在程序中断地方删除断点的好方法。
clear location
在指定的位置删除所有的断点。参见7.2节[制定位置]，68页，更多关于位置的形式；最有用的形
式如下表：
clear function
clear filename:function
删除在名为function入口点上的断点。
clear linenum
clear filename:linenum
删除在指定的行或文件名上的断点。
delete [breakpoints] [range...]
在指定的范围内删除断点，监视点或者捕获点。如果没有制定参数，就删除所有的断点（GDB会要求确定，
除非你设置了set confirm off）。delete命令可以缩写为d.
5.1.5 禁用断点
相比删除断点，监视点或者捕获点，你也许更愿意禁用它们。这将让断点不起作用就如它被删除了一样，但会记住
断点的信息，可以在以后激活。
可以用enable和disable命令禁用和激活断点，监视点和捕获点，可选择指定一个或多个断点号作为参数。如果不知道
用哪个断点号，用info break或info watch来打印断点，监视点，捕获点的信息。
禁用和激活有多个位置的断点会影响其所有的位置。
断点，监视点，捕获点有四种激活状态中的任意一种：
1.已激活的（Enabled）。断点会中断程序。这个状态是用break命令发起的。
2.已禁用的（Disabled）。断点不再影响程序。
3.激活一次（Enabled once）。断点会中断程序，但会变成disabled状态。
4.激活并删除（Enabled for deletion）。断点中断程序，但中断后立即就永久删除。这个状态是用tbreak命令发起的。
可以用下列命令来激活或禁用断点，监视点，捕获点：
disable [breakpoints] [range...]
禁用指定断点–或者所有的断点，如果没有参数的话。已禁用的断点不再起效，但没有被删除。所有的选项如
ignore-counts,conditions和commands会记住，以便将来再次激活。disable缩写dis。
enable [breakpoints] [range...]
激活指定的断点（或者是所有的断点）。重新可以中断程序。
enable [breakpoints] once range…
临时激活指定的断点。GDB会在这个断点中断程序之后立即禁用它。
enable [breakpoints] delete range…
激活断点中断一次，然后删除之。GDB在程序中断后立即删除这类断点。这类断点用tbreak命令发起。
除了用tbreak命令设置的断点（参见5.1.1[设置断点]，40页），断点会自动激活；因此，它们用上述的命令转换状态。
（命令util可以设置和删除它自己的断点，但不改变其它的断点的状态；参见[继续和单步跟踪]，54页）
5.1.6 中断条件
最简单的断点会在程序执行到指定位置时中断程序。也可以为断点指定条件。条件只是程序语言的一个Boolean
型的表达式（参见8.1节[表达式]，75页）。带条件的断点会在程序执行到底时候计算表达式的值，只有在条件为
真的时候才中断。
这是和程序断言的用法是相反的；这这个情况里，你希望在断言失败是中断–就是说，条件为假。在C语言里，如
果要测试由叫天assert表示的断言，应该在相应的断点上设置条件为‘! assert’。
监视点也可以用条件；其实监视点不太需要条件，因为监视点总在检测表达式的值–但用条件可能更简单，在一个
变量名上设置一个监视点，并制定一个条件来测试新值是否是你期望的。
断点条件可能有边际效应，甚至可能调用程序里的函数。这可能很有用，比如，在激活程序进程日志函数，或者用
你自己的打印函数来格式化特殊数据结构。除非在相同的位置还有另外已激活断点，否则效应是完全可预测的。（
假使那样的话，GDB会首先检查另外的断点来中断程序，不检查此断点的条件）注意，要在断点到达时实现边际效应
，断点命令通常比断点条件更方便更灵活。（参见5.1.7[断点命令列表]，51页）
在break命令里用’if’可以在设置断点时指定断点条件。参见5.1.1节[设置断点]，40页。它们也可以在任何时候用
condition命令改变。
你也可以在用watch时带if关键字。catch命令不识别if关键字。只有condition可以用来对捕获点进一步的设置。
condition bnum expression
为断点，监视点，捕获点指定断点条件表达式。一旦你设置了条件，断点bnum就只在表达式为真中断程序（
非零，在C里）。当用condition，GDB立即检查语义的正确性，然后判断它用到的符号是否用在了断点上下
文里。如果表达式用到的符号不在断点上下文里，GDB会打印一个错误消息：
No symbol “foo” in current context.
然而，GDB不会真的在用condition命令的同时就计算表达式（或者在一个命令带条件的设置断点，像break
if…）.参见8.1节[表达式]，75页。
condition bnum
从断点bnum里删除条件。这个断点就成为普通的无条件的断点。
一个特殊的条件断点的例子是在断点达到一定次数时才中断。这非常有用，因此有一个特别的方式来实现：用断点
的忽略计数。每个断点都有一个忽略计数，忽略计数是个整型数。大多数情况下，忽略计数是0，因此没有什么效
用。但是程序执行到一个忽略计数为正数的的断点的时候，那么就会中断执行，忽略计数减1，接着执行程序。结果是
，如果忽略计数是n，断点不会在接下来的n次中断程序。
ignore bnum count
将断点bnum的忽略计数设置为count。接下来的count次碰到断点，程序执行不会中断；除了忽略计数减1，
GDB不做别的。
要在下一次断点执行到的时候中断程序，设置忽略计数为0。在用continue在中断后来重新执行，可以直接
指定忽略计数为continue的参数，而不需要用ignore.参见5.2节[继续和单步跟踪]，54页。如果一个断点有
一个正当忽略计数和条件，不会检查条件。一旦忽略计数变为0，GDB会重新检查条件。
要达到和忽略计数一样的效果，可以用每次自减1的调试器方便变量作为断点条件来做，比如‘$foo– <= 0
’。
忽略计数可以用于断点，监视点和捕获点。
5.1.7 断点命令列表
可以为断点（或监视点，捕获点）设置一系列命令来让断点中断时执行之。例如，你可能想要打印某些表达式的值
，或者激活别的断点。
commands [bnum]
… command-list …
end 为断点bnum指定命令列表。commands后面接命令行。最后输入一行end阿里结束命令。
要删除一个断点的命令，输入commands后接一行end；就是说，不带命令。
不带bnum参数的话，commands指定最后的断点，监视点或者捕获点（不是最近执行到的断点）。
在命令列表里，按下回车键意味着重复上一个命令的功能将被禁用。
可以用断点命令来重新启动程序。仅仅只用continue命令，或者step，或者是其它重新执行的命令就可以了。
在重新执行的命令之后的命令将会被忽略不执行。这是因为每次重新执行的时候（即使只是next或step）,可能会碰
到别的断点–这个断点可能有自己的命令列表，会产生执行哪一个命令列表的歧义 。
如果你指定的命令列表的的哥命令是silent，通常断点中断的所产生的消息就不会打印。这个在打印一个特定的消
息，然后接着继续执行的中断而言是可取的。如果剩下的命令都不打印消息，你将看不到什么中断的迹象。silent只
在断点命令开头有意义。
命令echo，output和printf可以打印精确控制的输出，并常常在哑断点里很有用。参见20.4节[控制输出的命令]，
222页。
举个例子，下面的例子可以让你用断点命令来在foo的入口点，当x>0时打印x的值。
break foo if x>0
commands
silent
printf “x is %d\n”,x
cont
end
断点命令的一个应用是应付一个bug（就是说先放下此bug）来测试另一个。在出错行后的代码上设置一个断点，设
置条件来检查出错情况，用命令来给需要用到的变量设置正确的值。用continue命令来结束命令列表，因此程序就不
会停止，用silent命令来禁止输出信息。下面是一个例子：
break 403
commands
silent
set x = y + 4
cont
end
5.1.8 断点菜单
某些编程语言（特别是C++和Objective-C）允许一个函数名可以定义好几次，应用于不同的上下文，称之为重载。
当一个函数名重载时，‘break function’就不足与让GDB明白你需要在哪里设置断点。可以用函数的准确特征来指
明要设置的是哪个函数版本，例如用‘break function(types)’。否则，GDB会提供一个数字标识的菜单供你选择
不同的断点，并用提示符’>’等待你的选择。开头的两个选项是‘[0] cancel’和‘[1] all’。输入1会在每个函数
上设置一个断点，输入0取消break命令设置新的断点。
例如，下面的会话摘录显示的是在重载的符号String::after上设置断点。选择了3个特别的函数定义体：
(gdb) b String::after
[0] cancel
[1] all
[2] file:String.cc; line number:867
[3] file:String.cc; line number:860
[4] file:String.cc; line number:875
[5] file:String.cc; line number:853
[6] file:String.cc; line number:846
[7] file:String.cc; line number:735
> 2 4 6
Breakpoint 1 at 0xb26c: file String.cc, line 867.
Breakpoint 2 at 0xb344: file String.cc, line 875.
Breakpoint 3 at 0xafcc: file String.cc, line 846.
Multiple breakpoints were set.
Use the “delete” command to delete unwanted
breakpoints.
(gdb)
5.1.9 “不能插入断点”
在某些操作系统里， 如果有其它的进程运行了这个程序的话，断点就不能在程序里设置了。在此情况下，用一个断
点试图运行或继续执行程序会引起输出一个错误信息：
Cannot insert breakpoints.
The same program may be running in another process.
这个情况发生时，有三种继续的方式：
1.删除或关闭断点，接着继续。
2.挂起GDB，复制程序文件并命名为另一个名字。重新执行GDB，用exec-file命令来指定GDB要执行的程序文件名。接
着重启程序。
3.用链接器选项’-N’重新链接程序，以使文本段是非共享的.操作系统的限制可能不应用于非共享模式的可执行程序。
如果你要求设置太多有效的硬件支持的断点和监视点的话，类似的信息也会输出：
Stopped; cannot insert breakpoints.
You may have requested too many hardware breakpoints and watchpoints.
这个消息在你试图继续执行程序是打印，因为GDB只有在此时才能准确的知道有多少硬件断点和监视点需要插入。
在这个消息打印的时候，你需要禁用或者删除一些硬件支持断点和监视点，然后接着继续执行。
5.1.10 “断点地址已调整…”
某些处理器架构对断点所在的地址有限制。对于那些有限制的架构，GDB会试图调整断点的地址来符合它的限制。
这类架构的一个例子是富士的FR-V。FR-V是VLIW架构，有着类RISC的指令集，它的一组指令可能集合在一起以便于
并行运算。FR-V架构限制断点指令的位置在一组指令集的最低的地址空间。GDB会主动调整断点位置，将断点指令设置
在这组指令集的开头来适应FR-V的限制。
由于优化代码的原因，得到一组指令集常常和源代码的表述是不一样的，因此断点位置可能被调整到和源代码不一
致的地方。由于这样的调整使得GDB断点的行为可能和用户的预期有很大的不同，在设置断点的时候会打印出一个警告
信息，并且断点执行到时也会打印这样的信息。
断点在受到调整时，类似下面的警告信息会打印出来：
warning: Breakpoint address adjusted from 0×00010414 to 0×00010410.
对于用户可设置的和GDB内部的断点，这样的警告都可能出现。如果你看到一个这样的警告，你应该确认调整后的位置
上设置的断点是否具有你所期望的效果。如果不是，问题断点要删除，应该设置一个有效的断点。例如，可能在后面的指
令上设置断点就够了。在某些情况下，条件断点在防治断点出发调整方面也很有用。
GDB也会在调整后的断点上中断时打印一个警告：
warning: Breakpoint 1 address previously adjusted from 0×00010414
to 0×00010410.
遇到这个警告时，很可能要采取补救措施已经晚了，除非断点中断早于所期望的或者中断的频率比预期的高。
5.2 继续和单步跟踪
继续意味着重新执行程序知道程序正常结束。相反，单步跟踪意味着只执行程序“一步”，“一步”可能代表着一
行源代码，或者一条机器指令（依赖于你用的特定命令）。不论继续或是单步跟踪，程序可能很快就由于断点
或信号中断执行。（如果由于信号中断，你可能希望用handle,或者用’signal 0′来继续执行。参见5.3节[信号]，57页）
continue [ignore-count]
c [ignore-count]
fg [ignore-count]
在程序最近中断的地方重新执行；任何设置在这个地址上的断点都会被绕过。可选参数ignore-count可以让
你进一步指定在这个位置上忽略断点次数；它的效果就如ignore（参见5.1.6[断点条件]，50页）。
参数ignore-count只有在程序由于断点中断时才有意义。其他时候，continue的ignore-count参数会被忽略
。
同义词c和fg（表示foreground，因为被调试的程序总被认为是前台程序）只是为方便而提供的，其行为就如
continue一样。
要在不同的位置重新执行程序，可以用return（参见14.4节[从函数里返回]）来回到调用函数；或者jump（参见
14.2[在不同的地址继续]，150页）到程序里的绝对地址。
使用单步跟踪的典型的技术是在函数的入口点设置一个断点，或者在可能发生错误的程序段上设置，运行程
序知道它在断点上中断，再在这个嫌疑区域单步执行，检测感兴趣的变量，直到你发现错误发生。
step 继续执行程序直到另一行代码，再中断，把控制权交换GDB。可以缩写为s。
警告：如果在没有调试信息的函数里使用step命令，程序执行会继续执行直到有调试信息的一个函
数。类似的，不会单步进一个没有调试信息的函数。要跳过没有调试信息的函数，用stepi命令，下
面会介绍。
step命令只在一行源代码的第一个指令上中断。这就阻止了在类似switch语句，for循环上的多次中断。如果
在这行代码上调用的函数有调试信息，step会继续中断。换句话说是，step会进入这行代码所调用的所有函
数。
如果函数有行号信息，step命令也只进入这个函数。否则step命令就如next命令。这个规则可以在MIPS机器
上用cc -gl编译时避免错误。在以前，step会进入有调试信息的子函数。
step count
继续单步执行，不过执行count次。如果执行到一个断点，或者一个与单步跟踪无关的信号在count次单步执
行发生时，单步执行会立即中断。
next [count]
在当前栈帧（最内层）上继续执行到下一行源码行。和step相似，但在这行代码上调用的函数将不会中断。
程序执行到在原栈层里的另一行代码时会中断。缩写为n。
参数count是重复次数，和step的一样。
命令next只在一行源代码的第一个指令上中断。这就阻止了在类似switch语句，for循环上的多次中断。如果
在这行代码上调用的函数有调试信息，step会继续中断。
set step-mode
set step-mode on
set step-mode on命令会导致step命令在没有调试行信息的函数的入口点中断，而不是越过这个函数。
如果你对一个不带符号信息的函数的机器指令很感兴趣，又不想GDB越个这个函数的话，那么这个命令就很有用了。
set step-mode off
导致step命令越过不带调试信息的函数。这是缺省的。
show step-mode
显示GDB是否中断或越过不带源代码行调试信息的函数。
finish
继续执行直到当前选定栈帧上的函数返回。打印返回值（如果有）。
和return命令相反（参见14.4节[从一个函数里返回]，151页）。
until
u 在当前栈帧上继续执行直到越过当前行的源代码行。这个命令用来避免多次单步执行一个循环。和next命令，除了
until在遇到一个跳转时，until会自动继续执行直到程序计数器比跳转地址大的时候。
这就意味着在你用单步执行达到循环结束的时候，until会使程序继续执行直到循环结束。相反，在循环结束时，
next命令只是简单的又从循环开始单步执行，这就使得你要进行下次单步执行循环。
until总是在程序试图从当前栈帧中退出的时候中断执行。
如果机器指令的顺序和源代码的不相符合的话，until可能会产生和预期不大一样的结果。例如，下列调试会话摘录
里，f(frame)命令显示了程序执行在杭206中断；但用until，得到行195：
(gdb) f
#0 main (argc=4, argv=0xf7fffae8) at m4.c:206
206 expand_input();
(gdb) until
195 for ( ; argc > 0; NEXTARG) {
这是因为执行效率的缘故，编译器在循环尾产生结束测试的代码，而不是在循环开头–即使C for循环的测试实在循
环体前。until命令看上去就像会单步执行回循环的开头；然而，它不是真的要回到前面的代码里去–不是依照实际
的机器代码。
不带参数的until命令将使用单个指令的单步执行方式，因此比带参数的until要慢。
until location
u location
继续执行直到程序执行到指定的位置，或者从当前栈帧返回。location可以是在7.2节[指定位置]里讨论的任意一种
形式。这个命令形式使用临时断点，因此比不带参数的until命令要快。只有在这个指定的位置在当前帧上时，它才
会真的被执行到。这就意味着until可以用来跳过函数嵌套调用。如下面函数所示，如果当前位置是96行，执行命令
until 99会执行程序到99行，在内从调用返回的时候。
94 int factorial (int value)
95 {
96 if (value > 1) {
97 value *= factorial (value – 1);
98 }
99 return (value);
100 }
advance location
继续执行程序直到给定的位置location。参数是必须的，可以是可以是在7.2节[指定位置]里讨论的任意一种形式。
执行会在从当前栈帧上退出时中断。advance和until相似，但advance不会跳出函数嵌套调用，而且目标位置不必要
在当前帧上。
stepi
stepi arg
si 执行一个极其指令，接着中断然后返回到调试器。
在单步执行一个机器指令的时候，执行‘display/i $pc’很有用。这使得每次程序中断的时候，GDB在下一个指令
要执行的时候自动显示这个指令。参见8.6节[自动显示]，81页。
参数是重复次数，和step一样。
nexti
nexti arg
ni 执行下一个机器指令，但如果是一个函数调用的话，执行到这个函数返回。
参数是重复次数，和next一样。
5.3 信号
信号是程序里发生的异步事件。操作系统定义了信号种类，并命名这些信号，给这些信号编号。例如，在Unix里SIGINT是
程序在你输入一个中断字符（通常是Ctrl-c）的时候得到的信号;SIGSEGV是程序在程序引用了离当前所有用到的内存区域都
很远的内存时得到的信号；SIGALRM在定时器超时的时候发生（只有在程序定义了定时器的时候才发生）。
某些信号，包括SIGALRM，是程序的普通组成部分。其它的，像SIGSEGV，指示发生了错误；这些信号是致命的（它们会立
即结束你的程序），如果你没有预先定义好信号处理函数的话。SIGINT不表示程序发生错误，但常常也是致命的，所以可以
用来执行中断的目的：杀死进程。
GDB能够察觉程序里出现的任何信号。可以预先设定GDB如何应对每一种信号。
通常，GDB会将非错误性的信号悄悄的传进程序（因此不会干涉它们在程序里的功能角色），但在一个错误信号发生时立即
中断程序。可以用handle命令来改变这些设置。
info signals
info handle
打印所有信号和GDB被设置如何设置来处理它们。可以用这个命令来查看定义好的信号的编号。
info signals sig
和info handle相似，但只打印指定信号的信息。info handle是info signals的别名。
handle signal [keywords...]
改变GDB处理信号的方式。signal可以是一个信号的编号或则会名字（开头带或不带’SIG’）；信号编号形式
“log-high”列表；或者是’all’，代表所有的信号。可选参数keywords，如下所述，表示要设置什么。
handle命令带有的参数keywords可以缩写。它们是：
nostop GDB在信号发生的时候不中断程序。它可以打印一个信息告诉你有信号出现了。
stop GDB在信号出现的时候中断程序。意味着print关键字也同样。
print GDB在信号出现的时候打印一个信息。
noprint GDB在信号出现的时候不打印任何信息。意味着和nostop关键字一样。
pass
noignore
GDB让程序能得到这个信号。程序可以处理信号，或者如果信号是致命而又没有处理的话可以终止信号。pass和
noignore同义。
nopass
ignore GDB不允许程序得到信号。nopass和ignore同义。
在信号中断程序时，在程序继续执行前信号都是不可见的。如果在这个时间点上pass对此信号起作用了的话，程序就
能看到这个信号。换言之，GDB报告信号后，你可以用handle命令带pass或者nopass来控制程序在继续执行的时候是否可
见到信号。
缺省是设置为nostop，noprint，非错误性信号如SIGALRM是pass，错误性信号是SIGWINCH和SIGCHLD，stop，print。
用signal命令可以防止程序看见一个信号，或者看到通常不可见的信号，或者在任意时间给程序一个信号。例如，如
果程序由于某种内存引用错误导致的中断，你可能把正确的值存储进错误的变量然后继续执行，希望看见更多的执行；
但程序可能由于看到了致命的信号的缘故，立即就终止了；要防止这样的情况，用’signal 0′继续执行。参见14.3节[
向程序发一个信号]，151页。
5.4 中断和开始多线程程序
如果程序具有多个线程（参见4.9节[调试多线程程序]，31页），可以选择是否在所有线程上设置断点，或者在特定的
线程上设置断点。
break linespec thread threadno
break linespec thread threadno if …
linespec指定源代码行；有多种方式来指定（参见7.2节[指定位置]，68页），不过其效果都是指定某些源代
码行。
在断点命令里使用限定语’thread threadno’可以指定GDB只在特定线程执行到这个断点时中断程序。threadno
是GDB分配的线程标识号，’info threads’显示的第一列就是。
如果设定断点时没有指定’thread threadno’的话，那么断点就适用于程序里所有的线程。
thread限定词也可用于条件断点；这种情况下，把’thread threadno’放在断点条件前，像这样：
(gdb) break frik.c:13 thread 28 if bartab > lim
无论何时程序在GDB里因为何种原因而中断，所有的线程执行都将中断，而非仅仅是当前线程。这就可以让你检查程序
所有的状态，包括线程切换，而不用担心事情会悄无声息的发生改变。
然而有一个不幸的边际效应。如果一个线程由于断点而中断，或者因为别的缘故，而另一个线程由于一个系统调用而
阻塞住了，那么这个系统调用可能会过早的返回。这是多线程和某些信号相互影响的结果，这些信号是GDB用来实现断点
和别的用来中断执行的事件。
要处理这个问题，程序应当检查每个系统调用的返回值并作适当的反应。这总是好的编程风格。
例如，不要写这样的代码：
sleep (10);
sleep调用可能过早返回，由于其它的线程中断或别的原因的缘故。
相反，要这样写：
int unslept = 10;
while (unslept > 0)
unslept = sleep (unslept);
一个系统调用可过早返回，而系统还在执行这个调用。但GDB真的会导致程序和不在GDB里的行为不一样。
而且，GDB在线程库里用内部断点来监视某些事件，比如线程创建和线程销毁。这些事件发生时，另一个线程里系统调
用可能过早返回，即使程序没有中断。
相反，重启程序时，所有线程都会开始执行。即使用单步命令如step或next来执行程序时都是这样的。
特别的，GDB不能在锁步下单步执行所有线程。因为线程调度由调试操作系统决定（不是由GDB控制），其它的线程可
能比当前线程完成一次单步执行多执行一些。更进一步说，在程序中断的时候，通常其它的线程中断在一个语句的中间，
而不是在一个语句的边界上。
在继续或者单步执行之后，你甚至可能发现程序在另一个线程里中断。在其它线程执行到一个断点，信号，或者一个
异常发生,或者当前线程执行完成的时候，都可能发生这个现象。
在某些操作系统里，可以锁住操作系统的调度器来直让一个线程运行。
set scheduler-locking mode
设置调度器锁定模式。 如果是off,那么就不锁定，任何线程可以在任何时候执行。如果是on，那么只有当前线
程可以运行。step模式优化单步执行。在单步调试时，step用抢占当前线程的方式来阻止其他线程抢占控制权
。单步调试的时候，其它线程很少（或者从不）有机会来执行。用’next’来执行一个函数调用的话，它们有更
有可能运行，并且在用’continue’、’until’或者’finish’之类的命令的话，它们就完全自由的运行了。不过，
除非另一个线程在它自己的时间片里执行到了一个断点，它们从不从你正在调试的线程抢夺GDB的控制权。
show scheduler-locking
显示当前调度器的锁定模式。
GDB手册6:检查栈
6 检查栈
程序中断后，首先需要知道在哪里中断的和如和到此的。
每次程序执行了一个函数调用，调用信息就产生了。这些信息包含了程序里的调用位置，调用的参数和被调用函数的
本地比昂两。这些信息被存储在一块被称为堆栈帧的数据里。堆栈帧是在成为调用栈的内存区域里分配的。
程序中断的时候，GDB提供的堆栈检查命令可以看见所有此类信息。
GDB会选择其中的一个堆栈帧，GDB的很多命令也隐式地引用这个帧。特别的，在查看程序里的变量值的时候，这个值
就在这个选定的帧里。GDB提供了特殊的命令来要选择你感兴趣的堆栈帧。参见6.3节[选择一个帧]，64页。
在程序中断时，GDB自动选择当前执行的堆栈帧，并用和frame命令那样类似的描述这个帧，只不过简明一点。
6.1 堆栈帧
调用栈划分为连续的区块，称为堆栈帧，或者简称为栈；每个帧是一个函数调用另一个函数的相关数据。帧包含了传
递给被调用函数的参数，这个函数的本地变量和这个函数执行的地址。
在程序开始的时候，堆栈只有一个帧，那是主函数main的。这个帧称为初始帧或者最外层的帧。每当一个函数被调用
了，就产生一个新的堆栈帧。函数返回时，这个调用所属的帧就被销毁了。如果是递归函数，那么同一个函数就可能有
多个帧。当前正在执行的函数调用的帧称为最内层的帧。这是最近创建的帧，同时还有别的帧存在。
程序内部，堆栈帧用地址来标识。一个堆栈帧有许多字节组成，每个字节都有自己的地址；每种计算机都有自己的方
式选择作为堆栈帧的地址的一个字节。程序在这个帧里执行时，通常这个地址保存在成为帧指针寄存器里（参见8.10节[
寄存器]，90页）。
GDB为所有现存的堆栈帧编号，从最内层帧0开始，1是这个函数调用的帧，以此类推。这些编号并不真正在存在于程序
里；它们是由GDB分配用于GDB命令来区分堆栈帧的。
某些编译器提供编译不带函数堆栈帧的方法（例如，GCC选项‘-fomit-frame-pointer’产生不带帧的函数）。在频繁
调用库函数时，可以用这个技术来节省建立帧的时间。对于这类函数调用的处理，GDB的能力有限。如果最内层的函数调
用没有堆栈帧的话，GDB仍然认为它是由一个单独的堆栈帧，通常编号为0，因此可以正确的追踪函数调用链。然而，GDB
不在堆栈的其它地方提供无帧函数。
frame args
frame命令可以从一个堆栈帧转到另一个，并打印所选的堆栈帧。args可以是帧地址或是帧号。如果不带参数，
frame打印当前堆栈帧。
select-frame
select-frame命令可以从一个堆栈帧转到另一个而不打印这个帧。是frame的安静版本。
6.2 回溯
回溯是关于程序如何达到所处位置的概要。每行显示一个帧，对于多个帧的情况，从当前执行的帧（0帧）开始，接下
来是它的调用者（1帧），以此类推。
backtrace
bt 打印整个堆栈的回溯：每帧一行。
可以用输入系统中断字符在任意时间中断回溯，通常是Ctrl-c.
backtrace n
bt n 类似的，但只打印最内n层帧。
backtrace full
bt full
bt full n
bt full -n
也打印本地变量。n是要打印的帧的数量，如上所述。
where和info stack是backtrace的别名。
在多线程程序里，GDB默认只显示当前线程的回溯。要显示多个或所有线程的回溯，用thread apply命令（参见4.9节
[线程]，31页）。例如，输入thread apply all backtrace，GDB会显示所有线程的回溯；在调试一个多线程程序的core
dump的时候是很方便的。
回溯里的每一行显示了帧号和函数名。程序计数器的值也会显示–除非用了set print address off。回溯也显示源代
码文件名和行号，而且函数的参数也会显示。如果是在那行代码的开头，程序计数器的值会被忽略不显示。
下面是一个回溯的例子。用命令’bt 3′产生的，因此显示最内3层的堆栈帧。
#0 m4_traceon (obs=0x24eb0, argc=1, argv=0x2b8c8)
at builtin.c:993
#1 0x6e38 in expand_macro (sym=0x2b600) at macro.c:242
#2 0×6840 in expand_token (obs=0×0, t=177664, td=0xf7fffb08)
at macro.c:71
(More stack frames follow…)
没有在堆栈帧里存储的参数，其值用‘
如果需要显示这些优化掉的参数值，或者用其它依赖于这个参数的变量来推论，或者不带优化的重新编译程序。
大多数程序都有标准的用户入口点–在此处系统库和启动代码转化为用户代码。对于C是main函数（注1）。GDB要是发现
回溯里有入口函数，就会结束回溯，避免跟踪到高度系统相关（或通常不关心的）的代码。
要是需要检查启动代码，或者限制回溯到层次数量，可以改变其行为：
set backtrace past-main
set backtrace past-main on
回溯会在入口点处继续跟踪下去。
set backtrace past-main off
回溯在入口点处终止。默认行为。
show backtrace past-main
显示当前用户入口点回溯规则。
（注1，嵌入式程序（所谓的“自举”环境）不要求在入口点有main函数。甚至可以有多个入口点）
set backtrace past-entry
set backtrace past-entry on
回溯会在应用程序的内部入口点继续跟踪下去。这个入口点是由连接器在链接程序的时候
编码的，很可能是在用户入口点main函数（或者是相应的）之前被调用。
set backtrace past-entry off
回溯会在程序的内部入口点处终止。默认行为。
show backtrace past-entry
显示当前内部入口点回溯规则。
set backtrace limit n
set backtrace limit 0
显示回溯层为n。0代表不限制。
show backtrace limit
显示当前回溯层限制。
6.3 选择堆栈帧
大多数用来检查堆栈和数据的命令作用于此时所选择的堆栈帧上。有多个命令来选择堆栈帧；
都以打印一个堆栈帧的简明描述作为结束。
frame n
f n 选择编号为n的帧。回忆一下，0帧时最内层（当前执行）的帧，1帧时最内层帧所调用
的，以此类推。最高编号的帧时main函数的。
frame addr
f addr 选择在地址addr上的帧。这个命令在堆栈帧链被bug损坏的时候很有用，使得GDB可以为
所有帧编号。另外，要是程序有多个堆栈的时候，要在它们之间切换就很有用了。
在SPARC架构里，frame需要恋歌地址来选定一个绝对帧：一个帧指针和一个堆栈指针。
在MIPS和ALPHA架构里，需要两个地址：一个堆栈指针和一个程序计数器。
在29k架构里，需要3个地址：一个寄存器堆栈指针，一个程序计数器和一个内存堆栈
指针。
up n 在堆栈里上移n帧。对于正数n，向外层的帧移动，更高编号的帧，存在更长时间的帧。
n默认是1.
down n 在堆栈里下移n帧。对于正数n，向内层的帧移动，更低编号的帧，新近创建的帧。缩写
down为do。
这些命令都已打印两行描述堆栈帧的输出结束。第一行显示帧号，函数名，参数，源代码文件
和和行号。第二行显示源代码文本。
例如：
(gdb) up
#1 0x22f0 in main (argc=1, argv=0xf7fffbf4, env=0xf7fffbfc)
at env.c:10
10 read_input_file (argv[i]);
在此输出后，不带参数的list命令会以此帧的执行点为中心，显示10行代码。可以用edit命令来
编辑此执行点的代码。详情参见7.1节[打印源代码行]，67页。
up-silently n
down-silently n
这两个命令分别是up和down的变体；不同之处在于它们悄悄的处理，不输出新帧的信息。
主要是为GDB命令脚本用的，脚本的输出可能是不必要和恼人的。
6.4 堆栈帧信息
还有其它几个命令可以打印选定堆栈帧的信息。
fram
f 要是不带参数，命令不改变帧，但是打印当前选定堆栈帧的简明描述。可以缩写为f。带参数的话
用来选择堆栈帧。参见6.3节[选择堆栈帧]，64页。
info frame
info f 这个命令打印选定帧的文本描述，包括：
·帧地址
·下一个帧的地址（被这个帧调用的）
·上一个帧的地址（这个帧的调用者）
·这个帧对应的源代码的语言
·帧参数的地址
·帧的本地变量的地址
·帧里的程序计数器（调用者帧的执行地址）
·在帧里保存的计数器
要是发生了导致堆栈格式不能以通常的方式查看的错误的话，文本描述就很有用了。
info frame addr
info f addr
打印在地址addr上的帧的文本描述，但不选择此帧。此帧不会被此命令选中。要求和frame命令
相同的地址（对于某些架构，可能要求多个）。参见6.3节[选择堆栈帧]，64页。
info args
打印选定帧的参数，每个参数一行。
info locals
打印选定帧上的本地变量，每个一行。选定帧的执行点上可见的所有变量（声明为静态或自动的均可）。
info catch
打印当前帧的执行点上的异常处理函数的列表。要查看其它异常处理函数，访问相应的帧（用up,down
或者frame命令）；接着输入info catch。参见5.1.3节[设置捕获点]，47页。
GDB手册7:检查源文件
7 检查源文件
由于程序里记录的调试信息告诉GDB程序是由哪些文件编译的，GDB可以打印程序各部分源文件。程序
中断时，GDB同时自动打印是在哪一行上中断的。同样，当选择一个堆栈帧时（参见6.3节[选择帧]，64页），
GDB也打印那个帧上的执行是在哪一行里中断的。用显式的命令可以打印源文件别的信息。
如果通过GNU Emacs接口来用GDB，可以优先选择Emacs工具来查看源代码；参见23章[在GNU Emacs里用GDB]，
233页。
7.1 打印源代码行
要打印源文件里的代码行，用list命令（缩写为l）。缺省的，一次打印十行。有几个方式可以指定你希望
打印文件的哪部分；完整列表，参见7.2节[指定位置]，68页。
下面是命令list最常用的形式：
list linenum
以当前行为中心，打印当前源文件linenum行。
list function
以函数function开头为中心打印源文件。
list 打印更多行。如果用list命令打印过源文件行，list命令将会在打印的最后一行代码下接着打印；否则
，如果最近打印的源代码行是单独的一行，作为显示堆栈帧的一部分的话，list命令将已这一行为中心
开始打印文件代码。
list - 只打印最近已打印的代码行前的代码。
缺省的，用上述形式的list命令，GDB打印十行源代码。可以用set listsize改变：
set listsize count
设置list命令显示count行源代码（除非list命令明确指定其它的数字）。
show listsize
显示list打印行的数量。
用回车键省略参数的重复list命令，和只输入list相等。和列出相同的代码行相比更有用。参数是’-'的list命
令是例外；这个参数是用来重复执行的，每次执行都会在源文件里向上打印。
总之，list命令期待用户提供0，1或者2的行定义。行定义指定源代码行；有多种方式来制定（参见7.2节[指定位置]
，68页），不过其效果都是制定某些源代码行。
下面是list命令的完整的参数描述：
list linespec
以linespec为中心打印源代码。
list first,last
从first开始打印到last。两个参数都是行定义。当list命令有两个行定义时，并且第二个行定义的源文
件省略了的话，两个行定义指的是在同一个文件里的代码。
list ,last
打印到last行。
list first,
从first开始打印
list + 只打印最近打印行后的代码
list - 只打印最近打印行前的代码
list 如前所述。
7.2 指定位置
有多个GDB命令接受指定程序代码位置的参数。由于GDB是源代码级的调试器，位置通常指的是源代码里的某一
行；因此，位置通常是指行定义。
下面是GDB所能识别的代码位置的指定方式：
linenum 指定当前源文件的行数量linenum
-offset
+offset 指定从当前行偏移offset。对于list命令，当前行是最经打印过的；对于断点命令，是当前选定的
堆栈帧上的执行中断处（堆栈帧的描述，参见6.1节[帧]，61页）。要是用做list命令的两个行定义
的第二个参数，指定的是从第一个行定义开始的向上或向下的偏移。
filename:linenum
指定源文件filename的行号。
function
指定行从函数function为开始。例如，在C里，行是开括号{。
filename:function
指定行从文件filename里的函数function开始。要是有多个文件里有相同名字的函数的话，只需要用
文件名加上函数名就可以避免混淆了。
*address
指定程序地址address。对于行导向的命令，例如list和edit，这个参数指定位置为address的源代码行。
对于break和其它断点导向的命令，这个参数可以在不带调试信息或没有源文件的程序部分里设置断点。
这里address可以是当前工作语言（参见12章[语言]，119页）的任意有效的指定代码位置的表达式。另外
，GDB扩展了用于位置的表达式的语义，以此包含在调试过程中经常碰到的情况。下面是address的各种
形式：
expression
当前工作语言的任意有效表达式。
funcaddr
函数的地址或源自名字的过程的地址。在C，C++，Java，Object-C，Fortran，微指令和汇编里
这个参数是函数名function（或者是一个有效表达式的一个特例）。在Pascal和Modula-2，是
&function。在Ada里，是function’Address（虽然Pascal形式也可用）。
这中形式指定函数第一个指令的位置，这个位置是在堆栈帧和参数建立前的。
‘filename’::funcaddr
和上面的funcaddr类似，不过还指定了源文件名。这个形式在只指定函数名会造成歧义的时候很
有用，例如，如果在不同的文件里有多个函数都具有相同的名字时。
7.3 编辑源文件
要编辑源文件里的内容，用edit命令。你选择的编辑程序将被调用，并将程序里的当前行设置为激活行。另外，
有几种方式可以指定你希望打印文件的哪部分，如果你要想看程序的其它部分的话。
edit location
编辑指定为location的源文件。编辑从location开始，例如，在指定文件的指定行赏。参见7.2节[指定位
置]，68页，所有位置参数的可能形式；下面是edit命令最常用的形式：
edit number
将行number作为激活行编辑文件。
edit function
编辑包含函数function的文件，在其定义的开头开始编辑。
7.3.1 选择编辑器
GDB可以定制你所期望的任意编辑器（注1）。缺省的，是’/bin/ex’，但你可以在运行GDB前，设置环境变量
EDITOR来改变。例如，要配置GDB实用vi编辑器，在sh shell里用下面的命令：
EDITOR=/usr/bin/vi
export EDITOR
gdb …
（注1，唯一的限制在于，你的编辑器要识别如下命令行语义：ex +number file
可选的数值+number指定文件的行号。
）
或者在csh shell里，
setenv EDITOR /usr/bin/vi
gdb …
7.4 搜索源文件
有两个命令可以用正则表达式在当前文件里搜索。
forward-search regexp
search regexp
命令’forward-search regexp’检查每一行，从最近列出的行开始，查找正则表达式regexp的匹配项。命
令列出找到的行。也可以用同义词’search regexp’或缩写命令为fo.
reverse-search regexp
命令’reverse-search regexp’检查每一行，从最近列出的行往后，查找正则表达式regexp的匹配项。命
令列出找到的行。缩写为rev。
7.5 指定源文件目录
可执行程序有时并不记录源文件编译的目录，只记录名字。即使它们记录了，目录也可能在编译和调试期间被移
动了。GDB一个目录列表来搜索源文件；这些目录称为源代码路径。每次GDB需要源文件时，它都会尝试在所有的目
录列表里搜索，以它们在列表里的顺序进行，直到GDB找到所查询的文件。
例如，假设一个可执行文件引用了文件’/usr/src/foo-1.0/lib/foo.c’并且我们的源代码路径是’/mnt/cross’。
GDB首先会从字面上去查找；如果失败了，会在’/mnt/cross/usr/src/foo-1.0/lib/foo.c’里查找；如果还是失败
，会查找’/mnt/cross/foo.c’；如果再失败的话，会打印一个错误消息。GDB不会查找部分的路径名，例如
‘/mnt/cross/src/foo-1.0/lib/foo.c’。类似的，源代码路径的子目录也不会搜索：如果源代码路径是
‘/mnt/cross’,并且二进制文件引用了’foo.c’，GDB不会去’/mnt/cross/usr/src/foo-1.0/lib’路径下查找。
简单文件名，带先导路径的相对文件名，包含点的文件名（点文件）等等，都如上所述查找；比如，如果源代码
路径是’/mnt/cross’，并且像’../lib/foo.c’这样记录的话，GDB会首先尝试’../lib/foo.c’，接着
‘/mnt/cross/../lib/foo.c’，最后是’/mnt/cross/foo.c’。
注意，可执行文件搜索路径不用于定位源代码文件。
无论何时你重新设置或组织了源代码路径，GDB会清除任何缓存的关于路径和文件行的信息。
当你启动GDB时，它的源代码路径只包含’cdir’和’cwd’，且以此顺序排列。要增加其它目录，用directory命令。
搜索路径用于查找程序源文件和GDB脚本文件（读用’-command’选项和’source’命令）。
除了源文件路径，GDB提供了一些命令来管理源代码路径列表替换的规则。替换规则说明了在编译和调试期间目
录被移动的情况下，如何来重写存储于程序调试信息里的源代码目录。一个规则是由两个参数组成的，第一个参数
指定需要重写的路径，第二个参数指定这个路径如何重写。在[设置替换路径]，72页里，我们将这两个部分命名为
from和to。GDB简单的用to将from的源文件名的开头目录部分替换掉，并用替换后的结果来搜索源文件。
还用前例，假设’foo-1.0′目录树已从’/usr/src’移动到’/mnt/cross’，然后让GDB用’/mnt/cross’替换所有路径
的’/usr/src’。首先在路径’/mnt/cross/foo-1.0/lib/foo.c’查询，替代原来的路径’/usr/src/foo-1.0/lib/foo.c’。
要定义一个源代码路径替换规则，用set substitute-path命令（参见[设置替换路径]，72页）。
要避免意外的替换结果，规则只在目录名的from部分以目录分隔符结尾的情况下才应用。例如，用’/usr/source’
替换’/mnt/cross’的话，会得到’/usr/source/foo-1.0′，而不是’/usr/sourceware/foo-2.0′。并且替换规则只应
用于目录名的开头部分，这个规则不会得到’/root/usr/source/baz.c’的结果。
在很多情况下，可以用directory命令来达到相同的效果。然而，在源文件分布于一个复杂的，带有多个子目录
的目录树时，set substitute-path会更有效率。用directory命令的话，用户需要添加项目的每一个子目录。如果
将整个目录移动且保持内部代码组织的话，那么set substitute-path允许你只用一个命令就可以将调试器导向到
所有的源文件。
set substitute-path也不仅仅只是一个快捷命令。源代码路径只用于原目录下的文件不再存在的情况下。另一
方面，set substitute-path修改调试器行为模式来在重写的位置上搜索文件。所以，如果有任何原因导致源代码
文件相对于可执行程序的位置发生了改变，替换规则是唯一可以通知GDB新位置的方法。
directory dirname …
dir dirname …
在源代码路径前加上目录dirname。可以将几个目录名传递给这个命令，用’:'分隔（在MS-DOS和
MS-Windows是’;'，’:'通常是一个绝对路径名的一部分），或者用空格分隔。可以指定已存在的目录；这
会将此目录前移，GDB就能更快的搜索到它了。
可以用字符串’$cdir’来指代编译目录（如果已记录的话），’$cwd’指代当前工作目录。’$cwd’和’.'不相
同—前者记录在GDB调试会话期间变动的当前工作目录，后者则在你将一个目录添加进源代码路径时立即
展开为当前目录。
directory
将源代码路径重置为默认值（Unix系统下是’$cdir:$cwd’）。这个命令要求确认。
show directories
打印源代码路径：显示包含那个目录。
set substitute-path from to
定义一个源代码路径替换规则，并将其填加到当前替换规则列表的尾部。如果有相同的from规则存在的话
，那么旧的规则就会被删除。
例如，如果文件’/foo/bar/baz.c’移动到’/mnt/cross/baz.c’,那么命令
(gdb) set substitute-path /usr/src /mnt/cross
告诉GDB用’/mnt/cross’替换’/usr/src’,这就可以让GDB查找到’baz.c’,即使它已经移走了。
如果定义了多个替换规则，那么GDB会以规则定义的顺序一个接一个的计算它们。如果有的话，第一个匹
配项就会进行替换。
例如，如果我们输入了下列命令：
(gdb) set substitute-path /usr/src/include /mnt/include
(gdb) set substitute-path /usr/src /mnt/src
GDB会用第一个规则将’/usr/src/include/defs.h’用’/mnt/include/defs.h’替换。不过，它会用第二个
规则将’/usr/src/lib/foo.c’用’/mnt/src/lib/foo.c’替换。
unset substitute-path [path]
如果指定了path的话，在当前替换规则列表里搜索要重置的规则。如果找到的话就删除之。如果没有找到
的话，调试器会输出一个警告信息。
如果没有指定path的话，那么所有的替换规则都将被删除。
show substitute-path [path]
如果指定了path，那么打印打印源代码路径替换规则，如果有的话。
如果没有指定path，那么打印所有的替换规则。
如果源代码路径混杂着一些不再有用的目录的话，GDB可能在某些情况下造成错误的代码版本的混淆。可以用下
列命令来纠正这种错误：
1.用不带参数的directory命令来重置源代码路径为默认值。
2.用带正确参数的directory来添加你需要的目录。可以用一个命令将所有的路径添加。
7.6 源代码和机器代码
可以用命令info line将源代码映射到程序地址上（反过来一样），命令disassemble可以显示一定范围的机器指
令。在GNU Emacs模式下运行时，info line命令会引起箭头指向指定的行。而且，info line打印符号形式的地址
，也打印16进制的地址。
info line linespec
打印指定的源代码行的编译代码，从开始到结尾的地址。可以指定源代码行，7.2节[指定位置]，68页里
讨论的任意形式。
例如，我们可以用info line来查找函数m4_chagequote的第一行的目标代码：
(gdb) info line m4_changequote
Line 895 of “builtin.c” starts at pc 0x634c and ends at 0×6350.
我们也可以查询（用*addr作为linespec的形式）哪一行源代码对应一个特定的地址：
(gdb) info line *0x63ff
Line 926 of “builtin.c” starts at pc 0x63e4 and ends at 0×6404.
在info line后，x命令的缺省地址就变为这行的开头地址，所以’x/i’足以开始检查机器代码（参见8.5节[检查
内存]，79页）。而且，这个地址也存储与变量$_里（参见8.9节[便利的变量]，89页）。
disassemble
这个命令将一段内存作为机器指令转储。缺省的内存范围是选定堆栈帧的程序计数器所代表的函数。单个
参数的话是程序计数器的值；GDB转储值个值附近的函数。两个参数指定要转储的地址范围（第一个是开
始，第二个是结束）。
下面的例子显示了反汇编一个HP PA-RISC 2.0上的一段代码：
(gdb) disas 0x32c4 0x32e4
Dump of assembler code from 0x32c4 to 0x32e4:
0x32c4
0x32c8
0x32cc
0x32d0
0x32d4
0x32d8
0x32dc
0x32e0
End of assembler dump.
某些架构有多个通用的指令助记符或者同义词。
对于动态链接的和使用共享库的程序，调用函数或位于共享库的分支位置的指令可能显示伪地址–这个地址是重
定位表的位置。在某些架构里，GDB可以将这些伪地址映射到函数名上。
set disassembly-flavor instruction-set
用disassemble或x/i命令反汇编程序时，选择指令集。
目前这个命令只在Intel x86族平台上定义。可以设置指令集为intel或att。默认是att，基于x86系统的
Unix汇编器默认使用AT&T风格。
show disassembly-flavor
显示当前反汇编风格的设置。
GDB手册8:查看数据
第八章 查看数据
在程序里查看数据的常用方式是用print命令（缩写为p），或者用它的同义命令inspect。print命令会计算和打印用程序语言写的表达
式的值（参见12章[不同语言下使用GDB]，127页）。
print expr
print /f expr
expr是表达式（用程序语言写的）。缺省情况下，expr的值会以它的数据类型相近的格式打印；也可以用’/f’选择不同的格式，f是
格式描述符；参见8.5节[输出形式]，85页。
print
print /f
如果省略了expr，GDB将显示最后一次的值（从值的历史记录里；参见8.9节[值历史记录]，96页）。这个命令允许用户方便的换
一种格式查看相同值。
用x命令可以在更低层次上查看数据。x命令检验一个指定位置上的数据，并且以指定格式打印出来。参见8.6节[查看内存]，87页。
如果对数据类型感兴趣的话，或者想知道一个结构体或类里的一个域是如何声明的话，用ptype expr命令取代print命令就可以做到了。
参见13章[查看符号表]，151页。
8.1 表达式
print 很许多其他GDB命令一样接受一个表达式作为参数并且计算它的值。在GDB里，程序里定义的任意类型的常量，变量或者操作符都是有效的表达式。包括条件表 达式，函数调用，类型转换和字符串常量。也包括预定义宏，如果在编译程序时包含了的话；参见4.1节[编译]，25页。
GDB支持用户输入的表达式里包含数组常量。语法是{element,element…}。例如，可以用命令print {1,2,3}来在内存里建立一个数组，
而这个数组是目标系统里在自由堆里分配的。
由于C应用的如此广泛，因此本手册里的大多数例子里的表达式都是用C写的。关于在其它语言里如何使用表达式的信息，参见12章[不同语言下使用GDB]，119页。
在这节里，讨论可用于GDB表达式的与编程语言无关的操作符。
GDB支持下列操作符，另外还有其它编程语言可以通用的操作符：
@ ‘@’是二进制操作符，将一块内存作为数组。更多信息，参见8.3节[伪数组]，77页。
:: ‘::’可以指定一个文件或函数里定义的变量。参见8.2节[程序变量]，76页。
{type} addr
引用存储于addr位置上的type类型的对象。addr可能是一个表达式，其值是一个整型或是指针（但需要圆括号来进行类型转换）。
无论在addr地址上存储的数据是何种类型，这个用法都是允许的。
8.2 程序变量
在程序里，最常用的表达式类型是使用变量的名字。
表达式里的变量应理解为存储与一个特定的堆栈帧里（参见6.3节[选择一个帧]，64页）；变量可以是下列两种：
·全局变量（或是文件里的静态变量file-static）
·根据编程语言的变量生存规则，在当前执行的堆栈帧上是可见的变量
这意味着在函数
foo (a)
int a;
{
bar (a);
{
int b = test ();
bar (b);
}
}
程序在函数foo里执行时，用户可以检查和使用变量a，但只能在程序执行于b声明的块内（函数bar）使用或检查变量b。
有一个例外：可以引用生存期是单个文件的变量或函数，即使当前执行点不在这个文件上。不过，很有可能有多个变量
或函数有相同的名字（在不同的源文件）。如果那样的话，引用重名的变量可能会有预想不到的效果。如果需要，可以
指定一个特定函数或文件的静态变量，用双冒号（::）标记：
file::variable
function::variable
这里的file或function是这个静态变量的上下文的名字。对于文件名，可以用两个单引号将文件名包起以让GDB将其作为
一单个词分析–例如，要打印’f2.c’文件里定义的全局变量x:
(gdb) p ’f2.c’::x
与在C++相同符号的用法相比，C的’::’ 的用法很少有冲突。GDB也支持C++生存期操作符。
警告：偶尔的，一个本地变量可能在函数的某些点上显示错误的值–在进入一个新的生存期后和在离开前。
在用机器指令单步跟踪程序的时候，可能碰到这个问题。这是因为，在大多数机器里，需要多于一个的指令才能建立一个
堆栈帧（包括本定变量定义）；如果你是用机器指令来单步跟踪的话，变量就可能显示错误的值，直到堆栈帧完全建立为止。
在退出时，通常也需要多个机器指令才能销毁堆栈帧；在你开始单步执行通过这组指令的过程中，本地变量的定义可能已经
消失了。
这个问题也可能在编译器做了显著优化的时候碰到。要确保总是得到精确的值的话，在编译时关闭优化选项。
编译器优化结果所带来的另一个潜在影响是将没有用到的变量优化掉了，或者叫爱那个变量存储于寄存器（而不是内存地址
上）。由于依赖于编译器提供的调试信息格式对于此类问题的支持，GDB可能不能显示这些本地变量的值。如果真的这样，GDB
会打印类似如下的消息：
No symbol “foo” in current context.
要解决这些问题，要么不带优化选项重新编译，要么使用一个不同的调试信息格式，如果编译器支持多种格式的话。例如，
GCC，GNU C/C++编译器，通常支持’-gstabs+’选项。’-gstabs+’产生优于普通调格式（如COFF）的调试信息。可以用DWARF 2
（’-gdwarf-2′）,这也是一个有效的调试信息格式。参见节”调试程序或GCC的选项”。参见12.4.1节[C和C++],123页，更多关于
最佳C++程序调试信息格式的信息。
如果需要打印一个GDB未知其内容的对象，例如，由于调试信息没有完全说明它的数据类型，GDB会打印’
更多信息，参见13章[符号]，143页。
字符串是定义为无符号的char数组。signed char或unsigned char会以1字节宽度的整形数组打印。由于GDB定义字符串类型type
‘char’为无符号类型，-fsigned-char或-funsigned-charGCC选项不会起效。对于程序代码
char var0[] = “A”;
signed char var1[] = “A”;
可以在调试时得到下列信息
(gdb) print var0
$1 = “A”
(gdb) print var1
$2 = {65 ’A’, 0 ’\0’}
8.3 伪数组
打印几个在内存里连续的相同类型的对象，常常是很有用的；数组的一节，或一个动态决定大小的数组，在程序里只有一个指针存在。
用二进制操作符’@'将一个连续的内存区域作为伪数组,可以达到这个目的。’@'的左操作数应该是目标数组的第一个元素，并且是一个
单独的对象。右操作数应该是目标数组的长度。结果是整个数组的值，其元素都是左操作数的类型。第一个元素是左操作数；第二个元素
在内存中数紧邻着第一个元素，依此类推。下面是一个例子。如果程序
int *array = (int *) malloc (len * sizeof (int));
可以用下面命令打印数组的内容
p *array@len
‘@’的左操作数必须存在于内存中。用’@'打印的数组值和用其它下标索引得到的值一样，并且会在表达式里强制转换为指针。伪数组
常常通过值历史在表达式里出现（参见8.8节[值历史]，88页），在打印过后。
另一种创建伪数组的方法是使用强制转化。转化会将一个值作为一个数组对待。这个值不一定在内存里：
(gdb) p/x (short[2])0×12345678
$1 = {0×1234, 0×5678}
为方便起见，如果不指定数组长度（如’type[]value’）,GDB会计算这个伪数组合适的长度（如’sizeof(value)/sizeof(type)’）:
(gdb) p/x (short[])0×12345678
$2 = {0×1234, 0×5678}
有时伪数组机制还不够；在相当复杂的数据结构里，结构体里的元素可能不是真的相邻–例如，如果你需要的元素在结构体里声明为指
针。一个有用的变通方法（参见8.9节[惯用变量]，89页）是在表达式里使用惯用变量作为计数器，记录第一个值，然后通过回车键重复执行表达式。例如，假设有一个结构体数组名为dtab，其结构体定义了一个指针fv。下面是一个使用dtab的例子：
set $i = 0
p dtab[$i++]->fv
…
8.4 输出格式
缺省的，GDB根据数据类型打印数据值。不过，有时这种方式可能不是你想要的。例如，你可能要以16进制打印一个数值，或者以10进
制打印一个指针。或者你想要查看内存中某个地址上的数据，作为字符串或者一个指令。要做到这些，在打印值的时候指定输出格式就可
以了。
最简单的输出格式的用法是指定如何打印一个已计算过的值。要达到这个目的，在命令print后加上反斜杠’/'和一个格式符号就可以。
格式符号如下：
x 将数值作为整型数据，并以16进制打印。
d 打印带符号整型数据
u 打印以无符号整型数据
o 以8进制打印整形数据
t 以2进制打印整形。’t'代表’two’(注一).
注一：’b'不能用，因为这个格式在x命令里也用到了，x命令里’b'代表’byte’;参见8.5节[查看内存]，79页。
a 打印地址，打印16进制的绝对地址和最近符号的偏移量。可以用这个格式找出一个未知地址的位于何处（在哪个函数里）：
(gdb) p/a 0×54320
$3 = 0×54320 <_initialize_vx+396>
命令info symbol 0×54320也能得到相似的结果。参见13章[符号]143页。
c 将一个整型以字符常量打印。会打印一个数值和它表示的字符。超出7位的ASCII的数值（大于127）的字符用8进制的数字替代打
印。
不用这个格式的话，GDB将char，unsigned char和signed char数据作为字符常量打印。单字节的向量成员以整型数据打印。
f 将数据以浮点类型打印。
s 如果可能的话，以字符串形式打印。用这个格式，指向单字节数据的指针将以nll结尾的字符串打印，单字节数据的数组则会
以定长字符串打印。其它的值以它们原本类型打印。
不用这个格式的话，GDB将指向char，unsigned char和signed char作为字符串打印，这些类型的数组也同样处理。单字节向量
的成员以整型数组打印。
例如，要以16进制打印程序计数器（参见8.10节[寄存器]，90页），输入
p/x $pc
注意，在反斜杠前不需要空格；这是由于GDB里的命令名不能包含一个反斜杠。
要用其它格式打印最近值历史里的值，可以用print命令带一个格式就可以了，不用指定表达式。例如，’p/x’会以16进制打印最近的
值。
8.5 查看内存
可以用命令x（表示”examine”）以多种格式查看内存，而和程序数据类型无关。
x/nfu addr
x addr
x 用x命令查看内存。
n，f和u都是可选的参数，指定打印多长的内存数据和以何种格式打印之；addr是需要打印的内存的地址表达式。如果用默认的nfu，不
需要输入反斜杠’/'。有几个命令可以方便的设置addr的默认值。
n，重复次数
10进制整数；默认是1。指定显示多长的内存（需要和单元长度u一起计算得到）。
f，显示格式
显示格式和print命令的格式一样（’x',’d',’u',’o',’t',’a',’c',’f',’s'），外加’i'（表示机器指令格式）。默认是’x'（16
进制）。默认格式在用x或print命令的时候都会改变。
u，单元大小
单元大小如下：
b 字节
h 2节节
w 4字节。默认值。
g 8字节。
每次用x指定单元长度，这个长度就成为默认值，知道下一次用x再设置。（对于’s'和’i'格式，单元长度会被忽略而不会改写）
addr，要打印的起始位置
addr是要GDB开始打印的内存起始位置。表达式不需要指针值（虽然其可能是一个指针值）；这个表达式总会翻译为内存中一个
字节的整型地址。参见8.1节[表达式]，75页，更多关于表达式的信息。默认的addr通常是紧随最近查看地址之后–但其它几个
命令也可以设置默认地址：info breakpoints（设置为最近断点的地址），info line（设置一行代码的起始地址），和print（
如果用了print来显示内存中的一个值）。
例如，’x/3uh 0×54320′打印3个半字（6字节）的内存数据，以10进制整型格式打印（’u'），从地址0×54320开始。’x/4xw $sp’打印4
个字（’w'）的内存数据，以16进制从堆栈指针指向的内存开始（这里’$sp’；参见8.10节[寄存器]，90页）打印。
由于制定单元长度的字符和制定输出格式的字符是截然不同的，因此不需要记住单元长度和格式字符的先后顺序；无论哪个在先都可以
。输出格式声明’4xw’和’4wx’是一样的。（不过，次数n必须在先；’wx4′就是无效的。）
即使对于格式’s'和’i'来说单元长度u是忽略不计的，用户也可能要用一个计数n；例如，’3i’指定要看3个机器指令，包括操作数。为方便起见，特别 是在用display命令时，’i'格式会超过计数所知定的长度打印延迟转移槽指令，如果有的话，这个转移指令就紧接在计数长度的指令之后。 disassemble命令提供了另一种查看机器指令的方式；参见7.6节[源代码和机器代码]，72页。
x命令的全部缺省参数都为方便的继续扫描内存而设计的，这样每次继续使用x命令的时候就只需要很少的指定了。例如，用’x/3i addr’命令查看机器指令后，可以只用’x/7′来查看下7个指令。如果用回车键来重复x命令的话，就会重复n次;其它参数就成为接下来的x命令的缺省 值。
由于x命令打印的地址和内容通常是非常多而且可能会变成瓶颈，因此不会在值历史里保留。 相反，GDB将那些在后续表达式里用到的值形成惯用变量$_和$__。一个x命令之后，最后被查看的地址可以用惯用变量$_来在表达式里引用。这个地址的 内容，如前所查，可以用变量$__来引用。如果x命令带有重复次数参数，地址和内容会保存最后打印的内存单元；如果有多个单元在最后一行打印的话，就不是 记录最后打印的地址。
如果调试一个在远程机器上运行的程序（参见17章[远程调试]，179页），你可能希望确认和下载到远程机器上的可执行文件相比的内存中的程序文件。compare-sections命令提供了这样的功能。
compare-sections [section-name]
用可执行文件里的名为section-name的可加载段数据和远程机器内存中相同的段数据比较，并且打印不匹配的数据。如果不带参数，比
较所有的可加载段数据。这个命令的可用性依赖于系统对于”qCRC”远程请求的支持与否。
8.7 自动显示
如果你觉得需要频繁打印一个表达式的值（来查看其如何改变的），可能要把它加到自动显示列表里让GDB在每次程序中断时打印这个表达式的值。每个加入列表的表达式会有一个编号来标识；要将一个表达式从列表里删除，可以用这个编号。自动显示如下所示：
2: foo = 38
3: bar[5] = (struct hack *) 0×3804
这个输出显示了条目编号，表达式和它们目前的值。如同你手工用x或print命令那样打印输出那样，可以指定你喜欢的输出格式；事实上
display命令决定是用print还是用x命令，这取决于你指定的格式–如果你指定了’i'或者’s'格式的话，或者有一个单元长度的话，就用x；
否则就用print。
display expr
将表达式expr加入表达式列表，每次程序中断时自动显示。参见8.1节[表达式]，75页。
在时候此命令后再按回车键时，display不会重复执行。
display/fmt expr
fmt只指定显示格式，不指定大小和次数，将表达式expr加入自动显示列表；每次用指定格式fmt输出。参见8.4节[输出格式]，
78页。
display/fmt addr
对于’i'或者’s'格式，或者包含一个单元长度或一个单元数量的话，将表达式addr作为一个要查看的内存地址加入列表，每次程
序中断的时候打印。”查看”用’x/fmt addr’命令来实现。参见8.5节[查看内存]，79页。
例如，要在每次执行中断时查看机器指令，’display/i $pc’就很有用的（’$pc’是程序计数器的通用名；参见8.10节[寄存器]，90页）。
undisplay dnums…
delete display dnums…
从显示列表中删除编号为dnums的显示项。
在执行undisplay后再回车的话，undisplay不会重复。（否则你会得到’No display number….’的错误信息）
disable display dnums
禁用编号为dnums的显示项。禁用的显示项不会自动输出，但系统仍会记录它。可以再次激活。
enable display dnums…
激活编号为dnums的显示项。会再次自动显示其表达式的值，直到你禁用它。
display
显示当前列表中的变大是的值，就如同程序中断那样输出。
info display
打印此前设置的自动显示列表里的表达式，每个表达式带一个编号，但不显示其值。包括禁用的表达式，这类表达式会标明为禁
用。也包括目前不能显示的表达式，这类表达式引用了当前不可用的自动变量。
如果显示表达式引用了本地变量，那么在其设置范围外是没有意义的。在执行到其变量无定义的上下文时，这类表达式会被禁用。
例如，如果你在一个函数内执行了命令display last_char，last_char是此函数的参数，GDB会在程序再次执行到这个函数并在此函数中断
时自动显示此参数。要是在别的位置中断的话–那里没有变量last_char–就会将此显示项自动禁用。下次程序在last_char有意义的位置中
断时，可以再次激活这个显示表达式。
8.7 打印设置
GDB提供如下数组，结构体和符号的打印设置方法。在任何语言里下列设置对于调试都是很有用的：
set print address
set print address on
GDB打印内存地址，显示堆栈回溯的位置，结构体的值，指针值，断点等等，甚至在其也显示哪些地址上的内容时。缺省是on。
例如，下面是用set print address on来设置后，堆栈帧的输出：
(gdb) f
#0 set_quotes (lq=0x34c78 “<<”, rq=0x34c88 “>>”)
at input.c:530
530 if (lquote != def_lquote)
set print address off
在现实其值的时候不打印地址。例如，下面是用set print address off设置后相同的堆栈帧的输出：
(gdb) set print addr off
(gdb) f
#0 set_quotes (lq=”<<”, rq=”>>”) at input.c:530
530 if (lquote != def_lquote)
可以用’set print address off’来从GDB接口中取消所有机器相关的显示。例如，使用print address off，可以在所有机器上
得到相同的内容的回溯–不论时候牵涉到指针参数。
show print address
显示是否打印地址。
GDB打印符号的地址时，通常会打印离此地址最近且位置靠前的符号，外加打印偏移。如果符号不能指定位置的地址（例如，在一个文
件里的一个名字），你就需要确认它。一个确认的方法是用info line，例如’info line *0×4537′。另外一方法是，在打印一个符号的地
址时设置GDB要打印的源文件和行号：
set print symbol-filename on
设置GDB要打印的符号的源文件名和行号。
set print symbol-filename off
不打印符号的源文件名和行号。默认方式。
show print symbo-filename
显示是否打印符号的源文件名和行号。
显示符号文件名和行号的另外一种有用的情况是，在反汇编代码时打印文件名和行号。GDB会显示相应于每个指令的行号和源文件。
另外，你可能希望确认被打印地址的符号形式是否是离得最近且位置考前的符号：
set print max-symbolic-offset max-offset
设置GDB只显示地址的符号形式，如果偏移是在最近且靠前的符号和比max-offset低的地址区间。缺省值是0，GDB总是打印比
此地址靠前的符号。
show print max-symbolic-offset
显示GDB打印一个符号地址的最大偏移量。
如果有一个指针但不能确定它指向何处，可以用’set print symbol-filename on’来尝试。然后用’p/a pointer’来确认此指针指向的
名字和源文件的位置。这个命令可以将地址转换为符号形式。例如，下面是GDB显示的变量ptt指向另一个变量t,于’hi2.c’定义：
(gdb) set print symbol-filename on
(gdb) p/a ptt
$4 = 0xe008
警告：对于执行一个本地变量的指针，’p/a’不显示涉及到符号名和文件名，即使是把相关的set print选项打开也如此。
其他设置控制如何打印不同类型的对象的方法如下：
set print array
set print array on
以习惯方式打印数组。这个格式更便于阅读，但要更多空间。默认是关闭的。
set print array off
返回到压缩方式打印数组。
show print array
显示何种方式显示数组。
set print array-indexes
set print array-indexes on
在打印数组的时候打印每个数组成员的下标。可以方便的找到一个给定的数组成员的位置，或者查找一个给定成员的下标。缺省
是关闭的。
set print array-indexes off
在现实数组时，不打印数组成员下标。
show print array-indexes
显示在打印数组时是否输出成员下标。
set print elements number-of-elements
设置GDB打印的数组成员的数量。如果GDB打印一个大数组，在打印完set print elements命令设置的限制之后就不再继续打印此
数组成员。这个限制也会应用于字符串打印。GDB启动时，这个限制设置为200。将number-of-element设置为0意味着打印数组时
没有长度限制。
show print elements
显示GDB打印大数组的长度。如果是0，那么没有限制。
set print frame-arguments value
这个命令允许控制在调试器打印一个堆栈帧的时候，如何打印参数的值（参见6.1节[帧]，61页）。可能的值：
all 打印所有的参数值。缺省的。
scalars 只打印非向量参数。复杂的参数如数组，结构体，联合等，用…替代。下面是非向量参数的打印例子：
#1 0×08048361 in call_me (i=3, s=…, ss=0xbf8d508c, u=…, e=green)
at frame-args.c:23
none 不打印参数。所有的参数都用…替代。下面是这样的例子：
#1 0×08048361 in call_me (i=…, s=…, ss=…, u=…, e=…)
at frame-args.c:23
缺省的，总是打印所有的参数。不过这个命令在好几情况下是非常有用的。例如，在打印每个帧时可以用来减少输出的信息，使
得回溯更加可读。而且，在打印Ada帧时这个命令可以提高执行效率，因为有时大参数的计算可能是CPU密集型的，特别是在大程
序里。设置print frame-arguments为scalars或none可以避免这类运算，因此可以加速打印Ada帧。
show print frame-arguments
显示打印帧时如何显示参数。
set print repeats
设置打印数组的长度上限值。如果数组中连续相同的成员的数量超过这个上限，GDB会打印字符串”
是同样的重复次数，而不是重复打印这些相同的成员。将这个上限设置为0的话，打印所有的成员。默认上限时10。
show print repeats
显示打印重复相同成员的上限数量。
set print null-stop
设置GDB在初次遇到NULL字符是终止打印字符串。如果大数组里包含短字符串时很有用。默认关闭。
show print null-stop
显示GDB是否在初次遇到NULL字符串时停止打印。
set print pretty on
设置GDB在打印结构体时，以缩进的格式每行打印一个结构体成员，如下：
$1 = {
next = 0×0,
flags = {
sweet = 1,
sour = 1
},
meat = 0×54 “Pork”
}
set print pretty off
设置GDB以紧凑方式打印结构体，如下所示：
$1 = {next = 0×0, flags = {sweet = 1, sour = 1}, \
meat = 0×54 “Pork”}
默认方式。
set print sevenbit-strings on
只打印7bit的字符串。如果设置了这个选项，GDB用\nnn来显示8bit字符。如果在英语（ASCII）环境下执行或者将高位作为标记
位或作为元数据位的话，这个设置是非常有用的。
set print sevenbit-strings off
打印8bit字符。允许使用国际化字符集，缺省的。
show print sevenbit-strings
显示GDB是否打印7bit字符。
set print union on
设置GDB打印包含结构体或其他联合的联合。缺省设置。
set print union off
设置GDB不打印包含结构体或其他联合的联合。GDB用”{…}”替代之。
show print union
显示GDB是否打印包含结构体和其它联合的联合。
例如，假设下列声明
typedef enum {Tree, Bug} Species;
typedef enum {Big_tree, Acorn, Seedling} Tree_forms;
typedef enum {Caterpillar, Cocoon, Butterfly}
Bug_forms;
struct thing {
Species it;
union {
Tree_forms tree;
Bug_forms bug;
} form;
};
struct thing foo = {Tree, {Acorn}};
设置set print union on，’p foo’会打印如下输出：
$1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}}
设置set print union off，’p foo’会打印如下输出：
$1 = {it = Tree, form = {…}}
set print union对于类似C和Pascal的程序有效。
下面这些设置对于调试C++程序很有用：
set print demangle
set print demangle on
用源代码的形式打印C++名，而不是用编码后传递给汇编器和连接器的形式。默认打开。
show print demangle
显示是否用源码形式打印C++名。
set print asm-demangle
set print asm-demangle on
用源代码的形式打印C++名，而不用编码形式，即使在汇编代码的输出如指令反汇编。默认关闭。
show print asm-demangle
显示是否用源码形式打印汇编代码。
set demangle-style style
从编码方式中选择一种编码体系，解析C++名。style的选择有如下几种：
auto 设置GDB通过探测程序来选择一种解码方式。
gnu 基于GNU C++编译器(g++)的编码算法的解码方式。缺省方式。
hp 基于HP ANSI C++（aCC）编码算法的解码方式。
lucid 基于Lucid C++编译器编码算法的解码方式。
arm 用C++ Annotated Reference Manual里定义的算法解码。警告：这个选项不足与调试cfront产生的可执行程序。GDB要
改进才能调试此类程序。
如果忽略了style，可能会看多多种格式的输出。
show demangle-style
显示目前C++符号解析使用的编码方式。
set print object
set print object on
在打印一个指针指向的对象时，使用虚函数表来标明对象真实的类型，而不是其声明的类型。
set print object off
只显示对象所声明的类型，不引用虚函数表。默认选项。
show print object
显示是否打印真实的，或声明的对象类型。
set print static-members
set print static-members on
打印C++对象的静态成员。选项缺省打开。
set print static-members off
打印C++对象时不打印静态成员。
show print static-members
显示是否打印C++静态成员。
set print pascal_static-members
set print pascal_static-members on
打印Pascal对象的静态成员。选项默认打开。
set print pascal_static-members off
不打印Pascal对象的静态成员。
show print pascal_static-members
显示是否打印Pascal静态成员。
set print vtbl
set print vtbl on
以习惯方式打印C++虚函数表。默认关闭。（vtbl命令在HP ANSI C++编译器（aCC）编译的程序上无效。）
set print vtbl off
不以习惯方式打印C++虚函数表。
show print vtbl
显示是否以习惯方式打印C++虚函数表。
8.8 值历史
以print命令打印的值保存于GDB值历史里。这种方式使得在其它表达式里引用这些值。值会保留到符号重载或者被丢弃（例如用file或
者symbol-file命令）。在符号表改变时，值历史会被丢弃，因为值可能包含指向符号表里定义的类型。
打印过的值在历史表里都有编号，可以用此编号来引用值。这个编号是从1开始的连续整数。print在打印值的时候会在值前打印’$num=
‘，num是历史表里的编号。
要引用此前的值，用’$'后接值历史编号就可以了。print打印标记’$'就是提醒你这个的。只有一个$指最近的值，$$指倒数第二近的值
。$$n指倒数n近的值；$$2是比$$靠前一个的值，$$1和$$相等，$$0和$相等。
例如，假设刚打印过一个指针指向的结构体，想要查看这个结构体的内容。输入下列命令就可以了：
p *$
如果有一个结构体链表，其结构体里有一个成员next指向下一个结构体，可以用下面的命令来打印下一个结构体的内容：
p *$.next
可以重复执行这个命令来连续打印这个链表–只需要输入回车键。
注意，值历史记录值，不记录表达式。如果x的值是4，输入如下命令：
print x
set x=5
那么值历史里记录的值是4，即使x的值已经变为5了。
show values
打印值历史表里最近的10个值，带其编号打印。和’p $$9′重复类似，除了show values不改变值历史。
show values n
打印值历史表里的10个记录，以编号n为中心打印。
show values +
打印最近打印过的值前的10个值。如果没有记录，show values +不产生输出。
输入回车键来重复show values n和’show values +’效果一样。
8.9 惯用变量
GDB提供了惯用变量，用户可以在GDB里用来存储数据，在以后引用。这类变量在GDB里全程存在；它们不是被调试程序的组成部分，设置惯用变量对程序执行没有直接影响。这就是为什么可以自由使用这类变量的原因。
惯用变量有个前缀’$'。任何前导’$'的名字都可以用作惯用变量，除非是已经定义好的，系统指定的寄存器名（参见8.10节[寄存器]，
90页）。（相反，引用值历史，是在数字前加’$'。参见8.8节[值历史]，88页）
可以将一个表达式的值保存在惯用变量里，就如同在程序里设置一个变量一样。例如：
set $foo = *object_ptr
可以将指针object_ptr指向的值保存在$foo里。
第一次使用惯用变量的时候会创建此变量，但其值是void，直到设置一个值为止。可以在任何时间改变此值。
惯用变量没有固定的类型。可以为惯用变量指定任意类型的值，包括结构体和数组，即使此变量已经有一个不同类型的值。惯用变量，
在一个表达式里用时，其类型是当前值的类型。
show convenience
打印目前为止的惯用变量列表和它们的值。缩写为show conv。
init-if-undefined $variable=expression
设置一个惯用变量，如果其尚未设置的话。对于用户定义的保持某些状态的命令而言很有用。在概念上和在C语言里带初始化的
使用本地静态变量很相似（除了惯用变量是全局的）。也可以用于覆盖在命令脚本里设置的缺省值。
如果变量已经定义了，那么不计算表达式，因此也就没有边际效应。
惯用变量的一种使用方式是作为一个增量计数器或者是一个指针。例如，要打印一个结构体数组成员里的域：
set $i = 0
print bar[$i++]->contents
用回车键重复命令。
有些惯用变量是GDB自动创建的，记录有用的值。
$_ 变量$_是x命令自动设置的，记录最近查看的地址（参见8.5节[查看内存]，79页）。其它提供一个默认地址给x来查看的命令也
会设置这个变量；这些命令包括info line和info breakpoint。$_的类型是void *；在x命令设置之后，其类型是$__的指针。
$__ 变量$__是x命令自动设置的，记录最近查看地址上的值。其类型是打印的数据所匹配的类型。
$_exitcode
变量$_exitcode在程序调试结束时自动记录退出码。
在HP-UX系统里，如果被引用的函数或变量名前有一个$符号，GDB会先搜索用户或系统名，其后再搜索惯用变量。
8.10 寄存器
在表达式里可以引用系统寄存器内容，将在寄存器名前置$符作为变量来用。寄存器名对于各系统可能不一样；使用info registers可
以查看系统的寄存器名。
info registers
打印所有的寄存器名和值，除了浮点和向量寄存器（在选定的堆栈帧里）。
info all-registers
打印所有的寄存器名和值，包括浮点和向量寄存器（在选定的堆栈帧里）。
info registers regname …
打印所有指定寄存器对应的值。如下面详细讨论的那样，寄存器值通常是相对于选定的堆栈帧的。regname可能是系统里可用的
，任意的寄存器名带不带’$'都可以。
GDB有4个在多数系统里可用的（在表达式里）”标准” 寄存器名–他们和系统标准的寄存器名总是不冲突的。寄存器名$pc和$sp由于记
录程序计数器寄存器和堆栈指针。$fp用于记录当前堆栈帧的指针，$ps用于记录处理器状态的寄存器。例如，可以用16进制打印程序计数
器：
p/x $pc
或者打印下一条要执行的指令
x/i $pc
或者将堆栈指针加4(注)：
set $sp += 4
只要有可能，这4个标准寄存器名在系统里都是可用的，即使系统有不同的命名，只要没有冲突就行。info registers命令显示标准寄
存器名。例如，在SPARC系统里，info registers显示处理器状态寄存器为$psr，但也可应用$ps来引用；在基于x86的系统里$ps是EFLAGS
寄存器的别名。
GDB总是将一个普通寄存器的内容作为一个整型值，寄存器也是这样查看的。某些系统具有只能存储浮点数据的特殊寄存器；这类寄存
器因此应该认为具有浮点类型的值。没有方法将普通寄存器作为浮点型来引用（虽然可以用用print将此寄存器作为浮点数打印，’print/
f $regname’）。
某些寄存器具有不同的’原始’和’虚拟’的数据格式。这意味着由操作系统设置的寄存器值的数据格式和程序通常得到的不一样。例如，
68881浮点协处理器的寄存器总是保存”扩展”（原始）的数据格式，但所有C程序会以”double”(虚拟)的格式处理。在这些情况下，GDB通
常以虚拟格式处理（程序能够处理的格式），但info registers命令会以两种格式打印这个数据。
注：这是从堆栈里删除一个字的方法，在系统内存中堆栈是向下增长的（现代多数系统）。这种方法假设选定的是最内层的堆栈帧；在选
定别的堆栈帧时不允许设置$sp，使用return；参见14.4节[从函数返回]，151页。
某些系统具有一些其它特殊的寄存器，它们的内容可以有多种转换方式。例如，现代基于x86的系统有SSE何MMX寄存器，它们以不同的格
式保存打包在一起的多个值。GDB用结构体方式来引用这些寄存器：
(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
}
要设置这类寄存器，需要告诉GDB要设置寄存器的哪部分，就如设置一个结构体的域那样：
(gdb) set $xmm1.uint128 = 0x000000000000000000000000FFFFFFFF
通常，寄存器值和选定堆栈帧是相对应的（参见6.3节[选择帧]，64页）。这就是说，如果已经退出所有更深层的堆栈帧并且已经保存了
它们的寄存器值的话，你就可以得到这些寄存器的值。要查看硬件寄存器里的真实内容，必须选择最内层的堆栈帧（用’frame 0′）。
然而，GDB需要从编译器产生的机器代码里推导出寄存器保存于何处。如果某些寄存器没有保存的话，或者GDB不能定位已保存的寄存器
的话，那么选定的堆栈帧就没法区分了。
8.11 浮点硬件
取决于是如何配置的，GDB可以提供关于浮点硬件的状态信息。
info float
显示挂于浮点单元的硬件相关的信息。确切内容和布局随浮点芯片不同而有所差异。目前，’info float’在ARM和x86平台上支持
。
8.12 向量单元
取决于是如何配置的，GDB可以提供关于向量单元的状态信息。
info vector
显示向量单元的信息。确切内容和布局随硬件不同而有所差异。
8.13 操作系统辅助信息
GDB提供操作系统有用的工具的接口，用户可以用来帮助调试程序。
如果运行于Posix系统（如GNU或者Unix系统），GDB通过系统调用ptrace和操作系统内部进行通信。操作系统为这个接口创建了特殊的数
据结构，称为struct user。可以用命令info udot 来显示这个数据结构的内容。
info udot
显示操作系统内核维护的struct user结构体的内容。GDB用类似于examine命令的形式来显示struct user内容，打印出16进制数
据的列表。
某些操作系统在程序启动时提供了一个辅助向量。这个向量等效于为程序指定的参数、环境变量，包含一些系统相关的二进制的值，让
系统库得到关于硬件，操作系统和进程的重要的细节。每个值的目的都由一个整数标签指定；其含义是众所周知而又系统相关的。取决于
配置和操作系统的工具，GDB可以显示这些信息。对于远程系统，这个功能可能进步依赖于远程存根对于’qXfer:suxv:read’包的支持，参
见[qXfer辅助向量读]，354页。
info auxv
显示内部辅助向量，此向量可以是一个正在执行的进程或者是一个core dump文件。GDB以数值形式打印每个标签，并显示名称和
对可识别的标签显示文字描述。向量里的某些值是数字，某些位(bit)是掩码，某些是指向字符串或其它数据的指针。GDB会以适
当的方式显示每个可识别的标签，对于不可识别的标签则以16进制的形式显示。
8.14 内存区域属性
内存区域属性提供了描述由系统内存请求的特殊处理的功能。GDB使用属性来判断是否允许某些类型的内存访问；是否使用明确的访问宽
度；时候缓存系统内存。缺省的，内存区域的描述取自系统（如果当前系统支持的话），但用户可以覆盖被取的区域。
已定义的内存区域可以单独的激活或禁用。如果禁用一个内存区域，GDB会在访问这个区域时使用缺省属性。类似的，如果没有定义内存
区域的话，GDB在访问任何内存时都使用缺省属性。
如果定义了内存区域，会有一个整数来标识；要激活，禁用或删除它的话，应该用这个编号。
mem lower upper attributes…
定义一个内存区域，从lower到upper，属性是attribute…，并将其加入由GDB监控的区域列表。注意，upper==0是个特殊例子：
当作系统最大内存地址。（16位系统里是0xffff，32位系统是0xffffffff）
mem auto
放弃用户对内存区域的改变，并使用系统提供的区域，如果有的话，如果系统不提供的话就不适用内存区域。
delete mem nums…
从GDB监控的内存列表里删除内存区域nums…。
disable mem nums…
禁止监视内存区域nums…被禁用的内存区域不会被遗忘。可以在此激活之。
enable mem nums…
激活监控内存区域nums…
info mem
打印所有定义的内存区域列表，每个区域都有下面的列：
Memory Region Number
Enabled or Disabled.
以激活的内存区域标记为’y'。已禁用的内存区域标记为’n'。
Lo Address
内存区域最低地址。
Hi Address
内存区域最高地址。
Attributes
内存区域的属性集。
8.14.1 属性
8.14.1.1 内存访问模式
访问模式属性决定GDB是否可以对一个内存区域进行读写访问。
要是这些属性阻止GDB进行非法内存访问的话，它们将组织系统I/O，DMA之类的内存访问。
ro 内存只读。
wo 内存只写。
rw 内存可读写。默认属性。
8.14.1.2 内存访问的尺寸
访问尺寸属性告诉GDB使用指定大小的内存访问。通常内存和设备寄存器要求的指定大小的访问匹配。如果不指定访问尺寸属性，GDB可
能使用任意大小的访问。
8 使用8位内存访问。
16 使用16位内存访问。
32 使用32位内存访问。
64 使用64位内存访问。
8.14.1.3 数据缓冲
数据缓冲属性设置GDB是否缓冲系统内存。由于减少了调试协议的开销，这个属性可以改善性能，与此同时也可能导致错误的结果，因为
GDB不知道volatile变量和内存映射寄存器。
cache 激活缓存系统内存。
nocache 禁用缓冲系统内存。默认属性。
8.14.2 内存访问检查
GDB可以设置拒绝访问没有明确描述的内存。如果在某个系统下，访问这些内存区域存在不能预料的效果的话，要预防这种状况，或者要
提供一个更好的错误检查，都是很大帮助的。下列命令控制这种行为。
set mem inaccessible-by-default [on|off]
如果设置on，设置GDB将未明确描述范围的内存当作不存在的并拒绝对此内存的访问。只有在至少有一个已定义的内存范围的情况
下才会进行检查。如果设置了off，设置GDB将此未明确描述范围的内存作为RAM。默认值是on。
show mem inaccessible-by-default
显示当前对于未知内存访问的设置。
8.15 在内存和文件之间复制数据
可以用命令dump，append和restore来在目标内存和文件直线复制数据。dump和append命令将数据写入文件，restore命令将文件数据读入
到内存中。文件可以是二进制，Motorola S-record，Inetl16进制，或着Tekrronix16进制格式的；不过，GDB只支持将数据附加到二进制文
件。
dump [format] memory filename start_addr end_addr
dump [format] value filename expr
将内存从start_addr开始到end_addr的内容，或表达式expr的值，以指定格式转储到文件。
格式参数可以是下面类型之一：
binary 原始二进制形式
ihex Intel 16进制格式
srec Motorola S-record格式
tekhex Tektronix 16进制格式
GDB使用的格式和GNU二进制工具所使用的一样，比如’objdump’和’objcopy’。如果省略format，GDB用原始二进制格式转储数据。
append [binary] memory filename start_addr end_addr
append [binary] value filename expr
将内存从start_addr开始到end_addr的内容，或表达式expr的值，以原始二进制格式附加到文件。（GDB只能用原始二进制格式附
加数据到文件。）
restore filename [binary] bias start end
将文件filename的内容恢复到内存中。restore命令可以自动识别任何已知的BFD文件格式，除了原始二进制文件。要恢复原始二进
制文件，必须在文件名后指定可选关键字binary。
如果bias非零，它是指从文件开头的偏移量。二进制文件总是荣地址0开始，所以会从地址bias开始恢复。其他bfd文件有一个内置
位置；可以从那个位置再偏移bias开始恢复。
如果start和/或end是非零的话，那么只有在文件偏移start和文件偏移end之间的数据会恢复。这些偏移是相对于文件内的位置的
，且是在bias参数相加之前的偏移。
8.16 如何从程序里产生Core文件
core文件或者core dump记录执行中的进程的内存镜像和状态（例如寄存器值）。它的主用作用是对崩溃的程序事后调试。发生崩溃
的程序会自动产生core文件，除非这个功能被用户禁用了。关于事后调试模式的信息，参见15.1节[文件]，155页。
偶尔的，可能希望在调试程序期间产生core文件来保存进程的状态快照。GDB为此提供了一个特殊的命令。
generate-core-file [file]
gcore [file]
为调试进程产生core dump。可选参数file指定存储core dump的文件名。如果没有指定，文件名那个默认是’core.pid’，这里pid
是被调试进程的进程ID。
注意，这个命令只在某些系统上实现（到手册编写时，GNU/Linux，FreeBSD，Unixware和S390）。
8.17 字符集
如果调试中的程序使用的字符集和GDB使用的不一样，GDB可以自动为用户转换字符集。GDB使用的字符集我们称为宿主字符集；调试程序
使用的称为目标字符集。
例如，如果在GNU/Linux系统上运行GDB，GNU/Linux系统使用ISO Latin 1字符集，而用户用GDB远程协议（参见17章[远程调试]，171页
）来调试在IBM框架下运行的程序，其字符集是EBCDIC字符集，那么宿主字符集是Latin-1，而目标字符集是EBCDIC。如果用命令set
target-charset EBCDIC-US设置GDB，那么在输入字符或字符串或在表达式里使用字符和字符串时，GDB会在EBCDIC和Latin 1之间转换。
GDB不能自动识别调试中的程序所使用的字符集；用户必须告诉它，使用set target-charset命令，如下所述。
下面是控制GDB字符集的命令：
set target-charset charset
将当前目标字符集设置为charset。下面会列举GDB能识别的字符集名称，不过如果输入set target-charset接着再敲两次TAB键的
话，GDB会列出它所能识别的字符集。
set host-charset charset
设置当前的宿主字符集为charset。
缺省的，GDB使用的宿主字符集和系统的相近；可以用set host-charset命令覆盖默认值。
GDB只能使用某些字符集作为宿主字符集。下面会列举GDB能识别的字符集名称，并指明哪种可以用作宿主字符集，不过如果输入
set target-charset接着再敲两次TAB键的话，GDB会列出它所支持的宿主字符集。
set charset charset
涩会址当前的宿主和目标字符集为charset。如前所述，如果输入set charset接着再敲两次TAB键的话，GDB会列出它所支持的宿
主/目标字符集。
show charset
显示当前宿主和目标字符集。
show host-charset
显示当前宿主字符集名。
show target-charset
显示当前目标字符集名。
GDB目前支持下列字符集：
ASCII U.S. ASCII 7-bit。GDB可使之为其宿主字符集。
ISO-8859-1
ISO Latin 1字符集。为法语，德语和西班牙语的重音符号而扩展到字符集。GDB可使之为其宿主字符集。
EBCDIC-US
IBM1047
EBCDIC字符集的变体，用于某些IBM架构的操作系统。（S/390上的GNU/Linux使用U.S. ASCII）GDB不可使之为其宿主字符集。
注意，这些都是单字节字符集。GDB里的很多处理都需要支持多字节或可变长度字符编码，例如Unicode的UTF-8和UCS-2编码方法。
下面是GDB字符集支持的实际例子。假设下面的源代码在文件’charset-test.c’里：
#include
char ascii_hello[]
= {72, 101, 108, 108, 111, 44, 32, 119,
111, 114, 108, 100, 33, 10, 0};
char ibm1047_hello[]
= {200, 133, 147, 147, 150, 107, 64, 166,
150, 153, 147, 132, 90, 37, 0};
main ()
{
printf (“Hello, world!\n”);
}
在此程序里，ascii_hello和ibm1047_hello是包含字符串”hello,world!”的数组，用ASCII和IBM1047字符集编码。
编译此程序并开始调试之：
$ gcc -g charset-test.c -o charset-test
$ gdb -nw charset-test
GNU gdb 2001-12-19-cvs
Copyright 2001 Free Software Foundation, Inc.
…
(gdb)
用show charset命令来查看GDB目前使用哪中字符集来转换和显示字符和字符串：
(gdb) show charset
The current host and target character set is ‘ISO-8859-1’.
(gdb)
出于打印手册的缘故，让我们用ASCII作为初始字符集：
(gdb) set charset ASCII
(gdb) show charset
The current host and target character set is ‘ASCII’.
(gdb)
假设ASCII是目前宿主系统的真正字符集–换句话说，假设GDB用ASCII字符集打印字符，终端会正确的显示字符。由于当前的目标字符集
也是ASCII，ascii_hello的内容会以可读的形式打印：
(gdb) print ascii_hello
$1 = 0×401698 “Hello, world!\n”
(gdb) print ascii_hello[0]
$2 = 72 ’H’
(gdb)
GDB使用目标字符集来打印字符和字符串常量：
(gdb) print ’+’
$3 = 43 ’+’
gdb)
ASCII字符集使用数字43来编码字符’+'。
GDB依赖用户告知目标程序使用的是何种字符集。如果目标字符集还是ASCII，我们试图打印ibm1047_hello就会得到乱码：
(gdb) print ibm1047_hello
$4 = 0x4016a8 “\310\205\223\223\226k@\246\226\231\223\204Z%”
(gdb) print ibm1047_hello[0]
$5 = 200 ’\310’
(gdb)
如果输入set target-charset接着再敲两次TAB键，GDB会告知其所支持的字符集：
(gdb) set target-charset
ASCII EBCDIC-US IBM1047 ISO-8859-1
(gdb) set target-charset
我们可以选择IBM1047作为目标字符集，并再次检查程序字符串。现在ASCII字符串就是错误的了，但GDB会将ibm1047_hello从目标字符
集转换到宿主字符集ASCII，这样就可以正确显示了：
(gdb) set target-charset IBM1047
(gdb) show charset
The current host character set is ‘ASCII’.
The current target character set is ‘IBM1047’.
(gdb) print ascii_hello
$6 = 0×401698 “\110\145%%?\054\040\167?\162%\144\041\012″
(gdb) print ascii_hello[0]
$7 = 72 ’\110’
(gdb) print ibm1047_hello
$8 = 0x4016a8 “Hello, world!\n”
(gdb) print ibm1047_hello[0]
$9 = 200 ’H’
(gdb)
如前所示，GDB用目标字符集来打印字符和字符串常量：
(gdb) print ’+’
$10 = 78 ’+’
(gdb)
IBM1047字符集使用数字78来编码字符’+'。
8.18 缓存远程目标的数据
GDB可以缓存在调试器和远程目标之间交换的数据（参见17章[远程调试]，171页）。这种缓存通常可以改善性能，因为其可减少由于内
存读写所带来的远程协议的开销。不幸的是，目前GDB对volatile寄存器无能为力，因此如果使用了volatile寄存器的时候，数据缓存就会
带来错误的结果。
set remotecache on
set remotecache off
为远程目标设置缓存状态。如果是on的话，使用数据缓存。缺省的，此选项是off。
show remotecache
显示目前远程目标的数据缓存状态。
ifo dcache
打印数据缓存性能的信息。显示的信息包括：dcache的宽度和深度；对于每个缓存行，其被多少次引用到了，其数据和状态（脏
，坏，好，等等）。对于调试数据缓存操作，这个命令很有帮助。
GDB手册9:C预处理宏
第九章 C预处理宏某些语言，例如C和C++，提供定义和引用“预处理宏”的方法，这些宏可以展开为符号串。GDB 可以计算包含宏的表达式，显示宏展开的
结果，并且显示宏的定义，包括在何处定义的。
可能需要特别编译程序来给GDB提供预处理宏的信息。大多数编译器在调试信息中不包括宏，即使编译时使用’-g’选项。参见4.1节
[编译]，25页。
程序可能在某个点定义一个宏，在后面删除这个定义，然后在此后给这个宏提供另外的定义 。因此，在程序里不同点上，同一个宏可能
有不同的定义，或者根本就没有定义。如果在当前堆栈帧上，GDB 使用这个帧源代码行范围的宏。否则，GDB 使用当前位置范围的宏；参见[
打印源代码行]，67页。
同时，GDB 不支持##符号剪接操作符，#宏字符串常量替换操作符，或者可变长宏。
无论何时GDB计算表达式，总会将在表达式里引用的宏展开。GDB 也提供下列命令来明确地识别宏。
macro expand expression
macro exp expression
显示表达式里引用的所有预处理宏的展开结果。由于GDB只简单地展开宏，不会去解析结果，因此表达式不必是有效的；可以是包
含任意符号的的字符串。
macro expand-once expression
macro exp1 expression
（此命令尚未实现。）显示在表达式里引用的预处理宏的展开结果。表达式里的所引用的宏不会改变。这个命令可以更清楚的查
看一个特殊宏，而不会被更多的展开所迷惑。由于GDB只是简单展开宏，而不解析结果，表达式不必是有效的；可是是任意符号的
字符串。
info macro macro
显示名为macro的宏的定义，并显示这个定义是在代码的何处设立的。
macro define macro replacement-list
macro define macro(arglist) replacement-list
（此命令尚未实现。）为名为macro的宏引入一个定义，对其的引用将被给定的replacement-list所替换。此命令的第一中
形式定义了“对象式”的宏，不带参数；第二种形式定义了一个“函数式”的宏，用给定的arglist作为参数的。
用此命令引入的定义，其范围在GDB所计算的所有表达式中，知道用命令macro undef命令删除之，如下所述。此定义会覆盖调试程
序里所有名为macro的宏定义，并且也包括任何用户提供的定义。
macro undef macro
（此命令尚未实现。）删除所有用户提供的名为macro宏定义。此命令只影响用命令macro define所定义的宏。如前所述；不能删
除调试程序里的定义宏。
macro list
（此命令尚未实现。）列举所有用macro define命令定义的宏。
下面的例子展示了如何使用上述命令。首先，看一下源代码：
$ cat sample.c
#include
#include “sample.h”
#define M 42
#define ADD(x) (M + x)
main ()
{
#define N 28
printf (“Hello, world!\n”);
#undef N
printf (“We’re so creative.\n”);
#define N 1729
printf (“Goodbye, world!\n”);
}
$ cat sample.h
#define Q <
$
现在，让我们用GNU C编译器GCC来编译此程序。我用在编译的时候指定’-gdwarf-2′和’-g3′参数来产生预处理宏的调试信息。
$ gcc -gdwarf-2 -g3 sample.c -o sample
$
接着，我们就可以启动GDB来调试此例子程序了：
$ gdb -nw sample
GNU gdb 2002-05-06-cvs
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, …
(gdb)
我们可以展开宏并检查其定义，甚至是在程序尚未运行时。GDB 使用当前代码位置来判断哪个宏的定义处于此范围之内：
(gdb) list main
3
4 #define M 42
5 #define ADD(x) (M + x)
6
7 main ()
8 {
9 #define N 28
10 printf (“Hello, world!\n”);
11 #undef N
12 printf (“We’re so creative.\n”);
(gdb) info macro ADD
Defined at /home/jimb/gdb/macros/play/sample.c:5
#define ADD(x) (M + x)
(gdb) info macro Q
Defined at /home/jimb/gdb/macros/play/sample.h:1
included at /home/jimb/gdb/macros/play/sample.c:2
#define Q <
(gdb) macro expand ADD(1)
expands to: (42 + 1)
(gdb) macro expand-once ADD(1)
expands to: once (M + 1)
(gdb)
注意，在上面的这个例子里，macro expand-once只把原文本引用的宏展开–ADD的引用–但不展开宏M，此宏由ADD所引用。
一旦程序运行起来后，在当前堆栈帧的源代码上，GDB使用有效的宏定义：
(gdb) break main
Breakpoint 1 at 0×8048370: file sample.c, line 10.
(gdb) run
Starting program: /home/jimb/gdb/macros/play/sample
Breakpoint 1, main () at sample.c:10
10 printf (“Hello, world!\n”);
(gdb)
在第10行，宏N的有效定义是在第9行：
(gdb) info macro N
Defined at /home/jimb/gdb/macros/play/sample.c:9
#define N 28
(gdb) macro expand N Q M
expands to: 28 < 42
(gdb) print N Q M
$1 = 1
(gdb)
如果我们单步执行到删除N的定义之后，并给其新的定义，GDB会在每个点上找到有效的定义（或者没有定义）：
(gdb) next
Hello, world!
12 printf (“We’re so creative.\n”);
(gdb) info macro N
The symbol ‘N’ has no definition as a C/C++ preprocessor macro
at /home/jimb/gdb/macros/play/sample.c:12
(gdb) next
We’re so creative.
14 printf (“Goodbye, world!\n”);
(gdb) info macro N
Defined at /home/jimb/gdb/macros/play/sample.c:13
#define N 1729
(gdb) macro expand N Q M
expands to: 1729 < 42
(gdb) print N Q M
$2 = 0
(gdb)
GDB手册10:跟踪点
第十章 跟踪点
在某些应用程序里，调试器不大可能因为开发者要了解此程序的行为，长时间的中断程序的执行。如果程序的正确性依赖于实时行为，调试器造成的延迟会导致程序根本改变其行为，甚至在代码本省正确的情况下也可能导致失败。不中断程序的执行来观察其行为是非常有用的功能。
使用GDB的trace或者collect命令，可以指定程序里的位置，称为跟踪点，和在跟踪点执行到的时候要计算的任意表达式。稍后在跟踪点
执行到的时候，可以用tfind命令来查看表达式的值。表达式也可以引用内存里的对象–结构体或者数组，例如—GDB应该记录的值；在访
问一个特殊的跟踪点时，可以查看那些对象，如果在这个时间点上这些对象在内存里的话。不过，由于GDB不需要和用户交互就可以记录这些值，所以GDB可以迅速优雅的记录而不干扰调试程序运行。
目前，跟踪点功能只在远程系统上实现。参见第16章[目标],167页。另外，远程系统必须了解如何收集跟踪数据。这个功能实现于远程存根；不过，到这个 手册编写为止，没有存根支持GDB提供的跟踪点。实现跟踪点的远程数据包格式参见D.6节[跟踪点数据包]，356页。
本章说明跟踪点命令和功能。
10.1 设置跟踪点的命令
在运行跟踪尝试前，可以设置任意跟踪点号都。如同断点那样（参见5.1.1节[设置断点]，40页），跟踪点由GDB分配编号。和断点一样，跟踪点编号是从1开始连续的整数。跟踪点相关的命令，大多需要跟踪点号作为其参数来指定跟踪点。
可以为各个跟踪点指定要系统收集的任意的数据集，此数据存储于跟踪缓冲区里。收集的数据包括寄存器，本地变量和全局数据。接下来，可以用GDB命令来查看这些数据的值。
本节说明设置跟踪点的命令，并设置相关条件和操作。
10.1.1 创建和删除跟踪点
trace trace命令和break命令非常相似。其参数可以是源代码行，函数名或者目标程序的某个地址。参见5.1.1节[设置断点] ，40页。
trace命令创建跟踪点，程序在此点上短暂中断，收集数据，然后程序继续往下执行。设置跟踪点或者改变跟踪点命令直到下个
tstart命令才会生效；因此，不能在跟踪会话过程中改变跟踪点的属性。
下面是使用trace命令的一些例子：
(gdb) trace foo.c:121 // 源文件和行号
(gdb) trace +2 // 当前行的下两行
(gdb) trace my function // 函数的第一行代码
(gdb) trace *my function // 函数的真正开始的地方
(gdb) trace *0x2117c4 // 某个地址
trace可以简写为tr。
惯用变量$tpnum记录最近设置的跟踪点号。
delete tracepoint [num]
永久删除一个或多个跟踪点。不带参数的话，默认删除所有的跟踪点。
例如：
(gdb) delete trace 1 2 3 // 删除三个跟踪点
(gdb) delete trace // 删除所有跟踪点
此命令可以简写为del tr。
10.1.2 激活和禁用跟踪点
disable tracepoint [num]
禁用跟踪点num，或者所有跟踪点，如果不指定参数的话。已禁用的跟踪点在下一次跟踪会话期将不再有效，但不会被系统遗忘。
enable tracepoint命令可以再次激活已禁用的跟踪点。
enable tracepoint [num]
激活跟踪点num，或者所有的跟踪点。已激活的跟踪点将在下一次跟踪会话期起效。
10.1.3 跟踪点通过计数
passcount [n [num]]
设置跟踪点的通过计数。使用通过计数可以自动中止跟踪会话。如果跟踪点通过计数是n，那么跟踪会话会在跟踪点第n次执行到的
时候自动中止。如果没有指定跟踪点号num，通过计数命令将设置最近创建的跟踪点。如果没有指定通过计数，那么跟踪会话会在
一直执行，直到用户手动终止为止。
例如：
(gdb) passcount 5 2 // 跟踪点2在第5次执行时中止
(gdb) passcount 12 // 最近创建的跟踪点，在第12次执行时中断
(gdb) trace foo
(gdb) pass 3
(gdb) trace bar
(gdb) pass 2
(gdb) trace baz
(gdb) pass 1 // 在foo执行过3次，或者bar执行过2次，或者baz执行过1次时，中止跟踪
10.1.4 跟踪点操作列表
action [num]
此命令设置在跟踪点执行到时执行的操作。如果没有指定跟踪点号num，此命令会为最近创建的跟踪点设置操作（因此创建跟踪点
后执行actions命令就不必要再费事指定跟踪点号了）。接下来指明要执行的操作，每个操作一行，只有包含end的最后一行用来结
束操作列表。到目前为止，只定义了collect和while-stepping操作。
要删除跟踪点的所有操作，输入’actions num’，接下来立即输入end。
(gdb) collect data // 收集某些数据
(gdb) while-stepping 5 // 单步执行5次，收集数据
(gdb) end // 操作结束
下面的例子里，操作列表从collect命令开始，在跟踪点执行到时收集数据。那么，要单步执行和收集额外的数据，就要在设置单
步执行时收集数据之后执行while-stepping命令。需要用end命令来终结while-stepping命令。最后，用end命令来终结操作列表。
(gdb) trace foo
(gdb) actions
Enter actions for tracepoint 1, one per line:
> collect bar,baz
> collect $regs
> while-stepping 12
> collect $fp, $sp
> end
end
collect expr1, expr2, …
在跟踪点执行到时，收集指定表达式的结果。此命令可以接受以逗号分隔的任意有效表达式作为参数。另外，全局，静态或本地变
量以外的，也支持下列特殊的参数：
$regs 收集所有寄存器
$args 收集函数的所有参数
$locals 收集所有本地变量
可以连续使用collect命令，每个collect都可以有单独的参数，或者一个collect命令带多个参数，以逗号分隔：效果是相同的。
命令info scope（参见13章[符号]，143页）非常适合查出哪些数据是要收集的。
while-stepping n
在跟踪点后执行n次单步跟踪，每执行一步都收集一次数据。while-stepping命令后接要收集的数据列表（最后再接end结束while-
stepping命令）：
> while-stepping 12
> collect $regs, myglobal
> end
>
while-stepping可以缩写为ws或者stepping。
10.1.5 跟踪点列表
info tracepoints [num]
打印跟踪点num的信息。如果不指定跟踪点号，将显示所有跟踪点的信息。每个跟踪点都包含下列信息：
·跟踪点编号
·是否激活或禁用
·跟踪点地址
·用passcount n命令设置的通过计数
·用while-stepping n命令设置的单步执行次数
·跟踪点设置于源代码的何处
·用actions命令设置的操作列表
(gdb) info trace
Num Enb Address PassC StepC What
1 y 0x002117c4 0 0
2 y 0x0020dc64 0 0 in g_test at g_test.c:1375
3 y 0x0020b1f4 0 0 in get_data at ../foo.c:41
(gdb)
本命令可缩写为info tp。
10.1.6 开始和中止跟踪会话
tstart 此命令不需要参数。开始一次跟踪会话，并开始收集数据。如果不保留上一次跟踪会话期间收集的数据的话，可能会带来一些副
作用。
tstop 此命令不需要参数。结束一次跟踪会话，并停止收集数据。
注意：一次跟踪会话和数据收集可能在达到跟踪点通过计数时自动终止（参见10.1.3节[跟踪点通过计数]，106页），或者在跟踪
缓冲区满的时候也可能导致终止。
tstatus 此命令显示当前跟踪数据收集的状态。
下面是关于目前为止我们介绍的命令的例子：
(gdb) trace gdb c test
(gdb) actions
Enter actions for tracepoint #1, one per line.
> collect $regs,$locals,$args
> while-stepping 11
> collect $regs
> end
> end
(gdb) tstart
[time passes ...]
(gdb) tstop
10.2 使用已收集的数据
跟踪会话结束以后，可以使用GDB命令来检查跟踪数据。基本的概念是，在达到跟踪点的时候每次收集一个跟踪快照，此外每次单步跟踪
的时候都收集一次快照。所有这些快照都保存与跟踪缓冲区里，并且是从0开始连续编号的，所以可以供用户在以后来查看。要查看这些快
照，需要明确指定是哪一个。如果远程代理指定了某个跟踪快照的话，在接到GDB的请求时，它会从缓冲区里读取此快照相应的内存和寄存
器，而不是从实际的内存或寄存器里读取内容，反馈给GDB。这就意味着GDB所有命令（print,info registers,backtrace等等）都会像正在
调试程序期间一样工作，就如同在跟踪点发生时那样。如果请求的数据不在缓冲区里，此请求将会失败。
10.2.1 tfind n
从缓冲区里选择一个跟踪快照的基本命令是tfind n，tfind查找编号为n的跟踪快照，从0开始。如果没有指定参数，那么会选择下一个快
照。
下面是tfind命令各种形式。
tfind start
查找第一个快照。tfind 0的同义词（因为0是第一个快照的编号）。
tfind none
停止调试跟踪快照，重新开始现场调试。
tfind end
和’tfind none’相同。
tfind 不带参数代表查找下一个跟踪快照。
tfind - 查找当前快照的前调试过的快照。这就允许再次跟踪此前的步骤。
tfind tracepoint num
查找跟踪点编号num相对应的下一个快照。搜索从最近查看的跟踪点快照开始。如果不带参数num的，查找当前跟踪点的下一个快照
。
tfind pc addr
查找程序计数器地址addr对应的下一个快照。搜索从最近查看的跟踪点快照开始。如果不带参数的话，查找当前快照的PC对应的下
一个快照。
tfind outside addr1,addr2
查找指定范围之外的PC对应的下一个快照。
tfind range addr1,addr2
查找指定范围内的PC对应的下一个快照。
tfind line [file:]n
查找源代码行n对应的下一个快照。如果指定了可选参数file，那么指定是此源文件的代码行n。搜索从最近查看的跟踪点快照开始
。如果没有指定参数n，代表查找下一行，而不是当前检查的这一行；因此，重复tfind line就好象在现场调试期间的单步跟踪一
样。
tfind命令的默认参数是特别设计的，使得它方便的在跟踪缓冲区里搜索。例如，不带参数的tfind命令选择下一个跟踪快照，而不带参数
的tfind -命令选择前一个跟踪快照。所以，用一个tfind命令，再按回车键重复就可以依次检查所有的跟踪快照。或者，用tfind -再接着
重复按回车键就可以反向检查快照了。不带参数的tfind line命令选择下一行代码对应的快照。不带参数的tfind pc命令选择当前堆栈帧上
保存程序计数器PC对应的下一个快照。不带参数的tfind tracepoint命令选择当前跟踪点上收集的下一个快照。
除了让用户可以手动在跟踪缓冲区里搜索之外，这些命令也能方便的构建GDB脚本，搜索跟踪缓冲区并打印用户感兴趣的数据。因此，如
果我们想要检查缓冲区里的每个跟踪帧里的PC，FP和SP寄存器，我们可以用下面这些命令：
(gdb) tfind start
(gdb) while ($trace frame != -1)
> printf “Frame %d, PC = X, SP = X, FP = X\n”, \
$trace_frame, $pc, $sp, $fp
> tfind
> end
Frame 0, PC = 0020DC64, SP = 0030BF3C, FP = 0030BF44
Frame 1, PC = 0020DC6C, SP = 0030BF38, FP = 0030BF44
Frame 2, PC = 0020DC70, SP = 0030BF34, FP = 0030BF44
Frame 3, PC = 0020DC74, SP = 0030BF30, FP = 0030BF44
Frame 4, PC = 0020DC78, SP = 0030BF2C, FP = 0030BF44
Frame 5, PC = 0020DC7C, SP = 0030BF28, FP = 0030BF44
Frame 6, PC = 0020DC80, SP = 0030BF24, FP = 0030BF44
Frame 7, PC = 0020DC84, SP = 0030BF20, FP = 0030BF44
Frame 8, PC = 0020DC88, SP = 0030BF1C, FP = 0030BF44
Frame 9, PC = 0020DC8E, SP = 0030BF18, FP = 0030BF44
Frame 10, PC = 00203F6C, SP = 0030BE3C, FP = 0030BF14
或者，如果想要检查缓冲区里每行代码里的变量X：
(gdb) tfind start
(gdb) while ($trace frame != -1)
> printf “Frame %d, X == %d\n”, $trace_frame, X
> tfind line
> end
Frame 0, X = 1
Frame 7, X = 2
Frame 13, X = 255
10.2.2 tdump
本命令没有参数。tdump打印在当前跟踪快照里所有收集到的数据。
(gdb) trace 444
(gdb) actions
Enter actions for tracepoint #2, one per line:
> collect $regs, $locals, $args, gdb_long_test
> end
(gdb) tstart
(gdb) tfind line 444
#0 gdb_test (p1=0×11, p2=0×22, p3=0×33, p4=0×44, p5=0×55, p6=0×66)
at gdb_test.c:444
444 printp( “%s: arguments = 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X\n”, )
(gdb) tdump
Data collected at tracepoint 2, trace frame 1:
d0 0xc4aa0085 -995491707
d1 0×18 24
d2 0×80 128
d3 0×33 51
d4 0x71aea3d 119204413
d5 0×22 34
d6 0xe0 224
d7 0×380035 3670069
a0 0x19e24a 1696330
a1 0×3000668 50333288
a2 0×100 256
a3 0×322000 3284992
a4 0×3000698 50333336
a5 0x1ad3cc 1758156
fp 0x30bf3c 0x30bf3c
sp 0x30bf34 0x30bf34
ps 0×0 0
pc 0x20b2c8 0x20b2c8
fpcontrol 0×0 0
fpstatus 0×0 0
fpiaddr 0×0 0
p = 0x20e5b4 “gdb-test”
p1 = (void *) 0×11
p2 = (void *) 0×22
p3 = (void *) 0×33
p4 = (void *) 0×44
p5 = (void *) 0×55
p6 = (void *) 0×66
gdb_long_test = 17 ’\021’
(gdb)
10.2.3 save-tracepoints filename
本命令将当前所有跟踪点的定义以及它们的操作和通过计数保存到文件’filename’里， 以便以后的调试会话里使用。要读取保存的跟踪
点定义，使用sourcce命令（参见20.3节[命令文件]，221页）。
10.3 跟踪点的惯用变量
(int) $trace_frame
当前跟踪快照（也称为帧）编号，或者-1，如果没有选择快照的话。
(int) $tracepoint
当前跟踪快照的跟踪点。
(int) $trace_line
当前跟踪快照的行号。
(char []) $trace_file
当前跟踪快照的源文件。
(char []) $trace_func
包含$tracepoint的函数名。
注意：$trace_file不适于用printf，用output打印。
下面是使用这些惯用变量的例子，单步执行跟踪快照并打印数据。
(gdb) tfind start
(gdb) while $trace frame != -1
> output $trace_file
> printf “, line %d (tracepoint #%d)\n”, $trace_line, $tracepoint
> tfind
> end
译注：
stub，翻译成”存根”还是”代理”，”存根”感觉有点拗口，对应于中文的感觉不是很舒服；”代理”又觉得不能完整表达原文的意义。
翻译:shyboysby.spaces.live.com
本翻译遵从GPL。参见：
gdb is free software, protected by the gnu General Public License (GPL). The GPL gives
you the freedom to copy or adapt a licensed program—but every person getting a copy also
gets with it the freedom to modify that copy (which means that they must get access to the
source code), and the freedom to distribute further copies. Typical software companies use
copyrights to limit your freedoms; the Free Software Foundation uses the GPL to preserve
these freedoms.
Fundamentally, the General Public License is a license which says that you have these
freedoms and that you cannot take these freedoms away from anyone else.
欢迎转载（请注明出处），但不允许用以商业赢利。本翻译保留相应权利。
自由软件需要自由文档。
自由属于人民。
比较详细的GDB用法说明
$1={2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40}