C++调试排查技巧

我就是我 2022-09-21 05:45 186阅读 0赞

1. 调用栈系列  
下面是函数原型：

<table> 
 <tbody> 
 <tr> 
 <td> <pre>1
2
3
4
</pre> </td> 
 <td> <pre><code>#include "execinfo .h"
int backtrace(void **buffer, int size);
char **backtrace_symbols(void *const *buffer, int size);
void backtrace_symbols_fd(void *const *buffer, int size, int fd);</code></pre> </td> 
 </tr> 
 </tbody> 
</table>

接下来，对上面三个函数进行介绍：  
（1）backtrace用来获得当前程序的调用栈，把结果存在buffer中。通常，我们用gdb调试程序，设置合适的断点，停下来之后，用backtrace(bt)命令，就可以看到当前的调用栈。但是，有的时候，用到条件断点的时候，gdb的功能就没有程序本身的强大了，这个时候，可以考虑在程序中调用backtrace函数，来获取调用栈。  
（2）backtrace\_symbols把用backtrace获取的调用栈转换成字符串数组**，以字符串数组的形式返回，使用者需要在外面释放返回的字符串数组所占用的内存**  
（3）backtrace\_symbols\_fd把用backtrace获取**的调用栈信息写到fd所指定的文件中**

<table> 
 <tbody> 
 <tr> 
 <td> <pre>1
</pre> </td> 
 <td> <pre><code> void * __builtin_return_address (unsigned int level)</code></pre> </td> 
 </tr> 
 </tbody> 
</table>

这个函数用来得**到当前函数，或者调用它的函数的返回地址，得到这个地址后，通过gdb反汇编，便可得到调用函数相关的信息，这也是在应用中获取调用栈的一种方法。**

2. 内存分配、释放系列

<table> 
 <tbody> 
 <tr> 
 <td> <pre>1
2
</pre> </td> 
 <td> <pre><code>#include "malloc .h"
size_t malloc_usable_size((void *__ptr));</code></pre> </td> 
 </tr> 
 </tbody> 
</table>

这个函数的用法是返回调用malloc后实际分配的可用内存的大小。我们都知道在C++中，operator new()可以重载各种各样的版本，可以传入调用时的相关信息来跟踪内存分配情况，但是operator delete()却只有两种形式，不能随意重载，尤其是全局的operator delete()，只有一种版本，这个时候就比较痛苦了，究竟释放了多少内存呢? 这时候malloc\_usable\_size()这个函数就有用武之地了，调用它便可以获取当前释放的内存的大小。这里需要注意的是，如果在delete中用了malloc\_usable\_size来计算释放的内存大小，那么在new中也请用它来统计开辟的内存，这样才能对应起来。因为在调用malloc时，很多时候实际分配的内存会比用户申请的要大一些，所以如果两边的统计方法对应不起来的话，统计结果也会有比较大的判别。

几天帮同事跟踪的一个程序莫名退出，没有core dump(当然ulimit是打开的)的问题。我们知道，正常情况下，如果程序因为某种异常条件退出的话，应该会产生core dump，而如果程序正常退出的话，应该是直接或者间接的调用了exit()相关的函数。基于这个事实，我想到了这样一个办法，在程序开始时，通过系统提供的atexit()，向系统注册一个回调函数，在程序调用exit()退出的时候，这个回调函数就会被调用，然后我们在回调函数中打印出当前的函数调用栈，由此便可以知道exit()是在哪里调用，从而上述问题便迎刃而解了。上述方法用来解决类似问题是非常行之有效的。在上面，我提到了在“回调函数中打印出当前的函数调用栈”，相信细心的朋友应该注意到这个了，本文的主要内容就是详细介绍，如何在程序中打印中当前的函数调用栈。  
我之前写过一篇题目为《[介绍几个关于C/C++程序调试的函数][C_C]》的文章，看到这里，请读者朋友先看一下前面这篇，因为本文是以前面这篇文章为基础的。我正是用了backtrace()和backtrace\_symbols()这两个函数实现的，下面是一个简单的例子，通过这个例子我们来介绍具体的方法：

<table> 
 <tbody> 
 <tr> 
 <td> <pre>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
</pre> </td> 
 <td> <pre><code>#include &lt;execinfo .h&gt;
#include &lt;stdio .h&gt;
#include &lt;stdlib .h&gt;
&nbsp;
void fun1();
void fun2();
void fun3();
&nbsp;
void print_stacktrace();
&nbsp;
int main()
{
 
 fun3();
}
&nbsp;
void fun1()
{
 
 printf("stackstrace begin:\n");
 print_stacktrace();
}
&nbsp;
void fun2()
{
 
 fun1();
}
&nbsp;
void fun3()
{
 
 fun2();
}
&nbsp;
void print_stacktrace()
{
 
 int size = 16;
 void * array[16];
 int stack_num = backtrace(array, size);
 char ** stacktrace = backtrace_symbols(array, stack_num);
 for (int i = 0; i &lt; stack_num; ++i)
 {
 
 printf("%s\n", stacktrace[i]);
 }
 free(stacktrace);
}</code></pre> </td> 
 </tr> 
 </tbody> 
</table>

（说明：下面的介绍采用的环境是ubuntu 11.04, x86\_64, gcc-4.5.2）

* 1. 通过下面的方式编译运行：
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 </pre> </td> 
 <td> <pre><code>wuzesheng@ubuntu:~/work/test$ gcc test.cc -o test1
 wuzesheng@ubuntu:~/work/test$ ./test1
 stackstrace begin:
 ./test1() [0x400645]
 ./test1() [0x400607]
 ./test1() [0x400612]
 ./test1() [0x40061d]
 ./test1() [0x4005ed]
 /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xff) [0x7f5c59a91eff]
 ./test1() [0x400529]</code></pre> </td> 
 </tr> 
 </tbody> 
 </table>
 
 从上面的运行结果中，我们的确看到了函数的调用栈，但是都是16进制的地址，会有点小小的不爽。当然我们可以通过反汇编得到每个地址对应的函数，但这个还是有点麻烦了。不急，且听我慢慢道来，看第2步。
 * 2. 通过下面的方式编译运行：
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 </pre> </td> 
 <td> <pre><code>wuzesheng@ubuntu:~/work/test$ gcc test.cc -rdynamic -o test2
 wuzesheng@ubuntu:~/work/test$ ./test2
 stackstrace begin:
 ./test2(_Z16print_stacktracev+0x26) [0x4008e5]
 ./test2(_Z4fun1v+0x13) [0x4008a7]
 ./test2(_Z4fun2v+0x9) [0x4008b2]
 ./test2(_Z4fun3v+0x9) [0x4008bd]
 ./test2(main+0x9) [0x40088d]
 /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xff) [0x7f9370186eff]
 ./test2() [0x4007c9]</code></pre> </td> 
 </tr> 
 </tbody> 
 </table>
 
 这下终于可以看到函数的名字了，**对比一下2和1的编译过程，2比1多了一个-rdynamic的选项，让我们来看看这个选项是干什么的(来自gcc mannual的说明):**
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>1
 2
 </pre> </td> 
 <td> <pre style="font-family:monospace">-rdynamic
 Pass the flag -export-dynamic to the ELF linker, on targets that support it. This instructs the linker to add all symbols, not only used ones, to the dynamic symbol table. This option is needed for some uses of "dlopen" or to allow obtaining backtraces from within a program.</pre> </td> 
 </tr> 
 </tbody> 
 </table>
 
 从上面的说明可以看出，它的主要作用是让链接器把所有的符号都加入到动态符号表中，这下明白了吧。不过这里还有一个问题**，这里的函数名都是mangle过的，需要demangle才能看到原始的函数。关于c++的mangle/demangle机制，不了解的朋友可以在搜索引擎上搜一下，我这里就不多就介绍了。**这里介绍如何用命令来demangle，通过c++filt命令便可以:
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>1
 2
 </pre> </td> 
 <td> <pre><code>wuzesheng@ubuntu:~/work/test$ c++filt &lt; &lt;&lt; "_Z16print_stacktracev"
 print_stacktrace()</code></pre> </td> 
 </tr> 
 </tbody> 
 </table>
 
 写到这里，大部分工作就ok了。不过不知道大家有没有想过这样一个问题，同一个函数可以在代码中多个地方调用，如果我们只是知道函数，而不知道在哪里调用的，有时候还是不够方便，bingo，这个也是有办法的，可以通过address2line命令来完成，我们用第2步中编译出来的test2来做实验(address2line的-f选项可以打出函数名, -C选项也可以demangle)： 
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>1
 2
 3
 4
 </pre> </td> 
 <td> <pre><code>wuzesheng@ubuntu:~/work/test$ addr2line -a 0x4008a7 -e test2 -f
 0x00000000004008a7
 _Z4fun1v
 ??:0</code></pre> </td> 
 </tr> 
 </tbody> 
 </table>
 
 Oh no，怎么打出来的位置信息是乱码呢？不急，且看我们的第3步。
 * 3. 通过下面的方式编译运行：
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre>1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 </pre> </td> 
 <td> <pre><code>wuzesheng@ubuntu:~/work/test$ gcc test.cc -rdynamic -g -o test3 wuzesheng@ubuntu:~/work/test$ ./test3
 stackstrace begin:
 ./test3(_Z16print_stacktracev+0x26) [0x4008e5]
 ./test3(_Z4fun1v+0x13) [0x4008a7]
 ./test3(_Z4fun2v+0x9) [0x4008b2]
 ./test3(_Z4fun3v+0x9) [0x4008bd]
 ./test3(main+0x9) [0x40088d]
 /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xff) [0x7fa9558c1eff]
 ./test3() [0x4007c9]
 wuzesheng@ubuntu:~/work/test$ addr2line -a 0x4008a7 -e test3 -f -C
 0x00000000004008a7
 fun1()
 /home/wuzesheng/work/test/test.cc:20</code></pre> </td> 
 </tr> 
 </tbody> 
 </table>
 
 看上面的结果，我们不仅得到了调用栈，而且可以得到每个函数的名字，以及被调用的位置，大功告成。在这里需要说明一下的是，第3步比第2步多了一个-g选项**，-g选项的主要作用是生成调试信息，位置信息就属于调试信息的范畴，经常用gdb的朋友相信不会对这个选项感到陌生。**

4.打印程序占用内存

#include <unistd.h>
 #include <ios>
 #include <iostream>
 #include <fstream>
 #include <string>
 
 //
 //
 // process_mem_usage(double &, double &) - takes two doubles by reference,
 // attempts to read the system-dependent data for a process' virtual memory
 // size and resident set size, and return the results in KB.
 //
 // On failure, returns 0.0, 0.0
 
 void process_mem_usage(double& vm_usage, double& resident_set)
 {
 using std::ios_base;
 using std::ifstream;
 using std::string;
 
 vm_usage = 0.0;
 resident_set = 0.0;
 
 // 'file' stat seems to give the most reliable results
 //
 ifstream stat_stream("/proc/self/stat",ios_base::in);
 
 // dummy vars for leading entries in stat that we don't care about
 //
 string pid, comm, state, ppid, pgrp, session, tty_nr;
 string tpgid, flags, minflt, cminflt, majflt, cmajflt;
 string utime, stime, cutime, cstime, priority, nice;
 string O, itrealvalue, starttime;
 
 // the two fields we want
 //
 unsigned long vsize;
 long rss;
 
 stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
 >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
 >> utime >> stime >> cutime >> cstime >> priority >> nice
 >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest
 
 stat_stream.close();
 
 long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
 vm_usage = vsize / 1024.0;
 resident_set = rss * page_size_kb;
 }
 
 int main()
 {
 using std::cout;
 using std::endl;
 
 double vm, rss;
 process_mem_usage(vm, rss);
 cout << "VM: " << vm << "; RSS: " << rss << endl;
 }

或者

/*
 * Author: David Robert Nadeau
 * Site: http://NadeauSoftware.com/
 * License: Creative Commons Attribution 3.0 Unported License
 * http://creativecommons.org/licenses/by/3.0/deed.en_US
 */
 
 #if defined(_WIN32)
 #include <windows.h>
 #include <psapi.h>
 
 #elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
 #include <unistd.h>
 #include <sys/resource.h>
 
 #if defined(__APPLE__) && defined(__MACH__)
 #include <mach/mach.h>
 
 #elif (defined(_AIX) || defined(__TOS__AIX__)) || (defined(__sun__) || defined(__sun) || defined(sun) && (defined(__SVR4) || defined(__svr4__)))
 #include <fcntl.h>
 #include <procfs.h>
 
 #elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
 #include <stdio.h>
 
 #endif
 
 #else
 #error "Cannot define getPeakRSS( ) or getCurrentRSS( ) for an unknown OS."
 #endif
 
 
 
 
 
 /**
 * Returns the peak (maximum so far) resident set size (physical
 * memory use) measured in bytes, or zero if the value cannot be
 * determined on this OS.
 */
 size_t getPeakRSS( )
 {
 #if defined(_WIN32)
 /* Windows -------------------------------------------------- */
 PROCESS_MEMORY_COUNTERS info;
 GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
 return (size_t)info.PeakWorkingSetSize;
 
 #elif (defined(_AIX) || defined(__TOS__AIX__)) || (defined(__sun__) || defined(__sun) || defined(sun) && (defined(__SVR4) || defined(__svr4__)))
 /* AIX and Solaris ------------------------------------------ */
 struct psinfo psinfo;
 int fd = -1;
 if ( (fd = open( "/proc/self/psinfo", O_RDONLY )) == -1 )
 return (size_t)0L; /* Can't open? */
 if ( read( fd, &psinfo, sizeof(psinfo) ) != sizeof(psinfo) )
 {
 close( fd );
 return (size_t)0L; /* Can't read? */
 }
 close( fd );
 return (size_t)(psinfo.pr_rssize * 1024L);
 
 #elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
 /* BSD, Linux, and OSX -------------------------------------- */
 struct rusage rusage;
 getrusage( RUSAGE_SELF, &rusage );
 #if defined(__APPLE__) && defined(__MACH__)
 return (size_t)rusage.ru_maxrss;
 #else
 return (size_t)(rusage.ru_maxrss * 1024L);
 #endif
 
 #else
 /* Unknown OS ----------------------------------------------- */
 return (size_t)0L; /* Unsupported. */
 #endif
 }
 
 
 
 
 
 /**
 * Returns the current resident set size (physical memory use) measured
 * in bytes, or zero if the value cannot be determined on this OS.
 */
 size_t getCurrentRSS( )
 {
 #if defined(_WIN32)
 /* Windows -------------------------------------------------- */
 PROCESS_MEMORY_COUNTERS info;
 GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
 return (size_t)info.WorkingSetSize;
 
 #elif defined(__APPLE__) && defined(__MACH__)
 /* OSX ------------------------------------------------------ */
 struct mach_task_basic_info info;
 mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
 if ( task_info( mach_task_self( ), MACH_TASK_BASIC_INFO,
 (task_info_t)&info, &infoCount ) != KERN_SUCCESS )
 return (size_t)0L; /* Can't access? */
 return (size_t)info.resident_size;
 
 #elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
 /* Linux ---------------------------------------------------- */
 long rss = 0L;
 FILE* fp = NULL;
 if ( (fp = fopen( "/proc/self/statm", "r" )) == NULL )
 return (size_t)0L; /* Can't open? */
 if ( fscanf( fp, "%*s%ld", &rss ) != 1 )
 {
 fclose( fp );
 return (size_t)0L; /* Can't read? */
 }
 fclose( fp );
 return (size_t)rss * (size_t)sysconf( _SC_PAGESIZE);
 
 #else
 /* AIX, BSD, Solaris, and Unknown OS ------------------------ */
 return (size_t)0L; /* Unsupported. */
 #endif
 }

参考：http://stackoverflow.com/questions/669438/how-to-get-memory-usage-at-run-time-in-c

http://www.voidcn.com/blog/tycoon1988/article/p-4805871.html

[C_C]: http://www.wuzesheng.com/?p=1123