gdb调试手册




1. 一个简单的GDB会话
2. 进入和退出GDB
3. GDB命令
4. 在 GDB 下运行程序
7. 查看源码文件
9. C预处理宏
1. 一个简单的GDB会话
你可以在空闲的时候阅读全部的GDB手册。然而一些命令足以使你开始使用GDB,这一章就描述这些命令。
GNU m4(一个通用的宏处理器)的初始版本之一存在下面的bug:当我们改变单引号的默认表示时,一个用来捕获一个宏定义的命令停止工作。在下面较短的m4会 话中,我们定义一个宏foo扩展成0000;然後我们使用m4内置的defn命令定义bar做同样的事情。然而当我们改变左单引号为,右单引号为後,同样的程序在定义一个新的同义词baz时却失败了。
cd gnu/m4
./m4
define(foo,0000)
foo

0000
define(bar,defn(`foo'))
bar

0000
changequote(,)
define(baz,defn(foo))
baz
C-d

m4: End of input: 0: fatal error: EOF in string
让我们使用GDB来看看发生了什么。
gdb m4
GDB is free software and you are welcome to distribute copies
of it under certain conditions; type "show copying" to see
the conditions.
There is absolutely no warranty for GDB; type "show warranty"
for details.
GDB 6.5.50.20060706, Copyright 1999 Free Software Foundation, Inc...
(gdb)
GDB只读取很少的符号数据,这些数据足以让它知道在哪里能找到剩下的它需要的符号数据,因此,第一个命令提示符显示的很快。现在我们告诉GDB使用比平时更短的显示宽度,这样这些例子可以更好的显示在这个手册中。
(gdb) set width 70
我们需要看一看m4内置的changquote是怎么工作的。看了源码之後,我们知道相关的子例程是m4_changequote,因为我们使用GDB的break命令在那里设置一个断点。
(gdb) break m4_changequote
Breakpoint 1 at 0x62f4: file builtin.c, line 879.
通过使用run命令,在GDB的控制下我们启动m4的运行。只要控制没有达到m4_changequote子例程,程序运行的和平时一样。
(gdb) run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)
foo

0000
为了触发断点,我们调用changequote。GDB悬挂m4的执行,显示它停止地方的上下文信息。
changequote(,)
Breakpoint 1, m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:879
879         if (bad_argc(TOKEN_DATA_TEXT(argv[0]),argc,1,3))
现在我们使用命令n(next)执行当前函数的下一行。
(gdb) n
882         set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\
: nil,
set_quotes看起来像是有问题的子例程,通过使用命令s(step)代替next我们能进入它的内部执行。 step会进入将被执行的子例程的下一行,因此它进入了set_quotes。
(gdb) s
set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
530         if (lquote != def_lquote)
上面展示了m4(以及它的参数)被悬挂在这个栈里,这个显示被称为栈桢显示。它显示了栈的概要。我们可以使用backtrace命令(它也可以写成bt)来看一看在所有的栈中我们处在哪一个栈里:backtrace命令显示每一个活动子例程的栈桢。
(gdb) bt
#0  set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
#1  0x6344 in m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:882
#2  0x8174 in expand_macro (sym=0x33320) at macro.c:242
#3  0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
    at macro.c:71
#4  0x79dc in expand_input () at macro.c:40
#5  0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
我们再前进几行看看会发生什么。开始的两次,我们使用s;後面的两次我们使用n来避免进入 xstrdup子例程。
(gdb) s
0x3b5c  532         if (rquote != def_rquote)
(gdb) s
0x3b80  535         lquote = (lq == nil || *lq == '\0') ?  \
def_lquote : xstrdup(lq);
(gdb) n
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup(rq);
(gdb) n
538         len_lquote = strlen(rquote);
最後一行显示看起来有点奇怪。我们可以检查lquote和rquote变量,看看它们实际上是不是我们指定的新的左单引号和右单引号。我们使用命令p(print)来看它们的值。
(gdb) p lquote
$1 = 0x35d40 ""
(gdb) p rquote
$2 = 0x35d50 ""
lquote和rquote的确是新的左右单引号。为了看一些上下文,我们可以使用l(list)命令来显示围绕当前行的前後10行源代码。
(gdb) l
533             xfree(rquote);
534
535         lquote = (lq == nil || *lq == '\0') ? def_lquote\
: xstrdup (lq);
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup (rq);
537
538         len_lquote = strlen(rquote);
539         len_rquote = strlen(lquote);
540     }
541
542     void
让我们再向前执行两行设置len_lquote和len_rquote值的源代码,然後检查这些变量的值。
(gdb) n
539         len_rquote = strlen(lquote);
(gdb) n
540     }
(gdb) p len_lquote
$3 = 9
(gdb) p len_rquote
$4 = 7
假如len_lquote和len_rquote分别意味着lquote和rquote的长度,这看起来一定有问题。因为p命令能打印任何表达式的值--那些表达式能包括子例程和赋值。通过使用它,我们能把它们设置成别的更好的值。
(gdb) p len_lquote=strlen(lquote)
$5 = 7
(gdb) p len_rquote=strlen(rquote)
$6 = 9
对于修正使用m4内置的defn来设置新的引号引起的问题,这已经足够了吗?我们使用c(continue)命令可以让m4继续,然後试一试最初因为麻烦的那个例子。
(gdb) c
Continuing.
define(baz,defn(foo))
baz
0000
成功了!新的引号现在和默认的引号一样工作正常。问题似乎是那两个定义了错误的长度的行。我们给m4输入一个EOF让它退出。
C-d
Program exited normally.
这个消息`Program exited normally.'来自于GDB,它表明m4已经完成了执行。我们可以使用 GDB的quit命令来结束我们的GDB会话。
(gdb) quit 
            GDB简介:
            **************
            
                  调试器(比如象GDB)能让你观察另一个程序在执行时的内部活动,或程序出错时
            发生了什么。
                  GDB主要能为你做四件事(包括为了完成这些事而附加的功能),帮助你找出程序
            中的错误。
                  * 运行你的程序,设置所有的能影响程序运行的东西。
            
                  * 保证你的程序在指定的条件下停止。
            
                  * 当你程序停止时,让你检查发生了什么。
            
                  * 改变你的程序。那样你可以试着修正某个bug引起的问题,然后继续查找另一
                    个bug.
            
                  你可以用GDB来调试C和C++写的程序。(参考 *C 和C++)
            
            
                  调试Pascal程序时,有一些功能还不能使用。
            
                 GDB还可以用来调试FORTRAN程序,尽管现在还不支持表达式的输入,输出变量,
            或类FORTRAN的词法。
            * GDB是"free software",大家都可以免费拷贝。也可以为GDB增加新的功能,不
            过可要遵守GNU的许可协议幺。反正我认为GNU还是比较不错的:-)
            就这句话:
                  Fundamentally, the General Public License is a license which says
            that you have these freedoms and that you cannot take these freedoms
            away from anyone else.
            GDB的作者:
                  Richard Stallman是GDB的始作俑者,另外还有许多别的GNU的成员。许多人
            为此作出了贡献。(都是老外不提也罢,但愿他们不要来找我麻烦:-))
            
            这里是GDB的一个例子:
                       原文中是使用一个叫m4的程序。但很遗憾我找不到这个程序的原代码,
            所以没有办法来按照原文来说明。不过反正是个例子,我就拿一个操作系统的
            进程调度原码来说明把,原代码我会附在后面。
                       首先这个程序叫os.c是一个模拟进程调度的原程序(也许是个老古董了:-))。
            先说明一下如何取得包括原代码符号的可执行代码。大家有心的话可以去看一下gcc的
            man文件(在shell下打man gcc)。gcc -g  -o 
            -g 的意思是生成带原代码调试符号的可执行文件。
            -o 的意思是指定可执行文件名。
            (gcc 的命令行参数有一大堆,有兴趣可以自己去看看。)
            反正在linux下把os.c用以上方法编译连接以后就产生了可供gdb使用的可执行文件。
            我用gcc -g os.c -o os,产生的可执行文档叫os.
            然后打gdb os,就可进入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.16, Copyright 1995 Free Software Foundation, Inc...
             (gdb)
                 (gdb)是提示符,在这提示符下可以输入命令,直到退出。(退出命令是q/Q)
            为了尽量和原文档说明的命令相符,即使在本例子中没用的命令我也将演示。
            首先我们可以设置gdb的屏幕大小。键入:
             (gdb)set width 70
            就是把标准屏幕设为70列。
                 然后让我们来设置断点。设置方法很简单:break或简单打b后面加行号或函数名
            比如我们可以在main 函数上设断点:
             (gdb)break main
            或(gdb)b main
             系统提示:Breakpoint 1 at 0x8049552: file os.c, line 455.
             然后我们可以运行这个程序,当程序运行到main函数时程序就会停止返回到gdb的
            提示符下。运行的命令是run或r(gdb中有不少alias,可以看一下help,在gdb下打help)
            run 后面可以跟参数,就是为程序指定命令行参数。
            比如r abcd,则程序就会abcd以作为参数。(这里要说明的是可以用set args来指定参
            数)。打入r或run后,程序就开始运行直到进入main的入口停止,显示:
            Starting program: /os
            
            Breakpoint 1, main () at os.c:455
            455               Initial();
            这里455 Initial();是将要执行的命令或函数。
            gdb提供两种方式:1.单步进入,step into就是跟踪到函数内啦。命令是step或s
                                2.单步,next,就是简单的单步,不会进入函数。命令是next或n
            这两个命令还有别的用法以后再说。
            我们用n命令,键入:
            (gdb)n
            Success forking process# 1 ,pid is 31474
            
            Success forking process# 2 ,pid is 31475
            
            Success forking process# 3 ,pid is 31476
            
            
            Success forking process# 5 ,pid is 31478
            
            Success forking process# 6 ,pid is 31479
            
                               Dispatching Algorithm : FIFO
            ********************************************************************************
            
                           PCB#           PID        Priority           PC         State
                           1              31474         24               0         WAITING
                           2              31475         19               0         WAITING
                           3              31476         16               0         WAITING
                           4              31477         23               0         WAITING
                           5              31478         22               0         WAITING
                           6              31479         20               0         WAITING
            
            ******************************************************************************
            
            CPU     :     NO process running
            IO :     No process
            Waiting CPU!!!     31474      31475      31476      31477      31478      31479
            Waiting     IO       NONE
            456               State=WAITING;
            最后的一行就是下一句要执行的命令。我们现在在另一个函数上加断点。注意我们
            可以用l/list命令来显示原代码。这里我们键入
            (gdb)l
            451        main()
            452        {
            453                int message;
            454
            455               Initial();
            456               State=WAITING;
            457               printf("Use Control-C to halt \n");
            458               signal(SIGALRM,AlarmMessage);
            459               signal(SIGINT,InteruptMessage);
            460               signal(SIGUSR2,IoMessage);
            (gdb) l
            461               alarm(TimeSlot);
            462               for(;;)
            463                {
            464                message=GetMessage();
            465                      switch(message)
            466                        {
            
            468                                                        break;
            469                                case CHILD_IO:             WaitingIo();
            470                                                        break;
            显示了原代码,现在在AlarmMessage上加断点。
            (gdb) b AlarmMessage
            Breakpoint 2 at 0x8048ee3: file os.c, line 259.
            (gdb)
            然后我们继续运行程序。
            (gdb)c
            c或continue命令让我们继续被中断的程序。 显示:
            Continuing.
            Use Control-C to halt
            
            Breakpoint 2, AlarmMessage () at os.c:259
            259                ClearSignal();
            注意我们下一句语句就是ClearSignal();
            我们用s/step跟踪进入这个函数看看它是干什么的。
            (gdb) s
            ClearSignal () at os.c:227
            227                signal(SIGINT,SIG_IGN);
            用l命令列出原代码:
            (gdb) l
            222        }
            223
            224
            225        void ClearSignal()       /* Clear other signals */
            226        {
            227                signal(SIGINT,SIG_IGN);
            228                signal(SIGALRM,SIG_IGN);
            229                signal(SIGUSR2,SIG_IGN);
            230        }
            231
            (gdb)
            我们可以用s命令继续跟踪。现在让我们来试试bt或backtrace命令。这个命令可以
            显示栈中的内容。
            (gdb) bt
            #0     ClearSignal () at os.c:227
            #1     0x8048ee8 in AlarmMessage () at os.c:259
            #2     0xbffffaec in ?? ()
            #3     0x80486ae in ___crt_dummy__ ()
            (gdb)
            大家一定能看懂显示的意思。栈顶是AlarmMessage,接下来的函数没有名字--就是
            没有原代码符号。这显示了函数调用的嵌套。
            好了,我们跟踪了半天还没有检查过变量的值呢。检查表达式的值的命令是p或print
            格式是p 
            444444让我们来找一个变量来看看。:-)
            (gdb)l 1
            还记得l的作用吗?l或list显示原代码符号,l或list加就显示从开始的
            原代码。好了找到一个让我们来看看WaitingQueue的内容
            (gdb) p WaitingQueue
            $1 = {1, 2, 3, 4, 5, 6, 0}
            (gdb)
            WaitingQueue是一个数组,gdb还支持结构的显示,
            (gdb) p Pcb
            $2 = {{Pid = 0, State = 0, Prior = 0, pc = 0}, {Pid = 31474, State = 2,
                   Prior = 24, pc = 0}, {Pid = 31475, State = 2, Prior = 19, pc = 0}, {
                   Pid = 31476, State = 2, Prior = 16, pc = 0}, {Pid = 31477, State = 2,
                   Prior = 23, pc = 0}, {Pid = 31478, State = 2, Prior = 22, pc = 0}, {
                   Pid = 31479, State = 2, Prior = 20, pc = 0}}
            (gdb)
            这里可以对照原程序看看。
            原文档里是一个调试过程,不过我想这里我已经把gdb的常用功能介绍了一遍,基本上
            可以用来调试程序了。:-)
            
            运行GDB(一些详细的说明):
            
                 前面已经提到过如何运行GDB了,现在让我们来看一些更有趣的东西。你可以在运行
            GDB时通过许多命令行参数指定大量的参数和选项,通过这个你可以在一开始就设置好
            程序运行的环境。
                 这里将要描述的命令行参数覆盖了大多数的情况,事实上在一定环境下有的并没有
            什么大用处。最通常的命令就是使用一个参数:
             $gdb 
            你还可以同时为你的执行文件指定一个core文件:
             $gdb  core
            你也可以为你要执行的文件指定一个进程号:
             $gdb   如:&gdb os 1234将使gdb与进程1234相联系(attach)
            除非你还有一个文件叫1234的。gdb首先检查一个core文件。
            如果你是使用一个远程终端进行远程调试的话,那如果你的终端不支持的话,你将无法
            使用第二个参数甚至没有core dump。如果你觉得开头的提示信息比较碍眼的话,你可以
            用gdb -silent。你还可以用命令行参数更加详细的控制GDB的行为。
            打入gdb -help或-h 可以得到这方面的提示。所有的参数都被按照排列的顺序传给gdb
            除非你用了-x参数。
                 当gdb开始运行时,它把任何一个不带选项前缀的参数都当作为一个可执行文件或core
            文件(或进程号)。就象在前面加了-se或-c选项。gdb把第一个前面没有选项说明的参数
            看作前面加了-se 选项,而第二个(如果有的话)看作是跟着-c选项后面的。
                 许多选项有缩写,用gdb -h可以看到。在gdb中你也可以任意的把选项名掐头去尾,只
            要保证gdb能判断唯一的一个参数就行。
            在这里我们说明一些最常用的参数选项
            -symbols (-s )------从中读去符号。
            -exec (-e )----在合适的时候执行来做用正确的数据与core
             dump的作比较。
            -se ------从中读取符号并把它作为可执行文件。
            -core (-c )--指定为一个core dump 文件。
            -c ----连接到进程号为,与attach命令相似。
            -command 
            -x -----执行gdb命令,在指定的文件中存放着一序列的gdb命令,就
            象一个批处理。
            -directory(-d) ---指定路径。把加入到搜索原文件的路径中。
            -m
            -mapped----
                  注意这个命令不是在所有的系统上都能用。如果你可以通过mmap系统调用来获得内存
            映象文件,你可以用这个命令来使gdb把你当前文件里的符号写入一个文件中,这个文件
            将存放在你的当前路径中。如果你调试的程序叫/temp/fred那么map文件就叫
            ./fred.syms这样当你以后再调试这个程序时,gdb会认识到这个文件的存在,从而从这
            个文件中读取符号,而不是从可执行文件中读取。.syms与主机有关不能共享。
            -r
            -readnow---马上从符号文件中读取整个符号表,而不是使用缺省的。缺省的符号表是
            调入一部分符号,当需要时再读入一部分。这会使开始进入gdb慢一些,但可以加快以后
            的调试速度。
            
             -m和-r一般在一起使用来建立.syms文件
            
            
            接下来再谈谈模式的设置(请听下回分解 :-))
            附:在gdb文档里使用的调试例子我找到了在minix下有这个程序,叫m4有兴趣的
            可以自己去看看
            
            
            模式的选择
            --------------
            现在我们来聊聊gdb运行模式的选择。我们可以用许多模式来运行gdb,例如在“批模式”
            或“安静模式”。这些模式都是在gdb运行时在命令行作为选项指定的。
            `-nx'
            `-n'
                    不执行任何初始化文件中的命令。(一般初始化文件叫做`.gdbinit').一般情况下在
            
            `-quiet'
            `-q'
                    “安静模式”。不输出介绍和版权信息。这些信息在“批模式”中也被跳过。
            
            `-batch'
                    “批模式”。在“批模式”下运行。当在命令文件中的所有命令都被成功的执行后
                    gdb返回状态“0”,如果在执行过程中出错,gdb返回一个非零值。
                    “批模式”在把gdb作为一个过滤器运行时很有用。比如在一台远程计算机上下载且
                    执行一个程序。信息“ Program exited normally”(一般是当运行的程序正常结束
                    时出现)不会在这种模式中出现。
            `-cd DIRECTORY'
                    把DIRECTORY作为gdb的工作目录,而非当前目录(一般gdb缺省把当前目录作为工作目
                    录)。
            `-fullname'
            `-f'
                    GNU Emacs 设置这个选项,当我们在Emacs下,把gdb作为它的一个子进程来运行时,
                    Emacs告诉gdb按标准输出完整的文件名和行号,一个可视的栈内容。这个格式跟在
                    文件名的后面。行号和字符重新按列排,Emacs-to-GDB界面使用\032字符作为一个
                    显示一页原文件的信号。
            `-b BPS'
                    为远程调试设置波特率。
            
            `-tty DEVICE'
                    使用DEVICE来作为你程序的标准输入输出
1. 一个简单的GDB会话
2. 进入和退出GDB
3. GDB命令
4. 在 GDB 下运行程序
7. 查看源码文件
9. C预处理宏
1. 一个简单的GDB会话
你可以在空闲的时候阅读全部的GDB手册。然而一些命令足以使你开始使用GDB,这一章就描述这些命令。
GNU m4(一个通用的宏处理器)的初始版本之一存在下面的bug:当我们改变单引号的默认表示时,一个用来捕获一个宏定义的命令停止工作。在下面较短的m4会 话中,我们定义一个宏foo扩展成0000;然後我们使用m4内置的defn命令定义bar做同样的事情。然而当我们改变左单引号为,右单引号为後,同样的程序在定义一个新的同义词baz时却失败了。
cd gnu/m4
./m4
define(foo,0000)
foo

0000
define(bar,defn(`foo'))
bar

0000
changequote(,)
define(baz,defn(foo))
baz
C-d

m4: End of input: 0: fatal error: EOF in string
让我们使用GDB来看看发生了什么。
gdb m4
GDB is free software and you are welcome to distribute copies
of it under certain conditions; type "show copying" to see
the conditions.
There is absolutely no warranty for GDB; type "show warranty"
for details.
GDB 6.5.50.20060706, Copyright 1999 Free Software Foundation, Inc...
(gdb)
GDB只读取很少的符号数据,这些数据足以让它知道在哪里能找到剩下的它需要的符号数据,因此,第一个命令提示符显示的很快。现在我们告诉GDB使用比平时更短的显示宽度,这样这些例子可以更好的显示在这个手册中。
(gdb) set width 70
我们需要看一看m4内置的changquote是怎么工作的。看了源码之後,我们知道相关的子例程是m4_changequote,因为我们使用GDB的break命令在那里设置一个断点。
(gdb) break m4_changequote
Breakpoint 1 at 0x62f4: file builtin.c, line 879.
通过使用run命令,在GDB的控制下我们启动m4的运行。只要控制没有达到m4_changequote子例程,程序运行的和平时一样。
(gdb) run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)
foo

0000
为了触发断点,我们调用changequote。GDB悬挂m4的执行,显示它停止地方的上下文信息。
changequote(,)
Breakpoint 1, m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:879
879         if (bad_argc(TOKEN_DATA_TEXT(argv[0]),argc,1,3))
现在我们使用命令n(next)执行当前函数的下一行。
(gdb) n
882         set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\
: nil,
set_quotes看起来像是有问题的子例程,通过使用命令s(step)代替next我们能进入它的内部执行。 step会进入将被执行的子例程的下一行,因此它进入了set_quotes。
(gdb) s
set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
530         if (lquote != def_lquote)
上面展示了m4(以及它的参数)被悬挂在这个栈里,这个显示被称为栈桢显示。它显示了栈的概要。我们可以使用backtrace命令(它也可以写成bt)来看一看在所有的栈中我们处在哪一个栈里:backtrace命令显示每一个活动子例程的栈桢。
(gdb) bt
#0  set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
#1  0x6344 in m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:882
#2  0x8174 in expand_macro (sym=0x33320) at macro.c:242
#3  0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
    at macro.c:71
#4  0x79dc in expand_input () at macro.c:40
#5  0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
我们再前进几行看看会发生什么。开始的两次,我们使用s;後面的两次我们使用n来避免进入 xstrdup子例程。
(gdb) s
0x3b5c  532         if (rquote != def_rquote)
(gdb) s
0x3b80  535         lquote = (lq == nil || *lq == '\0') ?  \
def_lquote : xstrdup(lq);
(gdb) n
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup(rq);
(gdb) n
538         len_lquote = strlen(rquote);
最後一行显示看起来有点奇怪。我们可以检查lquote和rquote变量,看看它们实际上是不是我们指定的新的左单引号和右单引号。我们使用命令p(print)来看它们的值。
(gdb) p lquote
$1 = 0x35d40 ""
(gdb) p rquote
$2 = 0x35d50 ""
lquote和rquote的确是新的左右单引号。为了看一些上下文,我们可以使用l(list)命令来显示围绕当前行的前後10行源代码。
(gdb) l
533             xfree(rquote);
534
535         lquote = (lq == nil || *lq == '\0') ? def_lquote\
: xstrdup (lq);
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup (rq);
537
538         len_lquote = strlen(rquote);
539         len_rquote = strlen(lquote);
540     }
541
542     void
让我们再向前执行两行设置len_lquote和len_rquote值的源代码,然後检查这些变量的值。
(gdb) n
539         len_rquote = strlen(lquote);
(gdb) n
540     }
(gdb) p len_lquote
$3 = 9
(gdb) p len_rquote
$4 = 7
假如len_lquote和len_rquote分别意味着lquote和rquote的长度,这看起来一定有问题。因为p命令能打印任何表达式的值--那些表达式能包括子例程和赋值。通过使用它,我们能把它们设置成别的更好的值。
(gdb) p len_lquote=strlen(lquote)
$5 = 7
(gdb) p len_rquote=strlen(rquote)
$6 = 9
对于修正使用m4内置的defn来设置新的引号引起的问题,这已经足够了吗?我们使用c(continue)命令可以让m4继续,然後试一试最初因为麻烦的那个例子。
(gdb) c
Continuing.
define(baz,defn(foo))
baz
0000
成功了!新的引号现在和默认的引号一样工作正常。问题似乎是那两个定义了错误的长度的行。我们给m4输入一个EOF让它退出。
C-d
Program exited normally.
这个消息`Program exited normally.'来自于GDB,它表明m4已经完成了执行。我们可以使用 GDB的quit命令来结束我们的GDB会话。
(gdb) quit 
            GDB简介:
            **************
            
                  调试器(比如象GDB)能让你观察另一个程序在执行时的内部活动,或程序出错时
            发生了什么。
                  GDB主要能为你做四件事(包括为了完成这些事而附加的功能),帮助你找出程序
            中的错误。
                  * 运行你的程序,设置所有的能影响程序运行的东西。
            
                  * 保证你的程序在指定的条件下停止。
            
                  * 当你程序停止时,让你检查发生了什么。
            
                  * 改变你的程序。那样你可以试着修正某个bug引起的问题,然后继续查找另一
                    个bug.
            
                  你可以用GDB来调试C和C++写的程序。(参考 *C 和C++)
            
            
                  调试Pascal程序时,有一些功能还不能使用。
            
                 GDB还可以用来调试FORTRAN程序,尽管现在还不支持表达式的输入,输出变量,
            或类FORTRAN的词法。
            * GDB是"free software",大家都可以免费拷贝。也可以为GDB增加新的功能,不
            过可要遵守GNU的许可协议幺。反正我认为GNU还是比较不错的:-)
            就这句话:
                  Fundamentally, the General Public License is a license which says
            that you have these freedoms and that you cannot take these freedoms
            away from anyone else.
            GDB的作者:
                  Richard Stallman是GDB的始作俑者,另外还有许多别的GNU的成员。许多人
            为此作出了贡献。(都是老外不提也罢,但愿他们不要来找我麻烦:-))
            
            这里是GDB的一个例子:
                       原文中是使用一个叫m4的程序。但很遗憾我找不到这个程序的原代码,
            所以没有办法来按照原文来说明。不过反正是个例子,我就拿一个操作系统的
            进程调度原码来说明把,原代码我会附在后面。
                       首先这个程序叫os.c是一个模拟进程调度的原程序(也许是个老古董了:-))。
            先说明一下如何取得包括原代码符号的可执行代码。大家有心的话可以去看一下gcc的
            man文件(在shell下打man gcc)。gcc -g  -o 
            -g 的意思是生成带原代码调试符号的可执行文件。
            -o 的意思是指定可执行文件名。
            (gcc 的命令行参数有一大堆,有兴趣可以自己去看看。)
            反正在linux下把os.c用以上方法编译连接以后就产生了可供gdb使用的可执行文件。
            我用gcc -g os.c -o os,产生的可执行文档叫os.
            然后打gdb os,就可进入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.16, Copyright 1995 Free Software Foundation, Inc...
             (gdb)
                 (gdb)是提示符,在这提示符下可以输入命令,直到退出。(退出命令是q/Q)
            为了尽量和原文档说明的命令相符,即使在本例子中没用的命令我也将演示。
            首先我们可以设置gdb的屏幕大小。键入:
             (gdb)set width 70
            就是把标准屏幕设为70列。
                 然后让我们来设置断点。设置方法很简单:break或简单打b后面加行号或函数名
            比如我们可以在main 函数上设断点:
             (gdb)break main
            或(gdb)b main
             系统提示:Breakpoint 1 at 0x8049552: file os.c, line 455.
             然后我们可以运行这个程序,当程序运行到main函数时程序就会停止返回到gdb的
            提示符下。运行的命令是run或r(gdb中有不少alias,可以看一下help,在gdb下打help)
            run 后面可以跟参数,就是为程序指定命令行参数。
            比如r abcd,则程序就会abcd以作为参数。(这里要说明的是可以用set args来指定参
            数)。打入r或run后,程序就开始运行直到进入main的入口停止,显示:
            Starting program: /os
            
            Breakpoint 1, main () at os.c:455
            455               Initial();
            这里455 Initial();是将要执行的命令或函数。
            gdb提供两种方式:1.单步进入,step into就是跟踪到函数内啦。命令是step或s
                                2.单步,next,就是简单的单步,不会进入函数。命令是next或n
            这两个命令还有别的用法以后再说。
            我们用n命令,键入:
            (gdb)n
            Success forking process# 1 ,pid is 31474
            
            Success forking process# 2 ,pid is 31475
            
            Success forking process# 3 ,pid is 31476
            
            
            Success forking process# 5 ,pid is 31478
            
            Success forking process# 6 ,pid is 31479
            
                               Dispatching Algorithm : FIFO
            ********************************************************************************
            
                           PCB#           PID        Priority           PC         State
                           1              31474         24               0         WAITING
                           2              31475         19               0         WAITING
                           3              31476         16               0         WAITING
                           4              31477         23               0         WAITING
                           5              31478         22               0         WAITING
                           6              31479         20               0         WAITING
            
            ******************************************************************************
            
            CPU     :     NO process running
            IO :     No process
            Waiting CPU!!!     31474      31475      31476      31477      31478      31479
            Waiting     IO       NONE
            456               State=WAITING;
            最后的一行就是下一句要执行的命令。我们现在在另一个函数上加断点。注意我们
            可以用l/list命令来显示原代码。这里我们键入
            (gdb)l
            451        main()
            452        {
            453                int message;
            454
            455               Initial();
            456               State=WAITING;
            457               printf("Use Control-C to halt \n");
            458               signal(SIGALRM,AlarmMessage);
            459               signal(SIGINT,InteruptMessage);
            460               signal(SIGUSR2,IoMessage);
            (gdb) l
            461               alarm(TimeSlot);
            462               for(;;)
            463                {
            464                message=GetMessage();
            465                      switch(message)
            466                        {
            
            468                                                        break;
            469                                case CHILD_IO:             WaitingIo();
            470                                                        break;
            显示了原代码,现在在AlarmMessage上加断点。
            (gdb) b AlarmMessage
            Breakpoint 2 at 0x8048ee3: file os.c, line 259.
            (gdb)
            然后我们继续运行程序。
            (gdb)c
            c或continue命令让我们继续被中断的程序。 显示:
            Continuing.
            Use Control-C to halt
            
            Breakpoint 2, AlarmMessage () at os.c:259
            259                ClearSignal();
            注意我们下一句语句就是ClearSignal();
            我们用s/step跟踪进入这个函数看看它是干什么的。
            (gdb) s
            ClearSignal () at os.c:227
            227                signal(SIGINT,SIG_IGN);
            用l命令列出原代码:
            (gdb) l
            222        }
            223
            224
            225        void ClearSignal()       /* Clear other signals */
            226        {
            227                signal(SIGINT,SIG_IGN);
            228                signal(SIGALRM,SIG_IGN);
            229                signal(SIGUSR2,SIG_IGN);
            230        }
            231
            (gdb)
            我们可以用s命令继续跟踪。现在让我们来试试bt或backtrace命令。这个命令可以
            显示栈中的内容。
            (gdb) bt
            #0     ClearSignal () at os.c:227
            #1     0x8048ee8 in AlarmMessage () at os.c:259
            #2     0xbffffaec in ?? ()
            #3     0x80486ae in ___crt_dummy__ ()
            (gdb)
            大家一定能看懂显示的意思。栈顶是AlarmMessage,接下来的函数没有名字--就是
            没有原代码符号。这显示了函数调用的嵌套。
            好了,我们跟踪了半天还没有检查过变量的值呢。检查表达式的值的命令是p或print
            格式是p 
            444444让我们来找一个变量来看看。:-)
            (gdb)l 1
            还记得l的作用吗?l或list显示原代码符号,l或list加就显示从开始的
            原代码。好了找到一个让我们来看看WaitingQueue的内容
            (gdb) p WaitingQueue
            $1 = {1, 2, 3, 4, 5, 6, 0}
            (gdb)
            WaitingQueue是一个数组,gdb还支持结构的显示,
            (gdb) p Pcb
            $2 = {{Pid = 0, State = 0, Prior = 0, pc = 0}, {Pid = 31474, State = 2,
                   Prior = 24, pc = 0}, {Pid = 31475, State = 2, Prior = 19, pc = 0}, {
                   Pid = 31476, State = 2, Prior = 16, pc = 0}, {Pid = 31477, State = 2,
                   Prior = 23, pc = 0}, {Pid = 31478, State = 2, Prior = 22, pc = 0}, {
                   Pid = 31479, State = 2, Prior = 20, pc = 0}}
            (gdb)
            这里可以对照原程序看看。
            原文档里是一个调试过程,不过我想这里我已经把gdb的常用功能介绍了一遍,基本上
            可以用来调试程序了。:-)
            
            运行GDB(一些详细的说明):
            
                 前面已经提到过如何运行GDB了,现在让我们来看一些更有趣的东西。你可以在运行
            GDB时通过许多命令行参数指定大量的参数和选项,通过这个你可以在一开始就设置好
            程序运行的环境。
                 这里将要描述的命令行参数覆盖了大多数的情况,事实上在一定环境下有的并没有
            什么大用处。最通常的命令就是使用一个参数:
             $gdb 
            你还可以同时为你的执行文件指定一个core文件:
             $gdb  core
            你也可以为你要执行的文件指定一个进程号:
             $gdb   如:&gdb os 1234将使gdb与进程1234相联系(attach)
            除非你还有一个文件叫1234的。gdb首先检查一个core文件。
            如果你是使用一个远程终端进行远程调试的话,那如果你的终端不支持的话,你将无法
            使用第二个参数甚至没有core dump。如果你觉得开头的提示信息比较碍眼的话,你可以
            用gdb -silent。你还可以用命令行参数更加详细的控制GDB的行为。
            打入gdb -help或-h 可以得到这方面的提示。所有的参数都被按照排列的顺序传给gdb
            除非你用了-x参数。
                 当gdb开始运行时,它把任何一个不带选项前缀的参数都当作为一个可执行文件或core
            文件(或进程号)。就象在前面加了-se或-c选项。gdb把第一个前面没有选项说明的参数
            看作前面加了-se 选项,而第二个(如果有的话)看作是跟着-c选项后面的。
                 许多选项有缩写,用gdb -h可以看到。在gdb中你也可以任意的把选项名掐头去尾,只
            要保证gdb能判断唯一的一个参数就行。
            在这里我们说明一些最常用的参数选项
            -symbols (-s )------从中读去符号。
            -exec (-e )----在合适的时候执行来做用正确的数据与core
             dump的作比较。
            -se ------从中读取符号并把它作为可执行文件。
            -core (-c )--指定为一个core dump 文件。
            -c ----连接到进程号为,与attach命令相似。
            -command 
            -x -----执行gdb命令,在指定的文件中存放着一序列的gdb命令,就
            象一个批处理。
            -directory(-d) ---指定路径。把加入到搜索原文件的路径中。
            -m
            -mapped----
                  注意这个命令不是在所有的系统上都能用。如果你可以通过mmap系统调用来获得内存
            映象文件,你可以用这个命令来使gdb把你当前文件里的符号写入一个文件中,这个文件
            将存放在你的当前路径中。如果你调试的程序叫/temp/fred那么map文件就叫
            ./fred.syms这样当你以后再调试这个程序时,gdb会认识到这个文件的存在,从而从这
            个文件中读取符号,而不是从可执行文件中读取。.syms与主机有关不能共享。
            -r
            -readnow---马上从符号文件中读取整个符号表,而不是使用缺省的。缺省的符号表是
            调入一部分符号,当需要时再读入一部分。这会使开始进入gdb慢一些,但可以加快以后
            的调试速度。
            
             -m和-r一般在一起使用来建立.syms文件
            
            
            接下来再谈谈模式的设置(请听下回分解 :-))
            附:在gdb文档里使用的调试例子我找到了在minix下有这个程序,叫m4有兴趣的
            可以自己去看看
            
            
            模式的选择
            --------------
            现在我们来聊聊gdb运行模式的选择。我们可以用许多模式来运行gdb,例如在“批模式”
            或“安静模式”。这些模式都是在gdb运行时在命令行作为选项指定的。
            `-nx'
            `-n'
                    不执行任何初始化文件中的命令。(一般初始化文件叫做`.gdbinit').一般情况下在
            
            `-quiet'
            `-q'
                    “安静模式”。不输出介绍和版权信息。这些信息在“批模式”中也被跳过。
            
            `-batch'
                    “批模式”。在“批模式”下运行。当在命令文件中的所有命令都被成功的执行后
                    gdb返回状态“0”,如果在执行过程中出错,gdb返回一个非零值。
                    “批模式”在把gdb作为一个过滤器运行时很有用。比如在一台远程计算机上下载且
                    执行一个程序。信息“ Program exited normally”(一般是当运行的程序正常结束
                    时出现)不会在这种模式中出现。
            `-cd DIRECTORY'
                    把DIRECTORY作为gdb的工作目录,而非当前目录(一般gdb缺省把当前目录作为工作目
                    录)。
            `-fullname'
            `-f'
                    GNU Emacs 设置这个选项,当我们在Emacs下,把gdb作为它的一个子进程来运行时,
                    Emacs告诉gdb按标准输出完整的文件名和行号,一个可视的栈内容。这个格式跟在
                    文件名的后面。行号和字符重新按列排,Emacs-to-GDB界面使用\032字符作为一个
                    显示一页原文件的信号。
            `-b BPS'
                    为远程调试设置波特率。
            
            `-tty DEVICE'
                    使用DEVICE来作为你程序的标准输入输出

1. 一个简单的GDB会话
2. 进入和退出GDB
3. GDB命令
4. 在 GDB 下运行程序
7. 查看源码文件
9. C预处理宏
1. 一个简单的GDB会话
你可以在空闲的时候阅读全部的GDB手册。然而一些命令足以使你开始使用GDB,这一章就描述这些命令。
GNU m4(一个通用的宏处理器)的初始版本之一存在下面的bug:当我们改变单引号的默认表示时,一个用来捕获一个宏定义的命令停止工作。在下面较短的m4会 话中,我们定义一个宏foo扩展成0000;然後我们使用m4内置的defn命令定义bar做同样的事情。然而当我们改变左单引号为,右单引号为後,同样的程序在定义一个新的同义词baz时却失败了。
cd gnu/m4
./m4
define(foo,0000)
foo

0000
define(bar,defn(`foo'))
bar

0000
changequote(,)
define(baz,defn(foo))
baz
C-d

m4: End of input: 0: fatal error: EOF in string
让我们使用GDB来看看发生了什么。
gdb m4
GDB is free software and you are welcome to distribute copies
of it under certain conditions; type "show copying" to see
the conditions.
There is absolutely no warranty for GDB; type "show warranty"
for details.
GDB 6.5.50.20060706, Copyright 1999 Free Software Foundation, Inc...
(gdb)
GDB只读取很少的符号数据,这些数据足以让它知道在哪里能找到剩下的它需要的符号数据,因此,第一个命令提示符显示的很快。现在我们告诉GDB使用比平时更短的显示宽度,这样这些例子可以更好的显示在这个手册中。
(gdb) set width 70
我们需要看一看m4内置的changquote是怎么工作的。看了源码之後,我们知道相关的子例程是m4_changequote,因为我们使用GDB的break命令在那里设置一个断点。
(gdb) break m4_changequote
Breakpoint 1 at 0x62f4: file builtin.c, line 879.
通过使用run命令,在GDB的控制下我们启动m4的运行。只要控制没有达到m4_changequote子例程,程序运行的和平时一样。
(gdb) run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)
foo

0000
为了触发断点,我们调用changequote。GDB悬挂m4的执行,显示它停止地方的上下文信息。
changequote(,)
Breakpoint 1, m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:879
879         if (bad_argc(TOKEN_DATA_TEXT(argv[0]),argc,1,3))
现在我们使用命令n(next)执行当前函数的下一行。
(gdb) n
882         set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\
: nil,
set_quotes看起来像是有问题的子例程,通过使用命令s(step)代替next我们能进入它的内部执行。 step会进入将被执行的子例程的下一行,因此它进入了set_quotes。
(gdb) s
set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
530         if (lquote != def_lquote)
上面展示了m4(以及它的参数)被悬挂在这个栈里,这个显示被称为栈桢显示。它显示了栈的概要。我们可以使用backtrace命令(它也可以写成bt)来看一看在所有的栈中我们处在哪一个栈里:backtrace命令显示每一个活动子例程的栈桢。
(gdb) bt
#0  set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
#1  0x6344 in m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:882
#2  0x8174 in expand_macro (sym=0x33320) at macro.c:242
#3  0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
    at macro.c:71
#4  0x79dc in expand_input () at macro.c:40
#5  0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
我们再前进几行看看会发生什么。开始的两次,我们使用s;後面的两次我们使用n来避免进入 xstrdup子例程。
(gdb) s
0x3b5c  532         if (rquote != def_rquote)
(gdb) s
0x3b80  535         lquote = (lq == nil || *lq == '\0') ?  \
def_lquote : xstrdup(lq);
(gdb) n
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup(rq);
(gdb) n
538         len_lquote = strlen(rquote);
最後一行显示看起来有点奇怪。我们可以检查lquote和rquote变量,看看它们实际上是不是我们指定的新的左单引号和右单引号。我们使用命令p(print)来看它们的值。
(gdb) p lquote
$1 = 0x35d40 ""
(gdb) p rquote
$2 = 0x35d50 ""
lquote和rquote的确是新的左右单引号。为了看一些上下文,我们可以使用l(list)命令来显示围绕当前行的前後10行源代码。
(gdb) l
533             xfree(rquote);
534
535         lquote = (lq == nil || *lq == '\0') ? def_lquote\
: xstrdup (lq);
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup (rq);
537
538         len_lquote = strlen(rquote);
539         len_rquote = strlen(lquote);
540     }
541
542     void
让我们再向前执行两行设置len_lquote和len_rquote值的源代码,然後检查这些变量的值。
(gdb) n
539         len_rquote = strlen(lquote);
(gdb) n
540     }
(gdb) p len_lquote
$3 = 9
(gdb) p len_rquote
$4 = 7
假如len_lquote和len_rquote分别意味着lquote和rquote的长度,这看起来一定有问题。因为p命令能打印任何表达式的值--那些表达式能包括子例程和赋值。通过使用它,我们能把它们设置成别的更好的值。
(gdb) p len_lquote=strlen(lquote)
$5 = 7
(gdb) p len_rquote=strlen(rquote)
$6 = 9
对于修正使用m4内置的defn来设置新的引号引起的问题,这已经足够了吗?我们使用c(continue)命令可以让m4继续,然後试一试最初因为麻烦的那个例子。
(gdb) c
Continuing.
define(baz,defn(foo))
baz
0000
成功了!新的引号现在和默认的引号一样工作正常。问题似乎是那两个定义了错误的长度的行。我们给m4输入一个EOF让它退出。
C-d
Program exited normally.
这个消息`Program exited normally.'来自于GDB,它表明m4已经完成了执行。我们可以使用 GDB的quit命令来结束我们的GDB会话。
(gdb) quit 
            GDB简介:
            **************
            
                  调试器(比如象GDB)能让你观察另一个程序在执行时的内部活动,或程序出错时
            发生了什么。
                  GDB主要能为你做四件事(包括为了完成这些事而附加的功能),帮助你找出程序
            中的错误。
                  * 运行你的程序,设置所有的能影响程序运行的东西。
            
                  * 保证你的程序在指定的条件下停止。
            
                  * 当你程序停止时,让你检查发生了什么。
            
                  * 改变你的程序。那样你可以试着修正某个bug引起的问题,然后继续查找另一
                    个bug.
            
                  你可以用GDB来调试C和C++写的程序。(参考 *C 和C++)
            
            
                  调试Pascal程序时,有一些功能还不能使用。
            
                 GDB还可以用来调试FORTRAN程序,尽管现在还不支持表达式的输入,输出变量,
            或类FORTRAN的词法。
            * GDB是"free software",大家都可以免费拷贝。也可以为GDB增加新的功能,不
            过可要遵守GNU的许可协议幺。反正我认为GNU还是比较不错的:-)
            就这句话:
                  Fundamentally, the General Public License is a license which says
            that you have these freedoms and that you cannot take these freedoms
            away from anyone else.
            GDB的作者:
                  Richard Stallman是GDB的始作俑者,另外还有许多别的GNU的成员。许多人
            为此作出了贡献。(都是老外不提也罢,但愿他们不要来找我麻烦:-))
            
            这里是GDB的一个例子:
                       原文中是使用一个叫m4的程序。但很遗憾我找不到这个程序的原代码,
            所以没有办法来按照原文来说明。不过反正是个例子,我就拿一个操作系统的
            进程调度原码来说明把,原代码我会附在后面。
                       首先这个程序叫os.c是一个模拟进程调度的原程序(也许是个老古董了:-))。
            先说明一下如何取得包括原代码符号的可执行代码。大家有心的话可以去看一下gcc的
            man文件(在shell下打man gcc)。gcc -g  -o 
            -g 的意思是生成带原代码调试符号的可执行文件。
            -o 的意思是指定可执行文件名。
            (gcc 的命令行参数有一大堆,有兴趣可以自己去看看。)
            反正在linux下把os.c用以上方法编译连接以后就产生了可供gdb使用的可执行文件。
            我用gcc -g os.c -o os,产生的可执行文档叫os.
            然后打gdb os,就可进入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.16, Copyright 1995 Free Software Foundation, Inc...
             (gdb)
                 (gdb)是提示符,在这提示符下可以输入命令,直到退出。(退出命令是q/Q)
            为了尽量和原文档说明的命令相符,即使在本例子中没用的命令我也将演示。
            首先我们可以设置gdb的屏幕大小。键入:
             (gdb)set width 70
            就是把标准屏幕设为70列。
                 然后让我们来设置断点。设置方法很简单:break或简单打b后面加行号或函数名
            比如我们可以在main 函数上设断点:
             (gdb)break main
            或(gdb)b main
             系统提示:Breakpoint 1 at 0x8049552: file os.c, line 455.
             然后我们可以运行这个程序,当程序运行到main函数时程序就会停止返回到gdb的
            提示符下。运行的命令是run或r(gdb中有不少alias,可以看一下help,在gdb下打help)
            run 后面可以跟参数,就是为程序指定命令行参数。
            比如r abcd,则程序就会abcd以作为参数。(这里要说明的是可以用set args来指定参
            数)。打入r或run后,程序就开始运行直到进入main的入口停止,显示:
            Starting program: /os
            
            Breakpoint 1, main () at os.c:455
            455               Initial();
            这里455 Initial();是将要执行的命令或函数。
            gdb提供两种方式:1.单步进入,step into就是跟踪到函数内啦。命令是step或s
                                2.单步,next,就是简单的单步,不会进入函数。命令是next或n
            这两个命令还有别的用法以后再说。
            我们用n命令,键入:
            (gdb)n
            Success forking process# 1 ,pid is 31474
            
            Success forking process# 2 ,pid is 31475
            
            Success forking process# 3 ,pid is 31476
            
            
            Success forking process# 5 ,pid is 31478
            
            Success forking process# 6 ,pid is 31479
            
                               Dispatching Algorithm : FIFO
            ********************************************************************************
            
                           PCB#           PID        Priority           PC         State
                           1              31474         24               0         WAITING
                           2              31475         19               0         WAITING
                           3              31476         16               0         WAITING
                           4              31477         23               0         WAITING
                           5              31478         22               0         WAITING
                           6              31479         20               0         WAITING
            
            ******************************************************************************
            
            CPU     :     NO process running
            IO :     No process
            Waiting CPU!!!     31474      31475      31476      31477      31478      31479
            Waiting     IO       NONE
            456               State=WAITING;
            最后的一行就是下一句要执行的命令。我们现在在另一个函数上加断点。注意我们
            可以用l/list命令来显示原代码。这里我们键入
            (gdb)l
            451        main()
            452        {
            453                int message;
            454
            455               Initial();
            456               State=WAITING;
            457               printf("Use Control-C to halt \n");
            458               signal(SIGALRM,AlarmMessage);
            459               signal(SIGINT,InteruptMessage);
            460               signal(SIGUSR2,IoMessage);
            (gdb) l
            461               alarm(TimeSlot);
            462               for(;;)
            463                {
            464                message=GetMessage();
            465                      switch(message)
            466                        {
            
            468                                                        break;
            469                                case CHILD_IO:             WaitingIo();
            470                                                        break;
            显示了原代码,现在在AlarmMessage上加断点。
            (gdb) b AlarmMessage
            Breakpoint 2 at 0x8048ee3: file os.c, line 259.
            (gdb)
            然后我们继续运行程序。
            (gdb)c
            c或continue命令让我们继续被中断的程序。 显示:
            Continuing.
            Use Control-C to halt
            
            Breakpoint 2, AlarmMessage () at os.c:259
            259                ClearSignal();
            注意我们下一句语句就是ClearSignal();
            我们用s/step跟踪进入这个函数看看它是干什么的。
            (gdb) s
            ClearSignal () at os.c:227
            227                signal(SIGINT,SIG_IGN);
            用l命令列出原代码:
            (gdb) l
            222        }
            223
            224
            225        void ClearSignal()       /* Clear other signals */
            226        {
            227                signal(SIGINT,SIG_IGN);
            228                signal(SIGALRM,SIG_IGN);
            229                signal(SIGUSR2,SIG_IGN);
            230        }
            231
            (gdb)
            我们可以用s命令继续跟踪。现在让我们来试试bt或backtrace命令。这个命令可以
            显示栈中的内容。
            (gdb) bt
            #0     ClearSignal () at os.c:227
            #1     0x8048ee8 in AlarmMessage () at os.c:259
            #2     0xbffffaec in ?? ()
            #3     0x80486ae in ___crt_dummy__ ()
            (gdb)
            大家一定能看懂显示的意思。栈顶是AlarmMessage,接下来的函数没有名字--就是
            没有原代码符号。这显示了函数调用的嵌套。
            好了,我们跟踪了半天还没有检查过变量的值呢。检查表达式的值的命令是p或print
            格式是p 
            444444让我们来找一个变量来看看。:-)
            (gdb)l 1
            还记得l的作用吗?l或list显示原代码符号,l或list加就显示从开始的
            原代码。好了找到一个让我们来看看WaitingQueue的内容
            (gdb) p WaitingQueue
            $1 = {1, 2, 3, 4, 5, 6, 0}
            (gdb)
            WaitingQueue是一个数组,gdb还支持结构的显示,
            (gdb) p Pcb
            $2 = {{Pid = 0, State = 0, Prior = 0, pc = 0}, {Pid = 31474, State = 2,
                   Prior = 24, pc = 0}, {Pid = 31475, State = 2, Prior = 19, pc = 0}, {
                   Pid = 31476, State = 2, Prior = 16, pc = 0}, {Pid = 31477, State = 2,
                   Prior = 23, pc = 0}, {Pid = 31478, State = 2, Prior = 22, pc = 0}, {
                   Pid = 31479, State = 2, Prior = 20, pc = 0}}
            (gdb)
            这里可以对照原程序看看。
            原文档里是一个调试过程,不过我想这里我已经把gdb的常用功能介绍了一遍,基本上
            可以用来调试程序了。:-)
            
            运行GDB(一些详细的说明):
            
                 前面已经提到过如何运行GDB了,现在让我们来看一些更有趣的东西。你可以在运行
            GDB时通过许多命令行参数指定大量的参数和选项,通过这个你可以在一开始就设置好
            程序运行的环境。
                 这里将要描述的命令行参数覆盖了大多数的情况,事实上在一定环境下有的并没有
            什么大用处。最通常的命令就是使用一个参数:
             $gdb 
            你还可以同时为你的执行文件指定一个core文件:
             $gdb  core
            你也可以为你要执行的文件指定一个进程号:
             $gdb   如:&gdb os 1234将使gdb与进程1234相联系(attach)
            除非你还有一个文件叫1234的。gdb首先检查一个core文件。
            如果你是使用一个远程终端进行远程调试的话,那如果你的终端不支持的话,你将无法
            使用第二个参数甚至没有core dump。如果你觉得开头的提示信息比较碍眼的话,你可以
            用gdb -silent。你还可以用命令行参数更加详细的控制GDB的行为。
            打入gdb -help或-h 可以得到这方面的提示。所有的参数都被按照排列的顺序传给gdb
            除非你用了-x参数。
                 当gdb开始运行时,它把任何一个不带选项前缀的参数都当作为一个可执行文件或core
            文件(或进程号)。就象在前面加了-se或-c选项。gdb把第一个前面没有选项说明的参数
            看作前面加了-se 选项,而第二个(如果有的话)看作是跟着-c选项后面的。
                 许多选项有缩写,用gdb -h可以看到。在gdb中你也可以任意的把选项名掐头去尾,只
            要保证gdb能判断唯一的一个参数就行。
            在这里我们说明一些最常用的参数选项
            -symbols (-s )------从中读去符号。
            -exec (-e )----在合适的时候执行来做用正确的数据与core
             dump的作比较。
            -se ------从中读取符号并把它作为可执行文件。
            -core (-c )--指定为一个core dump 文件。
            -c ----连接到进程号为,与attach命令相似。
            -command 
            -x -----执行gdb命令,在指定的文件中存放着一序列的gdb命令,就
            象一个批处理。
            -directory(-d) ---指定路径。把加入到搜索原文件的路径中。
            -m
            -mapped----
                  注意这个命令不是在所有的系统上都能用。如果你可以通过mmap系统调用来获得内存
            映象文件,你可以用这个命令来使gdb把你当前文件里的符号写入一个文件中,这个文件
            将存放在你的当前路径中。如果你调试的程序叫/temp/fred那么map文件就叫
            ./fred.syms这样当你以后再调试这个程序时,gdb会认识到这个文件的存在,从而从这
            个文件中读取符号,而不是从可执行文件中读取。.syms与主机有关不能共享。
            -r
            -readnow---马上从符号文件中读取整个符号表,而不是使用缺省的。缺省的符号表是
            调入一部分符号,当需要时再读入一部分。这会使开始进入gdb慢一些,但可以加快以后
            的调试速度。
            
             -m和-r一般在一起使用来建立.syms文件
            
            
            接下来再谈谈模式的设置(请听下回分解 :-))
            附:在gdb文档里使用的调试例子我找到了在minix下有这个程序,叫m4有兴趣的
            可以自己去看看
            
            
            模式的选择
            --------------
            现在我们来聊聊gdb运行模式的选择。我们可以用许多模式来运行gdb,例如在“批模式”
            或“安静模式”。这些模式都是在gdb运行时在命令行作为选项指定的。
            `-nx'
            `-n'
                    不执行任何初始化文件中的命令。(一般初始化文件叫做`.gdbinit').一般情况下在
            
            `-quiet'
            `-q'
                    “安静模式”。不输出介绍和版权信息。这些信息在“批模式”中也被跳过。
            
            `-batch'
                    “批模式”。在“批模式”下运行。当在命令文件中的所有命令都被成功的执行后
                    gdb返回状态“0”,如果在执行过程中出错,gdb返回一个非零值。
                    “批模式”在把gdb作为一个过滤器运行时很有用。比如在一台远程计算机上下载且
                    执行一个程序。信息“ Program exited normally”(一般是当运行的程序正常结束
                    时出现)不会在这种模式中出现。
            `-cd DIRECTORY'
                    把DIRECTORY作为gdb的工作目录,而非当前目录(一般gdb缺省把当前目录作为工作目
                    录)。
            `-fullname'
            `-f'
                    GNU Emacs 设置这个选项,当我们在Emacs下,把gdb作为它的一个子进程来运行时,
                    Emacs告诉gdb按标准输出完整的文件名和行号,一个可视的栈内容。这个格式跟在
                    文件名的后面。行号和字符重新按列排,Emacs-to-GDB界面使用\032字符作为一个
                    显示一页原文件的信号。
            `-b BPS'
                    为远程调试设置波特率。
            
            `-tty DEVICE'
                    使用DEVICE来作为你程序的标准输入输出
1. 一个简单的GDB会话
2. 进入和退出GDB
3. GDB命令
4. 在 GDB 下运行程序
7. 查看源码文件
9. C预处理宏
1. 一个简单的GDB会话
你可以在空闲的时候阅读全部的GDB手册。然而一些命令足以使你开始使用GDB,这一章就描述这些命令。
GNU m4(一个通用的宏处理器)的初始版本之一存在下面的bug:当我们改变单引号的默认表示时,一个用来捕获一个宏定义的命令停止工作。在下面较短的m4会 话中,我们定义一个宏foo扩展成0000;然後我们使用m4内置的defn命令定义bar做同样的事情。然而当我们改变左单引号为,右单引号为後,同样的程序在定义一个新的同义词baz时却失败了。
cd gnu/m4
./m4
define(foo,0000)
foo

0000
define(bar,defn(`foo'))
bar

0000
changequote(,)
define(baz,defn(foo))
baz
C-d

m4: End of input: 0: fatal error: EOF in string
让我们使用GDB来看看发生了什么。
gdb m4
GDB is free software and you are welcome to distribute copies
of it under certain conditions; type "show copying" to see
the conditions.
There is absolutely no warranty for GDB; type "show warranty"
for details.
GDB 6.5.50.20060706, Copyright 1999 Free Software Foundation, Inc...
(gdb)
GDB只读取很少的符号数据,这些数据足以让它知道在哪里能找到剩下的它需要的符号数据,因此,第一个命令提示符显示的很快。现在我们告诉GDB使用比平时更短的显示宽度,这样这些例子可以更好的显示在这个手册中。
(gdb) set width 70
我们需要看一看m4内置的changquote是怎么工作的。看了源码之後,我们知道相关的子例程是m4_changequote,因为我们使用GDB的break命令在那里设置一个断点。
(gdb) break m4_changequote
Breakpoint 1 at 0x62f4: file builtin.c, line 879.
通过使用run命令,在GDB的控制下我们启动m4的运行。只要控制没有达到m4_changequote子例程,程序运行的和平时一样。
(gdb) run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)
foo

0000
为了触发断点,我们调用changequote。GDB悬挂m4的执行,显示它停止地方的上下文信息。
changequote(,)
Breakpoint 1, m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:879
879         if (bad_argc(TOKEN_DATA_TEXT(argv[0]),argc,1,3))
现在我们使用命令n(next)执行当前函数的下一行。
(gdb) n
882         set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\
: nil,
set_quotes看起来像是有问题的子例程,通过使用命令s(step)代替next我们能进入它的内部执行。 step会进入将被执行的子例程的下一行,因此它进入了set_quotes。
(gdb) s
set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
530         if (lquote != def_lquote)
上面展示了m4(以及它的参数)被悬挂在这个栈里,这个显示被称为栈桢显示。它显示了栈的概要。我们可以使用backtrace命令(它也可以写成bt)来看一看在所有的栈中我们处在哪一个栈里:backtrace命令显示每一个活动子例程的栈桢。
(gdb) bt
#0  set_quotes (lq=0x34c78 "", rq=0x34c88 "")
    at input.c:530
#1  0x6344 in m4_changequote (argc=3, argv=0x33c70)
    at builtin.c:882
#2  0x8174 in expand_macro (sym=0x33320) at macro.c:242
#3  0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
    at macro.c:71
#4  0x79dc in expand_input () at macro.c:40
#5  0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
我们再前进几行看看会发生什么。开始的两次,我们使用s;後面的两次我们使用n来避免进入 xstrdup子例程。
(gdb) s
0x3b5c  532         if (rquote != def_rquote)
(gdb) s
0x3b80  535         lquote = (lq == nil || *lq == '\0') ?  \
def_lquote : xstrdup(lq);
(gdb) n
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup(rq);
(gdb) n
538         len_lquote = strlen(rquote);
最後一行显示看起来有点奇怪。我们可以检查lquote和rquote变量,看看它们实际上是不是我们指定的新的左单引号和右单引号。我们使用命令p(print)来看它们的值。
(gdb) p lquote
$1 = 0x35d40 ""
(gdb) p rquote
$2 = 0x35d50 ""
lquote和rquote的确是新的左右单引号。为了看一些上下文,我们可以使用l(list)命令来显示围绕当前行的前後10行源代码。
(gdb) l
533             xfree(rquote);
534
535         lquote = (lq == nil || *lq == '\0') ? def_lquote\
: xstrdup (lq);
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
: xstrdup (rq);
537
538         len_lquote = strlen(rquote);
539         len_rquote = strlen(lquote);
540     }
541
542     void
让我们再向前执行两行设置len_lquote和len_rquote值的源代码,然後检查这些变量的值。
(gdb) n
539         len_rquote = strlen(lquote);
(gdb) n
540     }
(gdb) p len_lquote
$3 = 9
(gdb) p len_rquote
$4 = 7
假如len_lquote和len_rquote分别意味着lquote和rquote的长度,这看起来一定有问题。因为p命令能打印任何表达式的值--那些表达式能包括子例程和赋值。通过使用它,我们能把它们设置成别的更好的值。
(gdb) p len_lquote=strlen(lquote)
$5 = 7
(gdb) p len_rquote=strlen(rquote)
$6 = 9
对于修正使用m4内置的defn来设置新的引号引起的问题,这已经足够了吗?我们使用c(continue)命令可以让m4继续,然後试一试最初因为麻烦的那个例子。
(gdb) c
Continuing.
define(baz,defn(foo))
baz
0000
成功了!新的引号现在和默认的引号一样工作正常。问题似乎是那两个定义了错误的长度的行。我们给m4输入一个EOF让它退出。
C-d
Program exited normally.
这个消息`Program exited normally.'来自于GDB,它表明m4已经完成了执行。我们可以使用 GDB的quit命令来结束我们的GDB会话。
(gdb) quit 
            GDB简介:
            **************
            
                  调试器(比如象GDB)能让你观察另一个程序在执行时的内部活动,或程序出错时
            发生了什么。
                  GDB主要能为你做四件事(包括为了完成这些事而附加的功能),帮助你找出程序
            中的错误。
                  * 运行你的程序,设置所有的能影响程序运行的东西。
            
                  * 保证你的程序在指定的条件下停止。
            
                  * 当你程序停止时,让你检查发生了什么。
            
                  * 改变你的程序。那样你可以试着修正某个bug引起的问题,然后继续查找另一
                    个bug.
            
                  你可以用GDB来调试C和C++写的程序。(参考 *C 和C++)
            
            
                  调试Pascal程序时,有一些功能还不能使用。
            
                 GDB还可以用来调试FORTRAN程序,尽管现在还不支持表达式的输入,输出变量,
            或类FORTRAN的词法。
            * GDB是"free software",大家都可以免费拷贝。也可以为GDB增加新的功能,不
            过可要遵守GNU的许可协议幺。反正我认为GNU还是比较不错的:-)
            就这句话:
                  Fundamentally, the General Public License is a license which says
            that you have these freedoms and that you cannot take these freedoms
            away from anyone else.
            GDB的作者:
                  Richard Stallman是GDB的始作俑者,另外还有许多别的GNU的成员。许多人
            为此作出了贡献。(都是老外不提也罢,但愿他们不要来找我麻烦:-))
            
            这里是GDB的一个例子:
                       原文中是使用一个叫m4的程序。但很遗憾我找不到这个程序的原代码,
            所以没有办法来按照原文来说明。不过反正是个例子,我就拿一个操作系统的
            进程调度原码来说明把,原代码我会附在后面。
                       首先这个程序叫os.c是一个模拟进程调度的原程序(也许是个老古董了:-))。
            先说明一下如何取得包括原代码符号的可执行代码。大家有心的话可以去看一下gcc的
            man文件(在shell下打man gcc)。gcc -g  -o 
            -g 的意思是生成带原代码调试符号的可执行文件。
            -o 的意思是指定可执行文件名。
            (gcc 的命令行参数有一大堆,有兴趣可以自己去看看。)
            反正在linux下把os.c用以上方法编译连接以后就产生了可供gdb使用的可执行文件。
            我用gcc -g os.c -o os,产生的可执行文档叫os.
            然后打gdb os,就可进入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.16, Copyright 1995 Free Software Foundation, Inc...
             (gdb)
                 (gdb)是提示符,在这提示符下可以输入命令,直到退出。(退出命令是q/Q)
            为了尽量和原文档说明的命令相符,即使在本例子中没用的命令我也将演示。
            首先我们可以设置gdb的屏幕大小。键入:
             (gdb)set width 70
            就是把标准屏幕设为70列。
                 然后让我们来设置断点。设置方法很简单:break或简单打b后面加行号或函数名
            比如我们可以在main 函数上设断点:
             (gdb)break main
            或(gdb)b main
             系统提示:Breakpoint 1 at 0x8049552: file os.c, line 455.
             然后我们可以运行这个程序,当程序运行到main函数时程序就会停止返回到gdb的
            提示符下。运行的命令是run或r(gdb中有不少alias,可以看一下help,在gdb下打help)
            run 后面可以跟参数,就是为程序指定命令行参数。
            比如r abcd,则程序就会abcd以作为参数。(这里要说明的是可以用set args来指定参
            数)。打入r或run后,程序就开始运行直到进入main的入口停止,显示:
            Starting program: /os
            
            Breakpoint 1, main () at os.c:455
            455               Initial();
            这里455 Initial();是将要执行的命令或函数。
            gdb提供两种方式:1.单步进入,step into就是跟踪到函数内啦。命令是step或s
                                2.单步,next,就是简单的单步,不会进入函数。命令是next或n
            这两个命令还有别的用法以后再说。
            我们用n命令,键入:
            (gdb)n
            Success forking process# 1 ,pid is 31474
            
            Success forking process# 2 ,pid is 31475
            
            Success forking process# 3 ,pid is 31476
            
            
            Success forking process# 5 ,pid is 31478
            
            Success forking process# 6 ,pid is 31479
            
                               Dispatching Algorithm : FIFO
            ********************************************************************************
            
                           PCB#           PID        Priority           PC         State
                           1              31474         24               0         WAITING
                           2              31475         19               0         WAITING
                           3              31476         16               0         WAITING
                           4              31477         23               0         WAITING
                           5              31478         22               0         WAITING
                           6              31479         20               0         WAITING
            
            ******************************************************************************
            
            CPU     :     NO process running
            IO :     No process
            Waiting CPU!!!     31474      31475      31476      31477      31478      31479
            Waiting     IO       NONE
            456               State=WAITING;
            最后的一行就是下一句要执行的命令。我们现在在另一个函数上加断点。注意我们
            可以用l/list命令来显示原代码。这里我们键入
            (gdb)l
            451        main()
            452        {
            453                int message;
            454
            455               Initial();
            456               State=WAITING;
            457               printf("Use Control-C to halt \n");
            458               signal(SIGALRM,AlarmMessage);
            459               signal(SIGINT,InteruptMessage);
            460               signal(SIGUSR2,IoMessage);
            (gdb) l
            461               alarm(TimeSlot);
            462               for(;;)
            463                {
            464                message=GetMessage();
            465                      switch(message)
            466                        {
            
            468                                                        break;
            469                                case CHILD_IO:             WaitingIo();
            470                                                        break;
            显示了原代码,现在在AlarmMessage上加断点。
            (gdb) b AlarmMessage
            Breakpoint 2 at 0x8048ee3: file os.c, line 259.
            (gdb)
            然后我们继续运行程序。
            (gdb)c
            c或continue命令让我们继续被中断的程序。 显示:
            Continuing.
            Use Control-C to halt
            
            Breakpoint 2, AlarmMessage () at os.c:259
            259                ClearSignal();
            注意我们下一句语句就是ClearSignal();
            我们用s/step跟踪进入这个函数看看它是干什么的。
            (gdb) s
            ClearSignal () at os.c:227
            227                signal(SIGINT,SIG_IGN);
            用l命令列出原代码:
            (gdb) l
            222        }
            223
            224
            225        void ClearSignal()       /* Clear other signals */
            226        {
            227                signal(SIGINT,SIG_IGN);
            228                signal(SIGALRM,SIG_IGN);
            229                signal(SIGUSR2,SIG_IGN);
            230        }
            231
            (gdb)
            我们可以用s命令继续跟踪。现在让我们来试试bt或backtrace命令。这个命令可以
            显示栈中的内容。
            (gdb) bt
            #0     ClearSignal () at os.c:227
            #1     0x8048ee8 in AlarmMessage () at os.c:259
            #2     0xbffffaec in ?? ()
            #3     0x80486ae in ___crt_dummy__ ()
            (gdb)
            大家一定能看懂显示的意思。栈顶是AlarmMessage,接下来的函数没有名字--就是
            没有原代码符号。这显示了函数调用的嵌套。
            好了,我们跟踪了半天还没有检查过变量的值呢。检查表达式的值的命令是p或print
            格式是p 
            444444让我们来找一个变量来看看。:-)
            (gdb)l 1
            还记得l的作用吗?l或list显示原代码符号,l或list加就显示从开始的
            原代码。好了找到一个让我们来看看WaitingQueue的内容
            (gdb) p WaitingQueue
            $1 = {1, 2, 3, 4, 5, 6, 0}
            (gdb)
            WaitingQueue是一个数组,gdb还支持结构的显示,
            (gdb) p Pcb
            $2 = {{Pid = 0, State = 0, Prior = 0, pc = 0}, {Pid = 31474, State = 2,
                   Prior = 24, pc = 0}, {Pid = 31475, State = 2, Prior = 19, pc = 0}, {
                   Pid = 31476, State = 2, Prior = 16, pc = 0}, {Pid = 31477, State = 2,
                   Prior = 23, pc = 0}, {Pid = 31478, State = 2, Prior = 22, pc = 0}, {
                   Pid = 31479, State = 2, Prior = 20, pc = 0}}
            (gdb)
            这里可以对照原程序看看。
            原文档里是一个调试过程,不过我想这里我已经把gdb的常用功能介绍了一遍,基本上
            可以用来调试程序了。:-)
            
            运行GDB(一些详细的说明):
            
                 前面已经提到过如何运行GDB了,现在让我们来看一些更有趣的东西。你可以在运行
            GDB时通过许多命令行参数指定大量的参数和选项,通过这个你可以在一开始就设置好
            程序运行的环境。
                 这里将要描述的命令行参数覆盖了大多数的情况,事实上在一定环境下有的并没有
            什么大用处。最通常的命令就是使用一个参数:
             $gdb 
            你还可以同时为你的执行文件指定一个core文件:
             $gdb  core
            你也可以为你要执行的文件指定一个进程号:
             $gdb   如:&gdb os 1234将使gdb与进程1234相联系(attach)
            除非你还有一个文件叫1234的。gdb首先检查一个core文件。
            如果你是使用一个远程终端进行远程调试的话,那如果你的终端不支持的话,你将无法
            使用第二个参数甚至没有core dump。如果你觉得开头的提示信息比较碍眼的话,你可以
            用gdb -silent。你还可以用命令行参数更加详细的控制GDB的行为。
            打入gdb -help或-h 可以得到这方面的提示。所有的参数都被按照排列的顺序传给gdb
            除非你用了-x参数。
                 当gdb开始运行时,它把任何一个不带选项前缀的参数都当作为一个可执行文件或core
            文件(或进程号)。就象在前面加了-se或-c选项。gdb把第一个前面没有选项说明的参数
            看作前面加了-se 选项,而第二个(如果有的话)看作是跟着-c选项后面的。
                 许多选项有缩写,用gdb -h可以看到。在gdb中你也可以任意的把选项名掐头去尾,只
            要保证gdb能判断唯一的一个参数就行。
            在这里我们说明一些最常用的参数选项
            -symbols (-s )------从中读去符号。
            -exec (-e )----在合适的时候执行来做用正确的数据与core
             dump的作比较。
            -se ------从中读取符号并把它作为可执行文件。
            -core (-c )--指定为一个core dump 文件。
            -c ----连接到进程号为,与attach命令相似。
            -command 
            -x -----执行gdb命令,在指定的文件中存放着一序列的gdb命令,就
            象一个批处理。
            -directory(-d) ---指定路径。把加入到搜索原文件的路径中。
            -m
            -mapped----
                  注意这个命令不是在所有的系统上都能用。如果你可以通过mmap系统调用来获得内存
            映象文件,你可以用这个命令来使gdb把你当前文件里的符号写入一个文件中,这个文件
            将存放在你的当前路径中。如果你调试的程序叫/temp/fred那么map文件就叫
            ./fred.syms这样当你以后再调试这个程序时,gdb会认识到这个文件的存在,从而从这
            个文件中读取符号,而不是从可执行文件中读取。.syms与主机有关不能共享。
            -r
            -readnow---马上从符号文件中读取整个符号表,而不是使用缺省的。缺省的符号表是
            调入一部分符号,当需要时再读入一部分。这会使开始进入gdb慢一些,但可以加快以后
            的调试速度。
            
             -m和-r一般在一起使用来建立.syms文件
            
            
            接下来再谈谈模式的设置(请听下回分解 :-))
            附:在gdb文档里使用的调试例子我找到了在minix下有这个程序,叫m4有兴趣的
            可以自己去看看
            
            
            模式的选择
            --------------
            现在我们来聊聊gdb运行模式的选择。我们可以用许多模式来运行gdb,例如在“批模式”
            或“安静模式”。这些模式都是在gdb运行时在命令行作为选项指定的。
            `-nx'
            `-n'
                    不执行任何初始化文件中的命令。(一般初始化文件叫做`.gdbinit').一般情况下在
            
            `-quiet'
            `-q'
                    “安静模式”。不输出介绍和版权信息。这些信息在“批模式”中也被跳过。
            
            `-batch'
                    “批模式”。在“批模式”下运行。当在命令文件中的所有命令都被成功的执行后
                    gdb返回状态“0”,如果在执行过程中出错,gdb返回一个非零值。
                    “批模式”在把gdb作为一个过滤器运行时很有用。比如在一台远程计算机上下载且
                    执行一个程序。信息“ Program exited normally”(一般是当运行的程序正常结束
                    时出现)不会在这种模式中出现。
            `-cd DIRECTORY'
                    把DIRECTORY作为gdb的工作目录,而非当前目录(一般gdb缺省把当前目录作为工作目
                    录)。
            `-fullname'
            `-f'
                    GNU Emacs 设置这个选项,当我们在Emacs下,把gdb作为它的一个子进程来运行时,
                    Emacs告诉gdb按标准输出完整的文件名和行号,一个可视的栈内容。这个格式跟在
                    文件名的后面。行号和字符重新按列排,Emacs-to-GDB界面使用\032字符作为一个
                    显示一页原文件的信号。
            `-b BPS'
                    为远程调试设置波特率。
            
            `-tty DEVICE'
                    使用DEVICE来作为你程序的标准输入输出
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值