一个简单的使用C++在运行时获取调用堆栈的类

最新推荐文章于 2023-12-05 23:13:02 发布
最新推荐文章于 2023-12-05 23:13:02 发布
阅读量1.5k 收藏
点赞数
分类专栏： 黑色代碼

     明天游戏要封测了，感觉稍微早了点，哎，悲剧。昨天把我的Bug改完了，今天在公司闲了一天，写文档差点写得睡着。没事所以回来得早点，7点过就到家了，郁闷的是回来又被新闻联播着实恶心了一把。闲的蛋疼只好写点程序了。最近一直在整理过去写过的东西，希望能够达到拿到哪里都可以直接用，不需要配置什么，动机主要是最近自己写了一些小东西，发现很多东西我都是在做重复劳动，比如说string_shim、C++ string和String^的桥接等等。为了避免这些没有必要的重复劳动，所以就动手整理啦。

       我给它起了个名字叫dbsoft。感觉小写还是比较和谐的，嘿嘿。目前已经整理了不少公共组件，透露下：

      由于个人水平有限，代码当然不怎么样，但是我一直在努力，期待着进步。

      分享一个今晚刚写好的类，在C++中用于获取调用堆栈的信息。我写的最开始就是为VS2005和2008写的，所以VC6或者VC7.1等就不要尝试了，另外呢还是依赖于Boost的智能指针。如果你是VS2008 SP1的话可以用#include <memory>代替#include<boost/tr1/tr1/memory>。这本来是属于dbsoft的一部分，我专门把它提取了出来独立出来，这样方便大家整合。

简单的应用实例：

main.cpp

#include <iostream>

using namespace std;

#include "debug_tool.hpp"

#include <windows.h>
#include <DbgHelp.h>

#pragma comment( lib, "Dbghelp.lib" )

inline std::string GetLastErrorDescA( unsigned uErrorCode = ::GetLastError() )
{
LPVOID lpMsg = NULL;
::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
   NULL, uErrorCode, MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
   (LPSTR)&lpMsg,
   0,
   NULL
   );

if( lpMsg == NULL )
{
   return "δ֪";
}

std::string strReason = (const char*)lpMsg;

::LocalFree( lpMsg );

return strReason;
}

int SEHHanlerTest( LPEXCEPTION_POINTERS pep )
{
dbsoft::callstack::callstack_ptr pCall = dbsoft::callstack::generate( pep->ContextRecord );

cout<<" Error:: " << GetLastErrorDescA( pep->ExceptionRecord->ExceptionCode&0x0fffffff ) << endl;

if( pCall )
{
   for( dbsoft::callstack::const_iterator it = pCall->begin();
    it != pCall->end();
    ++it )
   {
    cout<< *it << endl;
   }
}

return 1;
}

void test_main()
{
int* p = NULL;

__try
{
   *p = 100;
}
__except( SEHHanlerTest( GetExceptionInformation() ) )
{

}
}

int main()
{
dbsoft::callstack::callstack_ptr call = dbsoft::callstack::generate();

if( call )
{
   for( dbsoft::callstack::const_iterator it = call->begin();
    it != call->end();
    ++it )
   {
    cout<< *it << endl;
   }
}

printf_s( "........................................................\n" );

test_main();

return 0;
}

输出：

dbsoft::detail::callstack_Imp::generate文件:e:\documents\visual studio 2008\proj
ects\callstacktest\debug_tool.cpp, 行数：209
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
dbsoft::callstack::generate文件:e:\documents\visual studio 2008\projects\callsta
cktest\debug_tool.cpp, 行数：312
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
main文件:e:\documents\visual studio 2008\projects\callstacktest\main.cpp, 行数：
69
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
__tmainCRTStartup文件:f:\dd\vctools\crt_bld\self_x86\crt\src\crtexe.c, 行数：586

模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
mainCRTStartup文件:f:\dd\vctools\crt_bld\self_x86\crt\src\crtexe.c, 行数：403
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
BaseThreadInitThunk 模块: C:\Windows\system32\kernel32.dll
RtlInitializeExceptionChain 模块: C:\Windows\SYSTEM32\ntdll.dll
RtlInitializeExceptionChain 模块: C:\Windows\SYSTEM32\ntdll.dll
RtlInitializeExceptionChain 模块: C:\Windows\SYSTEM32\ntdll.dll
........................................................
Error:: 拒绝访问。

test_main文件:e:\documents\visual studio 2008\projects\callstacktest\main.cpp,
行数：59
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
main文件:e:\documents\visual studio 2008\projects\callstacktest\main.cpp, 行数：
85
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
__tmainCRTStartup文件:f:\dd\vctools\crt_bld\self_x86\crt\src\crtexe.c, 行数：586

模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
mainCRTStartup文件:f:\dd\vctools\crt_bld\self_x86\crt\src\crtexe.c, 行数：403
模块: e:\Documents\Visual Studio 2008\Projects\callstacktest\Debug\callstacktes
t.exe
BaseThreadInitThunk 模块: C:\Windows\system32\kernel32.dll
RtlInitializeExceptionChain 模块: C:\Windows\SYSTEM32\ntdll.dll
RtlInitializeExceptionChain 模块: C:\Windows\SYSTEM32\ntdll.dll
RtlInitializeExceptionChain 模块: C:\Windows\SYSTEM32\ntdll.dll
请按任意键继续. . .


最后发上这个类吧：

// debug_tool.hpp

/**
* @brief   调试工具
* @author dongbo
* @date    2010-3-17
* @remarks
**/

#pragma once

#include <list>
#include <string>

#include <boost/tr1/tr1/memory>

namespace dbsoft
{
namespace detail
{
   class callstack_Imp;
}

class callstack
{
public:
   typedef std::string             func_name;
   typedef std::list< func_name >                 func_name_list;
   typedef func_name_list::const_iterator         const_iterator;
   typedef std::tr1::shared_ptr<callstack>        callstack_ptr;

   friend class detail::callstack_Imp;

public:
   callstack();
public:
   const_iterator begin() const;
   const_iterator end() const;

public:
   /** 
   * @brief 如果你不传递参数，那么你将得到当前时刻的调用堆栈
   *        如果你使用它来处理SEH异常，那么请将LPEXCEPTION_POINTERS->ContextRecord传进去
   **/
   static callstack_ptr generate( const void* pContext = NULL );

private:
   std::tr1::shared_ptr<detail::callstack_Imp>         m_spImp;
}; 
}

// debug_tool.cpp

/**
* @brief   调试工具
* @author dongbo
* @date    2010-3-17
* @remarks
**/

#include "debug_tool.hpp"

#include <windows.h>
#include <WinDNS.h>
#include <DbgHelp.h>
#include <Psapi.h>
#pragma comment( lib, "Dbghelp.lib" )
#pragma comment( lib, "Psapi.lib" )

namespace dbsoft
{
namespace detail
{
   class callstack_Imp
   {
   public:
    typedef callstack::func_name            func_name;
    typedef callstack::func_name_list                      func_name_list;
    typedef callstack::const_iterator                      const_iterator;
    typedef callstack::callstack_ptr                       callstack_ptr;

   public:
    callstack_Imp();

   public:
    const_iterator begin() const
    {
     return m_lstFunc.begin();
    }

    const_iterator end() const
    {
     return m_lstFunc.end();
    }

   private:
    func_name_list   m_lstFunc;

   public:
    static callstack_ptr generate( const void* pContext );
   protected:
    static void           _initialize();
    static bool           _loadAllModules();
    static void           _stackwalk( QWORD* pTrace, DWORD dwMaxDepth, CONTEXT* pContext );
    static func_name      _getfuncname( QWORD dwFunc );
   private:
    static bool           m_bInitialized;
   };

   bool callstack_Imp::m_bInitialized = false;

   callstack_Imp::callstack_Imp()
   {
    if( !m_bInitialized )
    {
     _initialize();
    }
   }

   void callstack_Imp::_stackwalk(QWORD *pTrace, DWORD dwMaxDepth, CONTEXT *pContext)
   {
    STACKFRAME64        sfStackFrame64;
    HANDLE              hProcess = ::GetCurrentProcess();
    HANDLE              hThread = ::GetCurrentThread();

    DWORD               dwDepth = 0;

    ::ZeroMemory( &sfStackFrame64, sizeof(sfStackFrame64) );

    __try
    {
     sfStackFrame64.AddrPC.Offset        = pContext->Eip;
     sfStackFrame64.AddrPC.Mode          = AddrModeFlat;
     sfStackFrame64.AddrStack.Offset     = pContext->Esp;
     sfStackFrame64.AddrStack.Mode       = AddrModeFlat;
     sfStackFrame64.AddrFrame.Offset     = pContext->Ebp;
     sfStackFrame64.AddrFrame.Mode       = AddrModeFlat;

     bool bSuccessed = true;

     while( bSuccessed && (dwDepth < dwMaxDepth) )
     {
      bSuccessed = ::StackWalk64( 
       IMAGE_FILE_MACHINE_I386,
       hProcess,
       hThread,
       &sfStackFrame64,
       pContext,
       NULL,
       SymFunctionTableAccess64,
       SymGetModuleBase64,
       NULL
       ) != FALSE ;

      pTrace[ dwDepth ] = sfStackFrame64.AddrPC.Offset;
      ++dwDepth;

      if( !bSuccessed )
      {
       break;
      }

      if( sfStackFrame64.AddrFrame.Offset == 0 )
      {
       break;
      }
     }
    }
    __except( EXCEPTION_EXECUTE_HANDLER )
    {
    }
   }

   callstack_Imp::func_name callstack_Imp::_getfuncname( QWORD dwFunc )
   {
    static const int gc_iMaxNameLength = 4096;
    char                    szSymbol[ sizeof(IMAGEHLP_SYMBOL64) + gc_iMaxNameLength ] = {0};
    PIMAGEHLP_SYMBOL64      Symbol;
    DWORD                   dwSymbolDisplacement = 0;
    DWORD64                 dw64SymbolDisplacement = 0;

    HANDLE                  hProcess = ::GetCurrentProcess();

    Symbol                  = (PIMAGEHLP_SYMBOL64)szSymbol;
    Symbol->SizeOfStruct    = sizeof(szSymbol);
    Symbol->MaxNameLength   = gc_iMaxNameLength;

    func_name              strResult;

    if( ::SymGetSymFromAddr64( 
     hProcess,
     dwFunc,
     &dw64SymbolDisplacement,
     Symbol )
     )
    {
     int i=0;
     for( ; Symbol->Name[i] < 32 || Symbol->Name[i] > 127; )
     {
      ++i;
     }

     strResult += ( const char* )( Symbol->Name + i );
    }
    else
    {
     return "未知函数";
    }

   IMAGEHLP_LINE64            ImageHelpLine;
   ImageHelpLine.SizeOfStruct = sizeof(ImageHelpLine);

   if( ::SymGetLineFromAddr64( hProcess, dwFunc, &dwSymbolDisplacement, &ImageHelpLine ) )
   {
     // 还是删掉吧，虽然这个操作很好用，但是过多的依赖我不想看到
    // fmt::WritePipe( strResult, "文件: ", ImageHelpLine.FileName, " 行数：", ImageHelpLine.LineNumber );

     // 我就不信，4096都不够
     char szBuf[4096] = {0};
     sprintf_s( szBuf, "文件:%s, 行数：%d\n", ImageHelpLine.FileName, ImageHelpLine.LineNumber );

     strResult += szBuf;
   }

    IMAGEHLP_MODULE64 ImageHelpModule;
    ImageHelpModule.SizeOfStruct = sizeof(ImageHelpModule);

    if( ::SymGetModuleInfo64( hProcess, dwFunc, &ImageHelpModule ) )
    {
     char               szModuleName[1024];
     sprintf_s( szModuleName, " 模块: %s", ImageHelpModule.ImageName );

     strResult += szModuleName;
    }

    return strResult;
   }

   callstack_Imp::callstack_ptr callstack_Imp::generate( const void* pContext )
   {
    if( !m_bInitialized )
    {
     _initialize();
    }

    CONTEXT Context;

    if( pContext != NULL )
    {
     ::memcpy_s( &Context, sizeof(CONTEXT), pContext, sizeof(CONTEXT) );
    }
    else
    {
     ::ZeroMemory( &Context, sizeof(Context) );
     Context.ContextFlags = CONTEXT_FULL;

     __asm
     {
      call FakeFuncCall
FakeFuncCall:

      pop eax
       mov Context.Eip, eax
       mov Context.Ebp, ebp
       mov Context.Esp, esp
     }
    }

    static const int gc_iMaxStackDepth = 512;
    QWORD aryStack[gc_iMaxStackDepth] = {0};

    // 由于_stackwalk内部使用SEH 因此不能在其内部使用C++类
    _stackwalk( aryStack, gc_iMaxStackDepth, &Context );

    callstack_ptr spCallStack( new callstack() );

    for( int i=0; i<gc_iMaxStackDepth && aryStack[i] != 0; ++i )
    {
     func_name name = _getfuncname(aryStack[i]);
     spCallStack->m_spImp->m_lstFunc.push_back( name );
    }  

    return spCallStack;
   }

   void callstack_Imp::_initialize()
   {
    if( m_bInitialized )
    {
     return;
    }

    // 设置符号引擎
    DWORD SymOpts = ::SymGetOptions();
    SymOpts |= SYMOPT_LOAD_LINES;
    SymOpts |= SYMOPT_DEBUG;
    ::SymSetOptions( SymOpts );

    if( FALSE == ::SymInitialize( ::GetCurrentProcess(), NULL, TRUE ) )
    {
     // DBSOFT_LogMsg( "::SymInitialize初始化失败..." );
     return;
    }

    if( !_loadAllModules() )
    {
     // DBSOFT_LogMsg( "LoadModules发生了错了" );
    }

    m_bInitialized = true;
   }

   bool callstack_Imp::_loadAllModules()
   {
    HANDLE                 hProcess = ::GetCurrentProcess();
    static const int       gc_iMaxHandles = 4096;
    HMODULE                aryHandles[ gc_iMaxHandles ] = {0};

    unsigned               uBytes = 0;

    BOOL bResult = ::EnumProcessModules(
     hProcess, aryHandles, sizeof(aryHandles), (LPDWORD)&uBytes );

    if( FALSE == bResult )
    {
     // DBSOFT_LogMsg( "::EnumProcessModules失败 Msg:", GetLastErrorDescA() );
     return false;
    }

    const int iCount = uBytes/sizeof(HMODULE);

    for( int i=0; i < iCount; ++i )
    {
     char szModuleName[4096] = {0};
     char szImageName[4096] ={0};
     MODULEINFO Info;

     ::GetModuleInformation( hProcess, aryHandles[i], &Info, sizeof(Info) );
     ::GetModuleFileNameExA( hProcess, aryHandles[i], szImageName, 4096 );
     ::GetModuleBaseNameA( hProcess, aryHandles[i], szModuleName, 4096 );

     ::SymLoadModule64( hProcess, aryHandles[i], szImageName, szModuleName, (DWORD64)Info.lpBaseOfDll, (DWORD)Info.SizeOfImage );
    }

    return true;
   }
}

callstack::callstack():m_spImp( new detail::callstack_Imp() )
{  
}

callstack::const_iterator callstack::begin() const
{
   return m_spImp->begin();
}

callstack::const_iterator callstack::end() const
{
   return m_spImp->end();
}

callstack::callstack_ptr callstack::generate( const void* pContext )
{
   return detail::callstack_Imp::generate( pContext );
}
}

        相信有了例子在，应该很好懂怎么用的了，呵呵。希望对你有所帮助。

如果您比我还懒，那么就下载这个试试看吧：

http://ishare.iask.sina.com.cn/f/7090776.html

mergerly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++中手动获取调用堆栈
loop in codes
09-14 6631
当我们的程序core掉之后，如果能获取到core时的函数调用堆栈将非常有利于定位问题。在Windows下可以使用SEH机制；在Linux下通过gdb使用coredump文件即可。 但有时候由于某些错误导致堆栈被破坏，发生拿不到调用堆栈的情况。 一些基础预备知识本文不再详述，可以参考以下文章： 函数调用栈的获取原理分析寄存器、函数调用与栈帧 需要知道的信息： 函数调用对应的call
C++函数调用栈
码上看世界
02-26 2201
在程序运行过程中，栈用于维护函数调用的上下文，离开了栈，函数调用就无法实现。
C++程序崩溃时获取函数调用栈信息
w1820020635的博客
11-30 1720
C++应用调试
C++高效获取函数调用堆栈
07-24
C++ 获取函数调用堆栈的 高效实现代码
在c/c++应用程序中获取调用栈信息方法
weixin_51077175的博客
03-20 755
调用栈 头文件 #include <execinfo.h> 使用方法 printf("=============takeFocus============in\n"); int j, nptrs = 0; #define SIZE 100 void *buffer[100]; char **strings; nptrs = backtrace(buffer, 100); strings = backtrace_symbols(buffer
调用堆栈的类
02-24
本文将深入探讨如何使用C++在运行时获取调用堆栈的信息。 首先，我们需要理解C++中的堆栈框架是如何工作的。每次函数调用都会创建一个新的堆栈帧，存储参数、返回地址以及局部变量。当函数执行完毕，其堆栈帧会被弹...
解析C/C++中如何终止线程的运行
12-25
3、同一个进程或另一个进程中的线程调用TerminateThread函数（应避免使用该方法）。 4、ExitProcess和TerminateProcess函数也可以用来终止线程的运行（应避免使用该方法）。 下面将详细介绍终止线程运行的方法：1-4...
StackAllocator:使用 C++11 的简单堆栈分配器实现
06-08
在给定的标题和描述中，我们看到一个使用C++11实现的简单堆栈分配器项目，它兼容Visual Studio 2015、g++4.8和clang++3.4这三种编译器。 在C++11中，引入了许多新特性，如右值引用、lambda表达式、类型推断（auto...
c/c++程序调用 堆栈分析 汇编
03-14
附件中时我对c/c++程序调用中用到的堆栈进行的分析
c++:3.函数堆栈调用
qiuxiaonao的博客
08-06 330
3.函数堆栈调用 c语言是结构化的语言：指的是把任务划分为多个由函数组成的小模块，通过函数共同作用完成任务要求 函数调用几个问题： 1.形参是否开辟内存 2.函数调用完成，系统怎么回退到对应调用函数的栈帧中（函数处于栈上，每个函数对应栈上内存为栈帧） 3.调用完成，栈帧回退后，程序如何知道执行下一行 一.预备知识： 1.1.寄存器： 1.1.1定义： 1.1.2分类（4个）：eax，ebx，ecx，edx 1.1.3栈底指针寄存器(ebp)，栈顶指针寄存器(esp)， 下一行指令寄存器（pc） 注：栈的地址
C++获取当前线程堆栈信息
最新发布
gaojunhuiwww的专栏
12-05 1431
windows下使用Dbghelp获取堆栈信息
在C/C++程序中打印当前函数调用栈
12-08 2071
前几天帮同事跟踪的一个程序莫名退出，没有core dump(当然ulimit是打开的)的问题。我们知道，正常情况下，如果程序因为某种异常条件退出的话，应该会产生core dump，而如果程序正常退出的话，应该是直接或者间接的调用了exit()相关的函数。基于这个事实，我想到了这样一个办法，在程序开始时，通过系统提供的atexit()，向系统注册一个回调函数，在程序调用exit()退出的时候，这个回
C++中打印调用栈
03-30 1237
在需要打印调用栈的地方加上 dumpCallStack(__FUNCTION__);
很早以前翻译的一篇文章，今天用到，又温习了一下，从博客转过来和大家分享。
我用CV我自豪。
04-10 1356
很早以前翻译的一篇文章，今天用到，又温习了一下，从博客转过来和大家分享。 Hello。 很早以前翻译的一篇文章，今天用到，又温习了一下，从博客转过来和大家分享。 作者：Jochen Kalmbach 翻译：Hefe 原文出处：www.codeproject.com 关键字：callstack, StackWalker 一，简介 有些情况下，我们需要显示当
C++debug 打印调用栈
shi_xin的专栏
07-24 1240
#include void __egl_get_backtrace(void) { ALOGD("%s start", __func__); android::CallStack stack(__func__); ALOGD("%s end", __func__); } 在需要的地方，添加这个函数就可以了。记得include这个头文件。 感谢David提供。
StackWalk64
weixin_30314631的博客
02-21 1057
#include <Windows.h> #define PULONG_PTR ULONG** #define PULONG ULONG* #define ULONG_PTR ULONG* #include <DbgHelp.h> #include <stdio.h> #include <stdarg.h> ...
使用Visual Leak Detector检测内存泄漏
陆小小的专栏
09-08 2384
 初识Visual Leak Detector       灵活自由是C/C++语言的一大特色，而这也为C/C++程序员出了一个难题。当程序越来越复杂时，内存的管理也会变得越加复杂，稍有不慎就会出现内存问题。内存泄漏是最常见的内存问题之一。内存泄漏如果不是很严重，在短时间内对程序不会有太大的影响，这也使得内存泄漏问题有很强的隐蔽性，不容易被发现。然而不管内存泄漏多么轻微，当程序长时间运行时
Android安卓 获取当前函数调用堆栈的方法
q345911572的博客
04-27 5072
在解bug或者排查问题时，经常需要知道一个方法在运行到里面的时候，是由谁来调用的，调用路径是什么（调用堆栈） Android 原生 SDK提供了方法： //获取调用堆栈的方法 String stackTraceString = Log.getStackTraceString(new Throwable()); 此时stackTraceString内容是： java.lang.Throwabl...
为啥都说获取堆栈从来就不是一件简单的事情？
m0_64420071的博客
07-10 838
获取堆栈！可能很多新朋友看到这个就会想，这有什么难的嘛！直接new 一个Throwable获取不就可以了嘛，或者Thread.currentThread().stackTrace（kotlin）等等也可以呀！
C++如何减少递归调用时的堆栈使用？
04-20
关于如何减少递归调用时的堆栈使用，有以下几个方法： 1. 尾递归优化：尾递归就是指在函数最后一步调用自身，并且返回值就是这个递归调用的结果。尾递归可以通过编译器的优化来实现，编译器会把递归调用变为迭代调用，从而避免堆栈溢出。 2. 迭代替代递归：将递归函数转化为迭代函数。迭代函数中通常需要一个栈来保存状态，但因为栈的空间大小是可控的，所以可以有效减少堆栈使用。 3. 减小每层递归数据结构的大小：递归函数要传递的参数和返回的数据都会占用堆栈空间，如果能减小这些数据的大小，就能有效减少堆栈使用。 4. 减少递归的深度：尽量避免递归调用过深，如果参数范围过大，可以考虑使用循环或者其他算法实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值