使用gdb调试c++程序
上篇(使用c++开发跨平台程序)说到,我不怕造东西,我怕的是造出来的东西,如果出了问题,我却不知道原因.所以调试分析是一个重要的手段.
C++调试是一个复杂的活.虽然大部分调试可以通过IDE在开发期间就解决了.但是必然的,还有很多东西需要在生产环境中还原它.分析它,然后解决它.gdb是一个成熟的工具.围绕着它有很多的工具可以选择.不过这么多工具的根本还是命令行模式下的gdb.
废话不多说,现在我就用gdb来分析调试一下吧.
生成dump文件:
在shell中输入命令:
ulimit -c unlimited;
然后运行自己的程序,如果程序此时崩溃,就会在目录生成一个名为core的文件.(这个也看系统配置.)
使用命令 gdb Test1 core加载文件.或者它的详细命令 gdb -c core -e Test1 --symbols Test1 --readnow
下面是一个命令行输出的截图:
clip_image002[10]
上图中可以解释的不多.因为我们现在刚要入门.所以只能注意上图中的三个红框.
红框1:命令行其中app7是可执行文件,而core是dump文件.
红框2:标明gdb在app7中找到了它对应的symbol.
红框3:标明core文件是经由app7产生的.这里是为了防止载入了错误的可执行文件.
注意一下几点:
如果使用sanitize,请取消.不然不会在崩溃时产生dump文件.反而是一个错误报告.
在生成可执行文件的时候,应该用debug模式,也可以用RelWithDebInfo模式.主要目的是能够获得程序的调试符号.
如果没有symbol信息,也可以调试,但是过程将会难上很多倍,毕竟我们是调试,不是破解.不过,还别说,gdb调试跟破解其实还是有点相通的.
由于gdb调试有非常多指令.从时效性上来说,不需要记住全部指令.只需要知道常用的指令就好.就算有人费事费力记住了所有指令,时间一长,如果不用的话也是会忘记的.所以能看到英文文档,我觉得比记住指令更有用.
大部分错误在IDE开发期间就已经被解决了.需要调试core dump文件的情况一般都是运行的时候出现的错误,我这里简单介绍以下几类
指针为NULL.栈溢出,除数为0,死锁.
调试指针为NULL
下面给定一个程序,程序的内容如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include
void bar(int* p)
{
int aa=*p;
}
void foo()
{
int* p=NULL;
bar(p);
}
int main(int argc, const char * argv[])
{
foo();
return 0;
}
编译后假设输出是app0,运行app0后会有core文件.现在我来加载这个core文件.截图如下:
clip_image004[10]
clip_image006[10]
加载完毕以后,可以看到gdb已经指出来了app0.cpp地15行有问题.
然后我们回到源码,查看第15行,的确是有问题.所有null问题已经解决.是不是简单无比?呵呵.但是我们要更进一.看看到底为什么.
1. 我使用p p,(第一个p是print,是gdb指令,第二个p是参数p);
clip_image008[10]
这说明p是一个0.所以这里会出错.
2. 按理说,以上的分析可以得出结论了.不过这里我想再进一步.
首先我列出 所有线程
info thread
就只有一个线程,很好.
其次,我看看堆栈
bt
可以看到调用堆栈,是从foo函数调用的bar函数.所以参数p是从foo里产生的.
可以看出,空引用虽然解决了,回头考虑一下的话,这里有点事后诸葛的意思.有人会问”你是已经事先知道空引用了.然后去分析的,这谁不会…”,真正的现实当中的空引用的确分析起来比这个困难一点.不过这个系列是让人们基本会用gdb.知道每种类型大体长什么样子.在现实问题中,分析的时候好有个方向.具体工作当中的问题.只能到时再分析.
调试栈溢出
栈溢出一般递归函数退出条件没有达成,导致的循环调用.栈溢出调试比较简单,特征也很明显.
下面我借用一个例子来说明一下.这个例子的作者是一个外国人,具体是谁.我忘记了.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include
#include
#include
#include
#include
void procF(int i)
{
int buffer[128] = {-1, 0, i+1, 0, -1};
procF(buffer[2]);
}
void procE()
{
procF(1);
}
#define THREAD_DECLARE(num,func) void bar_##num()\
{\
sleep(3);\
func;\
}\
\
void foo_##num()\
{\
bar_##num();\
}\
\
void * thread_##num (void *arg)\
{\
foo_##num();\
\
return 0;\
}
THREAD_DECLARE(one,procE())
THREAD_DECLARE(two,sleep(-1))
THREAD_DECLARE(three,sleep(-1))
THREAD_DECLARE(four,sleep(-1))
THREAD_DECLARE(five,sleep(-1))
#define THREAD_CREATE(num) {pthread_t threadID_##num; pthread_create (&threadID_##num, NULL,thread_##num, NULL);}
int main(int argc, const char * argv[])
{
THREAD_CREATE(one)
THREAD_CREATE(two)
THREAD_CREATE(three)
THREAD_CREATE(four)
THREAD_CREATE(five)
sleep(-1);
return 0;
}
以上文件很简单,定义了一个宏,然后使用这个宏,复制生成了5个线程.其中thread_one这个线程,会陷入死循环.它会在procF中循环调用,导致一个堆栈溢出.
我们来看看它长什么样子.具体怎么加载core我这里就略过了.直接看gdb内容吧.
clip_image014[10]
上面说cannot access memory at address xxx,然后列出最近执行具体位置是一个大括号,没有什么参考意义
1. 我先看看所有线程
clip_image016[10]
6个线程,除去第一个是不能能读取内存的错误以为,其余的都在sleep.这里按照gdb的提示(它说procF有问题),我先看看thread 1,因为只有它停留在了procF;
2. 指令thread 1 表示切换到线程1.然后查看它的堆栈,看看是如何到达这个procF的.
clip_image018[10]
到这里发现procF自己调用自己,按照经验,这里应该是栈溢出了.但是为了确认一下,我决定看看它调用了多少层.
3. 指令 bt是打印调用堆栈了.bt -20是打印最底层的20个调用
clip_image020[10]
发现它调用了15000次..这里还有一个好处就是,可以看到来源.是从procE来的.
下一步就可以去查看proceE的内容了.在gdb中也是可以做到的,如下图
clip_image022[10]
好了,到此调用栈溢出就解决了.
但是,还是可以在这里展开一下.我们知道函数的调用是放置在线程的占空间的.我们从占空间中看看,有没有什么规律.
为了显示栈空间,需要用到gdb的一个指令x(查看)
详细观察 bt -20返回的结果,可以看到类似如下
#14971 0x00005636f87b2c91 in procF (i=1) at /root/clionproject/Test1/dump/app6.cpp:16
#14972 0x00005636f87b2cb6 in procE () at /root/clionproject/Test1/dump/app6.cpp:20
其中#14971是frame的编号.
后边的0x00005636f87b2c91,是代码在内存中的位置.即app6.cpp:16这行所对应的二进制代码就在内存的此位置
gdb搞起
clip_image024[10]
p $rsp 和 info r $rsp 代表打印寄存器rsp里面的值. $rsp是指向栈顶端的寄存器.所以它的值就一定是栈顶端.
我来检查一下这个栈.
clip_image026[10]
这里主要是引出x指令.x是查看指定地址的指令.
除数为0
除数为0是一个简单的问题.代码我就不上了.
载入core文件就会显示
clip_image028[10]
说这是一个算术问题.发生在procD函数中
现在我检查一下procD是什么东西
clip_image030[10]
Disass是disassembly 的意思,指令是打印对应地址的反汇编代码.
上图中红框处,就是现在指令所运行的位置.系统认为在这个位置出错了.看idivl 它显然是一个除法.到这里十有八九是除数为零了.
看到汇编指令idivl -0x8(%rbp),其中的-x8(%rbp),代表一个值,这个值就是除数.所以我要把它代表的值找到.
首先查看一下 rbp是什么东东,rbp是一个寄存器,它指向了一个base point,你可以简单的认为所有函数内部申请的栈变量(比如 int a=0等等),都是通过rbp换算的.
clip_image032[10]
其次查看一下这个地址-8是啥.
clip_image034[10]
既然$rbp-0x8是一个变量的地址,那么我们就看看这个地址写的什么值.
clip_image036[10]
可以看到它的确是写的0.
除数为0,就结束了.
死锁
死锁也是一个常见的问题,不过死锁有个特点,并不是每一个死锁都会被dump下来.所以在遇到死锁的时候,有时候需要使用在线调试的办法,不过这个办法.
现在我使用以下代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include
#include
#include
#include
#include
static int sequence1 = 0;
static int sequence2 = 0;
std::mutex lock1;
std::mutex lock2;
int func1()
{
lock1.lock();
sleep(1);
sequence1++;
lock2.lock();
sequence2++;
lock1.unlock();
lock2.unlock();
return sequence1;
}
int func2()
{
lock2.lock();
sleep(1);
sequence2++;
lock1.lock();
sequence1++;
lock2.unlock();
lock1.unlock();
return sequence1;
}
void* thread1(void *arg)
{
int rev = 0;
while(1)
{
rev = func1();
if (rev == 100000)
{
pthread_exit(NULL);
}
}
}
void* thread2(void *arg)
{
int rev = 0;
while(1)
{
rev = func2();
if (rev == 100000)
{
pthread_exit(NULL);
}
}
}
void* thread3(void *arg)
{
int count = 0;
while(1)
{
sleep(1);
if ( count++ > 10000)
{
pthread_exit(NULL);
}
}
}
void* thread4(void *arg)
{
int count = 0;
while(1)
{
sleep(1);
if ( count++ > 10000)
{
pthread_exit(NULL);
}
}
}
int main()
{
pthread_t tid[4];
if(pthread_create(&tid[0], NULL, & thread1, NULL) != 0)
{
_exit(1);
}
if(pthread_create(&tid[1], NULL, & thread2, NULL) != 0)
{
_exit(1);
}
if(pthread_create(&tid[2], NULL, & thread3, NULL) != 0)
{
_exit(1);
}
if(pthread_create(&tid[3], NULL, & thread4, NULL) != 0)
{
_exit(1);
}
sleep(5);
pthread_join(tid[0], NULL);
pthread_join(tid[1], NULL);
pthread_join(tid[2], NULL);
pthread_join(tid[3], NULL);
return 0;
}
以上代码主要集中在func1和func2中,他们相互等待就有可能会死锁.现在我编译它运行以下.
clip_image038[10]
由于它只是死锁,所有在我机器上并没有dump下来,我要用gdb,在线调试它.截图如下
clip_image040[10]
我先用ps找到了进程id是14661,用gdb 附着了它,现在开始调试了.
先看thread
clip_image042[10]
这两个线程有可能死锁.先看看 thread 2 是如何调用的.调用堆栈搞起.
clip_image044[10]
它是调用了func1,我看看func1的内容
clip_image046[10]
它提示有两个变量分别是lock1和lock2.所以我想看看这两个变量
clip_image048[10]
提示,这两个锁,被不同的线程持有.
再回头看看thread 2 的调用堆栈
clip_image050[10]
可以看到,它提示线程14662 停在了lock2.lock()方法那里了这个线程想要获得锁的所有权. 而lock2,按照上一个截图,已经被14663持有了.
用相同的办法也可以得到lock1的细节.我这里就不复述了.
所以这个死锁就被我找到了原因.
小结
真正现实当中遇到的问题,不会像这样就很快的被找到.因为这里是创造问题然后去解决,有点事后诸葛的意思.比如现实当中的死锁,找到对应的锁变量这一步就不会那么容易,需要耐心和运气,不过使用gdb的第一步就是首先熟悉出问题的时候大体的调用堆栈模式,然后再去尝试可能的出错方向,进而解决它.如果只是记得冷冰冰gdb指令,在我眼里就如同多记住了几个英文单词而已,我认为意义不大.https://www.cnblogs.com/gaopang/p/11588683.html