gdb

你可以输入GDB来启动GDB程序。GDB程序有许多参数，在此没有必要详细介绍，但一个最为常用的还是要介绍的：如果你已经编译好一个程序，我们假设文件名为hello，你想用GDB调试它，可以输入gdb hello来启动GDB并载入你的程序。如果你仅仅启动了GDB，你必须在启动后，在GDB中再载入你的程序。

3．2　载入程序 === file

在GDB内，载入程序很简单，使用file命令。如file hello。当然，程序的路径名要正确。

退出GDB === quit

在GDB的命令方式下，输入quit，你就可以退出GDB。你也可以输入'C-d'来退出GDB。

3．3运行程序 === run

当你在GDB中已将要调试的程序载入后，你可以用run命令来执行。如果你的程序需要参数，你可以在run指令后接着输入参数，就象你在SHELL下执行一个需要参数的命令一样。

3．4查看程序信息 === info

info指令用来查看程序的信息，当你用help info查看帮助的话，info指令的参数足足占了两个屏幕，它的参数非常多，但大部分不常用。我用info指令最多的是用它来查看断点信息。

3．4．1　查看断点信息

info br

br是断点break的缩写，记得GDB的补齐功能吧。用这条指令，你可以得到你所设置的所有断点的详细信息。包括断点号，类型，状态，内存地址，断点在源程序中的位置等。

3．4．2　查看当前源程序

info source

3．4．3　查看堆栈信息

info stack

用这条指令你可以看清楚程序的调用层次关系。

3．4．4　查看当前的参数

info args

3．5　列出源一段源程序 === list

3．5．1　列出某个函数

list FUNCTION

3．5．2　以当前源文件的某行为中间显示一段源程序

list LINENUM

3．5．3　接着前一次继续显示

list

3．5．4　显示前一次之前的源程序

list -

3．5．5　显示另一个文件的一段程序

list FILENAME:FUNCTION 或 list FILENAME:LINENUM

3．6　设置断点 === break

现在我们将要介绍的也许是最常用和最重要的命令：设置断点。无论何时，只要你的程序已被载入，并且当前没有正在运行，你就能设置，修改，删除断点。设置断点的命令是break。有许多种设置断点的方法。如下：

3．6．1　在函数入口设置断点

break FUNCTION

3．6．2　在当前源文件的某一行上设置断点

break LINENUM

3．6．3　在另一个源文件的某一行上设置断点

break FILENAME:LINENUM

3．6．4　在某个地址上设置断点，当你调试的程序没有源程序是，这很有用

break *ADDRESS

除此之外，设置一个断点，让它只有在某些特定的条件成立时程序才会停下，我们可以称其为条件断点。这个功能很有用，尤其是当你要在一个程序会很多次执行到的地方设置断点时。如果没有这个功能，你必须有极大的耐心，加上大量的时间，一次一次让程序断下，检查一些值，接着再让程序继续执行。事实上，大部分的断下并不是我们所希望的，我们只希望在某些条件下让程序断下。这时，条件断点就可以大大提高你的效率，节省你的时间。条件断点的命令如下，在后面的例子中会有示例。

3．6．5　条件断点

break ...if COND

COND是一个布尔条件表达式，语法与C语言中的一样。条件断点与一般的断点不同之处是每当程序执行到断点处，都要计算条件表达式，如果为真，程序才会断下，否则程序会一直执行下去。

3．7　其它断点操作

GDB给每个断点赋上一个整数数字，这个数字在操作断点时起到重要作用，它实际上就代表相应的断点。GDB中的断点有四种状态：

有效(Enabled)

禁止(Disabled)

一次有效(Enabled once)

有效后删除(Enabled for deletion)

在上面的四个状态有效和禁止都很好理解，禁止就是让断点暂时失效。一次有效就是当程序在此断点断下后，断点状态自动变为禁止状态。有效后删除就是当程序在此断点断下后，断点被删除。实际上，后两种状态一般不会碰到。

当你设置一个断点后，它的确省状态是有效。你可以用enable和disable指令来设置断点的状态为有效或禁止。例如，如果你想禁止2号断点，可以用下面的指令：

disable 2

相应的，如果想删除2号断点，可以有下面的指令：

delete 2

3．8　设置监视点 === watch

当你调试一个很大的程序，并且在跟踪一个关键的变量时，发现这个变量不知在哪儿被改动过，如何才能找到改动它的地方。这时你可以使用watch命令。简单地说，监视点可以让你监视某个表达式或变量，当它被读或被写时让程序断下。watch命令的用法如下：

watch EXPRESSION

watch指令是监视被写的，当你想监视某个表达式或变量被读的话，需要使用rwatch指令，具体用法是一样的。要注意的是，监视点有硬件和软件两种方式，如果可能Linux尽可能用硬件方式，因为硬件方式在速度上要大大快于软件方式。软件方式由于要在每次执行一条指令后都要检查所要监视的值是否被改变，因此它的执行速度会大大降低。同时它也无法设置成被读时让程序断下，因为读操作不会改变值，所以GDB无法检测到读操作。幸运的是，目前的PC机基本都支持硬件方式。如果你想确认一下你的机器是否支持硬件，你可以在调试程序时用watch设置一个监视点，如果GDB向你显示：

Hardware watchpoint NUM: EXPR

那么你可以放心了，你的机器支持硬件方式。

3．9　检查数据

最常用的检查数据的方法是使用print命令。

print exp

print指令打印exp表达式的值。却省情况下，表达式的值的打印格式依赖于它的数据类型。但你可以用一个参数/F来选择输出的打印格式。F是一个代表某种格式的字母，详细可参考输出格式一节。表达式可以是常量，变量，函数调用，条件表达式等。但不能打印宏定义的值。表达式exp中的变量必须是全局变量或当前堆栈区可见的变量。否则GDB会显示象下面的一条信息：

No symbol "varible" in current context

3．10　修改变量值

在调试程序时，你可能想改变一个变量的值，看看在这种情况下会发生什么。用set指令可以修改变量的值：

set varible=value

例如你想将一个变量tmp的值赋为10，

set tmp=10

3．11　检查内存值

检查内存值的指令是x，x是examine的意思。用法如下：

x /NFU ADDR

其中N代表重复数，F代表输出格式(见2.13)，U代表每个数据单位的大小。U可以去如下值：

b ：字节(byte)

h ：双字节数值

w ：四字节数值

g ：八字节数值

因此，上面的指令可以这样解释：从ADDR地址开始，以F格式显示N个U数值。例如：

x/4ub 0x4000

会以无符号十进制整数格式(u)显示四个字节(b)，0x4000，0x4001，0x4002，0x4003。

3．12　输出格式

缺省情况下，输出格式依赖于它的数据类型。但你可以改变输出格式。当你使用print命令时，可以用一个参数/F来选择输出的打印格式。F可以是以下的一些值：

'x' 16进制整数格式

'd' 有符号十进制整数格式

'u' 无符号十进制整数格式

'f' 浮点数格式

3．13　单步执行指令

单步执行指令有两个step和next。Step可以让你跟踪进入一个函数，而next指令则不会进入函数。

3．14　继续执行指令

当程序被断下后，你查看了所需的信息后，你会希望程序执行下去，输入 continue， 程序会继续执行下去。

3．15　帮助指令help

在GDB中，如果想知道一条指令的用法，最方便的方法是使用help。使用方法很简单，在help后跟上指令名。例如，想知道list指令用法，输入

help list

4.一个简单的例子

上面仅是GDB常用指令的简单介绍。本节将结合一个简单的例子，向大家演示这些常用指令的具体应用。这是一个冒泡排序算法的程序，这个例子的目的仅仅是演示，并不是实际调试。将下面的源程序存为bubble.c文件，并编译好。

#include <stdio.h> #define MAX_RECORD_NUMBER 10 int record[MAX_RECORD_NUMBER] = {12,76,48,62,94,17,37,52,69,32}; swap(int * x , int * y ) { int temp; temp = *x; *x = *y; *y = temp; } int main() { int i,j; for( i = 0 ; i < MAX_RECORD_NUMBER - 1; i++ ) { for( j = MAX_RECORD_NUMBER - 1; j > i; j--) if( record[j] < record[j-1] ) swap(&record[j],&record[j-1]); } for( i = 0; i < MAX_RECORD_NUMBER -1; i++) printf("%d ",record[i]); printf("\n"); return 1; }

记得在编译时用-g开关。如：gcc -g -o bubble bubble.c。你能在当前子目录下得到一个编译好的文件bubble。我们下面将以这个程序为例子向大家演示上面的指令在实际中的应用。

首先启动GDB，可以在启动的同时载入文件bubble，如：gdb bubble。也可以分两步进行，先启动GDB，执行gdb，进入GDB后，再执行file bubble。

这时可以用list指令列出源程序，list的使用比较简单，但其实在GDB中最不方便的就是看源程序，主要原因是因为GDB仅是一个文本方式的调试器，无法让你用鼠标和光标键来翻阅源程序，在这方面ddd等窗口程序有巨大的优势。

我们先来查看一下当前源程序的信息，如下：

(gdb) info source Current source file is bubble.c Compilation directory is /root/sample/ Located in /root/sample/bubble.c Contains 32 lines. Source language is c. Compiled with stabs debugging format.

我们可以知道程序名，目录，文件大小，语言等信息。

下面我们来设置断点，我们想在函数swap出设置一个断点：

(gdb) br swap

Breakpoint 1 at 0x80483d6: file bubble.c, line 11.

br是break的简写。上面的一行是GDB告诉我们这个断点的信息，我们可以知道这个断点的断点号是1，地址是0x80483d6，它在文件bubble.c的11行。

我们再在一个行号上设一个断点，

(gdb) br 23

Breakpoint 2 at 0x804844a: file bubble.c, line 23.

我们已经设了两个断点，许多时候你会想查看一下断点的信息和状态，因此你会用到你最常使用的info指令，info br。

(gdb) info br

Num Type Disp Enb Address What

1 breakpoint keep y 0x080483d6 in swap at bubble.c:11

2 breakpoint keep y 0x0804844a in main at bubble.c:23

我用这条指令的大多数原因是想查看一下某个断点的断点号，就是第一列的数值。有时也会看一下断点的状态是enable还是disable。以上的两个断点都是y，也就是都处于enable状态。type列显示breakpoint，是因为info br指令同时也会显示watch的信息，因此用type来识别是断点breakpoint还是检查点watch。

如果你知道断点号，想删除断点很简单，例如想删除断点2，执行del 2就行了。

在程序中，断点2本来设在循环中，那样程序会频烦断下，这也许不是我们希望的。也许我们仅想在某个条件下让它断下，如想当j=5时。

(gdb) br 23 if j==5 Breakpoint 3 at 0x804844a: file bubble.c, line 23. (gdb) info br Num Type Disp Enb Address What 1 breakpoint keep y 0x080483d6 in swap at bubble.c:11 3 breakpoint keep y 0x0804844a in main at bubble.c:23 stop only if j == 5

注意现在的断点信息，虽然断点2被删除了，但新设的断点号没有使用2号，而是使用了3号。新设的断点是个条件断点，这从"stop only if j == 5"可以清楚的看出。

现在执行程序，输入run指令。

(gdb) run Starting program: /root/sample/bubble Breakpoint 1, swap (x=0x80495a4, y=0x80495a0) at bubble.c:11 11 temp = *x;

程序已经在断点1停了下来。当断点停下时，我们经常需要查看变量值。如查看x值。

(gdb) p x

$1 = (int *) 0x80495a4

GDB告诉我们x是一个指向整数的指针，指针值是0x80495a4。如果想查看指针指向的值。执行：

(gdb) p *x

$2 = 32

(gdb) p *y

$3 = 69

单步执行

(gdb) n

12 *x = *y;

查看变量temp值

(gdb) p temp

$4 = 32

(gdb) n

13 *y = temp;

(gdb) p *x

$5 = 69

现在删除断点1

(gdb) del 1

继续执行

(gdb) cont

Continuing.

Breakpoint 3, main () at bubble.c:23

23 swap(&record[j],&record[j-1]);

程序在断点3停下，记得断点3是个条件断点。要验证很简单，查看一下变量j的值是不是5。

(gdb) p j

$6 = 5

我们可以查看一下全局变量record的值，

(gdb) p record

$7 = {12, 76, 48, 62, 94, 17, 32, 37, 52, 69}

也可以查看一下变量record的地址，

(gdb) p &record

$8 = (int (*)[10]) 0x8049580

知道地址时，也可以x指令查看内存值。

(gdb) x/4uw 0x8049580

0x8049580 : 12 76 48 62

上面的指令查看4个4字节数，以整数方式显示。可以看到这与reocrd值是相附的。

(gdb) x/4bb record

0x8049580 : 12 0 0 0

显示4个单字节数，以字节当时显示。上面的4个字节值正好是record数组第一个整数值，因为整数是4字节，而且intel机器的数值是低字节在前。

改变变量值也很简单，如果想将reocrd数组第一个值该为1，

(gdb) set record[0]=1

看一下值是否改变了。

(gdb) p record

$10 = {1, 76, 48, 62, 94, 17, 32, 37, 52, 69}

第一个值以改成了1。

以上简单地介绍了一些常用的GDB指令，由于篇幅所限，我们无法涉及GDB所有指令及GDB其它许多功能，读者应当自己在实践中不断地学习。Linux系统中会有详细的GDB的资料，你可以用info gdb来查阅这些资料。

//===================================================================

在命令行上键入 gdb 并按回车键就可以运行 gdb 了, 如果一切正常的话, gdb 将被启动并且你将在屏幕上看到类似的内容:

GDB is free software and you are welcome to distribute copies of it under certain conditions; type "show copying" to see the conditions. There is absolutely no warranty for GDB; type "show warranty" for details. GDB 4.14 (i486-slakware-linux), Copyright 1995 Free Software Foundation, Inc. (gdb)

    当你启动 gdb 后, 你能在命令行上指定很多的选项. 你也可以以下面的方式来运行 gdb :

gdb <fname>

    当你用这种方式运行 gdb , 你能直接指定想要调试的程序. 这将告诉gdb 装入名为 fname 的可执行文件. 你也可以用 gdb 去检查一个因程序异常终止而产生的 core 文件, 或者与一个正在运行的程序相连. 你可以参考 gdb 指南页或在命令行上键入 gdb -h 得到一个有关这些选项的说明的简单列表.
 

为调试编译代码(Compiling Code for Debugging)

    为了使 gdb 正常工作, 你必须使你的程序在编译时包含调试信息. 调试信息包含你程序里的每个变量的类型和在可执行文件里的地址映射以及源代码的行号.  gdb 利用这些信息使源代码和机器码相关联.

    在编译时用 -g 选项打开调试选项.
 

gdb 基本命令

     gdb 支持很多的命令使你能实现不同的功能. 这些命令从简单的文件装入到允许你检查所调用的堆栈内容的复杂命令, 表27.1列出了你在用 gdb 调试时会用到的一些命令. 想了解 gdb 的详细使用请参考 gdb 的指南页.

  表 27.1. 基本 gdb 命令.  

     gdb 支持很多与 UNIX shell 程序一样的命令编辑特征. 你能象在 bash 或 tcsh里那样按 Tab 键让 gdb 帮你补齐一个唯一的命令, 如果不唯一的话 gdb 会列出所有匹配的命令. 你也能用光标键上下翻动历史命令.

gdb 应用举例

    本节用一个实例教你一步步的用 gdb 调试程序. 被调试的程序相当的简单, 但它展示了 gdb 的典型应用.
 
    下面列出了将被调试的程序. 这个程序被称为 greeting , 它显示一个简单的问候, 再用反序将它列出.

#include  <stdio.h> main () {   char my_string[] = "hello there";   my_print (my_string);   my_print2 (my_string); } void my_print (char *string) {   printf ("The string is %s\n", string); } void my_print2 (char *string) {   char *string2;   int size, i;   size = strlen (string);   string2 = (char *) malloc (size + 1);   for (i = 0; i < size; i++)     string2[size - i] = string[i];   string2[size+1] = `\0';   printf ("The string printed backward is %s\n", string2); }

    用下面的命令编译它:
 

gcc -o test test.c

    这个程序执行时显示如下结果:

The string is hello there The string printed backward is

    输出的第一行是正确的, 但第二行打印出的东西并不是我们所期望的. 我们所设想的输出应该是:

The string printed backward is ereht olleh

    由于某些原因, my_print2 函数没有正常工作. 让我们用  gdb 看看问题究竟出在哪儿, 先键入如下命令:
 

gdb greeting

    如果你在输入命令时忘了把要调试的程序作为参数传给 gdb , 你可以在 gdb 提示符下用 file 命令来载入它:
 

(gdb) file greeting

    这个命令将载入 greeting 可执行文件就象你在 gdb 命令行里装入它一样.

    这时你能用 gdb 的 run 命令来运行 greeting 了. 当它在 gdb 里被运行后结果大约会象这样:

(gdb) run Starting program: /root/greeting The string is hello there The string printed backward is Program exited with code 041

    这个输出和在 gdb 外面运行的结果一样. 问题是, 为什么反序打印没有工作? 为了找出症结所在, 我们可以在 my_print2 函数的 for 语句后设一个断点, 具体的做法是在 gdb 提示符下键入 list 命令三次, 列出源代码:

(gdb) list (gdb) list (gdb) list

    第一次键入 list 命令的输出如下:
 

1       #include  <stdio.h> 2 3       main () 4       { 5         char my_string[] = "hello there"; 6 7         my_print (my_string); 8         my_print2 (my_string); 9       } 10

    如果按下回车, gdb 将再执行一次 list 命令, 给出下列输出:
 

11      my_print (char *string) 12      { 13        printf ("The string is %s\n", string); 14      } 15 16      my_print2 (char *string) 17      { 18        char *string2; 19        int size, i; 20

    再按一次回车将列出 greeting 程序的剩余部分:

21        size = strlen (string); 22        string2 = (char *) malloc (size + 1); 23        for (i = 0; i < size; i++) 24          string2[size - i] = string[i]; 25        string2[size+1] = `\0'; 26        printf ("The string printed backward is %s\n", string2); 27      }

    根据列出的源程序, 你能看到要设断点的地方在第24行, 在 gdb 命令行提示符下键入如下命令设置断点:

(gdb) break 24

    gdb 将作出如下的响应:

Breakpoint 1 at 0x139: file greeting.c, line 24 (gdb)

    现在再键入 run 命令, 将产生如下的输出:
 

Starting program: /root/greeting The string is hello there Breakpoint 1, my_print2 (string = 0xbfffdc4 "hello there") at greeting.c :24 24  string2[size-i]=string[i]

    你能通过设置一个观察 string2[size - i] 变量的值的观察点来看出错误是怎样产生的, 做法是键入:
 

(gdb) watch string2[size - i]

    gdb 将作出如下回应:

Watchpoint 2: string2[size - i]

    现在可以用 next 命令来一步步的执行 for 循环了:
 

(gdb) next

    经过第一次循环后,  gdb 告诉我们 string2[size - i] 的值是 `h`. gdb 用如下的显示来告诉你这个信息:
 

Watchpoint 2, string2[size - i] Old value = 0 `\000' New value = 104 `h' my_print2(string = 0xbfffdc4 "hello there") at greeting.c:23 23 for (i=0; i<size; i++)

    这个值正是期望的. 后来的数次循环的结果都是正确的. 当 i=10 时, 表达式 string2[size - i] 的值等于 `e`,  size - i 的值等于 1, 最后一个字符已经拷到新串里了.

    如果你再把循环执行下去, 你会看到已经没有值分配给 string2[0] 了,  而它是新串的第一个字符, 因为 malloc 函数在分配内存时把它们初始化为空(null)字符. 所以 string2 的第一个字符是空字符. 这解释了为什么在打印 string2 时没有任何输出了.

    现在找出了问题出在哪里, 修正这个错误是很容易的. 你得把代码里写入 string2 的第一个字符的的偏移量改为 size - 1 而不是 size. 这是因为 string2 的大小为 12, 但起始偏移量是 0, 串内的字符从偏移量 0 到 偏移量 10, 偏移量 11 为空字符保留.

    为了使代码正常工作有很多种修改办法. 一种是另设一个比串的实际大小小 1 的变量. 这是这种解决办法的代码:

#include  <stdio.h> main () {   char my_string[] = "hello there";   my_print (my_string);   my_print2 (my_string); } my_print (char *string) {   printf ("The string is %s\n", string); } my_print2 (char *string) {   char *string2;   int size, size2, i;   size = strlen (string);   size2 = size -1;   string2 = (char *) malloc (size + 1);   for (i = 0; i < size; i++)     string2[size2 - i] = string[i];   string2[size] = `\0';   printf ("The string printed backward is %s\n", string2); }