C++ 程序崩溃调用堆栈打印_windows 崩溃 记录调用栈信息

程序现场发布，最头痛程序崩溃 但是日志又找不出什么蛛丝马迹  win32下可以增加如下 可以在release下打印调用堆栈信息  

//.h

#ifndef _CALL_STACK_TOOL_2017_10_30_
#define _CALL_STACK_TOOL_2017_10_30_
 
#include <Windows.h>  
#include <DbgHelp.h>  
#include <iostream>  
#include <vector>  
 
// 添加对dbghelp.lib的编译依赖  
//  
#pragma comment(lib, "dbghelp.lib")  
 
using namespace std;
 
const int MAX_ADDRESS_LENGTH = 32;
const int MAX_NAME_LENGTH = 1024;
 
// 崩溃信息  
//   
struct CrashInfo
{
	CHAR ErrorCode[MAX_ADDRESS_LENGTH];
	CHAR Address[MAX_ADDRESS_LENGTH];
	CHAR Flags[MAX_ADDRESS_LENGTH];
};
 
// CallStack信息  
//   
struct CallStackInfo
{
	CHAR ModuleName[MAX_NAME_LENGTH];
	CHAR MethodName[MAX_NAME_LENGTH];
	CHAR FileName[MAX_NAME_LENGTH];
	CHAR LineNumber[MAX_NAME_LENGTH];
};
 
// 安全拷贝字符串函数  
void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc);
 
// 得到程序崩溃信息   
CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord);
 
// 得到CallStack信息    
vector<CallStackInfo> GetCallStack(const CONTEXT *pContext);
 
LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException);
 
#endif

//.cpp

#include "stdafx.h"
#include "CallStackTool.h"
#include "VpPublic.h"
 
#include <iostream>    
#include <windows.h>    
#include <psapi.h>    
//#pragma comment(lib,"psapi.lib")
 
 
void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc)
{
	if (nMaxDestSize <= 0) return;
	if (strlen(szSrc) < nMaxDestSize)
	{
		strcpy_s(szDest, nMaxDestSize, szSrc);
	}
	else
	{
		strncpy_s(szDest, nMaxDestSize, szSrc, nMaxDestSize);
		szDest[nMaxDestSize - 1] = '\0';
	}
}
 
// 得到程序崩溃信息  
//  
CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord)
{
	CrashInfo crashinfo;
	SafeStrCpy(crashinfo.Address, MAX_ADDRESS_LENGTH, "N/A");
	SafeStrCpy(crashinfo.ErrorCode, MAX_ADDRESS_LENGTH, "N/A");
	SafeStrCpy(crashinfo.Flags, MAX_ADDRESS_LENGTH, "N/A");
 
	sprintf_s(crashinfo.Address, "%08X", pRecord->ExceptionAddress);
	sprintf_s(crashinfo.ErrorCode, "%08X", pRecord->ExceptionCode);
	sprintf_s(crashinfo.Flags, "%08X", pRecord->ExceptionFlags);
 
	return crashinfo;
}
 
// 得到CallStack信息  
//  
vector<CallStackInfo> GetCallStack(const CONTEXT *pContext)
{
	HANDLE hProcess = GetCurrentProcess();
 
	SymInitialize(hProcess, NULL, TRUE);
 
	vector<CallStackInfo> arrCallStackInfo;
 
	CONTEXT c = *pContext;
 
	STACKFRAME64 sf;
	memset(&sf, 0, sizeof(STACKFRAME64));
	DWORD dwImageType = IMAGE_FILE_MACHINE_I386;
 
	// 不同的CPU类型，具体信息可查询MSDN  
	//  
#ifdef _M_IX86  
	sf.AddrPC.Offset = c.Eip;
	sf.AddrPC.Mode = AddrModeFlat;
	sf.AddrStack.Offset = c.Esp;
	sf.AddrStack.Mode = AddrModeFlat;
	sf.AddrFrame.Offset = c.Ebp;
	sf.AddrFrame.Mode = AddrModeFlat;
#elif _M_X64  
	dwImageType = IMAGE_FILE_MACHINE_AMD64;
	sf.AddrPC.Offset = c.Rip;
	sf.AddrPC.Mode = AddrModeFlat;
	sf.AddrFrame.Offset = c.Rsp;
	sf.AddrFrame.Mode = AddrModeFlat;
	sf.AddrStack.Offset = c.Rsp;
	sf.AddrStack.Mode = AddrModeFlat;
#elif _M_IA64  
	dwImageType = IMAGE_FILE_MACHINE_IA64;
	sf.AddrPC.Offset = c.StIIP;
	sf.AddrPC.Mode = AddrModeFlat;
	sf.AddrFrame.Offset = c.IntSp;
	sf.AddrFrame.Mode = AddrModeFlat;
	sf.AddrBStore.Offset = c.RsBSP;
	sf.AddrBStore.Mode = AddrModeFlat;
	sf.AddrStack.Offset = c.IntSp;
	sf.AddrStack.Mode = AddrModeFlat;
#else  
#error "Platform not supported!"  
#endif  
 
	HANDLE hThread = GetCurrentThread();
 
	while (true)
	{
		// 该函数是实现这个功能的最重要的一个函数  
		// 函数的用法以及参数和返回值的具体解释可以查询MSDN  
		//  
		if (!StackWalk64(dwImageType, hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
		{
			break;
		}
 
		if (sf.AddrFrame.Offset == 0)
		{
			break;
		}
 
		CallStackInfo callstackinfo;
		SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, "N/A");
		SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, "N/A");
		SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, "N/A");
		SafeStrCpy(callstackinfo.LineNumber, MAX_NAME_LENGTH, "N/A");
 
		BYTE symbolBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH];
		IMAGEHLP_SYMBOL64 *pSymbol = (IMAGEHLP_SYMBOL64*)symbolBuffer;
		memset(pSymbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH);
 
		pSymbol->SizeOfStruct = sizeof(symbolBuffer);
		pSymbol->MaxNameLength = MAX_NAME_LENGTH;
 
		DWORD symDisplacement = 0;
 
		// 得到函数名  
		//  
		if (SymGetSymFromAddr64(hProcess, sf.AddrPC.Offset, NULL, pSymbol))
		{
			SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, pSymbol->Name);
		}
 
		IMAGEHLP_LINE64 lineInfo;
		memset(&lineInfo, 0, sizeof(IMAGEHLP_LINE64));
 
		lineInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
 
		DWORD dwLineDisplacement;
 
		// 得到文件名和所在的代码行  
		//  
		if (SymGetLineFromAddr64(hProcess, sf.AddrPC.Offset, &dwLineDisplacement, &lineInfo))
		{
			SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, lineInfo.FileName);
			sprintf_s(callstackinfo.LineNumber, "%d", lineInfo.LineNumber);
		}
 
		IMAGEHLP_MODULE64 moduleInfo;
		memset(&moduleInfo, 0, sizeof(IMAGEHLP_MODULE64));
 
		moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
 
		// 得到模块名  
		//  
		if (SymGetModuleInfo64(hProcess, sf.AddrPC.Offset, &moduleInfo))
		{
			SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, moduleInfo.ModuleName);
		}
 
		arrCallStackInfo.push_back(callstackinfo);
	}
 
	SymCleanup(hProcess);
 
	return arrCallStackInfo;
}
 
LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)
{
	// 确保有足够的栈空间  
	//  
#ifdef _M_IX86  
	if (pException->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)
	{
		static char TempStack[1024 * 128];
		__asm mov eax, offset TempStack[1024 * 128];
		__asm mov esp, eax;
	}
#endif    
 
	CrashInfo crashinfo = GetCrashInfo(pException->ExceptionRecord);
 
	OS_LOG_INFO("********************************************************************************");
	OS_LOG_INFO("ErrorCode: " << crashinfo.ErrorCode);
	OS_LOG_INFO("Address: " << crashinfo.Address);
	OS_LOG_INFO("Flags: " << crashinfo.Flags);
 
 
	vector<CallStackInfo> arrCallStackInfo = GetCallStack(pException->ContextRecord);
 
	// 输出CallStack  
	//  
	OS_LOG_INFO("CallStack: ");
	for (vector<CallStackInfo>::iterator i = arrCallStackInfo.begin(); i != arrCallStackInfo.end(); ++i)
	{
		CallStackInfo callstackinfo = (*i);
		OS_LOG_INFO(callstackinfo.MethodName << "() : [" << callstackinfo.ModuleName << "] (File: " << callstackinfo.FileName << " @Line " << callstackinfo.LineNumber << ")" );
	}
	OS_LOG_INFO("********************************************************************************");
 
	HANDLE handle = GetCurrentProcess();    
	PROCESS_MEMORY_COUNTERS pmc;    
	GetProcessMemoryInfo(handle,&pmc,sizeof(pmc));
 
	OS_LOG_INFO("当前使用内存:" << pmc.WorkingSetSize/1024/1024 << "M," 
		"峰值使用内存:" << pmc.PeakWorkingSetSize/1014/1024 << "M,"
		"虚拟内存:" << pmc.PagefileUsage/1024/1024 << "M," 
		"峰值虚拟内存:" << pmc.PeakPagefileUsage/1014/1024 << "M"
		);
 
	return EXCEPTION_EXECUTE_HANDLER;
}








PS:
每次发布记得随身带pdb 文件