1.GDB 

GDB（the GNU Project Debugger）是 GNU 发布的一个功能强大的 UNIX 程序调试工具，可以调试 Ada、C、C++、Objective-C 和 Pascal 等多种语言的程序，可以在大多数 UNIX 和Microsoft Windows 变种上运行。GDB 既可以在本地调试，也可以进行远程调试。

通过 GDB 能够对程序进行如下调试：

● 运行程序，还可以给程序加上某些参数，指定程序的行为。

● 使程序在特定的条件下停止。

● 检查程序停止时的运行状态。

● 改变程序的参数，以纠正程序中的错误。

2.GDB  基本命令

需要使用 GDB 调试的程序，在编译的时候必须加-g 参数，开启调试信息。运行 GDB调试程序通常使用如下方式：

$ gdb <程序名称>

在 GDB 的命令提示符，输入 help，能够得到 GDB 命令的分类，主要有：

● aliases 命令别名

● breakpoints 断点设置

● data 数据查看

● files 指定和检查文件

● internals 维护命令

● running 运行程序

● stack 检查堆栈

● status 状态查看

● tracepoints 跟踪程序

基本命令：

break  ----------------设置断点：break + 要设置断点的行号

clear  -----------------清除断点：clear + 要清除断点的行号

delete  ---------------用于清除断点和自动显示的表达式的命令

disable  -------------让所设断点暂时失效。如果要让多个编号处的断点失效可将编号用空格隔开

enable -------------- 与 disable 相对

run  -------------------运行调试程序

countinue  ----------继续执行正在调试的程序

file  --------------------装入想要调试的可执行文件

kill  --------------------终止正在调试的程序

list  --------------------列出产生执行文件的源代码的一部分

next  ------------------执行一行源代码但不进入函数内部

step  ------------------执行一行源代码而且进入函数内部

run  -------------------执行当前被调试的程序

quit  ------------------终止 gdb

watch  ---------------监视一个变量的值而不管它何时被改变

make  ---------------在 GDB 中重新产生可执行文件

shell  -----------------在 gdb 中执行 UNIX shell 命令

where ----------------查看程序可能出错的地方

 

gdb

GUN Debugger



注意

在程序编译过程中，使用-g选项 

gcc -g -o test test.c

gdb filename 

这里的filename是可执行文件，而不是源文件



基本命令



file命令

quit： 

shell： 切入shell当中

exit：从shell界面退出到gdb

list：列出调试程序的源代码 

list  

list n 

list begin,end 

list - 

list +

show listsize：显示list默认显示的行数 

set listsize n：修改list默认显示的行数为n行



控制程序的执行

break：设置断点 

break 10：在第10行设置断点 

break main：在main函数处设置断点

info breakpoints（info break）：查看断点

delete：删除所有断点 

delete n：删除编号为n号的断点



程序的运行

run：运行程序，执行到断点处，或者直到程序结束 

next（n）：单步执行，不进入函数内部 

step：单步执行，进入函数内部 

continue：程序从当前位置开始运行，直到断点处，或者直到程序结束 

kill：终止本次调试

查看运行时的数据： 

print：查看变量的值/表达式的值 

print i 

print i*j 

print arry[n]@m   //显示从下标为n开始的m个数

set：修改变量的值 

set variable j=10 

print j=10

display：动态观察变量的值 

info display：显示当前设置的表达式的清单 

delete display：取消对设置的表达式的自动显示功能

显示函数调用堆栈的信息 


点击此处查看gdb调试多进程程序

启动gdb
gdb -tui：分屏显示源代码

gdb -q：不显示开始的提示信息
可以在.bashrc中加入
alias gdb="gdb -q -tui"

开始调试
执行run（需要提前设置断点），也可以在调试过程中重新运行调试的程序，run后可以跟随发给该程序的任何参数。
常用命令

命令
功能
list（简写l）
显示当前行前面和后面的10行代码
list n1 n2
显示n1到行和n2行之间的代码
list main
显示main函数代码
info functions regex
列出符合正则表达式的函数名称
info breakpoints（简写info b）
查看当前所有的断点信息（断点号，断点类型，断点位置）
break func
在当前文件的func函数处设置断点
break fileName:N
在某文件的第N行处设置断点，当前文件第N行设置断点可以忽略fileName
break func(或fileName:N) if exp
条件断点，exp成立则断点
delete N
删除第N号断点
delete
删除所有断点
clear N
清除第N行上的断点
watch exp
exp成立程序停住
next（简写n）
单步执行，遇到函数会跳过
next N
执行N次单步执行
step（简写s)
单步执行，遇到函数会进入
finish
执行完当前函数，返回到调用它的位置
continue
运行到下一个断点处
until（简写u）
鼠标放到代码行，运行到该代码行停止
jump N
跳转到第N行开始执行，不会主动在N行停住
run
重新运行调试的程序，可以带参数
[Enter]
直接回车执行上次执行的命令
print var（简写p）
查看变量var的值
print /x var
按16进制格式显示变量值
ptype var
查看变量var的结构或类型
backtrach
查看调用堆栈
多进程调试
默认设置下，在调试多进程程序时GDB只会调试主进程。但是GDB（>V7.0）支持多进程的分别以及同时调试。换句话说，GDB可以同时调试多个程序。只需要设置follow-fork-mode(默认值：parent)和detach-on-fork（默认值：on）即可。

follow-fork-mode
detach-on-fork
说明
parent
on
只调试主进程（GDB默认）
child
on
只调试子进程
parent
off
同时调试两个进程，gdb跟主进程，子进程block在fork位置
child
off
同时调试两个进程，gdb跟子进程，主进程block在fork位置
设置方法：set follow-fork-mode [parent|child]   set detach-on-fork [on|off]

查询正在调试的进程：info inferiors

切换调试的进程： inferior 

添加新的调试进程： add-inferior [-copies n] [-exec executable] ,可以用file executable来分配给inferior可执行文件。

其他：remove-inferiors infno， detach inferior

https://www.cnblogs.com/HKUI/p/8955443.html


GDB调试

启动程序准备调试

GDB yourpram

或者

先输入GDB

然后输入 file yourpram

然后使用run或者r命令开始程序的执行,也可以使用 run parameter将参数传递给该程序

参数列表





命令



命令缩写



命令说明





list



l



显示多行源代码





break



b



设置断点,程序运行到断点的位置会停下来





info



i



描述程序的状态





run



r



开始运行程序





display



disp



跟踪查看某个变量,每次停下来都显示它的值





step



s



执行下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句





next



n



执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)





print



p



打印内部变量值





continue



c



继续程序的运行,直到遇到下一个断点





set var name=v



 



设置变量的值





start



st



开始执行程序,在main函数的第一条语句前面停下来





file



 



装入需要调试的程序





kill



k



终止正在调试的程序





watch



 



监视变量值的变化





backtrace



bt



产看函数调用信息(堆栈)





frame



f



查看栈帧





quit



q



退出GDB环境





 

　　


//e.c
 #include <stdio.h>
void debug(char *str)
{
    printf("debug info :%s\n",str );
}
main(int argc,char *argv[]){
    int i,j;
    j=0;
    for(i=0;i<10;i++){
        j+=5;
        printf("now a=%d\n", j);
    }
}



gcc -g -o e e.c

调试gdb e

或者输入gdb

然后 file e

list 命令用法

list命令显示多行源代码,从上次的位置开始显示,默认情况下,一次显示10行,第一次使用时,从代码其实位置显示


gdb) list
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    main(int argc,char *argv[]){
7        int i,j;
8        j=0;
9        for(i=0;i<10;i++){
10            j+=5;
(gdb) 



list n显示已第n行未中心的10行代码


(gdb) list 8
3    {
4        printf("debug info :%s\n",str );
5    }
6    main(int argc,char *argv[]){
7        int i,j;
8        j=0;
9        for(i=0;i<10;i++){
10            j+=5;
11            printf("now a=%d\n", j);
12        }
(gdb) 



list functionname显示以functionname的函数为中心的10行代码


(gdb) list main
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    main(int argc,char *argv[]){
7        int i,j;
8        j=0;
9        for(i=0;i<10;i++){
10            j+=5;
(gdb) 



list - 显示刚才打印过的源代码之前的代码


(gdb) list 10
5    }
6    main(int argc,char *argv[]){
7        int i,j;
8        j=0;
9        for(i=0;i<10;i++){
10            j+=5;
11            printf("now a=%d\n", j);
12        }
13    }(gdb) list -
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
(gdb) 



断点命令break

break location:在location位置设置断点,改位置可以为某一行,某函数名或者其它结构的地址

GDB会在执行该位置的代码之前停下来




gdb) list
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    main(int argc,char *argv[]){
7        int i,j;
8        j=0;
9        for(i=0;i<10;i++){
10            j+=5;
(gdb) 
11            printf("now a=%d\n", j);
12        }
13    }(gdb) break 10
Breakpoint 1 at 0x40050a: file e.c, line 10.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e 

Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
10            j+=5;
(gdb) c
Continuing.
now a=5

Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
10            j+=5;
(gdb) c
Continuing.
now a=10

Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
10            j+=5;
(gdb) 




使用delete breakpoints 断点号 删除断点

这里的断点号表示的是第几个断点,刚才执行break 10返回 reakpoint 1 at 0x40050a: file e.c, line 10.

中的1表示该断点的标号，因此使用 delete breakpoints 1表示删除第10行所定义的断点

clear n表示清除第n行的断点,因此clear 10等同于delete breakpoints 1

disable/enable n表示使得编号为n的断点暂时失效或有效

可使用info查看断点相关的信息

info breakpoints


gdb) info breakpoints
No breakpoints or watchpoints.
(gdb) break 10
Breakpoint 2 at 0x40050a: file e.c, line 10.
(gdb) break 9
Breakpoint 3 at 0x400501: file e.c, line 9.
(gdb) info breakpoints
Num     Type           Disp Enb Address            What
2       breakpoint     keep y   0x000000000040050a in main at e.c:10
3       breakpoint     keep y   0x0000000000400501 in main at e.c:9



display命令

查看参数的值




(gdb) break 10
Breakpoint 1 at 0x40050a: file e.c, line 10.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e 

Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
10            j+=5;
(gdb) display j
1: j = 0
(gdb) c
Continuing.
now a=5

Breakpoint 1, main (argc=1, argv=0x7fffffffe548) at e.c:10
10            j+=5;
1: j = 5
(gdb) display
1: j = 5
(gdb) display i
2: i = 1
(gdb) display j
3: j = 5
(gdb) display j*2
4: j*2 = 10
(gdb) info display
Auto-display expressions now in effect:
Num Enb Expression
4:   y  j*2
3:   y  j
2:   y  i
1:   y  j




也可以使用disable,enable,delete,info命令修改及查看其状态,用法与对断点的一样

step及next命令

step可使得程序逐条执行,即执行完一条语句然后在吓一跳语句前停下来,等待用户的命令

一般使用step命令是，可使用display或者watch命令查看变量的变化,从而判断程序行为是否符合要求

当下一条指令为函数时,s进入函数内部,在其第一条语句前停下来

step n,next n 表示连续但不执行n条指令,如果期间遇到断点,则停下来




(gdb) list
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    
7    main(int argc,char *argv[]){
8        int i,j;
9        j=0;
10        for(i=0;i<10;i++){
(gdb) 
11            j+=5;
12            printf("now j=%d\n", j);
13            debug("x=======x");
14        }
15    }(gdb) 
Line number 16 out of range; e.c has 15 lines.
(gdb) break 11
Breakpoint 1 at 0x40050a: file e.c, line 11.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e1 

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:11
11            j+=5;
(gdb) s
12            printf("now j=%d\n", j);
(gdb) s
__printf (format=0x400648 "now j=%d\n") at printf.c:30
30    {
(gdb) bt
#0  __printf (format=0x400648 "now j=%d\n") at printf.c:30
#1  0x0000000000400525 in main (argc=1, argv=0x7fffffffe538) at e.c:12
(gdb) n
34      va_start (arg, format);
(gdb) n
35      done = vfprintf (stdout, format, arg);
(gdb) n
now j=5
39    }
(gdb) bt
#0  __printf (format=<value optimized out>) at printf.c:39
#1  0x0000000000400525 in main (argc=1, argv=0x7fffffffe538) at e.c:12
(gdb) n
main (argc=1, argv=0x7fffffffe538) at e.c:13
13            debug("x=======x");
(gdb) n
debug info :x=======x
10        for(i=0;i<10;i++){
(gdb) s

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:11
11            j+=5;
(gdb) s
12            printf("now j=%d\n", j);
(gdb) n
now j=10
13            debug("x=======x");
(gdb) n
debug info :x=======x
10        for(i=0;i<10;i++){
(gdb) 




watch

watch可设置观察点(watchpoint)。使用观察点可以使得当某表达式的值发生变化时,程序暂停执行。

执行该命令前，必须保证程序已经运行




(gdb) list 
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    
7    main(int argc,char *argv[]){
8        int i,j;
9        j=0;
10        for(i=0;i<10;i++){
(gdb) 
11            j+=5;
12            printf("now j=%d\n", j);
13            debug("x=======x");
14        }
15    }(gdb) 
Line number 16 out of range; e.c has 15 lines.
(gdb) b main
Breakpoint 1 at 0x4004fa: file e.c, line 9.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e1 

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:9
9        j=0;
(gdb) watch j
Hardware watchpoint 2: j
(gdb) c
Continuing.
Hardware watchpoint 2: j

Old value = 0
New value = 5
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=5
debug info :x=======x
Hardware watchpoint 2: j

Old value = 5
New value = 10
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);




print命令




(gdb) list
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    
7    main(int argc,char *argv[]){
8        int i,j;
9        j=0;
10        for(i=0;i<10;i++){
(gdb) 
11            j+=5;
12            printf("now j=%d\n", j);
13            debug("x=======x");
14        }
15    }(gdb) 
Line number 16 out of range; e.c has 15 lines.
(gdb) break 12
Breakpoint 1 at 0x40050e: file e.c, line 12.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e1 

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) p j
$1 = 5
(gdb) c
Continuing.
now j=5
debug info :x=======x

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) p i,j
$2 = 10
(gdb) p j
$3 = 10
(gdb) 




set var name=value

在程序运行中动态改变变量的值




(gdb) list
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    
7    main(int argc,char *argv[]){
8        int i,j;
9        j=0;
10        for(i=0;i<10;i++){
(gdb) 
11            j+=5;
12            printf("now j=%d\n", j);
13            debug("x=======x");
14        }
15    }(gdb) 
Line number 16 out of range; e.c has 15 lines.
(gdb) break main
Breakpoint 1 at 0x4004fa: file e.c, line 9.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e1 

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:9
9        j=0;
(gdb) watch i
Hardware watchpoint 2: i
(gdb) watch j
Hardware watchpoint 3: j
(gdb) c
Continuing.
Hardware watchpoint 3: j

Old value = 0
New value = 5
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=5
debug info :x=======x
Hardware watchpoint 2: i

Old value = 0
New value = 1
0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
10        for(i=0;i<10;i++){
(gdb) c
Continuing.
Hardware watchpoint 3: j

Old value = 5
New value = 10
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=10
debug info :x=======x
Hardware watchpoint 2: i

Old value = 1
New value = 2
0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
10        for(i=0;i<10;i++){
(gdb) c
Continuing.
Hardware watchpoint 3: j

Old value = 10
New value = 15
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=15
debug info :x=======x
Hardware watchpoint 2: i

Old value = 2
New value = 3
0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
10        for(i=0;i<10;i++){
(gdb) c
Continuing.
Hardware watchpoint 3: j

Old value = 15
New value = 20
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=20
debug info :x=======x
Hardware watchpoint 2: i

Old value = 3
New value = 4
0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
10        for(i=0;i<10;i++){
(gdb) set var i=8
(gdb) c
Continuing.
Hardware watchpoint 3: j

Old value = 20
New value = 25
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=25
debug info :x=======x
Hardware watchpoint 2: i

Old value = 8
New value = 9
0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
10        for(i=0;i<10;i++){
(gdb) c
Continuing.
Hardware watchpoint 3: j

Old value = 25
New value = 30
main (argc=1, argv=0x7fffffffe538) at e.c:12
12            printf("now j=%d\n", j);
(gdb) c
Continuing.
now j=30
debug info :x=======x
Hardware watchpoint 2: i

Old value = 9
New value = 10
0x0000000000400533 in main (argc=1, argv=0x7fffffffe538) at e.c:10
10        for(i=0;i<10;i++){
(gdb) c
Continuing.

Watchpoint 2 deleted because the program has left the block in
which its expression is valid.

Watchpoint 3 deleted because the program has left the block in
which its expression is valid.
__libc_start_main (main=0x4004eb <main>, argc=1, ubp_av=0x7fffffffe538, init=<value optimized out>, fini=<value optimized out>, rtld_fini=<value optimized out>, 
    stack_end=0x7fffffffe528) at libc-start.c:258
258      exit (result);
(gdb) c
Continuing.

Program exited with code 026.




函数调用相关的

backtrace

可使用frame 查看堆栈中某一帧的信息




(gdb) list
1    #include <stdio.h>
2    void debug(char *str)
3    {
4        printf("debug info :%s\n",str );
5    }
6    
7    main(int argc,char *argv[]){
8        int i,j;
9        j=0;
10        for(i=0;i<10;i++){
(gdb) 
11            j+=5;
12            printf("now j=%d\n", j);
13            debug("x=======x");
14        }
15    }(gdb) 
Line number 16 out of range; e.c has 15 lines.
(gdb) b 13
Breakpoint 1 at 0x400525: file e.c, line 13.
(gdb) r
Starting program: /mnt/hgfs/www/c/gcc/e1 
now j=5

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:13
13            debug("x=======x");
(gdb) s
debug (str=0x400652 "x=======x") at e.c:4
4        printf("debug info :%s\n",str );
(gdb) bt
#0  debug (str=0x400652 "x=======x") at e.c:4
#1  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
(gdb) s
__printf (format=0x400638 "debug info :%s\n") at printf.c:30
30    {
(gdb) bt
#0  __printf (format=0x400638 "debug info :%s\n") at printf.c:30
#1  0x00000000004004e9 in debug (str=0x400652 "x=======x") at e.c:4
#2  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
(gdb) s
34      va_start (arg, format);
(gdb) bt
#0  __printf (format=0x400638 "debug info :%s\n") at printf.c:34
#1  0x00000000004004e9 in debug (str=0x400652 "x=======x") at e.c:4
#2  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
(gdb) s
35      done = vfprintf (stdout, format, arg);
(gdb) s
_IO_vfprintf_internal (s=0x333a58f040, format=0x400638 "debug info :%s\n", ap=0x7fffffffe330) at vfprintf.c:236
236      int save_errno = errno;
(gdb) bt
#0  _IO_vfprintf_internal (s=0x333a58f040, format=0x400638 "debug info :%s\n", ap=0x7fffffffe330) at vfprintf.c:236
#1  0x000000333a24effa in __printf (format=<value optimized out>) at printf.c:35
#2  0x00000000004004e9 in debug (str=0x400652 "x=======x") at e.c:4
#3  0x000000000040052f in main (argc=1, argv=0x7fffffffe538) at e.c:13
(gdb) c
Continuing.
debug info :x=======x
now j=10

Breakpoint 1, main (argc=1, argv=0x7fffffffe538) at e.c:13
13            debug("x=======x");
(gdb) bt
#0  main (argc=1, argv=0x7fffffffe538) at e.c:13