gdb手册

GDB手册

一个GDB会话样例

翻译:shyboysby.spaces.live.com

 

本翻译遵从GPL。参见：

gdb is freesoftware, protected by the gnu General Public License (GPL). The GPL gives

you the freedomto copy or adapt a licensed program—but every person getting a copy also

gets with it thefreedom 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 tolimit 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 andthat you cannot take these freedoms away from anyone else.

欢迎转载（请注明出处），但不允许用以商业赢利。本翻译保留相应权利。

自由软件需要自由文档。

自由属于人民。

 

GDB:第一章

第一章：一个GDB会话样例

1 一个GDB会话样例

  你可以随意用这部手册来了解有关GDB的一切。然而，一些趁手的命令就足以开始使用调试器。这一章介绍了这些命令。

  在这个简单的会话里，我们强调用户输入用黑体来显示，这样可以和环境输出明确的区分开来。 

  GNU m4（通用宏处理器）的以前版本有以下的一个bug:有时候，在我们改变了宏默认的引号字符串的时候，用来在别的宏里捕获

宏定义的命令就失效了。在接下来简短的m4例子里，我们定义了一个展开是“0000”的宏foo；我们接着用m4内建的defn来定义宏bar，bar的

值也是“0000”。然而，在我们用<QUOTE>来替代开引号字符和用<UNQUOTE>替代闭引号字符的后，定义一个同义词baz的相同的过程却失败了。

baz:

$ cd gnu/m4

$ ./m4

define(foo,0000)

foo

0000

define(bar,defn(‘foo’))

bar

0000

changequote(<QUOTE>,<UNQUOTE>)

define(baz,defn(<QUOTE>foo<UNQUOTE>))

baz

Ctrl-d

m4: End ofinput: 0: fatal error: EOF in string

  让我们试着用GDB来看看发生了什么。

$ gdb m4

gdb is freesoftware and you are welcome to distribute copies

of it undercertain conditions; type “show copying” to see

the conditions.

There isabsolutely no warranty for gdb; type “show warranty”

for details.

gdb6.8.50.20080307, Copyright 1999 Free Software Foundation, Inc…

(gdb)

  GDB只是读入仅够在有需要的时候用来发现哪里能够找到后续内容的数据；这将是GDB的第一个提示很开出现。现在我们

让GDB用一个比通常窄的显示区域，这样可以让本书的例子显示的更好。

(gdb) set width70

我们需要探查m4内建函数changequote是如何工作的。因为已经看过了源代码，我们知道相关的子函数是m4_changequote，所以我们

用GDB break命令在这个函数上设置一个断点。

(gdb) break m4changequote

Breakpoint 1 at0x62f4: file builtin.c, line 879.

用run命令，m4就在GDB的控制下运行了。只要还没有运行到m4_changequote子函数，程序就如同往常一样运行：

(gdb) run

Startingprogram: /work/Editorial/gdb/gnu/m4/m4

define(foo,0000)

foo

0000

  为了出发断点，我们要调用changequote.GDB挂起m4，显示出在它停止执行处的上下文信息。

changequote(<QUOTE>,<UNQUOTE>)

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

882set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\

: nil,

  set_quotes看上去像有可能失败的子函数。为了进入子函数，我们可以用命令s(step)而不是用next。step进入被调用的

子函数的第一行，所以step进入set_qoutes.

(gdb) s

set_quotes(lq=0x34c78 “<QUOTE>”, rq=0x34c88 “<UNQUOTE>”)

at input.c:530

530 if (lquote!= def_lquote)

  这些输出显示了在m4挂起时的调用函数栈。它显示了栈的概要。我们可以用命令backtrace(也可以用缩写bt)来看当前在哪里：

backtrace命令显示了每一个活动子程序的栈。

gdb) bt

#0 set_quotes(lq=0x34c78 “<QUOTE>”, rq=0x34c88 “<UNQUOTE>”)

at input.c:530

#1 0×6344 inm4_changequote (argc=3, argv=0x33c70)

at builtin.c:882

#2 0×8174 inexpand_macro (sym=0×33320) at macro.c:242

#3 0x7a88 inexpand_token (obs=0×0, t=209696, td=0xf7fffa30)

at macro.c:71

#4 0x79dc inexpand_input () at macro.c:40

#5 0×2930 inmain (argc=0, argv=0xf7fffb20) at m4.c:195

 

我们step几行来观察会发生什么。在开始的两次为了避免进入xstrdup子程序，我们用’s';接下来的两次我们用’n'。

(gdb) s

0x3b5c 532 if(rquote != def_rquote)

(gdb) s

0x3b80 535lquote = (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“<QUOTE>”

(gdb) p rquote

$2 = 0x35d50“<UNQUOTE>”

lquote和rquote确实是新的左右引号。为了查看一些相关的信息，我们可以用命令l(list)显示当前代码附近的10行代码。

(gdb) l

533xfree(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 lenlquote

$3 = 9

(gdb) p lenrquote

$4 = 7

假设len_lqoute和len_rquote分别代表lqoute和rquote的长度，很显然这个结果是错误的，我们可以用命令p来设置

较合理的值，p命令不仅可以打印表达式的值，而且表达式也可以调用子函数，也可以给表达式赋值。

(gdb) p lenlquote=strlen(lquote)

$5 = 7

(gdb) p lenrquote=strlen(rquote)

$6 = 9

是不是这样就足以修正m4内建的defn关于使用新的引号的错误了呢？我们可以用命令c让m4继续执行,接着试这个刚刚过引起问题的例子：

(gdb) c

Continuing.

define(baz,defn(<QUOTE>foo<UNQUOTE>))

baz

0000

成功了！这个新的引用现在和默认的一样正确了。这个问题看来是两个形参搞错了。我们输入一个EOF让m4退出：

Ctrl-d

Program exitednormally.

消息’Program exitednormally.’是GDB输出的；它显示了m4已经执行完了。我们可以用quit命令来结束GDB会话。

 

第二章：进入和离开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-commandcommand

-ex command 执行单一的GDB命令。这个选项可以多次调用来执行多个命令。它也可以用’-command’交叉.

            gdb -ex ’targetsim’ -ex ’load’ \

                -xsetbreakpoints -ex ’run’ a.out

-directorydirectory

-d directory

    加入路径directory作为源代码和脚本文件的搜索路径.

 

-r

-readnow  立即读入每一个符号文件的符号表，而不是默认的那种在需要时才渐次读入的方式。这将是初始阶段慢一点，

          而以后执行将更快。

 

2.1.2 选择模式

   你可以用多种模式运行GDB–例如，批处理模式和安静模式。

-nx

-n  不执行任何初始化文件里的命令。通常，在处理完所有的命令选项和参数之后，GDB会执行这些文件里的命令。

 

-quiet

-silent

-q  “安静”。不打印介绍和版权信息。在批处理模式下这些信息也不打印。

 

-batch  以批处理模式运行。处理完所有命令文件（用’-x’指定）后以0状态退出（如果没有用‘-x’选项，需要执行完在

初始化文件里的所有命令）。批处理模式在将GDB作为过滤器运行的时候很有用，例如下载和运行一个远程计算机

上的程序；为了使这个模式更有用，信息‘Program exitednormally.’将不输出（通常在GDB控制下会输出的）

 

-batch-silent

    类似于批处理模式运行，但是完全的安静。GDB所有的输出到stdout的信息都将禁止（stderr不受影响）。这个模式

比’-silent’更安静而将是交互式的会话失效。这个模式在使用给出‘Loadingsection’信息的目标是特别有用。

    注意，通过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 annotatelevel’命令相同（参见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]）。

 

-interpreterinterp

    把解释器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目录下初始化文件可以设置选项(

像’setcomplaints’),这样可以影响此后的命令行选项和参数的处理。如果你用了’-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 commandstring

    启动标准shell执行command string.如果环境变量SHELL存在，环境变量SHELL决定哪一个shell来运行。否则GDB将用默认的shell(

Unix系统’/bin/sh’，MS-DOS用’COMMAND.COM’).

  在编译环境里make工具通常都是必需的。在GDB里你不需要用shell命令调用make:

make make-args

    用指定参数执行make程序。和’shell makemake-args’相同。

 

2.4 日志输出

你可能想要保存GDB命令的输出到一个文件里。有多个命令可以控制GDB的日志。

set logging on

    激活日志功能.

set logging off

    关闭日志功能.

set logging filefile

    改变当前的logfile名字l.默认的logfile是‘gdb.txt’.

set loggingoverwrite [on|off]

    默认的，gdb会以附加的方式保存日志。如果你想改为覆盖方式保存的话，可以设置为覆盖方式。

set loggingredirect [on|off]

    默认的，gdb输出会打印到终端和logfile。可以将终端重定向到logfile里，如果你只要它输出到logfile里。

show logging

    显示当前日志设置

    

    

    第三章 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<TABi>

GDB补全’breakpoints’的剩余部分，因为只有info子命令以’bre’开头：

(gdb) infobreakpoints

 现在你可以敲入回车键来运行info breakpoints命令；假如’breakpoints’看上去不像你期待的，你可以用回退键删除之，然后敲入别的。，假如 ‘breakpoints’看上去不像你期待的。（如果在开头你就确信你要的就是info breakpoints，你就可以用缩写的形式来立即回车运行’info bre’，而不必等命令补全再回车）。

  如果在你按下TAB键的时候有过个候选项的话，GDB会发出一个铃声。你可以多敲入几个字符后再试一下，或者再按一次TAB键

；GDB会为你显示所有可能补全的候选项。例如，你可能想要在一个名字开头是’make_’子函数里设置一个断点,而在你敲入bmake_<TAB>的时候，GDB会发出一声响。再次敲入<TAB>键会显示所有以make_开头的函数，例如：

(gdb) b make_<TAB>

gdb sounds bell;press hTABi again, to see:

make_a_section_from_filemake_environ

make_abs_sectionmake_function_type

make_blockvectormake_pointer_type

make_cleanupmake_reference_type

make_commandmake_symbol_completion_list

(gdb) b make_

显示完所有可能的候选项之后，GDB会复制你刚才的输入（在这个例子里是’b make_’）以便你完成这个命令。

  如果你只是想要在开始的时候看看候选列表，你可以按下M-?而不是按下<TAB>两次。M-?是<META>?.你可以在敲入?的时候按住

<META>键（假如键盘上有这个键的话），假如没有这个键，你可以按下<ESC>再按下?来代替。

  有时候你需要的字符串可能含有圆括号，或者GDB认为这个字符串是不一个字。为了让补全功能在这种情况下生效，你可以用’

(单括号)封起来。

  这种情况最有可能出现在你敲入一个C++函数名的时候。这是因为C++允许函数重载（同一个函数名多次定义，以参数类型来区分）。例如，在一个名为 name的函数设置断点的时候，你需要区分是在参数为int的函数name上还是参数为float的函数name设置断点的。为了在这时用词补全功能，在函数名之前敲入一个单引号’。这样GDB就可以知道需要考虑比通常只按下<TAB>或者M-?更多的信息：

(gdb) b?ˉbubble( M-?

bubble(double,double)bubble(int,int)

(gdb) b?ˉbubble(

  在某些需要补全的情况下，GDB可以提示你需要引号。这时，如果你开始的时候没有敲入引号，GDB会为你插入一个引号：

(gdb) b bub<TAB>

GDB会以下面的输出提醒你，然后响一声：

(gdb) b ’bubble(

通常的，在有重载符号情况下，在你还没有开始敲入参数列表的时候就用补全功能的时候，GDB提示需要一个引号然后插入它。

更多有关重载函数信息，参见12.4.1.3节[C++表达式],126页。你可以用setoverload-resolution off命令关闭重载解决方案，参见12.4.1.7节，[GDB的C++功能],128页。

 

3.3 帮助

  用help功能，你可以获得GDB的命令信息。

help

h    你可以用help(缩写h)不带参数来显示一个命令分类的简短列表。

    (gdb) help

    List of classesof commands:

    aliases —Aliases of other commands

    breakpoints —Making program stop at certain points

    data — Examiningdata

    files —Specifying and examining files

    internals —Maintenance commands

    obscure —Obscure features

    running —Running the program

    stack —Examining the stack

    status — Statusinquiries

    support —Support facilities

    tracepoints —Tracing of program execution without

    stopping theprogram

    user-defined — User-definedcommands

    Type “help”followed by a class name for a list of

    commands in thatclass.

    Type “help”followed by command name for full

    documentation.

    Command nameabbreviations are allowed if unambiguous.

    (gdb)

help class

    用help分类作为参数，你可以得到这个分类里命令列表。比如，下面是status分类的帮助显示：

    (gdb) helpstatus

    Statusinquiries.

    List ofcommands:

    info — Genericcommand for showing things

    about theprogram being debugged

    show — Genericcommand for showing things

    about thedebugger

    Type “help”followed by command name for full

    documentation.

    Command nameabbreviations are allowed if unambiguous.

    (gdb)

help command

    用命令名作参数，GDB会显示一段如何使用这个命令的信息。

apropos args

    apropos命令会在命令和文档里文档搜索这个args指定的正则表达式。这个命令会打印所有符合的结果。例如：

    apropos reload

    结果：

    setsymbol-reloading — Set dynamic symbol table reloading

                multiple timesin one run

    showsymbol-reloading — Show dynamic symbol table reloading

                multiple timesin 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里运行程序

 

  在你开始在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 “helptarget” 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和unsetenvironment改变某些影响你的程序的

    环境变量。参见4.4节[程序的环境]，28页。

The workingdirectory.

    你的程序从GDB里继承工作目录。你可以用GDB命令cd来改变工作目录。参见4.5节[程序的工作目录]，29页。

The standardinput 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 environmentvarname [=value]

    设置环境变量varname的为value.这个值只为你的程序改变，GDB本身不改变。value可以使任意字符串；环境变量

    都是字符串，你的程序负责转译；如果被删除了，变量的值就被设置为null值。例如，命令：

        set env USER =foo

    告诉被调试的程序，下一次执行run的时候，它的用户是’foo’.(‘=’附近的空格是为了清楚些；空格不是必须的)

unsetenvironment 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

showinferior-tty

    显示被调试程序目前的tty设备名

 

4.7 调试一个已经在运行的进程

attachprocess-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提供了多个调试多线程的工具：

新线程的自动通知

‘threadthreadno’，切换线程

‘info threads’，查询线程

‘thread apply[threadno] [all] args’，对线程列表执行命令

线程特定断点

‘set printthread-events’，控制线程开始和结束时打印消息

  警告：在各个支持线程的操作系统里，不是所有的GDB配置都支持这些工具的。如果你的GDB不支持线程，这个命

令就无效。例如，不支持线程的系统里’info threads’命令就不能输出信息，也会拒绝thread命令，如下：

(gdb) infothreads

(gdb) thread 1

Thread ID 1 notknown. Use the “info threads” command to

see the IDs ofcurrently known threads.

  GDB线程调试工具可以观察进程的所有线程，而一旦GDB控制线程的话，这个线程就总是调试的焦点了。这个线程

称为当前线程。调试命令从当前线程的角度来显示进程的信息。

 一旦GDB察觉到进程的新线程，GDB就会用‘[New systag]’的方式显示目标系统的标识。systag是线程的标识，各

个系统不一样。例如，当GDB发现一个新线程的时候，在GNU/Linux你可能看到

    [New Thread46912507313328 (LWP 25582)]。

而在SGI系统里，systag就简单的形如‘process 368’，没有更多信息。

  出于调试的目的，GDB自己会给线程一个编号–总是一个整数。

info threads

    显示当前进程里的线程的总概要。GDB显示每个线程（以此为序）：

    1.GDB分配的线程号

    2.目标系统的线程标识（systag）

    3.线程当前栈的概要

    线程号左边的星号’*'代表此线程是当前线程。例如：

(gdb) infothreads

3 process 35thread 27 0x34e5 in sigpause ()

2 process 35thread 23 0x34e5 in sigpause ()

* 1 process 35thread 13 main (argc=1, argv=0x7ffffff8)

atthreadtest.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) infothreads

    * 3 systemthread 26607 worker (wptr=0x7b09c318 “@”) \

        atquicksort.c:137

    2 system thread26606 0x7b0030d8 in __ksleep () \

        from/usr/lib/libc.2

    1 system thread27905 0x7b003498 in _brk () \

        from/usr/lib/libc.2

  在Solaris系统，那你可以用一个Solaris特有的命令来显示更多的信息：

maint infosol-threads

    显示Solaris用户线程的信息。

thread threadno

    将threadno指向的线程设置为当前线程。这个命令的参数threadno是GDB内部的线程号，就是’info threads’

    命令显示第一列。

    GDB会显示你选择的线程的系统标识和它当前栈的概要：

    (gdb) thread 2

    [Switching toprocess 35 thread 23]

    0x34e5 insigpause ()

    伴随着’[New...]‘消息，’Switching to’之后的文本形式由你的系统线程标识表示方式决定。

thread apply[threadno] [all] command

    thread apply命令可以让你在一个或多个线程上执行名为command命令。用参数threadno指定你希望操作的

    线程数目。可以是单个线程号，’info threads’显示的第一列；或者可以是线程范围，像2-4.要操作所有

    线程，敲入thread apply allcommand。

set printthread-events

set printthread-events on

set printthread-events off

    GDB察觉到新线程启动或线程结束的时候，set printthread-events命令可以开启或关闭打印信息。缺省

    下，如果目标系统支持的话，这些事件发生的时候，这些信息会打印出来。注意，这些信息不一定在所有目

    标系统里都可以关闭的。

show printthread-events

    显示是否在GDB察觉线程启动或结束时打印信息。

  由断点或者信号决定，无论何时GDB停止程序，它都会选择断点或信号发生的线程。GDB会用‘[Switching tosyst

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会继续调试父进程，而子进程不受影响。

  如果你要调试子进程，用命令

setfollow-fork-mode.

setfollow-fork-mode mode

    设置调试器对于fork或vfork调用的反应。fork或vfork创建一个子进程。mode参数可以是：

    parent    fork之后调试原进程。子进程不受影响。这是缺省方式。

    child    fork之后调试新的进程。父进程不受影响。

showfollow-fork-mode

    显示当前调试器对于fork/vfork调用的反应。

  在Linux下，如果你要调试父进程和子进程，用命令

setdetach-on-fork.

setdetach-on-fork mode

    设置GDB在fork之后是否detach进程中的其中一个，或者继续保留控制这两个进程。

    on    子进程（或者父进程，依赖于follow-fork-mode的值）会被detach然后独立运行。这是缺省mode。

    off    两个进程都由GDB控制。一个进程（子进程或者父进程，依赖于follow-fork-mode）被调试，另外

        一个则被挂起。

showdetach-on-fork

    显示detach-on-forkmode

如果你选择了设置‘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’所显示列表的第一

    列。

processprocess-id

    切换到process-id指定的进程。参数process-id必须是’info forks’输出的。

  要想结束调试一个被创建的进程，可以用detach fork命令（允许这个进程独立的运行），或者用删除（也杀死）

的方法delete fork命令。

detach forkfork-id

    detach一个由GDB标识的fork-id指定的进程，然后从fork列表里删除。这个进程会被允许继续独立运行。

delete forkfork-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, orlabel

restartcheckpoint-id

    在检查点号的状态上重新启动。所有程序变量，寄存器，栈帧等等都恢复到检查点上保存的状态。本质上将，gdb会

    把时钟回拨到检查点所记录的时间。

    注意，断点，GDB变量，命令历史等不受检查点重置的影响。通常，检查点只重置被调试程序内部的状态，不影响调试器

    本省的状态。

deletecheckpoint checkpoint-id

    删除以前保存的检查点

  回到以前保存的检查点，会重置程序的用户状态，加上相当数量的系统状态，包括文件指针。重置不会撤销已写入文件的数据，但

是会把文件指针指向以前的文职，因此以前写入的数据就可以被覆盖。对于以只读模式打开的文件，指针也会回到以前的位置，因此

可以重新读取数据。

  当然，送到打印机（或者其它外设）的字符不能收回，而从别的设备（比如串口设备）里读取的数据可以从内部程序缓冲里撤销，

但是不能被塞回到串行管道里去，然后再读取他们。相似的是文件的内如如果被改变了，也不能被重置。

  然而，在这些约束条件下，你可以重新回到以前保存的程序状态去，重新调试–然后你可以改变事件的过程来执行一个不同的路径

调试。

  最后，在你回到检查点的时候，有些内部程序状态会不一样—程序的进程id。每个检查点会有一个独立的进程id(pid),每个都和原

来的pid不一样。如果你的程序保存了一个进程id的本地副本，这会有一个潜在的问题。

 

4.11.1 使用检查点的隐含好处

  在某些系统里（例如GNU/Linux）,出于安全考虑，每个新进程的地址空间都要随机确定。这就很难或者说不可能在一个绝对地址上

设置一个断点或者观察点，因为一个符号的绝对位置每次执行都不一样。

  然而，一个检查点是一个进程的相同的副本。因此如果你在主函数的入口点创建了一个检查点，你可以避开地址空间的随机化的影

响，而且符号也会呆在相同的位置。

 

 

第五章  中断和继续

  使用调试器的主要目的是在程序结束之前可以中断它；或者是在程序出现问题的时候，你可以调查为什么出问题。

  在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代表打印特定断点的信息（或者监视点，捕获点）。对于每个断点，打印下列信息：

    BreakpointNumbers

    Type    断点，监视点，或捕获点

    Disposition

        断点是否标记为禁用或删除

    Enabled orDisabled

        用’y'标记激活断点，用’n'标记断点禁用。

    Address

        程序里的断点位置，内存里的位置。对于一个挂起的断点，它的位置是未

        知的，这个域会包含’<PENDING>’。这类断点在共享库没被加载前世不会

        起作用的。详细说明见下面。一个断点对应多个位置的话，这个域会包含

        ‘<MULTPLE>’–详细说明见下面。

    What

        断点位置在程序源代码，文件和行号。对于一个挂起的断点，由于在对应

        的共享库未被加载前不能解释，此时断点命令会显示一个初始的字符串。

    如果断点是有条件的，info break会显示被断点影响的行上的条件；断点命令，如果有的话，

    会在这行后显示。一个挂起的断点可以有条件的指定。这个条件会在共享库加载后分析有效性，

    以此来确定一个有效的位置。

    info break带有一个断点号n的参数将只显示此断点。变量$_和x命令缺省的检查地址用来显示

    最近位置的断点（参见8.5节[查看内存]，79页）。

    info break断点被执行过的次数。这个命令在和ignore命令和用的时候特别有用。你可以忽略

    大部分的断点执行，查看断点信息来看断点总共有多少次执行，然后再次运行，忽略这个总数

    少一次的端点执行。这将可以让你快速的到达断点的最后一次执行。

  GDB可以在程序的同一位置设置任意数量的断点。这不是愚蠢或毫无意义的。特别是在断点是条件性的

情况下，更为有用（参见5.1.6节[断点条件]，50页）。

  一个断点可能对应于多个位置。这种情况的例子如下：

    对于C++构造函数，GCC编译器产生函数体多个的实例，用于不同的重载场景。

    对于C++模板函数，函数里一个给定的行可以对应于任意数量的实例。

    对于内联函数，一个给定的源代码行可以对应于多个内联的地址。

  在这些情况下，GDB会在这些相关的位置插入断点。

  一个对应于多个位置的断点可能会用多行来显示断点信息表–一个表头行，接下来是每一行对应于每一

断点位置。表头行在地址列里有’<MULTIPLE>’。每个位置有单独的行，这一行包含位置的实际地址，和那

个位置对应的函数名。断点号列的形式是断点号.位置号。

  例如：

    Num Type DispEnb Address What

    1 breakpointkeep y <MULTIPLE>

    stop only ifi==1

    breakpointalready hit 1 time

    1.1 y 0x080486a2in void foo<int>() at t.cc:8

    1.2 y 0x080486cain void foo<double>() at t.cc:8

将断点号.位置号作为参数传递给enable何disable命令，每个位置就可以被单独的激活或者禁用。注意，不能

从列表里删除一个单独的位置，只能删除从属于父断点的整个位置列表（用delete num命令，num是父断点的编号

，上面例子里是1）.禁用或者激活父断点（参见5.1.5[禁用]，49页）影响所有属于这个断点的位置。

  在共享库里设置断点是很平常的事。程序运行的时候共享库可以显式加载/卸载，还可以多次重复。为了支持这

个用例，GDB会在共享库加载/卸载的时候更新断点位置。典型地，在库尚未加载或库的符号还不可用的时候，你可

以在调试会话的开始在库里设置一个断点。在设置此类断点的时，GDB会问你是否想要设置一个所谓的挂起断点–

断点的地址还不能解释。

  程序运行后，当一个新共享库加载以后，GDB会重新计算所有断点。当一个新加载的共享库包含挂起断点引用到

的符号或者行时，这个断点就变为已解析和普通断点了。在共享库卸载时，所有引用到它的符号或行的断点都成为

挂起断点。

  这个逻辑也适用于对应于多个位置的断点。例如，如果你在一个C++模板函数里设置了一个断点，一个新加载的

共享库有此模板的一个实例，一个新的位置会加到断点的位置列表里。

  除了位置未解析外，挂起断点和常规断点没有区别。你可以设置条件或者命令，激活或者禁用和执行别的断点操

作。

  在’break’命令不能解析断点地址时，GDB提供了附加的命令来控制解析此地址：

set breakpointpending auto

    这个命令是缺省行为。GDB不能找到断点位置时，它会向你询问是否该创建一个刮起断点。

set breakpointpending on

    设置未识别断点位置应该自动的创建一个刮起断点。

set breakpointpending off

    挂起断点不创建。任何未识别断点位置都将导致一个错误。这个设置不影响此前创建的挂

    起断点。

show breakpointpending

    显示目前关于创建挂起断点的行为模式。

  上面的设置只影响break命令和它的参数。一旦断点被设置了，共享库加载/卸载时会被自动的更新。

  上面的设置只影响break命令和它的参数。一旦断点被设置了，共享库加载/卸载时会被自动的更新。

  对于某些目标，断点所在的位置可以在只读或是可读写的，GDB可以根据断点位置来自行决定用硬件或者软件断点。这

个规则应用于用break命令来设置的断点，也用于那些用next和finish之类的命令设置的内部断点。对于用hbreak命令设置

的断点，GDB总会用硬件断点。

  用下列命令控制这个自动行为：

set breakpointauto-hw on

    这是缺省行为。GDB设置断点时，它会尝试用目标内存映射来决定是用软件还是用硬件断点。

set breakpointauto-hw off

    设置GDB不自动选择断点类型。如果目标提供了内存映射，GDB会在试图在只读地址上设置软件断点的时候警告。

  GDB本身会在程序里为某些特殊目的设置断点，例如为了恰当的处理longjmp（在C程序里）。这些内部断点分配负值编号，

从-1开始；’infobreakpoints’不显示它们。可以用GDB维持命令’maint infobreakpoints’来查看它们（参见[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

    如果命令包含[threadthreadnum]参数，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就再也不会试图去

设置硬件监视点了，即使这个系统支持硬件监视点（注意，此前设置的硬件-协助的监视点仍将使用硬件机制来监视

表达式的值）。

setcan-use-hw-watchpoints

    设置是否用硬件监视点。

showcan-use-hw-watchpoints

    显示硬件监视点的当前模式。

  对于远程系统，你可是限制硬件监视点的数量，参见[设置远程硬件-断点-限制]，177页。

  在执行watch命令时，GDB报告：

    Hardwarewatchpoint num: expr

如果成功设置了一个硬件监视点的话。

  目前，awatch和rwatch命令只能设置硬件监视点，因为不改变被监视的表达式的值的数据的访问不在每个执行到它

的指令上都加以检查的话，就没法探测到；目前GDB也没有那样做。如果GDB发现用awatch或者rwatch不能设置硬件监视

点的话，会打印类似如下信息：

    Expressioncannot be implemented with read/access watchpoint.

  有时候，由于被监视的表达式的数据类型长度超出目标系统上支持的硬件监视点，GDB可能不能设置硬件监视点。例

如,某些系统只能监视最多4个字节宽的硬件监视点；在这些系统里，不能为带有双精度的浮点指针数据（通常是8字节

长）的表达式设置一个硬件断点。一个可能的替代方案是，把一个长区域分成一系列小的监视点。

  如果设置了太多的硬件监视点，GDB有可能不能再继续执行程序时插入所有的监视点。由于准确的有效监视点的数量

在程序重新执行后才能知道，GDB可能不能在设置监视点的时候给出警告，警告信息会在程序重新执行后发出：

    Hardwarewatchpoint 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 execptionProgram_Error）,调试器

        就只会在这个异常发生时中断。否则，调试器会在任意的Ada异常发生时中断。

    exceptionunhandled

        没有被程序处理的异常。

    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

    clearfilename:function

        删除在名为function入口点上的断点。

    clear linenum

    clearfilename: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 fordeletion）。断点中断程序，但中断后立即就永久删除。这个状态是用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 bnumexpression

    为断点，监视点，捕获点指定断点条件表达式。一旦你设置了条件，断点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 bnumcount

    将断点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 ifx>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明白你需要在哪里设置断点。可以用函数的准确特征来指

明要设置的是哪个函数版本，例如用‘breakfunction(types)’。否则，GDB会提供一个数字标识的菜单供你选择

不同的断点，并用提示符’>’等待你的选择。开头的两个选项是‘[0] cancel’和‘[1] all’。输入1会在每个函数

上设置一个断点，输入0取消break命令设置新的断点。

  例如，下面的会话摘录显示的是在重载的符号String::after上设置断点。选择了3个特别的函数定义体：

    (gdb) bString::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 at0xb26c: file String.cc, line 867.

    Breakpoint 2 at0xb344: file String.cc, line 875.

    Breakpoint 3 at0xafcc: file String.cc, line 846.

    Multiplebreakpoints were set.

    Use the “delete”command to delete unwanted

    breakpoints.

    (gdb)

 

5.1.9 “不能插入断点”

  在某些操作系统里，如果有其它的进程运行了这个程序的话，断点就不能在程序里设置了。在此情况下，用一个断

点试图运行或继续执行程序会引起输出一个错误信息：

    Cannot insertbreakpoints.

    The same programmay be running in another process.

  这个情况发生时，有三种继续的方式：

1.删除或关闭断点，接着继续。

2.挂起GDB，复制程序文件并命名为另一个名字。重新执行GDB，用exec-file命令来指定GDB要执行的程序文件名。接

着重启程序。

3.用链接器选项’-N’重新链接程序，以使文本段是非共享的.操作系统的限制可能不应用于非共享模式的可执行程序。

  如果你要求设置太多有效的硬件支持的断点和监视点的话，类似的信息也会输出：

    Stopped; cannotinsert breakpoints.

    You may haverequested 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-modeoff

    导致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

        206expand_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 linespecthread threadno

break linespecthread threadno if …

    linespec指定源代码行；有多种方式来指定（参见7.2节[指定位置]，68页），不过其效果都是指定某些源代

    码行。

    在断点命令里使用限定语’threadthreadno’可以指定GDB只在特定线程执行到这个断点时中断程序。threadno

    是GDB分配的线程标识号，’info threads’显示的第一列就是。

    如果设定断点时没有指定’threadthreadno’的话，那么断点就适用于程序里所有的线程。

    thread限定词也可用于条件断点；这种情况下，把’threadthreadno’放在断点条件前，像这样：

        (gdb) breakfrik.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控制），其它的线程可

能比当前线程完成一次单步执行多执行一些。更进一步说，在程序中断的时候，通常其它的线程中断在一个语句的中间，

而不是在一个语句的边界上。

  在继续或者单步执行之后，你甚至可能发现程序在另一个线程里中断。在其它线程执行到一个断点，信号，或者一个

异常发生,或者当前线程执行完成的时候，都可能发生这个现象。

  在某些操作系统里，可以锁住操作系统的调度器来直让一个线程运行。

setscheduler-locking mode

    设置调度器锁定模式。如果是off,那么就不锁定，任何线程可以在任何时候执行。如果是on，那么只有当前线

    程可以运行。step模式优化单步执行。在单步调试时，step用抢占当前线程的方式来阻止其他线程抢占控制权

    。单步调试的时候，其它线程很少（或者从不）有机会来执行。用’next’来执行一个函数调用的话，它们有更

    有可能运行，并且在用’continue’、’until’或者’finish’之类的命令的话，它们就完全自由的运行了。不过，

    除非另一个线程在它自己的时间片里执行到了一个断点，它们从不从你正在调试的线程抢夺GDB的控制权。

showscheduler-locking

    显示当前调度器的锁定模式。

    

    

    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 allbacktrace，GDB会显示所有线程的回溯；在调试一个多线程程序的core

dump的时候是很方便的。

  回溯里的每一行显示了帧号和函数名。程序计数器的值也会显示–除非用了set printaddress off。回溯也显示源代

码文件名和行号，而且函数的参数也会显示。如果是在那行代码的开头，程序计数器的值会被忽略不显示。

  下面是一个回溯的例子。用命令’bt 3′产生的，因此显示最内3层的堆栈帧。

    #0 m4_traceon(obs=0x24eb0, argc=1, argv=0x2b8c8)

    at builtin.c:993

    #1 0x6e38 inexpand_macro (sym=0x2b600) at macro.c:242

    #2 0×6840 inexpand_token (obs=0×0, t=177664, td=0xf7fffb08)

    at macro.c:71

    (More stackframes follow…)

  没有在堆栈帧里存储的参数，其值用‘<value optimized out>’来替代。

  如果需要显示这些优化掉的参数值，或者用其它依赖于这个参数的变量来推论，或者不带优化的重新编译程序。

  大多数程序都有标准的用户入口点–在此处系统库和启动代码转化为用户代码。对于C是main函数（注1）。GDB要是发现

回溯里有入口函数，就会结束回溯，避免跟踪到高度系统相关（或通常不关心的）的代码。

  要是需要检查启动代码，或者限制回溯到层次数量，可以改变其行为：

set backtracepast-main

set backtracepast-main on

    回溯会在入口点处继续跟踪下去。

set backtracepast-main off

    回溯在入口点处终止。默认行为。

show backtracepast-main

    显示当前用户入口点回溯规则。

（注1，嵌入式程序（所谓的“自举”环境）不要求在入口点有main函数。甚至可以有多个入口点）

set backtracepast-entry

set backtracepast-entry on

    回溯会在应用程序的内部入口点继续跟踪下去。这个入口点是由连接器在链接程序的时候

编码的，很可能是在用户入口点main函数（或者是相应的）之前被调用。

set backtracepast-entry off

    回溯会在程序的内部入口点处终止。默认行为。

show backtracepast-entry

    显示当前内部入口点回溯规则。

set backtracelimit n

set backtracelimit 0

    显示回溯层为n。0代表不限制。

show backtracelimit

    显示当前回溯层限制。

 

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 inmain (argc=1, argv=0xf7fffbf4, env=0xf7fffbfc)

    at env.c:10

    10read_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页。

 

    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 listsizecount

    设置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-searchregexp

search regexp

    命令’forward-searchregexp’检查每一行，从最近列出的行开始，查找正则表达式regexp的匹配项。命

    令列出找到的行。也可以用同义词’search regexp’或缩写命令为fo.

reverse-searchregexp

    命令’reverse-searchregexp’检查每一行，从最近列出的行往后，查找正则表达式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’。

要定义一个源代码路径替换规则，用setsubstitute-path命令（参见[设置替换路径]，72页）。

  要避免意外的替换结果，规则只在目录名的from部分以目录分隔符结尾的情况下才应用。例如，用’/usr/source’

替换’/mnt/cross’的话，会得到’/usr/source/foo-1.0′，而不是’/usr/sourceware/foo-2.0′。并且替换规则只应

用于目录名的开头部分，这个规则不会得到’/root/usr/source/baz.c’的结果。

  在很多情况下，可以用directory命令来达到相同的效果。然而，在源文件分布于一个复杂的，带有多个子目录

的目录树时，setsubstitute-path会更有效率。用directory命令的话，用户需要添加项目的每一个子目录。如果

将整个目录移动且保持内部代码组织的话，那么setsubstitute-path允许你只用一个命令就可以将调试器导向到

所有的源文件。

  set substitute-path也不仅仅只是一个快捷命令。源代码路径只用于原目录下的文件不再存在的情况下。另一

方面，setsubstitute-path修改调试器行为模式来在重写的位置上搜索文件。所以，如果有任何原因导致源代码

文件相对于可执行程序的位置发生了改变，替换规则是唯一可以通知GDB新位置的方法。

directorydirname …

dir dirname …

    在源代码路径前加上目录dirname。可以将几个目录名传递给这个命令，用’:'分隔（在MS-DOS和

    MS-Windows是’;'，’:'通常是一个绝对路径名的一部分），或者用空格分隔。可以指定已存在的目录；这

    会将此目录前移，GDB就能更快的搜索到它了。

    可以用字符串’$cdir’来指代编译目录（如果已记录的话），’$cwd’指代当前工作目录。’$cwd’和’.'不相

    同—前者记录在GDB调试会话期间变动的当前工作目录，后者则在你将一个目录添加进源代码路径时立即

    展开为当前目录。

directory

    将源代码路径重置为默认值（Unix系统下是’$cdir:$cwd’）。这个命令要求确认。

show directories

    打印源代码路径：显示包含那个目录。

setsubstitute-path from to

    定义一个源代码路径替换规则，并将其填加到当前替换规则列表的尾部。如果有相同的from规则存在的话

    ，那么旧的规则就会被删除。

    例如，如果文件’/foo/bar/baz.c’移动到’/mnt/cross/baz.c’,那么命令

        (gdb) setsubstitute-path /usr/src /mnt/cross

    告诉GDB用’/mnt/cross’替换’/usr/src’,这就可以让GDB查找到’baz.c’,即使它已经移走了。

    如果定义了多个替换规则，那么GDB会以规则定义的顺序一个接一个的计算它们。如果有的话，第一个匹

    配项就会进行替换。

    例如，如果我们输入了下列命令：

        (gdb) setsubstitute-path /usr/src/include /mnt/include

        (gdb) setsubstitute-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’替换。

unsetsubstitute-path [path]

    如果指定了path的话，在当前替换规则列表里搜索要重置的规则。如果找到的话就删除之。如果没有找到

    的话，调试器会输出一个警告信息。

    如果没有指定path的话，那么所有的替换规则都将被删除。

showsubstitute-path [path]

    如果指定了path，那么打印打印源代码路径替换规则，如果有的话。

    如果没有指定path，那么打印所有的替换规则。

  如果源代码路径混杂着一些不再有用的目录的话，GDB可能在某些情况下造成错误的代码版本的混淆。可以用下

列命令来纠正这种错误：

1.用不带参数的directory命令来重置源代码路径为默认值。

2.用带正确参数的directory来添加你需要的目录。可以用一个命令将所有的路径添加。

 

7.6 源代码和机器代码

  可以用命令info line将源代码映射到程序地址上（反过来一样），命令disassemble可以显示一定范围的机器指

令。在GNU Emacs模式下运行时，info line命令会引起箭头指向指定的行。而且，info line打印符号形式的地址

，也打印16进制的地址。

info linelinespec

    打印指定的源代码行的编译代码，从开始到结尾的地址。可以指定源代码行，7.2节[指定位置]，68页里

    讨论的任意形式。

  例如，我们可以用info line来查找函数m4_chagequote的第一行的目标代码：

    (gdb) info linem4_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) disas0x32c4 0x32e4

    Dump ofassembler code from 0x32c4 to 0x32e4:

    0x32c4<main+204>: addil 0,dp

    0x32c8<main+208>: ldw 0x22c(sr0,r1),r26

    0x32cc<main+212>: ldil 0×3000,r31

    0x32d0 <main+216>:ble 0x3f8(sr4,r31)

    0x32d4<main+220>: ldo 0(r31),rp

    0x32d8<main+224>: addil -0×800,dp

    0x32dc<main+228>: ldo 0×588(r1),r26

    0x32e0<main+232>: ldil 0×3000,r31

    End of assemblerdump.

  某些架构有多个通用的指令助记符或者同义词。

  对于动态链接的和使用共享库的程序，调用函数或位于共享库的分支位置的指令可能显示伪地址–这个地址是重

定位表的位置。在某些架构里，GDB可以将这些伪地址映射到函数名上。

setdisassembly-flavor instruction-set

    用disassemble或x/i命令反汇编程序时，选择指令集。

    目前这个命令只在Intel x86族平台上定义。可以设置指令集为intel或att。默认是att，基于x86系统的

    Unix汇编器默认使用AT&T风格。

show disassembly-flavor

    显示当前反汇编风格的设置。

 

第八章查看数据

  在程序里查看数据的常用方式是用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会打印’<incompletetype>’。

更多信息，参见13章[符号]，143页。

  字符串是定义为无符号的char数组。signed char或unsigned char会以1字节宽度的整形数组打印。由于GDB定义字符串类型type

‘char’为无符号类型，-fsigned-char或-funsigned-charGCC选项不会起效。对于程序代码

    char var0[] =“A”;

    signed charvar1[] = “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

    pdtab[$i++]->fv

    <RET>

    <RET>

    …

 

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/a0×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 displaydnums…

    从显示列表中删除编号为dnums的显示项。

    在执行undisplay后再回车的话，undisplay不会重复。（否则你会得到’No displaynumber….’的错误信息）

disable displaydnums

    禁用编号为dnums的显示项。禁用的显示项不会自动输出，但系统仍会记录它。可以再次激活。

enable displaydnums…

    激活编号为dnums的显示项。会再次自动显示其表达式的值，直到你禁用它。

display

    显示当前列表中的变大是的值，就如同程序中断那样输出。

info display

    打印此前设置的自动显示列表里的表达式，每个表达式带一个编号，但不显示其值。包括禁用的表达式，这类表达式会标明为禁

    用。也包括目前不能显示的表达式，这类表达式引用了当前不可用的自动变量。

  如果显示表达式引用了本地变量，那么在其设置范围外是没有意义的。在执行到其变量无定义的上下文时，这类表达式会被禁用。

例如，如果你在一个函数内执行了命令displaylast_char，last_char是此函数的参数，GDB会在程序再次执行到这个函数并在此函数中断

时自动显示此参数。要是在别的位置中断的话–那里没有变量last_char–就会将此显示项自动禁用。下次程序在last_char有意义的位置中

断时，可以再次激活这个显示表达式。

 

8.7 打印设置

  GDB提供如下数组，结构体和符号的打印设置方法。在任何语言里下列设置对于调试都是很有用的：

set printaddress

set printaddress on

    GDB打印内存地址，显示堆栈回溯的位置，结构体的值，指针值，断点等等，甚至在其也显示哪些地址上的内容时。缺省是on。

    例如，下面是用set printaddress on来设置后，堆栈帧的输出：

        (gdb) f

        #0 set_quotes(lq=0x34c78 “<<”, rq=0x34c88 “>>”)

        at input.c:530

        530 if (lquote!= def_lquote)

set printaddress off

    在现实其值的时候不打印地址。例如，下面是用set printaddress off设置后相同的堆栈帧的输出：

        (gdb) set printaddr off

        (gdb) f

        #0 set_quotes(lq=”<<”, rq=”>>”) at input.c:530

        530 if (lquote!= def_lquote)

    可以用’set printaddress off’来从GDB接口中取消所有机器相关的显示。例如，使用print addressoff，可以在所有机器上

    得到相同的内容的回溯–不论时候牵涉到指针参数。

show printaddress

    显示是否打印地址。

  GDB打印符号的地址时，通常会打印离此地址最近且位置靠前的符号，外加打印偏移。如果符号不能指定位置的地址（例如，在一个文

件里的一个名字），你就需要确认它。一个确认的方法是用info line，例如’info line*0×4537′。另外一方法是，在打印一个符号的地

址时设置GDB要打印的源文件和行号：

set printsymbol-filename on

    设置GDB要打印的符号的源文件名和行号。

set printsymbol-filename off

    不打印符号的源文件名和行号。默认方式。

show printsymbo-filename

    显示是否打印符号的源文件名和行号。

  显示符号文件名和行号的另外一种有用的情况是，在反汇编代码时打印文件名和行号。GDB会显示相应于每个指令的行号和源文件。

  另外，你可能希望确认被打印地址的符号形式是否是离得最近且位置考前的符号：

set printmax-symbolic-offset max-offset

    设置GDB只显示地址的符号形式，如果偏移是在最近且靠前的符号和比max-offset低的地址区间。缺省值是0，GDB总是打印比

    此地址靠前的符号。

show printmax-symbolic-offset

    显示GDB打印一个符号地址的最大偏移量。

  如果有一个指针但不能确定它指向何处，可以用’set printsymbol-filename on’来尝试。然后用’p/a pointer’来确认此指针指向的

名字和源文件的位置。这个命令可以将地址转换为符号形式。例如，下面是GDB显示的变量ptt指向另一个变量t,于’hi2.c’定义：

    (gdb) set printsymbol-filename on

    (gdb) p/a ptt

    $4 = 0xe008<t in hi2.c>

    警告：对于执行一个本地变量的指针，’p/a’不显示涉及到符号名和文件名，即使是把相关的set print选项打开也如此。

  其他设置控制如何打印不同类型的对象的方法如下：

set print array

set print arrayon

    以习惯方式打印数组。这个格式更便于阅读，但要更多空间。默认是关闭的。

set print arrayoff

    返回到压缩方式打印数组。

show print array

    显示何种方式显示数组。

set print array-indexes

set printarray-indexes on

    在打印数组的时候打印每个数组成员的下标。可以方便的找到一个给定的数组成员的位置，或者查找一个给定成员的下标。缺省

    是关闭的。

set printarray-indexes off

    在现实数组时，不打印数组成员下标。

show printarray-indexes

    显示在打印数组时是否输出成员下标。

set printelements number-of-elements

    设置GDB打印的数组成员的数量。如果GDB打印一个大数组，在打印完set printelements命令设置的限制之后就不再继续打印此

    数组成员。这个限制也会应用于字符串打印。GDB启动时，这个限制设置为200。将number-of-element设置为0意味着打印数组时

    没有长度限制。

show printelements

    显示GDB打印大数组的长度。如果是0，那么没有限制。

set printframe-arguments value

    这个命令允许控制在调试器打印一个堆栈帧的时候，如何打印参数的值（参见6.1节[帧]，61页）。可能的值：

    all    打印所有的参数值。缺省的。

    scalars    只打印非向量参数。复杂的参数如数组，结构体，联合等，用…替代。下面是非向量参数的打印例子：

        #1 0×08048361 incall_me (i=3, s=…, ss=0xbf8d508c, u=…, e=green)

        atframe-args.c:23

    none    不打印参数。所有的参数都用…替代。下面是这样的例子：

        #1 0×08048361 incall_me (i=…, s=…, ss=…, u=…, e=…)

        atframe-args.c:23

    缺省的，总是打印所有的参数。不过这个命令在好几情况下是非常有用的。例如，在打印每个帧时可以用来减少输出的信息，使

    得回溯更加可读。而且，在打印Ada帧时这个命令可以提高执行效率，因为有时大参数的计算可能是CPU密集型的，特别是在大程

    序里。设置printframe-arguments为scalars或none可以避免这类运算，因此可以加速打印Ada帧。

show printframe-arguments

    显示打印帧时如何显示参数。

set printrepeats

    设置打印数组的长度上限值。如果数组中连续相同的成员的数量超过这个上限，GDB会打印字符串”<repeats ntimes>”，这里n

    是同样的重复次数，而不是重复打印这些相同的成员。将这个上限设置为0的话，打印所有的成员。默认上限时10。

show printrepeats

    显示打印重复相同成员的上限数量。

set printnull-stop

    设置GDB在初次遇到NULL字符是终止打印字符串。如果大数组里包含短字符串时很有用。默认关闭。

show printnull-stop

    显示GDB是否在初次遇到NULL字符串时停止打印。

set print prettyon

    设置GDB在打印结构体时，以缩进的格式每行打印一个结构体成员，如下：

        $1 = {

        next = 0×0,

        flags = {

            sweet = 1,

            sour = 1

        },

        meat = 0×54“Pork”

        }

set print prettyoff

    设置GDB以紧凑方式打印结构体，如下所示：

        $1 = {next =0×0, flags = {sweet = 1, sour = 1}, \

        meat = 0×54“Pork”}

    默认方式。

set printsevenbit-strings on

    只打印7bit的字符串。如果设置了这个选项，GDB用\nnn来显示8bit字符。如果在英语（ASCII）环境下执行或者将高位作为标记

    位或作为元数据位的话，这个设置是非常有用的。

set printsevenbit-strings off

    打印8bit字符。允许使用国际化字符集，缺省的。

show printsevenbit-strings

    显示GDB是否打印7bit字符。

set print unionon

    设置GDB打印包含结构体或其他联合的联合。缺省设置。

set print unionoff

    设置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 unionon，’p foo’会打印如下输出：

        $1 = {it = Tree,form = {tree = Acorn, bug = Cocoon}}

    设置set print unionoff，’p foo’会打印如下输出：

        $1 = {it = Tree,form = {…}}

    set print union对于类似C和Pascal的程序有效。

下面这些设置对于调试C++程序很有用：

set printdemangle

set printdemangle on

    用源代码的形式打印C++名，而不是用编码后传递给汇编器和连接器的形式。默认打开。

show printdemangle

    显示是否用源码形式打印C++名。

set printasm-demangle

set printasm-demangle on

    用源代码的形式打印C++名，而不用编码形式，即使在汇编代码的输出如指令反汇编。默认关闭。

show printasm-demangle

    显示是否用源码形式打印汇编代码。

set demangle-stylestyle

    从编码方式中选择一种编码体系，解析C++名。style的选择有如下几种：

    auto    设置GDB通过探测程序来选择一种解码方式。

    gnu    基于GNU C++编译器(g++)的编码算法的解码方式。缺省方式。

    hp    基于HP ANSI C++（aCC）编码算法的解码方式。

    lucid    基于Lucid C++编译器编码算法的解码方式。

    arm    用C++ Annotated Reference Manual里定义的算法解码。警告：这个选项不足与调试cfront产生的可执行程序。GDB要

        改进才能调试此类程序。

    如果忽略了style，可能会看多多种格式的输出。

showdemangle-style

    显示目前C++符号解析使用的编码方式。

set print object

set print objecton

    在打印一个指针指向的对象时，使用虚函数表来标明对象真实的类型，而不是其声明的类型。

set print objectoff

    只显示对象所声明的类型，不引用虚函数表。默认选项。

show printobject

    显示是否打印真实的，或声明的对象类型。

set printstatic-members

set printstatic-members on

    打印C++对象的静态成员。选项缺省打开。

set printstatic-members off

    打印C++对象时不打印静态成员。

show printstatic-members

    显示是否打印C++静态成员。

set print pascal_static-members

set printpascal_static-members on

    打印Pascal对象的静态成员。选项默认打开。

set printpascal_static-members off

    不打印Pascal对象的静态成员。

show printpascal_static-members

    显示是否打印Pascal静态成员。

set print vtbl

set print vtblon

    以习惯方式打印C++虚函数表。默认关闭。（vtbl命令在HP ANSI C++编译器（aCC）编译的程序上无效。）

set print vtbloff

    不以习惯方式打印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

    printbar[$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

    打印所有的寄存器名和值，除了浮点和向量寄存器（在选定的堆栈帧里）。

infoall-registers

    打印所有的寄存器名和值，包括浮点和向量寄存器（在选定的堆栈帧里）。

info registersregname …

    打印所有指定寄存器对应的值。如下面详细讨论的那样，寄存器值通常是相对于选定的堆栈帧的。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 upperattributes…

    定义一个内存区域，从lower到upper，属性是attribute…，并将其加入由GDB监控的区域列表。注意，upper==0是个特殊例子：

    当作系统最大内存地址。（16位系统里是0xffff，32位系统是0xffffffff）

mem auto

    放弃用户对内存区域的改变，并使用系统提供的区域，如果有的话，如果系统不提供的话就不适用内存区域。

delete mem nums…

    从GDB监控的内存列表里删除内存区域nums…。

disable memnums…

    禁止监视内存区域nums…被禁用的内存区域不会被遗忘。可以在此激活之。

enable mem nums…

    激活监控内存区域nums…

info mem

    打印所有定义的内存区域列表，每个区域都有下面的列：

    Memory RegionNumber

    Enabled orDisabled.

        以激活的内存区域标记为’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 meminaccessible-by-default

    显示当前对于未知内存访问的设置。

 

8.15 在内存和文件之间复制数据

  可以用命令dump，append和restore来在目标内存和文件直线复制数据。dump和append命令将数据写入文件，restore命令将文件数据读入

到内存中。文件可以是二进制，MotorolaS-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-charsetEBCDIC-US设置GDB，那么在输入字符或字符串或在表达式里使用字符和字符串时，GDB会在EBCDIC和Latin 1之间转换。

  GDB不能自动识别调试中的程序所使用的字符集；用户必须告诉它，使用settarget-charset命令，如下所述。

  下面是控制GDB字符集的命令：

settarget-charset charset

    将当前目标字符集设置为charset。下面会列举GDB能识别的字符集名称，不过如果输入settarget-charset接着再敲两次TAB键的

    话，GDB会列出它所能识别的字符集。

set host-charsetcharset

    设置当前的宿主字符集为charset。

    缺省的，GDB使用的宿主字符集和系统的相近；可以用set host-charset命令覆盖默认值。

    GDB只能使用某些字符集作为宿主字符集。下面会列举GDB能识别的字符集名称，并指明哪种可以用作宿主字符集，不过如果输入

    settarget-charset接着再敲两次TAB键的话，GDB会列出它所支持的宿主字符集。

set charsetcharset

    涩会址当前的宿主和目标字符集为charset。如前所述，如果输入set charset接着再敲两次TAB键的话，GDB会列出它所支持的宿

    主/目标字符集。

show charset

    显示当前宿主和目标字符集。

showhost-charset

    显示当前宿主字符集名。

showtarget-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<stdio.h>

    charascii_hello[]

        = {72, 101, 108,108, 111, 44, 32, 119,

            111, 114, 108,100, 33, 10, 0};

    charibm1047_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 -gcharset-test.c -o charset-test

    $ gdb -nwcharset-test

    GNU gdb2001-12-19-cvs

    Copyright 2001Free Software Foundation, Inc.

    …

    (gdb)

  用show charset命令来查看GDB目前使用哪中字符集来转换和显示字符和字符串：

    (gdb) showcharset

    The current hostand target character set is ‘ISO-8859-1’.

    (gdb)

  出于打印手册的缘故，让我们用ASCII作为初始字符集：

    (gdb) setcharset ASCII

    (gdb) showcharset

    The current hostand target character set is ‘ASCII’.

    (gdb)

  假设ASCII是目前宿主系统的真正字符集–换句话说，假设GDB用ASCII字符集打印字符，终端会正确的显示字符。由于当前的目标字符集

也是ASCII，ascii_hello的内容会以可读的形式打印：

    (gdb) printascii_hello

    $1 = 0×401698“Hello, world!\n”

    (gdb) printascii_hello[0]

    $2 = 72 ’H’

    (gdb)

  GDB使用目标字符集来打印字符和字符串常量：

    (gdb) print ’+’

    $3 = 43 ’+’

    gdb)

  ASCII字符集使用数字43来编码字符’+'。

  GDB依赖用户告知目标程序使用的是何种字符集。如果目标字符集还是ASCII，我们试图打印ibm1047_hello就会得到乱码：

    (gdb) printibm1047_hello

    $4 = 0x4016a8“\310\205\223\223\226k@\246\226\231\223\204Z%”

    (gdb) printibm1047_hello[0]

    $5 = 200 ’\310’

    (gdb)

  如果输入set target-charset接着再敲两次TAB键，GDB会告知其所支持的字符集：

    (gdb) settarget-charset

    ASCII EBCDIC-USIBM1047 ISO-8859-1

    (gdb) settarget-charset

  我们可以选择IBM1047作为目标字符集，并再次检查程序字符串。现在ASCII字符串就是错误的了，但GDB会将ibm1047_hello从目标字符

集转换到宿主字符集ASCII，这样就可以正确显示了：

    (gdb) settarget-charset IBM1047

    (gdb) showcharset

    The current hostcharacter set is ‘ASCII’.

    The currenttarget character set is ‘IBM1047’.

    (gdb) printascii_hello

    $6 = 0×401698“\110\145%%?\054\040\167?\162%\144\041\012″

    (gdb) printascii_hello[0]

    $7 = 72 ’\110’

    (gdb) printibm1047_hello

    $8 = 0x4016a8“Hello, world!\n”

    (gdb) printibm1047_hello[0]

    $9 = 200 ’H’

    (gdb)

  如前所示，GDB用目标字符集来打印字符和字符串常量：

    (gdb) print ’+’

    $10 = 78 ’+’

    (gdb)

  IBM1047字符集使用数字78来编码字符’+'。

 

8.18 缓存远程目标的数据

  GDB可以缓存在调试器和远程目标之间交换的数据（参见17章[远程调试]，171页）。这种缓存通常可以改善性能，因为其可减少由于内

存读写所带来的远程协议的开销。不幸的是，目前GDB对volatile寄存器无能为力，因此如果使用了volatile寄存器的时候，数据缓存就会

带来错误的结果。

set remotecacheon

set remotecacheoff

    为远程目标设置缓存状态。如果是on的话，使用数据缓存。缺省的，此选项是off。

show remotecache

    显示目前远程目标的数据缓存状态。

ifo dcache

    打印数据缓存性能的信息。显示的信息包括：dcache的宽度和深度；对于每个缓存行，其被多少次引用到了，其数据和状态（脏

    ，坏，好，等等）。对于调试数据缓存操作，这个命令很有帮助。

    

    

    第九章 C预处理宏

  某些语言，例如C和C++，提供定义和引用“预处理宏”的方法，这些宏可以展开为符号串。GDB可以计算包含宏的表达式，显示宏展开的

结果，并且显示宏的定义，包括在何处定义的。

  可能需要特别编译程序来给GDB提供预处理宏的信息。大多数编译器在调试信息中不包括宏，即使编译时使用’-g’选项。参见4.1节

[编译]，25页。

  程序可能在某个点定义一个宏，在后面删除这个定义，然后在此后给这个宏提供另外的定义。因此，在程序里不同点上，同一个宏可能

有不同的定义，或者根本就没有定义。如果在当前堆栈帧上，GDB使用这个帧源代码行范围的宏。否则，GDB使用当前位置范围的宏；参见[

打印源代码行]，67页。

  同时，GDB不支持##符号剪接操作符，#宏字符串常量替换操作符，或者可变长宏。

  无论何时GDB计算表达式，总会将在表达式里引用的宏展开。GDB也提供下列命令来明确地识别宏。

macro expandexpression

macro expexpression

    显示表达式里引用的所有预处理宏的展开结果。由于GDB只简单地展开宏，不会去解析结果，因此表达式不必是有效的；可以是包

    含任意符号的的字符串。

macroexpand-once expression

macro exp1expression

    （此命令尚未实现。）显示在表达式里引用的预处理宏的展开结果。表达式里的所引用的宏不会改变。这个命令可以更清楚的查

    看一个特殊宏，而不会被更多的展开所迷惑。由于GDB只是简单展开宏，而不解析结果，表达式不必是有效的；可是是任意符号的

    字符串。

info macro macro

    显示名为macro的宏的定义，并显示这个定义是在代码的何处设立的。

macro definemacro replacement-list

macro define macro(arglist)replacement-list

    （此命令尚未实现。）为名为macro的宏引入一个定义，对其的引用将被给定的replacement-list所替换。此命令的第一中

    形式定义了“对象式”的宏，不带参数；第二种形式定义了一个“函数式”的宏，用给定的arglist作为参数的。

    用此命令引入的定义，其范围在GDB所计算的所有表达式中，知道用命令macro undef命令删除之，如下所述。此定义会覆盖调试程

    序里所有名为macro的宏定义，并且也包括任何用户提供的定义。

macro undefmacro

    （此命令尚未实现。）删除所有用户提供的名为macro宏定义。此命令只影响用命令macro define所定义的宏。如前所述；不能删

    除调试程序里的定义宏。

macro list

    （此命令尚未实现。）列举所有用macro define命令定义的宏。

  下面的例子展示了如何使用上述命令。首先，看一下源代码：

    $ cat sample.c

    #include<stdio.h>

    #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 gdb2002-05-06-cvs

    Copyright 2002Free Software Foundation, Inc.

    GDB is freesoftware, …

    (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 macroADD

    Defined at/home/jimb/gdb/macros/play/sample.c:5

    #define ADD(x)(M + x)

    (gdb) info macroQ

    Defined at/home/jimb/gdb/macros/play/sample.h:1

    included at/home/jimb/gdb/macros/play/sample.c:2

    #define Q <

    (gdb) macroexpand ADD(1)

    expands to: (42+ 1)

    (gdb) macroexpand-once ADD(1)

    expands to: once(M + 1)

    (gdb)

  注意，在上面的这个例子里，macro expand-once只把原文本引用的宏展开–ADD的引用–但不展开宏M，此宏由ADD所引用。

  一旦程序运行起来后，在当前堆栈帧的源代码上，GDB使用有效的宏定义：

    (gdb) break main

    Breakpoint 1 at0×8048370: file sample.c, line 10.

    (gdb) run

    Startingprogram: /home/jimb/gdb/macros/play/sample

    Breakpoint 1,main () at sample.c:10

    10 printf(“Hello, world!\n”);

    (gdb)

  在第10行，宏N的有效定义是在第9行：

    (gdb) info macroN

    Defined at/home/jimb/gdb/macros/play/sample.c:9

    #define N 28

    (gdb) macroexpand N Q M

    expands to: 28< 42

    (gdb) print N QM

    $1 = 1

    (gdb)

  如果我们单步执行到删除N的定义之后，并给其新的定义，GDB会在每个点上找到有效的定义（或者没有定义）：

    (gdb) next

    Hello, world!

    12 printf(“We’re so creative.\n”);

    (gdb) info macroN

    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 socreative.

    14 printf(“Goodbye, world!\n”);

    (gdb) info macroN

    Defined at/home/jimb/gdb/macros/play/sample.c:13

    #define N 1729

    (gdb) macroexpand N Q M

    expands to: 1729< 42

    (gdb) print N QM

    $2 = 0

    (gdb)

    

    

    第十章  跟踪点

  在某些应用程序里，调试器不大可能因为开发者要了解此程序的行为，长时间的中断程序的执行。如果程序的正确性依赖于实时行为，调试器造成的延迟会导致程序根本改变其行为，甚至在代码本省正确的情况下也可能导致失败。不中断程序的执行来观察其行为是非常有用的功能。

  使用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) tracefoo.c:121 // 源文件和行号

        (gdb) trace +2// 当前行的下两行

        (gdb) trace myfunction // 函数的第一行代码

        (gdb) trace *myfunction // 函数的真正开始的地方

        (gdb) trace*0x2117c4 // 某个地址

    trace可以简写为tr。

    惯用变量$tpnum记录最近设置的跟踪点号。

delete tracepoint[num]

    永久删除一个或多个跟踪点。不带参数的话，默认删除所有的跟踪点。

    例如：

        (gdb) deletetrace 1 2 3 // 删除三个跟踪点

        (gdb) deletetrace // 删除所有跟踪点

    此命令可以简写为del tr。

 

10.1.2 激活和禁用跟踪点

disabletracepoint [num]

    禁用跟踪点num，或者所有跟踪点，如果不指定参数的话。已禁用的跟踪点在下一次跟踪会话期将不再有效，但不会被系统遗忘。

    enabletracepoint命令可以再次激活已禁用的跟踪点。

enabletracepoint [num]

    激活跟踪点num，或者所有的跟踪点。已激活的跟踪点将在下一次跟踪会话期起效。

 

10.1.3 跟踪点通过计数

passcount [n[num]]

    设置跟踪点的通过计数。使用通过计数可以自动中止跟踪会话。如果跟踪点通过计数是n，那么跟踪会话会在跟踪点第n次执行到的

    时候自动中止。如果没有指定跟踪点号num，通过计数命令将设置最近创建的跟踪点。如果没有指定通过计数，那么跟踪会话会在

    一直执行，直到用户手动终止为止。

    例如：

        (gdb) passcount5 2 // 跟踪点2在第5次执行时中止

        (gdb) passcount12 // 最近创建的跟踪点，在第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) collectdata // 收集某些数据

        (gdb)while-stepping 5 // 单步执行5次，收集数据

        (gdb) end // 操作结束

    下面的例子里，操作列表从collect命令开始，在跟踪点执行到时收集数据。那么，要单步执行和收集额外的数据，就要在设置单

    步执行时收集数据之后执行while-stepping命令。需要用end命令来终结while-stepping命令。最后，用end命令来终结操作列表。

        (gdb) trace foo

        (gdb) actions

        Enter actionsfor tracepoint 1, one per line:

        > collectbar,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-stepping12

    > 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 AddressPassC StepC What

        1 y 0x002117c4 00 <gdb_asm>

        2 y 0x0020dc64 00 in g_test at g_test.c:1375

        3 y 0x0020b1f4 00 in get_data at ../foo.c:41

        (gdb)

    本命令可缩写为info tp。

 

10.1.6 开始和中止跟踪会话

tstart    此命令不需要参数。开始一次跟踪会话，并开始收集数据。如果不保留上一次跟踪会话期间收集的数据的话，可能会带来一些副

    作用。

tstop    此命令不需要参数。结束一次跟踪会话，并停止收集数据。

    注意：一次跟踪会话和数据收集可能在达到跟踪点通过计数时自动终止（参见10.1.3节[跟踪点通过计数]，106页），或者在跟踪

    缓冲区满的时候也可能导致终止。

tstatus    此命令显示当前跟踪数据收集的状态。

  下面是关于目前为止我们介绍的命令的例子：

    (gdb) trace gdbc test

    (gdb) actions

    Enter actionsfor 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,inforegisters,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 tracepointnum

    查找跟踪点编号num相对应的下一个快照。搜索从最近查看的跟踪点快照开始。如果不带参数num的，查找当前跟踪点的下一个快照

    。

tfind pc addr

    查找程序计数器地址addr对应的下一个快照。搜索从最近查看的跟踪点快照开始。如果不带参数的话，查找当前快照的PC对应的下

    一个快照。

tfind outsideaddr1,addr2

    查找指定范围之外的PC对应的下一个快照。

tfind rangeaddr1,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) tfindstart

    (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 actionsfor tracepoint #2, one per line:

    > collect$regs, $locals, $args, gdb_long_test

    > end

    (gdb) tstart

    (gdb) tfind line444

    #0 gdb_test(p1=0×11, p2=0×22, p3=0×33, p4=0×44, p5=0×55, p6=0×66)

    atgdb_test.c:444

    444 printp( “%s:arguments = 0x%X 0x%X 0x%X 0x%X 0x%X 0x%X\n”, )

    (gdb) tdump

    Data collectedat tracepoint 2, trace frame 1:

    d0 0xc4aa0085-995491707

    d1 0×18 24

    d2 0×80 128

    d3 0×33 51

    d4 0x71aea3d119204413

    d5 0×22 34

    d6 0xe0 224

    d7 0×3800353670069

    a0 0x19e24a1696330

    a1 0×300066850333288

    a2 0×100 256

    a3 0×3220003284992

    a4 0×300069850333336

    a5 0x1ad3cc1758156

    fp 0x30bf3c0x30bf3c

    sp 0x30bf340x30bf34

    ps 0×0 0

    pc 0x20b2c80x20b2c8

    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.3save-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) tfindstart

    (gdb) while$trace frame != -1

    > output$trace_file

    > printf “,line %d (tracepoint #%d)\n”, $trace_line, $tracepoint

    > tfind

    > end

 

译注：

stub，翻译成”存根”还是”代理”，”存根”感觉有点拗口，对应于中文的感觉不是很舒服；”代理”又觉得不能完整表达原文的意义。

 

 

第十一章调试使用覆盖技术的程序

  如果程序大到不能放到系统的内存里，你可以使用覆盖技术来规避这个问题。GDB提供了调试使用覆盖技术的程序的支持。

 

11.1 覆盖是如何工作的

  假设你的计算机的指令地址空间只有64KB长，而有超过此长度的内存可供别的方式访问：例如：特殊指令，段寄存器，或者内存管理硬件。进一步假设，你要将一个超过64KB长的程序加载到此计算机上运行。

  一个解决方法是，将相对独立且相互之间没有直接调用的程序模块单独标识；这些模块称为覆盖段。将这些覆盖段从主程序里隔离，将它们的机器码放在更大的内存中。将主程序放在指令内存中，而同时保留至少足够大的空间来存放最大的覆盖段。

  现在，要调用一个位于覆盖段上的函数，首先必须从大内存里将此覆盖段的机器代码复制到指令内存中来，并跳转到其入口点。

                Data                   Instruction              Larger

                Address Space  Address Space     Address Space

                +———–+     +———–+      +———–+

                |                   |      |                  |        |                  |

                +———–+     +———–+      +———–+<–overlay 1

                | program     |      |     main       | .—-| overlay 1  | load address

                | variables   |       | program     | |     +———–+

                | and heap   |      |                   | |      |                  |

                +———–+     |                   | |      +———–+<– overlay 2

                |                  |      +———–+ |      |                 | load address

                +———–+    |                    | |    . -| overlay 2 |

                                         |                    | |   |    |                |

                     mapped—>+———–+  |   |    +———–+

                     address       |                     | |   |    |                  |

                                         | overlay        |<- |    |                  |

                                         | area             |<—  +———–+<– overlay 3

                                         |                     | <—.|                   | load address

                                         +———–+ ‘–    | overlay3    |

                                         |                    |          |                   |

                                        +———–+           |                   |

                                                                        +———–+

                                                                        |                   |

                                                                        +———–+

                覆盖代码

  这个图（参见[覆盖代码]，113页）展示了将数据和指令地址空间分割的系统。要映射一个覆盖段，程序需要从大地址空

间将代码复制到指令空间。由于上面介绍的所有复占位段使用相同的映射地址，所以在同一时刻只有一个可以映射。对于数据和指令使用同一个地址空间的系统，原理是相同的，只是程序变量，堆，主程序和覆盖段共享一个地址空间。

  一个已经加载进指令内存且准备好使用的覆盖段称为已映射的覆盖段；其映射到地址是指令内存中的地址。指令空间中未加载（或部分加载）的覆盖段称为未映射覆盖段；其加载地址是在大内存中的地址。已映射地址也称为虚拟内存地址，或VMA；加载地址也称为加载内存地址，或者LMA。

  不幸的是，对于将程序放置在有限指令内存的方法，覆盖段不完全是透明的方式。它们引进了一些新的全局行限制，在设计程序时必须时刻牢记在心：

·在调用前或返回到一个覆盖段里的函数时，程序必须保证此段是已映射的。否则，调用或返回会将控制交给此实际地址，但错误的段，程序很可能会崩溃。

·如果系统里映射覆盖段的处理很昂贵，那就需要仔细的选择覆盖段来减少其对程序性能的影响。

· 加载进系统的可执行文件必须包含每个覆盖段的指令，就是说覆盖段的加载地址，不是它们的已映射地址。不过，每个重复占位的指令必须重新重新定位，其符号就如同段在它的已映射地址上。可以用GNU连接器脚本来为程序的各个段指定不同的加载和重定位地址；参见使用ld:GNU连接器，节”覆盖段描述”。

·系统加载可执行文件的程序不但要能够将可执行文件的内容加载进大地址空间，也要能加载进指令和数据空间。

  上面介绍的覆盖段系统是相对简单的，还可以有许多改进的方式：

·如果系统有合适的体开关寄存器或者存储器管理硬件的话，可以用这些工具来让覆盖段的加载区域内容简单的映射到在经过映射后的指令地址空间里。这个方式很可能比复制覆盖段的内容到映射区域去要快得多。

·如果覆盖段足够小，可以一次设置多个段，并且可以同时映射多个段。

· 可以用覆盖段来管理数据，就如同指令那样。通常来说，数据覆盖段比代码覆盖段更加不透明：只有在调用或返回到代码覆盖段的时候，才需要关心，数据覆盖段却时刻需要注意你所访问的数据。而且，如果改变了一个数据覆盖段的内容，在复制其它的数据覆盖段到此映射区域前，必须将其内容复制回其加载地址。

 

11.2  覆盖命令

  要使用GDB对覆盖的支持，程序里每个覆盖必须对应可执行文件里的一个单独段。段虚拟内存地址和加载内存地址必须是覆盖段的映射和加载地址。将覆盖段和程序段等价使得GDB可以判断函数或变量的恰当的地址，由此覆盖段是否映射就可以推测。

  所有GDB覆盖段命令都以overlay开头；可以缩写为ov获ovly。这些命令是：

overlay off

    禁用GDB对覆盖段的支持。禁用覆盖的支持之后，GDB会假设所有的函数和变量都位于其映射地址上。缺省的，GDB禁用

    对覆盖的支持。

overlay manual

    激活手动覆盖调试。在此模式下，GDB由用户告知映射的是哪个段，哪个段未映射，使用下面介绍的overlaymap-overlay

    和overlay unmap-overlay命令。

overlaymap-overlay overlay

overlay mapoverlay

    通知GDB段已映射；overlay必须是目标文件包含此覆盖段的名字。段映射后，GDB假定可以在映射地址上查找到覆盖段的函

    数和变量。GDB假定其他会重叠在此映射地址上的段都未映射。

overlayunmap-overlay overlay

overlay unmapoverlay

    通知GDB段解除映射；overlay必须是目标文件包含此覆盖段的名字。段解除映射之后，GDB假定段的函数和变量都位于其加载地

    址上。

overlay auto

    激活自动覆盖调试。在此模式下，GDB会查询一个由内部覆盖管理器维护的数据结构，以此得知映射的哪一个段。更多

    细节，参见11.3节[自动覆盖调试]，446页。

overlayload-target

overlay load

    从内部重读覆盖段表。通常，每次GDB在内部中断时都会自动重读此表，因此这个命令只在手动该表段映射时才需要使用。此命

    令只在使用自动段调试时才有用。

overlaylist-overlays

overlay list

    打印当前已映射段的列表，输出映射地址，加载地址和大小。

  通常，GDB在打印一个代码地址时，会包含函数名，和地址：

    (gdb) print main

    $3 = {int ()}0x11a0 <main>

当覆盖段调试启用后，GDB能够识别未映射段上的代码，并用*符号来标识次未映射函数名。例如，如果foo是位于未映射段上的函数，

GDB会如下打印：

    (gdb) overlaylist

    No sections aremapped.

    (gdb) print foo

    $5 = {int (int)}0×100000 <*foo*>

foo对应的段映射后，GDB会正常方式打印函数名：

    (gdb) overlaylist

    Section.ov.foo.text, loaded at 0×100000 – 0×100034,

        mapped at 0×1016– 0x104a

    (gdb) print foo

    $6 = {int (int)}0×1016 <foo>

  覆盖调试启用后，GDB就可以在覆盖段上正确地查找函数和变量的地址了。因此，大多数GDB命令，如break何disassemble，就可以正常使用了，即使是在未映射段上也可以。然而，GDB断点支持还是有一些限制：

·只要GDB可以往在加载地址上的段上写入数据，就可以在此未映射段上的函数里设置断点。

·GDB不能在未映射段上设置硬件和基于模拟器的断点。不过，如果在覆盖管理器的尾部上设置断点的话（并告诉GDB映射的是哪个段，如果手动管理重覆盖段的话），GDB恰当地会重新设置其断点。

 

11.3 自动覆盖调试

  只要覆盖管理器提供一些简单的协作，GDB就可以自动跟踪段的映射情况。如果用overlay auto命令启用了自动段调试（参见11.2节[覆盖命令]，114页），GDB会从内部存储器里查找某些变量来，就可以得到当前段的状态。

  要支持GDB自动覆盖调试，下面是覆盖管理器必须定义的变量：

_ovly_table:

    这个变量必须是下面结构体的数组：

        struct

        {

       

        unsigned long vma;

       

        unsigned longsize;

       

        unsigned longlma;

       

        unsigned longmapped;

        }

_novlys:

    这个变量必须是一个4字节的有符号整数，存储_ovly_table的数量。

  要判断一个特殊段映射与否，GDB会从_ovly_table里查找一个节点，比较其vma和lma是否和此段在可执行文件上的VMA和LMA相等。GDB查到

匹配的节点时，就会通过结构体成员mapped来判断此段是否已经映射了。

  另外，段管理器也可能定义一个函数，函数名为_ovly_debug_event。如果定义了此函数，GDB可以悄悄地在此函数上设置一个断点。如果

段管理器在其改变了段表时调用这个函数，就可以使得GDB能够准确的跟踪段的映射情况，并且更新其上设置的断点。即使段还在ROM或者其

它不可写内存上，还没有执行的时候，这个功能也能让断点能够执行。

 

11.4 覆盖示例程序

  在链接使用了覆盖的程序时，必须将段置于其加载地址上，而在运行时再将其重定位于映射地址上。要达到这个目的，必须写一个连接器脚本（参见节”覆盖介绍”使用ld:GNU连接器）。不幸的是，由于连接器脚本是和宿主系统，目标架构和目标内存布局高度相关的，本手册不能提供可移植的示例代码来演示GDB的覆盖支持。

  不过，作为GDB源代码的测试套件的一部分，GDB源代码发布版包含了一个覆盖程序，带有支持一些系统的连接器脚本。程序由’gdb/testsuite/gdb.base’目录下的文件组成：

‘overlays.c’

    主程序文件。

‘ovlymgr.c’

    覆盖管理器，由’overlays.c’调用。

‘foo.c’

‘bar.c’

‘baz.c’

‘grbx.c’

    覆盖模块，由’overlays.c’加载和使用。

‘d10v.ld’

‘m32r.ld’

    连接器脚本，链接生成测试程序的目标d10v-els和m32r-elf目标。

  用d10v-elf GCC交叉编译器来生成测试程序：

    $ d10v-elf-gcc-g -c overlays.c

    $ d10v-elf-gcc-g -c ovlymgr.c

    $ d10v-elf-gcc-g -c foo.c

    $ d10v-elf-gcc-g -c bar.c

    $ d10v-elf-gcc-g -c baz.c

    $ d10v-elf-gcc-g -c grbx.c

    $ d10v-elf-gcc-g overlays.o ovlymgr.o foo.o bar.o \

    baz.o grbx.o-Wl,-Td10v.ld -o overlays

  各个架构的编译的过程都一样，除了必须将相应的编译器和链接器替换为相应目标系统的编译器和链接器。   

  

  

  第十二章用GDB调试不同语言编写的程序

  虽然编程语言通常都有一些共同的东西，但是事实上它们却很少能够用相同的形式来表述。例如，在ANSI C里，对指针p取值是用*p来表示的，而在Modula-2里，用p^。值的表示（或者显示）也可能不相同。C里的16进制数的表示形如”0x1ae”，而在Modula-2里表示如”1AEH”。

  GDB里内置了某些语言的与其相关的信息，可以用程序原语言来执行类似上述的操作，也使得GDB可以和程序元语言一致的形式输出值。用来建立表达式的语言成为工作语言。

 

12.1 切换源代码语言

  有两种方式可以控制工作语言–一种是让GDB自动设置，一种是用户手动设置。可以用set language命令来达到意图。GDB在启动时会自动设置语言。工作语言用来决定如何翻译用户输入的表达式，如何打印这些结果，等等。

  除了工作语言之外，GDB能识别的源文件都有其自己的工作语言。对于某些目标文件格式，编译器可能会提示此特定源文件是那种语言。不过，大多数时候GDB都是从文件名里推断语言种类的。源文件的语言控制C++名字是否去修饰符–这种方式是backtrace以其自身语言来恰当地显示每一个帧。参见 12.2节[显示语言]，120页。

  使用程序时，例如cfront或f2c，这类程序产生C的目标代码，但其本身是用其它语言编写的，通常都会碰到问题。在此情况下，让程序在其C输出里使用#line指令；这种方式可以让GDB知道原程序代码正确的语言，并能显示源代码，而不是显示其所产生的C代码。

 

12.1.1 文件扩展名和语言列表

  如果源文件的扩展名是下列名称之一，那么GDB就会推断其语言。

‘.ada’

‘.ads’

‘.adb’

‘.a’ Ada 源文件.

‘.c’ C 源文件

‘.C’

‘.cc’

‘.cp’

‘.cpp’

‘.cxx’

‘.c++’ C++ 源文件

‘.m’ Objective-C源文件

‘.f’

‘.F’ Fortran 源文件

‘.mod’ Modula-2 源文件

‘.s’

‘.S’    汇编源文件。和C一样执行，但在单步跟踪时GDB不会跳过函数的序言。

  另外，可以设置和文件扩展名相关的语言。参见12.2节[显示语言]，120页。

 

12.1.2 设置工作语言

  如果允许GDB自动设置语言的话，那么在程序和调试会话里表达式就以相同的方式转换。

  如果用户期望的话，也可以手动设置。要手动设置，执行命令’set languagelang’，lang是语言的名称，例如c和modula-3。要得到GDB支

持的语言列表，执行命令’set language’。

  手动设置语言将妨碍GDB自动更新工作语言。在调试工作语言和源代码语言不想同时，如果两种语言都可以接受表达式—但表示不同的事情的话，就可能导致一些困惑了。例如，如果当前的源文件是用C写的，GDB分析Modula-2，如下的命令：

    print a = b + c

可能不会得到你所期望的那个结果。在C里，这个命令表示得失将b和c相加，并将其结果赋值给a。结果是打印出a的值。在Modula-2里，这个命令表示比较a和b+c的结果，产生一个布尔值。

 

12.1.3 让GDB推断源语言

  要让GDB自动设置工作语言，用’set languagelocal’或者’set language auto’。GDB就会推断工作语言了。也就是说，程序在一个堆栈帧里中断的时候（通常是遇到了一个断点），GDB就会为此栈上的函数设置已记录的工作语言。如果此帧的语言未知（那就是说，此帧上的函数或代码块定义于某个源文件，此文件的扩展名却是未知的），当前工作语言不会改变，GDB会发出一个警告。

  这个命令对于多数只用同一种源代码语言编写的程序来说不是必须的。不过，用同一个源代码语言编写的程序模块和库可以被不同源语言编写的主程序调用。使用’set languageauto’可以免除用户手动设置工作语言之苦。

 

12.2 显示语言

  下面的命令可以助你找出何种工作语言，并找出程序是哪种源代码语言编写的。

show language

    显示当前工作语言。可以用这个语言来执行命令（如print）来建立和计算表达式，表达式里可以引用程序里的变量。

info frame

    显示此帧的源代码语言。如果从此帧上使用了一个标志符的话，这个语言就变成工作语言。要识别列于此处的其他信息，参见6.4节

    [堆栈帧的信息]，65页。

info source

    显示此源代码的源代码语言。要识别列于此处的其他信息，参见13章[检验符号表]，143页。

  在某些异常情况下，源文件的扩展名可能不在标准列表里。可以明确将语言和扩展名关联起来。

set extension-languageext language

    设置GDB将扩展名ext的文件认为是由源代码语言language编写的。

info extensions

    列出所有的文件扩展名和相关连的语言。

 

12.3 类型和域检查

  警告：在本版手册里，包括了GDB类型和域检查命令，但还没有效用。本节文档介绍了预期的功能。

  通过编译期和运行时检查，某些语言的设计可以防止程序员犯一些常见的错误。这些检查包括函数和操作符的参数的类型检查，保证在运行时捕获算术溢出。一旦通过排除类型不匹配的错误，程序编译好之后，检查这些有助于保证程序的正确性，并能在程序运行时提供对域错误的实时检查。

  GDB可以检查如上述条件的检查。虽然不检查程序里的状态，GDB可以检查直接传递给它的表达式，例如print命令可以计算表达式的值。如同工作语言一样，GDB也可以基于程序的源语言来决定是否自动检查。关于缺省的语言支持设置，参见12.4节[语言支持]。

 

12.3.1 类型检查概述

  某些语言，如Modula-2，是强类型的，也就是说操作符和函数的参数必须是正确的类型，否则就会发生错误。这个检查防止类型不匹配的错误引起运行时错误。例如，

    1 + 2 => 3

但

    [error] 1 + 2.3

  第二个例子的错误是因为序数（CARDINAL）1和实数（REAL）2.3类型不相容。

  对用于GDB命令的表达式，用户可以设置让GDB类型检查器不检查；将任意不匹配作为错误并拒绝表达式；或者在遇到类型不匹配时只发出警告，但会计算表达式。如果选择了最后一项，GDB会计算如上述第二个例子的表达式，但会发出一个警告。

  即使关闭了类型检查，也还有其他和类型有关的理由来防止GDB去对表达式进行计算。例如，GDB不知道如何将一个int型和struct foo型相加。这些特殊的类型错误和使用的语言无关，常常在表达式里引起，例如前面介绍的那个例子，其错误是不知道如何计算。

  每种语言都定义了其对类型检查的严格程度。例如，Modula-2和C要求算数操作符的参数都是数字。在C里，枚举类型和指针可以转换为数

值型，所以他们对于算数操作符也是有效的。关于特定语言的更多细节，参见12.4节[语言支持]。

  GDB提供了附加命令来控制类型检查器：

set check typeauto

    设置自动类型检查，由当前工作语言决定。各种语言的缺省设置，参见12.4节[语言支持]。

set check typeon

set check typeoff

    设置类型检查启用或关闭，覆盖掉当前工作语言的缺省设置。如果设置不匹配语言的缺省值就会发出一个警告。如果启用了类型检

    查，在计算表达式的时候发现类型不匹配的话，GDB会打印警告信息并放弃计算表达式。

set check rangewarn

    在GDB域检查器发现域错误的时候输出警告信息，但会尝试计算表达式的值。由于其他缘故，表达式计算可能会失败，例如访

    问不属于进程的内存（许多Unix系统的典型例子）。

show range

    显示当前域检查器的设置，以及GDB是否自动设置了域检查器。

 

12.4 语言支持

  GDB支持C，C++，Objective-C，Fortran，Java，Pascal，汇编，Modula-2和Ada语言。GDB的某些功能可以用于和语言无关的表达式：GDB@，::操作符和’{type}addr’指令（参见8.1节[表达式]，75页）可以和任何GDB支持的语言的指令一起用。

  接下来的章节详细的介绍了GDB对于每种语言的支持程度。这些章节不是语言导论和参考，而只是GDB表达式解析器能接受何种表达式的参考指引，以及对于各种不同语言的输入输出格式。有许多关于这些语言很好的书；请参考这些书的参考或导论。

 

12.4.1 C和C++

  由于C和C++关系很近，GDB的很多功能都能在这两种语言上使用。在这些情况下，我们一起讨论这两种语言。

  C++调试工具是由C++编译器和GDB共同实现的。因此，要有效调试C++代码，必须用支持C++的编译器上编译C++程序，例如GNU g++，或HP ANSI C++编译器（aCC）。

  使用GNU C++时要得到最佳效果，应使用DWARF 2调试格式；如果此格式不能在你的系统里执行，请尝试用stabs+调试格式。你可以用g++命令行选项’-gdwarf-2′和’-gstabs+’选择格式。“Options forDebugging Your Program or GCC” in Using the gnu Compiler Collection (GCC)。

 

12.4.1.1 C和C++操作符

  操作符必须定义于明确类型的值。例如，+定义于数值，但不是结构体。操作符常常定义与类型组。

  下列定义表述了C和C++的目的：

·整型类型包括int和其存储类型限定符；char；enum；以及C++的bool。

·浮点类型包括float，double和long double（如果目标平台支持的话）。

·指针类型包括所有定义为(type*)的类型。

·标量类型包括所有上述类型。

  GDB支持下列操作符。下面将以递增的次序列举：

,         逗号和顺序操作符。用逗号分隔的表达式列表将从左到右计算，最后计算整个表达式的结果。

=        赋值。赋值表达式的值是被赋值的值。定义于标量类型。

op=    用于形如a op=b的表达式里，并转换到a = a op b。op=和=具有相同的优先顺序。op是下面的任意操作符之一：|, ^, &,<<, >>,

          +, -, *, /, %。

?:        三进制操作符。a?b:C可以如此认为：如果a那么b，否则c。a必须是整形类型。

||         逻辑或。定义于整形类型。

&&   逻辑与。定义于整形类型。

|         位或。定义于整形类型。

^        位异或。定义于整形类型。

&       位与。整形类型。

==,!=    相等和不相等。表达式的值0代表假，非0代表真。

<, >,<=, >=

             小于，大于，小于等于，大于等于。定义与标量类型。表达式的值0代表假，非0代表真。

<<,>>    左移，右移。定义于整形类型。

@           GDB”人工数组”操作符（参见8.1节[表达式]，75页）。

+,-           加和减。定义于整形类型，浮点类型和指针类型。

*, /, %     乘，除和求余。乘和除定义于整形和浮点类型。求余定义与整形类型。

++，–    自增和自减。位于变量前面，此操作符会于变量使用前执行；位于变量后面，操作符会在变量使用后执行。

*             对指针取值。定义于指针类型。和++的优先级相同。

&          地址操作符。定义于变量。和++的优先级相同。

             对于调试C++，除了在C++语言里的用法，GDB还实现了’&’的另一种用法：可以用’&(&ref)’来查看C++引用变量（用’&ref’声

             明）的存储地址。

-           负。定义于整形和浮点类型。和++的优先级相同。

!           逻辑非。定义于整形类型。和++的优先级相同。

~          按位求补运算符。定义与整形类型。按位求补运算符。

.,->       结构体成员，结构体指针成员。为方便起见，GDB视这两种操作符为等同，基于存储类型信息来选择是否对一个指针取值。定

            义于结构体和联合数据。

.*,->*    对指针指向的成员取值。

[]          数组索引。a[i]定义如*(a+i)。和->的优先级相同。

()          函数参数列表。和->的优先级相同。

::           C++范围解析操作符。定义于结构体，联合和类。

::           双冒号也表示GDB范围解析操作符（参见8.1节[表达式]，75页）。和::的优先级相同，如上。

  如果在用户代码里重新定义了操作符，通常GDB会尝试用重新定义的版本来执行，而不用预定义的方式。

 

12.4.1.2 C和C++常量

  GDB允许用户用下列方式表示C和C++的常量：

·整形常量是数字系列。8进制常量的由’0′(即0)开头，16进制常量由’0x’或’0X’开头。常量也可以用字符’l'结尾，指明次常量应该视为

  long(长整型)类型。

· 浮点指正常量是数字系列，接着一个十进制小数点，再接着数字系列，还可以接着一个指数。指数形如’e[[+]|-]nnn’，这里nnn是另一个

  数字系列。如是正的指数，’+'可选用。浮点常量也可以用字符’f'或者’F'结尾，指明此常量应视为float（而不是默认的double）类型；

  或者用字符’l'或者’L'来结尾，指明是long double常量。

·枚举常量有枚举变量，或者是枚举变量对应的整数组成。

· 字符常量是由单引号(‘)括起来的单个字符，或者一个数字–字符对应的原始数值(通常是其ASCII值)组成。在引号里，单字符可以用一    个词或者转义序列表示，形如’\nnn’，这里nnn是字符序数的八进制表现形式；或者形如’\x’，这里’x'是预定义的特殊字符—例如，’\n’

 表示新行（newline）。

·字符串常量由双引号(“)括起来的字符常量系列组成。任何有效的字符常量（如上所述）都可以。字符串里的双引号必须跟在反斜杠后面，例如’”a\”b’c”‘是5字符的字符串。

·指针常量是整形值。也可以用C操作符’&’将指针写道常量里。

· 数组常量用花括号’{‘和’}'括起来，用逗号分隔；例如，’{1,2,3}’是3元素的整形数组，‘{{1,2}, {3,4},{5,6}}’是3行2列的数组，   而‘{&”hi”, &”there”, &”fred”}’是3元素的指针数组。

 

12.4.1.3 C++表达式

  GDB可以处理大多数C++表达式。

  注意：只有在使用正确的编译器和调试格式的情况下，GDB才能调试C++代码。目前，在用GCC 2.95.3或者GCC 3.1或者更新的版本上，使用选项‘-gdwarf-2’或者‘-gstabs+’的C++代码上，GDB工作的最好。DWARF 2优于stabs+。大多数GCC的配置选用DWARF 2或者stabs+作为其默认调试格式，所以通常不需要手动指定调试格式。用其它编译器编译的和/或者调试格式的代码，GDB可能工作的不太好，也可能根本就不起效。

1.允许调用成员函数；调用表达式如下：

    count =aml->GetOriginal(x, y)

2.当成员函数可用时（在选定的堆栈帧上），表达式和成语函数具有相同的可用的名字空间；那就是说，用C++相同的规则，GDB允许

   隐式引用类实例指针this。

3.可以调用重载函数；GDB会在某些限制下解决函数调用中函数的正确的定义。涉及到用户定义类型的转换，构造函数的调用，不在程 

  序里的模板实例，GDB都不会去进行重载解析。GDB也不能处理省略参数列表或者默认参数的情况。

  GDB可以执行整形转换和提升（例如在函数参数char提升到int），浮点提升，算术转换，指针转换，类对象转换到基类，以及标准转 

  换如函数和数组到指针；GDB需要精确匹配函数参数的数量。

  总是执行重载解析，除非指定了set overload-resolution off。参见节12.4.1.7[GDB的C++功能]，128页。

  要使用明确的函数签名来调用一个重载函数，必须指定setoverload-resolution off，如

      p ’foo(char,int)’(’x’, 13)

  GDB命令补全功能可以简化这些；参见节3.2[命令补全]，19页。

4.GDB能理解定义为C++引用的变量；可以在表达式里使用这些变量，如同在C++源代码里一样–它们是自动取值的。

  在GDB显示堆栈帧的时候，引用变量的值不睡显示在参数列表里（和其它类型的变量不同）；这样能避免聚集，因为引用变量常常用 

  于大的结构体。总是显示引用变量的地址，除非指定了’set printaddress off’。

5.GDB支持C++名字解析操作符::–表达式可以使用此操作符就如同在程序里那样。由于一个范围可以定义于另外一个，如果需要可以 

  重复使用::，例如表达式如’scope1::scope2::name’。

  在C和C++调试里，GDB也可以参考源文件来解决名字空间（参见8.2节[程序变量]，76页）。

  另外，要是用HP的C++编译器，GDB支持虚函数调用，打印对象的虚基类，调用基类子对象的函数，对象转换，以及调用用户定义的

  操作符。

 

12.4.1.4 C和C++缺省值

  如果允许GDB自动设置类型和域检查，工作语言转换到C或者C++时，这两个设置的缺省设置都是off。不论用户或GDB是否选择工

作语言，GDB都是这样处理的。

  如果允许GDB自动设置语言，GDB会识别文件名以’.c’，’.C’或者’.cc’等等结尾的文件，在GDB进入以这些文件编译的代码时，GDB会将工作语言设置为C或者C++。更多细节，参加节12.1.3[设置GDB推断源文件语言]，120页。

 

12.4.1.5 C和C++类型和域检查

  在GDB分析C或者C++表达式，缺省的，不使用类型检查。不过，如果你将类型检查打开，GDB认为这两种变量类型相等，如果：

·这两种变量是结构化的且具有相同的结构，联合，或者枚举标签。

·这两种变量具有相同的类型名，或者用是用typedef声明的相等的类型。

  域检查，如果打开的话，用于数学操作。由于下标常常用于索引一个指针，而指针本身并不是数组，数组下标不检查。

 

12.4.1.6 GDB和C

  set print union和show print union命令应用于union类型。要是设置为’on’，任何struct或者class里的union都会打印。否则，会用

‘{…}’替代。

  @操作符有助于调试用指针和内存分配函数分配的动态数组。参见节8.1[表达式]，75页。

 

12.4.1.7 GDB的C++功能

  GDB某些命令对于C++特别有用，而有些是特殊设计用于C++。下面是这些命令的概述：

breakpoint menus

    要想在一个重载函数里设置断点，GDB断点菜单可以助你指定哪个函数定义上设置。参见节5.1.8[断点菜单]，52页。

rbreak regex

    用正则表达式设置断点，正则表达式断点对于在不是任何特殊类的成员重载函数上设置断点，很有帮助。参见节5.1.1[设置断点]

    ，40页。

catch throw

catch catch

    使用这两个命令，调试C++异常处理。参见节5.1.3[设置捕获点]，47页。

ptype typename

    打印继承关系和其它有关类型typename的信息。参见13章[检验符号表]，143页。

set printdemangle

show printdemangle

set printasm-demangle

show printasm-demangle

    控制是否以源代码形式显示C++符号，在现实C++源代码和汇编的时候。参见节8.7[打印设置]，82页。

set print object

show printobject

    选择是否打印派生（实际的）或者声明的对象类型。参见节8.7[打印设置]，82页。

set print vtbl

show print vtbl

    控制打印虚函数表的格式。参见节8.7[打印设置]，82页。（vtbl命令在用HP ANSI C++编译器编译（aCC）的程序上不起效。）

setoverload-resolution on

    激活C++表达式计算的重载解析。缺省打开。对于重载函数，GDB使用C++转换规则计算参数并搜索签名匹配参数类型的函数（更多

    细节，参见节12.4.1.3[C++表达式]）。如果不能找到匹配项，将打印一个消息。

setoverload-resolution off

    关闭C++表达式计算的重载解析。对于不是类成员函数的重载函数，GDB选择在符号表里找到的此名字的第一个函数，不论其参数

    是否是正确的类型。对于是类成员函数的重载函数，GDB搜索签名精确匹配参数类型的函数。

showoverload-resolution

    显示当前重载解析的设置。

Overloadedsymbol names

    使用相同的用于声明C++符号的标识，可知指定重载符号的特殊定义：type symbol(types)而不仅仅是symbol。也可以用GDB命令

    行字补全功能来列出可用的选择，或者来补全类型列表。参见节3.2[命令补全]，关于如何完成的更多细节。

 

12.4.1.8 十进制浮点格式

  GDB可以十进制浮点格式来检验，设置和执行数字计算，在C语言里相应的用_Decimal32， _Decimal64和 _Decimal128类型的扩展支持十进制浮点算术。

  在实际应用中有两种编码方式，依赖于系统架构：x86和x86-64平台下是BID(BinaryInteger Decimal)，PowerPC是DPD(DenselyPacked

Decimal)。GDB为已配置的系统使用恰当的编码格式。

  由于’libdecnumber’的限制，此库用于操作十进制浮点数，不能将宽度超过32位的整形转换到十进制浮点。

  另外，要模仿GDB的二进制浮点计算行为，十进制浮点操作里的错误检查将忽略下溢，上溢和0除异常。

  PowePC架构，GDB 提供了伪寄存器集来检查存储于浮点寄存器里的_Decimal128值。更多细节，参见节18.4.7[PowerPC]，207页。

 

12.4.2Objective-C

  本节提供的命令和命令选项的信息有助于调试Objective-C代码。参见13章[符号]，143页，和13章[符号]，143页，更多Objective-C相

关的命令。

 

12.4.2.1 命令里的方法名

  下面是接受Objective-C方法名的扩展命令，

· clear

· break

· info line

· jump

· list

  完全合格的的Objective-C方法名应声明如下：

    -[ClassmethodName]

  这里减号用来表示对象实例方法，加号（没显示出来）用来表示一个类方法。类名Class和方法名methodName用括号括起来，和Objective-C源代码里消息表示方法相似。例如，要在调试程序里的类Fruit的实例create方法上设置一个断点，输入：

    break -[Fruitcreate]

  要显示类方法initialize附近的10行程序代码，输入：

    list +[NSTextinitialize]

  在目前的GDB版本上，需要输入加号和减号。以后的GDB版本，加号和减号会是可选的，但可以用来缩小搜索范围。也可能只需要指定一

个方法名：

    break create

  必须指定完整的方法名，包括冒号。如果程序源文件包含多个create方法的话，将以编号方式打印实现了此方法的类列表。用编号指定

所选择的方法，或者输入’0′来退出，如果不选择的话。

  另一个例子是清除在NSWindow类的makeKeyAndOrderFront:方法上的断点，输入：

    clear -[NSWindowmakeKeyAndOrderFront:]

 

12.4.2.2 和Objective-C协作的Print命令

  print命令也扩展接受方法。例如：

    print -[objecthash]

让GDB发送hash消息给对象object并打印结果。而且，也增加了附加命令，print-object或缩写为po，此命令打印对象的描述。不过，此命

令依赖于Objective-C库实现了特殊的钩子函数，_NSPrintForDebugger。

 

12.4.3 Fortran

  GDB可以调试用Fortran写的程序，但目前只支持Fortran 77语言的特征。

  某些Fortran编译器（GNU Fortran 77和Fortran 95编译器）在变量和函数上添加一个下划线。在调试用这些编译器的编译的程序时，引

用变量和函数时需要加上下划线。

 

12.4.3.1 Fortran操作符和表达式

  操作符必须定义与特定类型上。例如，+定义于数字，但不能定义于字符或者其它非算术类型。操作符通常定义于类型组。

**    求幂操作符。将第一个操作数作为第二个操作数的乘方。

:       域操作符。常用于数组形式，表示数组的一部分。

 

12.4.3.2 Fortran的缺省值

  Fortran符号通常是不区分大小写的，所以GDB缺省使用大小写不区分地匹配Fortran符号。用’setcase-insensitive’命令改变此设置，

更多细节，参见13章[符号]，143页。

 

12.4.3.3 Fortran的特殊命令

  GDB实现了一些支持Fortran相关特征的命令，例如显示公共块。

info common[common-name]

    此命令打印名为common-name的公共块里的数据值。不带参数的话，打印当前程序所有可访问的共块的名字。

 

12.4.4 Pascal

  目前不能调试使用集合，子域，文件变量和嵌套函数的Pascal程序。GDB不支持进入表达式，打印数值，或者相似的使用Pascal句法。

  Pascal特定的命令set print pascal_static-members控制是否显示静态Pascal对象。参见8.7节[打印设置]，82页。

 

12.4.5 Modula-2

  GDB对Modula-2的扩展支持智能支持由GNU Modula-2编译器（目前尚处于开发中）编译的程序。目前尚未支持其他Modula-2编译器，试图调试此类编译器产生的可执行程序的话，GDB会在读入可执行程序的符号表时打印一个出错信息。

 

12.4.5.1 操作符

  操作符必须定义域特定类型的数据上。例如，+定义于数字，但不能在结构体上。操作符通常定义于类型组。就Modula-2而言，有下列定义：

·整形类型由INTEGER，CARDINAL，以及它们的子域组成。

·字符类型由CHAR和其子域组成。

·浮点类型由REAL组成。

·指针类型由任意声明为POINTER TO类型组成。

·向量类型由上述所有类型组成。

·集合类型由SET和BITSET类型组成。

·布尔类型由BOOLEAN组成。

  下面的介绍支持的操作符，以增序排列：

,             函数参数或数组索引分割符。

:=           赋值。var := value的值是value。

<, >       小于，大于，定义于整型，浮点型和枚举型。

<=, >=   小于等于，大于等于，定义于整型，浮点型和枚举型，集包含和集合类型。和<优先顺序相同。

=, <>, #

              相等和两种不相等的表示，向量类型也起效。和<优先顺序相同。在GDB脚本里，只有<>可以表示不相等，因为#和脚本注释

              符冲突。

IN          集合成员。定义与集合类型和其成员的类型。和<优先顺序相同。

OR         布尔析取。定义于布尔型。

AND,&   布尔合取。定义于布尔型。

@           GDB“伪数组”操作符（参见8.1节[表达式]，75页）。

+, -         加和减，定义于整型和浮点型，联合和集合差类型。

*            乘，定义于整型和浮点型，或者集合交集。

/             除，定义于浮点类型，或者集合类型的对称集合差。和*优先顺序相同。

DIV, MOD

              整型出和求余。定义于整型。和*优先顺序相同。

-             负。定义于INTEGER和REAL数据。

^             对指针取值。定义于指针类型。

NOT       布尔非。定义于布尔型。和^有限顺序相同。

.              RECORD(记录)域选择符。定义于RECORD数据。和^优先顺序相同。

[]            数组索引。定义于ARRAY数据。和^优先顺序相同。

()            过程参数列表。定义于PROCEDURE对象。和^优先顺序相同。

::, .          GDB和Modula-2域操作符。

  警告：设置表达式和它们的操作还不支持，GDB在集合上使用操作符IN，+， -， *， /， =， ,， <>， #，<=，>=会引起错误。

 

12.4.5.2 内建函数和过程

  Modula-2也提供了一些内建的过程和函数。在介绍之前，先介绍下面用到的元变量：

a    表示一个数组变量。

c    表示一个CHAR常量或变量。

i    表示一个变量或者整型常量。

m    表示属于一个集合的标识符。通常和原变量s一起用于同一个函数。s的类型英格是SET OF mtype（这里mtype是m的类型）。

n    表示一个整型或浮点类型的变量或者常量

r    表示一个浮点类型的变量或常量。

t    表示一个类型。

v    表示一个变量。

x    表示一个变量或常量，其类型是多种类型中的其一。详细参见函数的解释。

  所有Modula-2内建过程都返回一个结果，见下。

ABS(n)    返回n的绝对值。

CAP(c)    如果c是小写字符，返回它对应的大写字符，否则返回c。

CHR(i)    返回值是i的字符。

DEC(v)    将变量v的值减1.返回新的值。

DEC(v,i)

          将变量v的值减i。返回新的值。

EXCL(m,s)

          将元素m从集合s里删除。返回新的集合。

FLOAT(i)

           返回整形变量i对应的浮点数。

HIGH(a)    返回数组a的最后一个元素的索引。

INC(v)     将变量v增加1。返回新的值。

INC(v,i)

           将变量v的值增加i。返回新的值。

INCL(m,s)

          如果m不在集合s的话，将元素m加入集合s。返回新的集合。

MAX(t)    返回类型t的最大值。

MIN(t)    返回类型t的最小值。

ODD(i)    如果i是一个奇数，返回TRUE。

ORD(x)    返回参数的原始值。例如，一个字符的原始值是其ASCII值（机器支持的ASCII字符集）。x必须是一个序数类型，

          包括整形，字符和枚举类型。

SIZE(x)   返回参数的大小。x可以是变量或类型。

TRUNC(r)

          返回r的实数部分。

TSIZE(x)

          返回参数的大小。x可以是变量或类型。

VAL(t,i)

          返回类型t的成员，其值是i。

警告：集合和它们的操作还未支持，所以使用过程INCL和EXCL的话，GDB会视为错误。

 

12.4.5.3 常量

  GDB允许用下列方式表示Modula-2的常量：

·整型常量，此类型常量是数据序列。在用于表达式中时，常量会转换为和表达式其它部分相容的类型。16进制整数应该后接’H'，二进 

  制整数后接’B'。

·浮点常量也是数据序列，后接一个小数点和另外一个数据序列。可以指定一个可选的指数，其形式是’E[+|-]nnn’，这里’[+|-]nnn’表

  示指数。浮点常量的所有数据都必须是有效的10进制数据。

·字符常量由用一对单引号或双引号括起来的单个字符组成。用C风格的转义序列也是可以的。转义序列的简明介绍，参见节12.4.1.2[C

  和C++常量]，125页。

·字符串常量由一对单引号或双引号括起来的字符序列组成。用C风格的转义序列也是可以的。转义序列的简明介绍，参见节12.4.1.2[C

  和C++常量]，125页。

·枚举常量由由枚举标志符组成。

·布尔常量由标志符TRUE和FALSE表示。

·指针常量由整数值组成。

·集合常量目前尚未支持。

 

12.4.5.4Modula-2类型

  目前，GDB可以在Modula-2上下文中打印下列数据类型：数组类型，记录类型，集合类型，指针类型，过程类型，枚举类型，子域类型和基类。还可以打印用这些类型定义的变量内容。本节所示的GDB调试例子，包括几个源代码的样例。

  第一个例子包含下列的代码段：

    VAR

       s: SET OF CHAR ;

       r: [20..40] ;

可以用GDB查询r和s的类型和值。

    (gdb) print s

    {’A’..’C’, ’Z’}

    (gdb) ptype s

    SET OF CHAR

    (gdb) print r

    21

    (gdb) ptype r

    [20..40]

类似的，如果源代码声明s为：

    VAR

       s: SET [’A’..’Z’] ;

那么可以查询s的类型：

    (gdb) ptype s

    type = SET[’A’..’Z’]

  注意，目前还不能用调试器交互的操作集合表达式。

  下面的例子演示在Modula-2里如何生命数组和怎样用GDB来打印其类型和内容：

    VAR

       s: ARRAY [-10..10] OF CHAR ;

    (gdb) ptype s

    ARRAY [-10..10]OF CHAR

  注意，数组处理尚未完全实现，虽然类型可以正确打印，表达式处理仍然会假设所有的数组的下标是0，本例中将不会认为是-10。

  下面还有一些Modula-2类型相关的例子：

    TYPE

       colour = (blue, red, yellow, green) ;

       t = [blue..yellow] ;

    VAR

       s: t ;

    BEGIN

       s := blue ;

  GDB交互显示如何查询数据类型和变量的值。

    (gdb) print s

    $1 = blue

    (gdb) ptype t

    type = [blue..yellow]

  在这个例子中声明了一个Modula-2的数组，打印其内容。观察到数组的内容以如同C对应的数据那样的相同方式写入。

    VAR

      s: ARRAY [1..5] OF CARDINAL ;

    BEGIN

      s[1] := 1 ;

    (gdb) print s

    $1 = {1, 0, 0,0, 0}

    (gdb) ptype s

    type = ARRAY[1..5] OF CARDINAL

  Modula-2语言对于GDB的接口也理解指针类型，如下例所示：

    VAR

      s: POINTER TO ARRAY [1..5] OF CARDINAL ;

    BEGIN

      NEW(s) ;

      s^[1] := 1 ;

可以要求GDB描述s的类型。

    (gdb) ptype s

    type = POINTERTO ARRAY [1..5] OF CARDINAL

  GDB可以处理复合类型，正如本例所示。下面将数组类型，记录类型，指针类型和子域类型结合起来：

    TYPE

       foo = RECORD

           f1: CARDINAL ;

        f2: CHAR ;

        f3: myarray ;

        END ;

      myarray = ARRAY myrange OF CARDINAL ;

      myrange = [-2..2] ;

    VAR

      s: POINTER TO ARRAY myrange OF foo ;

可以让GDB描述s的类型，如下所示。

    (gdb) ptype s

    type = POINTERTO ARRAY [-2..2] OF foo = RECORD

        f1 : CARDINAL;

        f2 : CHAR;

        f3 : ARRAY[-2..2] OF CARDINAL;

    END

 

12.4.5.5Modula-2的缺省设置

  如果GDB自动设置了类型和域检查的话，那么在工作语言切换为Modula-2的时候这两项设置将是激活的

。不论用户或GDB选择工作语言与否，都是这么设置的。

  如果允许GDB自动设置语言，那么在进入文件名以’.mod’结尾的文件编译成代码时，工作语言会设置为

Modula-2。更多细节，参见12.1.3节[让GDB推断源代码语言]。

 

12.4.5.6 与标准Modula-2的差异

  为了更容易调试Modula-2程序，做了一些修改。主要是放宽了类型限制。

·与标准Modula-2不同，指针常量可以用整数来构成。这就允许在调试期修改指针变量。（在标准Modul

  a-2里，指针变量的实际地址是不可见的；其地址只能用另外一个指针变量或者返回一个指针的表达式

  来直接赋值去改变。）

·C转义序列可用于字符串和字符来表示不可打印字符。GDB用内嵌的转移序列来输出这些字符串。单个

  不可打印字符用’CHR(nnn)’的形式输出。

·赋值操作符(:=)返回右值参数的值。

·所有内置的过程都可以修改和返回参数。

 

12.4.5.7Modula-2类型和域检查

  警告：在此版本中，GDB不执行类型和域检查。

  GDB将两个Modula-2变量的类型视为相等，如果

·用TYPE t1 = t2声明的变量，这两个变量的类型就是相等的。

·在同一行中声明的变量。（注意：在GNU Modual-2编译器里是正确的，但在其他编译器里就未必。）

  只要打开了类型检查，任何试图将不同类型的变量联合的操作都是错误的。

  域检查用于所有的算术操作，赋值，数据索引边界和所有内置函数和过程。

 

12.4.5.8 范围操作符::和.

  Modula-2的范围操作符(.)和GDB范围操作符(::)有一些微妙的差异。这两个操作符都有相似的语法：

    module . id

    scope :: id

这里的scope是模块或过程的名字，module是模块的名字，id是除了另外模块的名字外，程序里定义的标

识符。

  使用::操作符可以让GDB在scope指定的范围里搜索标志符id。如果在指定的范围里没有查找到，那么

GDB会在包含字符串scope的所有范围里搜索。

  使用.操作符可以放GDB在module指定的模块里搜索标志符id。如果模块module定义里没有引进标志符

id，或者id不是moudle里定义的标志符，使用这个操作符将引发错误。

 

12.4.5.9 GDB和Modula-2

  GDB的某些命令很少应用于调试Modula-2程序。set print和show print的5个子命令’vtbl’ ,’demangl

e’,'asm-demangle’,'object’,'union’是专门为C和C++设计的。前4个命令用于C++，第5个用于C union

类型，Modula-2没有union相似的类型。

  @操作符（参见8.1节[表达式]，75页），虽然在所有语言里都可用，但对于Modula-2而言并不很有用

。其设计意图是帮助调试动态数组，而Modula-2不能如同C和C++那样创建动态数据。不过，由于可以用

整型常量指定一个地址，指令’{type}adrexp’还是很用用的。

  在GDB脚本里，Modula-2不相等操作符#会转译为注释的开始。用<>替代#。

 

12.4.6 Ada

  GDB对Ada的扩展只支持GNU Ada(GNAT)编译器产生的程序。其他Ada编译器目前尚未支持，并且要调试

它们所产生的可执行程序很困难。

 

12.4.6.1 介绍

  GDB的扩展Ada模式支持相当大的Ada表达式语法子集。这个子集的设计背后的哲学是：

·GDB应该提供基本的文字和为算法，取值，域选择，索引，子程序调用的操作访问，将更复杂的计算留

  给程序的子程序（子程序可供GDB调用）。

·Ada语言的类型安全和限制对GDB用户不是特别重要。

·简介对GDB用户很重要。

  因此，要简介，调试器对于所有用户包好像隐含with和use子句，使得不必要用它们的包来完全限定大

多数名字，而不用管上下文。在产生歧义的地方，GDB要询问用户的