Linux下利用backtrace追踪函数调用堆栈以及定位段错误

最新推荐文章于 2023-05-05 15:40:11 发布
最新推荐文章于 2023-05-05 15:40:11 发布
阅读量2k 收藏 2
点赞数
分类专栏： linux技术

一般察看函数运行时堆栈的方法是使用GDB（bt命令）之类的外部调试器,但是,有些时候为了分析程序的BUG,(主要针对长时间运行程序的分析),在程序出错时打印出函数的调用堆栈是非常有用的。

在glibc头文件"execinfo.h"中声明了三个函数用于获取当前线程的函数调用堆栈。

int backtrace(void **buffer,int size) 

该函数用于获取当前线程的调用堆栈,获取的信息将会被存放在buffer中,它是一个指针列表。参数 size 用来指定buffer中可以保存多少个void* 元素。函数返回值是实际获取的指针个数,最大不超过size大小

在buffer中的指针实际是从堆栈中获取的返回地址,每一个堆栈框架有一个返回地址

注意:某些编译器的优化选项对获取正确的调用堆栈有干扰,另外内联函数没有堆栈框架;删除框架指针也会导致无法正确解析堆栈内容

char ** backtrace_symbols (void *const *buffer, int size) 

backtrace_symbols将从backtrace函数获取的信息转化为一个字符串数组. 参数buffer应该是从backtrace函数获取的指针数组,size是该数组中的元素个数(backtrace的返回值)

函数返回值是一个指向字符串数组的指针,它的大小同buffer相同.每个字符串包含了一个相对于buffer中对应元素的可打印信息.它包括函数名，函数的偏移地址,和实际的返回地址

现在,只有使用ELF二进制格式的程序才能获取函数名称和偏移地址.在其他系统,只有16进制的返回地址能被获取.另外,你可能需要传递相应的符号给链接器,以能支持函数名功能(比如,在使用GNU ld链接器的系统中,你需要传递(-rdynamic)， -rdynamic可用来通知链接器将所有符号添加到动态符号表中，如果你的链接器支持-rdynamic的话，建议将其加上！)

该函数的返回值是通过malloc函数申请的空间,因此调用者必须使用free函数来释放指针.

注意:如果不能为字符串获取足够的空间函数的返回值将会为NULL

void backtrace_symbols_fd (void *const *buffer, int size, int fd) 

backtrace_symbols_fd与backtrace_symbols 函数具有相同的功能,不同的是它不会给调用者返回字符串数组,而是将结果写入文件描述符为fd的文件中,每个函数对应一行.它不需要调用malloc函数,因此适用于有可能调用该函数会失败的情况
 
下面是glibc中的实例（稍有修改）：

#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>

/* Obtain a backtrace and print it to @code{stdout}. */
void print_trace (void)
{
 void *array[10];
 size_t size;
 char **strings;
　 size_t i;
　
 size = backtrace (array, 10);
 strings = backtrace_symbols (array, size);
 if (NULL == strings)
 {
　  perror("backtrace_synbols");
  Exit(EXIT_FAILURE);
 }

 printf ("Obtained %zd stack frames.\n", size);

 for (i = 0; i < size; i++)
  printf ("%s\n", strings[i]);

 free (strings);
　 strings = NULL;
}

/* A dummy function to make the backtrace more interesting. */
void dummy_function (void)
{
 print_trace ();
}

int main (int argc, char *argv[])
{
 dummy_function ();
 return 0;
}

输出如下：

Obtained 4 stack frames.
./execinfo() [0x80484dd]
./execinfo() [0x8048549]
./execinfo() [0x8048556]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3) [0x70a113]

我们还可以利用这backtrace来定位段错误位置。

通常情况系，程序发生段错误时系统会发送SIGSEGV信号给程序，缺省处理是退出函数。我们可以使用 signal(SIGSEGV, &your_function);函数来接管SIGSEGV信号的处理，程序在发生段错误后，自动调用我们准备好的函数，从而在那个函数里来获取当前函数调用栈。

举例如下：

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <execinfo.h>
#include <signal.h>

void dump(int signo)
{
 void *buffer[30] = {0};
 size_t size;
 char **strings = NULL;
 size_t i = 0;

 size = backtrace(buffer, 30);
 fprintf(stdout, "Obtained %zd stack frames.nm\n", size);
 strings = backtrace_symbols(buffer, size);
 if (strings == NULL)
 {
  perror("backtrace_symbols.");
  exit(EXIT_FAILURE);
 }
 
 for (i = 0; i < size; i++)
 {
  fprintf(stdout, "%s\n", strings[i]);
 }
 free(strings);
 strings = NULL;
 exit(0);
}

void func_c()
{
 *((volatile char *)0x0) = 0x9999;
}

void func_b()
{
 func_c();
}

void func_a()
{
 func_b();
}

int main(int argc, const char *argv[])
{
 if (signal(SIGSEGV, dump) == SIG_ERR)
  perror("can't catch SIGSEGV");
 func_a();
 return 0;
}

编译程序：
gcc -g -rdynamic test.c -o test; ./test
输出如下：

Obtained6stackframes.nm
./backstrace_debug(dump+0x45)[0x80487c9]
[0x468400]
./backstrace_debug(func_b+0x8)[0x804888c]
./backstrace_debug(func_a+0x8)[0x8048896]
./backstrace_debug(main+0x33)[0x80488cb]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0x129113]

接着：
objdump -d test > test.s
在test.s中搜索804888c如下：

8048884 <func_b>:
8048884: 55          push %ebp
8048885: 89 e5      mov %esp, %ebp
8048887: e8 eb ff ff ff      call 8048877 <func_c>
804888c: 5d            pop %ebp
804888d: c3            ret

其中80488c时调用（call 8048877）C函数后的地址，虽然并没有直接定位到C函数，通过汇编代码， 基本可以推出是C函数出问题了（pop指令不会导致段错误的）。
我们也可以通过addr2line来查看

addr2line 0x804888c -e backstrace_debug -f 

输出：

func_b
/home/astrol/c/backstrace_debug.c:57

************************************http://www.linuxidc.com/Linux/2012-11/73470p2.htm

一．用途：
主要用于程序异常退出时寻找错误原因
二．功能：
回溯堆栈，简单的说就是可以列出当前函数调用关系
三．原理：
1． 通过对当前堆栈的分析，找到其上层函数在栈中的帧地址，再分析上层函数的堆栈，再找再上层的帧地址……一直找到最顶层为止，帧地址指的是一块：在栈上存放局部变量，上层返回地址，及寄存器值的空间。
2． 由于不同处理器堆栈方式不同，此功能的具体实现是编译器的内建函数__buildin_frame_address及__buildin_return_address中，它涉及工具glibc和gcc, 如果编译器不支持此函数，也可自己实现此函数，举例中有arm上的实现
四．方法：
在程序中加入backtrace及相关函数调用
五．举例：
1． 一般backtrace的实现
i. 程序
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <execinfo.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#define PRINT_DEBUG
static void print_reason(int sig, siginfo_t * info, void *secret)
{
void *array[10];
size_t size;
#ifdef PRINT_DEBUG
char **strings;
size_t i;
size = backtrace(array, 10);
strings = backtrace_symbols(array, size);
printf("Obtained %zd stack frames.\n", size);
for (i = 0; i < size; i++)
printf("%s\n", strings[i]);
free(strings);
#else
int fd = open("err.log", O_CREAT | O_WRONLY);
size = backtrace(array, 10);
backtrace_symbols_fd(array, size, fd);
close(fd);
#endif
exit(0);
}
void die()
{
char *test1;
char *test2;
char *test3;
char *test4 = NULL;
strcpy(test4, "ab");
}
void test1()
{
die();
}
int main(int argc, char **argv)
{
struct sigaction myAction;
myAction.sa_sigaction = print_reason;
sigemptyset(&myAction.sa_mask);
myAction.sa_flags = SA_RESTART | SA_SIGINFO;
sigaction(SIGSEGV, &myAction, NULL);
sigaction(SIGUSR1, &myAction, NULL);
sigaction(SIGFPE, &myAction, NULL);
sigaction(SIGILL, &myAction, NULL);
sigaction(SIGBUS, &myAction, NULL);
sigaction(SIGABRT, &myAction, NULL);
sigaction(SIGSYS, &myAction, NULL);
test1();
}
ii. 编译参数
gcc main.c -o test -g -rdynamic
2． 根据不同的处理器自已实现backtrace
i. arm的backtrace函数实现
static int backtrace_xy(void **BUFFER, int SIZE)
{
volatile int n = 0;
volatile int *p;
volatile int *q;
volatile int ebp1;
volatile int eip1;
volatile int i = 0;
p = &n;
ebp1 = p[4];
eip1 = p[6];
fprintf(stderr, "======================= backtrace_xy addr: 0x%0x, param1: 0x%0x, param2: 0x%0x\n",
backtrace_xy, &BUFFER, &SIZE);
fprintf(stderr, "n addr is 0x%0x\n", &n);
fprintf(stderr, "p addr is 0x%0x\n", &p);
for (i = 0; i &lt; SIZE; i++)
{
fprintf(stderr, "ebp1 is 0x%0x, eip1 is 0x%0x\n", ebp1, eip1);
BUFFER[i] = (void *)eip1;
p = (int*)ebp1;
q = p - 5;
eip1 = q[5];
ebp1 = q[2];
if (ebp1 == 0 || eip1 == 0)
break;
}
fprintf(stderr, "total level: %d\n", i);
return i;
}
六．举例2：
/*main.c*/
#include "sigsegv.h"
#include &lt;string.h>
int die() {
  char *err = NULL;
  strcpy(err, "gonner");
  return 0;
}
int main() {
  return die();
}
/*sigsegv.c*/
#define _GNU_SOURCE
#include <memory.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <ucontext.h>
#include <dlfcn.h>
#include <execinfo.h>
#define NO_CPP_DEMANGLE
#ifndef NO_CPP_DEMANGLE
#include <cxxabi.h>
#endif
#if defined(REG_RIP)
# define SIGSEGV_STACK_IA64
# define REGFORMAT "%016lx"
#elif defined(REG_EIP)
# define SIGSEGV_STACK_X86
# define REGFORMAT "%08x"
#else
# define SIGSEGV_STACK_GENERIC
# define REGFORMAT "%x"
#endif
static void signal_segv(int signum, siginfo_t* info, void*ptr) {
    static const char *si_codes[3] = {"", "SEGV_MAPERR", "SEGV_ACCERR"};
    size_t i;
    ucontext_t *ucontext = (ucontext_t*)ptr;
#if defined(SIGSEGV_STACK_X86) || defined(SIGSEGV_STACK_IA64)
    int f = 0;
    Dl_info dlinfo;
    void **bp = 0;
    void *ip = 0;
#else
    void *bt[20];
    char **strings;
    size_t sz;
#endif
    fprintf(stderr, "Segmentation Fault!\n");
    fprintf(stderr, "info-&gt;si_signo = %d\n", signum);
    fprintf(stderr, "info-&gt;si_errno = %d\n", info-&gt;si_errno);
//    fprintf(stderr, "info-&gt;si_code  = %d (%s)\n", info-&gt;si_code, info-&gt;si_codes[si_code]);
    fprintf(stderr, "info-&gt;si_addr  = %p\n", info-&gt;si_addr);
    for(i = 0; i < NGREG; i++)
        fprintf(stderr, "reg[%02d]       = 0x" REGFORMAT "\n", i, ucontext->uc_mcontext.gregs[i]);
#if defined(SIGSEGV_STACK_X86) || defined(SIGSEGV_STACK_IA64)
# if defined(SIGSEGV_STACK_IA64)
    ip = (void*)ucontext-&gt;uc_mcontext.gregs[REG_RIP];
    bp = (void**)ucontext-&gt;uc_mcontext.gregs[REG_RBP];
# elif defined(SIGSEGV_STACK_X86)
    ip = (void*)ucontext-&gt;uc_mcontext.gregs[REG_EIP];
    bp = (void**)ucontext-&gt;uc_mcontext.gregs[REG_EBP];
# endif
    fprintf(stderr, "Stack trace:\n");
    while(bp != & ip) {
        if(!dladdr(ip, &dlinfo))
            break;
        const char *symname = dlinfo.dli_sname;
#ifndef NO_CPP_DEMANGLE
        int status;
        char *tmp = __cxa_demangle(symname, NULL, 0, &status);
        if(status == 0 !=& tmp)
            symname = tmp;
#endif
        fprintf(stderr, "% 2d: %p < %s+%u> (%s)\n",
                ++f,
                ip,
                symname,
                (unsigned)(ip - dlinfo.dli_saddr),
                dlinfo.dli_fname);
#ifndef NO_CPP_DEMANGLE
        if(tmp)
            free(tmp);
#endif
        if(dlinfo.dli_sname != !strcmp(dlinfo.dli_sname, "main"))
            break;
        ip = bp[1];
        bp = (void**)bp[0];
    }
#else
    fprintf(stderr, "Stack trace (non-dedicated):\n");
    sz = backtrace(bt, 20);
    strings = backtrace_symbols(bt, sz);
    for(i = 0; i < sz; ++i)
        fprintf(stderr, "%s\n", strings[i]);
#endif
    fprintf(stderr, "End of stack trace\n");
    exit (-1);
}
int setup_sigsegv() {
    struct sigaction action;
    memset(&action, 0, sizeof(action));
    action.sa_sigaction = signal_segv;
    action.sa_flags = SA_SIGINFO;
    if(sigaction(SIGSEGV, &action, NULL) &lt; 0) {
        perror("sigaction");
        return 0;
    }
    return 1;
}
#ifndef SIGSEGV_NO_AUTO_INIT
static void __attribute((constructor)) init(void)
{
    setup_sigsegv();
}
#endif
/*sigsegv.h*/
#ifndef __sigsegv_h__
#define __sigsegv_h__
#ifdef __cplusplus
extern "C" {
#endif
  int setup_sigsegv();
#ifdef __cplusplus
}
#endif
#endif /* __sigsegv_h__ */
编译时需要加入-rdynamic -ldl –ggdb
 

void
handle_signal_error(int rec_signal,siginfo_t* signal_info,void* context)
{
NE_Info* __attribute__ ((unused)) ne_info = NULL;
struct sigaction action;
FILE* file;
void* backtr[NUMBER_OF_BACKTRACE];
cpal_uns32 __attribute__ ((unused)) i = 0;
cpal_uns32 backtr_size = 0;
ucontext_t *u_context;
time_t seconds_time;
struct tm* time_struct;
cpal_si32 ret_t;
char filename[SIZE_OF_FILENAME];  

if(g_handler_running)
return;

g_handler_running = CPAL_TRUE;
ret_t = time(&seconds_time); 

if(ret_t != - 1)
{
time_struct = gmtime(&seconds_time);

snprintf(filename,SIZE_OF_FILENAME,"%s%d%d%d-%d%d%d-%s",BACKTRACE_FILE_PATH,time_struct->tm_mon,time_struct-&gt;tm_mday,
(time_struct-&gt;tm_year-100)+2000,time_struct-&gt;tm_hour,time_struct-&gt;tm_min,time_struct-&gt;tm_sec,BACKTRACE_FILE);
}
else
{
snprintf(filename,SIZE_OF_FILENAME,"%s",BACKTRACE_FILE);
}
file = fopen(filename,"w");


if(file == NULL)
{
  return;
}
if(signal_info == NULL)
{
  return;
}

if(context == NULL)
{
  return;
}

u_context = (ucontext_t*)context;
/*Restore the default action for this signal and re-raise it, so that the default action occurs. */
action.sa_sigaction = SIG_DFL;
sigemptyset(&action.sa_mask);
action.sa_flags = SA_RESTART;

sigaction(rec_signal,&action,NULL);

/* Print out the backtrace. */
backtr_size = backtrace(backtr,20);
   
/* The backtrace points to sigaction in libc, not to where the signal was actually raised.
   This overwrites the sigaction with where the signal was sent, so we can resolve the sender. */
#if __WORDSIZE == 64
backtr[1] = (void*)u_context-&gt;uc_mcontext.gregs[REG_RIP];
#else
backtr[1] = (void*)u_context-&gt;uc_mcontext.gregs[REG_EIP];
#endif //__WORDSIZE
   
    backtrace_symbols_fd(backtr,backtr_size,fileno(file));

fprintf(file,"Backtrace is above.\nFatal signal %d received.\n",rec_signal);
#if __WORDSIZE == 64
    fprintf(file,"Signal received at address %p from 0x%08x.\n",signal_info-&gt;si_addr,
                                                          u_context-&gt;uc_mcontext.gregs[REG_RIP]);
#else
        fprintf(file,"Signal received at address %p from 0x%08x.\n",signal_info-&gt;si_addr,
                                                          u_context-&gt;uc_mcontext.gregs[REG_EIP]);
#endif //__WORDSIZE


#if CPAL_LM_DEBUG
/* Print all NE_Infos */
for(; i < MAX_NO_OF_CONNS; i++)
{
ne_info = g_ne_hash_tab[i];
while(ne_info != NULL)
{
      ne_info = ne_info->next_ne;
}
}
#endif

fflush(file);
fclose(file);
sleep (50); /* Sleep for 50 seconds */
g_handler_running = *_FALSE;
raise(rec_signal);
}

http://www.2cto.com/kf/201107/97270.html


djinglan
关注
专栏目录
Linux下使用backtrace追踪函数调用堆栈以及定位段错误
CyberXZ的博客
09-24 432
在signal_handler函数中，我们首先调用backtrace函数来获取调用堆栈的地址，并将其存储在一个指针数组中。然后，我们调用backtrace_symbols函数将地址转换为对应的符号名，并打印出调用堆栈信息。在Linux开发中，当程序出现段错误（Segmentation Fault）时，我们需要追踪函数的调用堆栈，以便快速定位错误所在的代码位置。通过使用backtrace和backtrace_symbols函数，我们可以方便地在Linux下追踪函数的调用堆栈，并定位段错误。
【Linux】linux backtrace()详细使用说明，分析Segmentation fault
最新发布
smartvxworks的博客
05-08 2066
用户态或者内核态程序异常退出时回溯堆栈信息。开发应用程序时，经常碰到程序挂掉后，串口打印输出一大串让人看不懂的数据。其实这些数据是程序挂掉时的堆栈帧数据（stack frame data）。通过这些堆栈帧数据可以分析出程序当时的运行状态和定位程序哪里出现了问题。这就是本文要讲的—backtrace()和backtrace_symbols()函数的使用。
Linux用backtrace定位分析段错误
misterdo的专栏
04-01 1273
Linux c/c++开发环境下，可以使用以下函数来获取进程调用的堆栈信息 #include <execinfo.h> int backtrace(void **buffer, int size); 该函数用于获取当前线程的调用堆栈,获取的信息将会被存放在buffer中,它是一个指针列表。 参数 size 用来指定buffer中可以保存多少个void* 元素。 函数返回值是实际获取的指针个数,最大不超过size大小，为了取得全部的函数调用列表， 应保证buffer和size足够大。
linux排错诊断工具,Linux问题诊断工具strace
weixin_30182831的博客
05-10 161
引言“Oops，系统挂死了..."“Oops，程序崩溃了..."“Oops，命令执行报错..."对于维护人员来说，这样的悲剧每天都在上演。理想情况下，系统或应用程序的错误日志提供了足够全面的信息，通过查看相关日志，维护人员就能很快地定位出问题发生的原因。但现实情况，许多错误日志打印模凌两可，更多地描述了出错时的现象(比如"could not open file"，"connect to XXX t...
linux下使用backtrace记录程序崩溃时的堆栈信息，并进行分析
Turn X7
05-05 1566
linux下使用backtrace记录程序崩溃时的堆栈信息，并进行分析
linux调用堆栈函数,使用 backtrace 获得 Linux 函数调用栈
weixin_42633137的博客
05-03 412
一、源码使用backtrace 获得 Linux 函数调用栈源码来自：man backtrace#include #include #include #include void myfunc3(void){int j, nptrs;#define SIZE 100void *buffer[100];char **strings;nptrs = backtrace(buffer, SIZE);pr...
linux C用户态调试追踪函数调用堆栈以及定位段错误.docx
11-08
Linux C用户态调试追踪函数调用堆栈以及定位段错误是指在 Linux 平台上使用 C 语言编写的程序中，如何追踪函数调用堆栈并定位段错误的方法。 在 Linux 平台上，使用 GDB 调试器是最常用的方法来追踪函数调用堆栈。...
浅谈在linux kernel中打印函数调用的堆栈的方法
09-15
在Linux内核开发和调试过程中，理解函数调用堆栈是非常关键的，它能帮助开发者追踪问题的根源，尤其是在处理内核崩溃或者异常时。本文将深入探讨如何在Linux内核中打印函数调用的堆栈。 首先，Linux内核提供了一个...
Linux下追踪函数调用，打印栈帧
01-09
也是是Pop出来的对象没有Push回去，情况很难复现，所以在Pop里的打印日志，跟踪是谁调用了它，我想在GDB调试里可以追踪调用的栈帧，那也一定有方法实现。首先上网搜索了一下，并没有结果！还好代码量不是很多，只能...
xgboost 已编译 （64位windows下 用mingw64 在 cygwin环境下编译）
03-07
具体过程可以参考 这篇博客 http://blog.csdn.net/true_love1314/article/details/60607115
万字解析Linux内核调试之动态追踪
youzhangjing_的博客
03-30 806
动态追踪技术，是通过探针机制来采集内核或者应用程序的运行信息，从而可以不用修改内核或应用程序的代码，就获得调试信息，对问题进行分析、定位。通常在排查和调试异常问题时，我们首先想到的是使用 GDB 在程序运行路径上设置断点，然后结合命令进行分析定位；或者，在程序源码中增加一系列的日志，从日志输出中寻找线索。不过，断点往往会中断程序的正常运行；而增加新的日志，往往需要重新编译和部署。在面对偶现问题以及对时延要求严格的场景下，GDB 和增加日志的方式就不能满足需求了。
backtrace execinfo.h
qingsong1001的专栏
10-11 4831
http://man7.org/linux/man-pages/man3/backtrace.3.html BACKTRACE(3) linux编程者手册 BACKTRACE(3) 名称 top backtrace, backtrace_symbols, backtrace_symbols_fd - ...
利用objdump找到程序挂死位置
qq_36475346的博客
06-19 767
利用objdump找到程序挂死位置 文章目录利用objdump找到程序挂死位置一、问题描述二、使用步骤1.找到动态链接库2.反汇编三、根据反汇编文件找到挂死位置附：如何找到对应的动态链接库so文件 一、问题描述 程序崩溃时效果如下： 二、使用步骤 1.找到动态链接库 在终端代码仓下输入下面的命令： find -name libc.so find -name libc.so 终端输出： ./prebuilts/aosp_prebuilt_libs/asdk_libs/ndk/platforms/cur
Linux backtrace的实现原理
TSZ0000的博客
09-03 4723
在平时写应用程序中，当项目庞大后，遇到程序崩溃后需要查看函数的调用流程，在gdb中可用bt命令快速的查看backtrace，那么backtrace的实现原理是什么呢，接下来就认识学习一下。 backtrace实例代码 使用glibc提供的backtrace函数实现函数调用流程抓取，代码如下： #include <stdio.h> #include <execinfo.h&...
根据内核打印的段错误信息分析驱动程序——根据出错PC来分析
bytxl的专栏
07-30 2091
http://liu1227787871.blog.163.com/blog/static/20536319720126101202205/
linux打印错误值,linux下打印用户态段错误信息的一种方法
weixin_33122261的博客
05-13 779
引自：韦东山嵌入式视频第二期 “第31课第3节_应用调试之配置修改内核打印用户态段错误信息_P” 第6分钟起。1.配置内核支持DEBUG_USER (勾选 Kernel hacking -> Verbose user fault messages[*] 即可)(视频第8：23)2.设置bootargs，添加参数 user_debug = 0xFF 即可。user_debug的每一位代表设...
gcc4.4下实现backtrace代码
weixin_30622107的博客
11-07 147
最近在一块新的板子下作开发， 有些变量发生异常（就是我们不想到的值），可以加上backtrace，知道是哪个函数调用它，导致出现异常， 就像死机了，你可以gdb和core文件用bt 命令，查看死机在哪里（有一种 情况 不能看见， 就是发生信号异常不在本文范围 ）， 本人感觉还有用， 关说不炼、假把式，下面是实现代码： 首先实现核心代码backtrace函数： [html] vi...
C++ 实现高效函数调用堆栈追踪
高效获取C++函数调用堆栈可以帮助开发者迅速定位问题，尤其在大型项目中，能够快速定位错误来源，极大地提高了调试效率。通过理解调用堆栈和异常处理机制，开发者可以自行实现这样的工具，以满足特定需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值