自己的底层代码库（八）——获取函数调用堆栈

最新推荐文章于 2024-05-17 10:02:01 发布
最新推荐文章于 2024-05-17 10:02:01 发布
阅读量6.2k 收藏 11
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zilaishuichina/article/details/8756392
版权

今天放上一个工具类，用来获取当前线程/所有线程的当前函数调用堆栈

主要是为了方便用于在打log时，可以将调用堆栈一起输出到文件当中

PS：想打出正确的log是依赖于PDB文件的

类似于VS的向output窗口输出$CALLSTACK


主要用了dbghelp的一些API

参考了：

http://www.cnblogs.com/zplutor/archive/2011/04/23/2025549.html

http://www.codeproject.com/KB/threads/StackWalker/StackWalker.zip


剥离了一些不需要的功能，只提供两个接口

//打印当前进程下 指定线程号的线程调用堆栈

BOOL GetCallstack(std::vector<std::string>& callStacks, DWORD dwThreadId);

//打印当前进程下 所有线程的调用堆栈
BOOL GetCallstack(std::vector<std::string>& callStacks);


下面直接上代码：

CStackWalker.h：

#ifndef _CStackWalker_h_
#define _CStackWalker_h_

#include <windows.h>

#include <map>
#include <vector>

#include <tchar.h>

#include <DbgHelp.h>
#include <tlhelp32.h>

#undef MODULEENTRY32
#undef PMODULEENTRY32
#undef LPMODULEENTRY32

class StackWalkerInterface
{
public:
	StackWalkerInterface();

	~StackWalkerInterface();

	// SymInitialize()
	typedef BOOL (__stdcall *fpSymInitialize)(
		IN HANDLE hProcess,
		IN PSTR UserSearchPath, 
		IN BOOL fInvadeProcess
		);
	fpSymInitialize m_fpSymInitialize;

	// SymCleanup()
	typedef BOOL (__stdcall *fpSymCleanup)(
		IN HANDLE hProcess
		);
	fpSymCleanup m_fpSymCleanup;

	// StackWalk64()
	typedef BOOL (__stdcall *fpStackWalk64)(
		DWORD MachineType, 
		HANDLE hProcess,
		HANDLE hThread, 
		LPSTACKFRAME64 StackFrame, 
		PVOID ContextRecord,
		PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
		PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
		PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
		PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
		);
	fpStackWalk64 m_fpStackWalk64;

	// SymSetContext()
	typedef BOOL (__stdcall *fpSymSetContext)(
		HANDLE hProcess,
		PIMAGEHLP_STACK_FRAME StackFrame,
		PIMAGEHLP_CONTEXT Context
		);
	fpSymSetContext m_fpSymSetContext;

	// SymEnumSymbols()
	typedef BOOL (__stdcall *fpSymEnumSymbols)(
		HANDLE hProcess,
		ULONG64 BaseOfDll,
		PCTSTR Mask,
		PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
		PVOID UserContext
		);
	fpSymEnumSymbols m_fpSymEnumSymbols;

	// SymGetOptions()
	typedef DWORD (__stdcall *fpSymGetOptions)();
	fpSymGetOptions m_fpSymGetOptions;

	// SymSetOptions()
	typedef DWORD (__stdcall *fpSymSetOptions)(IN DWORD SymOptions);
	fpSymSetOptions m_fpSymSetOptions;

	// SymFunctionTableAccess64()
	typedef PVOID (__stdcall *fpSymFunctionTableAccess64)(
		HANDLE hProcess,
		DWORD64 AddrBase
		);
	fpSymFunctionTableAccess64 m_fpSymFunctionTableAccess64;

	// SymGetLineFromAddr64()
	typedef BOOL (__stdcall *fpSymGetLineFromAddr64)(
		IN HANDLE hProcess,
		IN DWORD64 dwAddr,
		OUT PDWORD pdwDisplacement,
		OUT PIMAGEHLP_LINE64 Line
		);
	fpSymGetLineFromAddr64 m_fpSymGetLineFromAddr64;

	// SymGetModuleBase64()
	typedef DWORD64 (__stdcall *fpSymGetModuleBase64)(
		IN HANDLE hProcess,
		IN DWORD64 dwAddr
		);
	fpSymGetModuleBase64 m_fpSymGetModuleBase64;

	// SymGetSymFromAddr64()
	typedef BOOL (__stdcall *fpSymGetSymFromAddr64)(
		IN HANDLE hProcess,
		IN DWORD64 dwAddr,
		OUT PDWORD64 pdwDisplacement,
		OUT PIMAGEHLP_SYMBOL64 Symbol );
	fpSymGetSymFromAddr64 m_fpSymGetSymFromAddr64;

	// UnDecorateSymbolName()
	typedef DWORD (__stdcall WINAPI *fpUnDecorateSymbolName)(
		PCSTR DecoratedName,
		PSTR UnDecoratedName,
		DWORD UndecoratedLength,
		DWORD Flags );
	fpUnDecorateSymbolName m_fpUnDecorateSymbolName;

	// SymLoadModule64()
	typedef DWORD64 (__stdcall *fpSymLoadModule64)(
		IN HANDLE hProcess,
		IN HANDLE hFile,
		IN PSTR ImageName,
		IN PSTR ModuleName,
		IN DWORD64 BaseOfDll,
		IN DWORD SizeOfDll
		);
	fpSymLoadModule64 m_fpSymLoadModule64;

	
	
	// CreateToolhelp32Snapshot()
	typedef HANDLE (__stdcall *fpCreateToolhelp32Snapshot)(
		DWORD dwFlags, 
		DWORD th32ProcessID
		);
	fpCreateToolhelp32Snapshot m_fpCreateToolhelp32Snapshot;
	
	// Module32First()
	typedef BOOL (__stdcall *fpModule32First)(
		HANDLE hSnapshot, 
		LPMODULEENTRY32 lpme
		);
	fpModule32First m_fpModule32First;

	// Module32Next()
	typedef BOOL (__stdcall *fpModule32Next)(
		HANDLE hSnapshot, 
		LPMODULEENTRY32 lpme
		);
	fpModule32Next m_fpModule32Next;

	// Thread32First()
	typedef BOOL (__stdcall *fpThread32First)(
		HANDLE hSnapshot, 
		LPTHREADENTRY32 lpme
		);
	fpThread32First m_fpThread32First;

	// Thread32Next()
	typedef BOOL (__stdcall *fpThread32Next)(
		HANDLE hSnapshot, 
		LPTHREADENTRY32 lpme
		);
	fpThread32Next m_fpThread32Next;

	bool Init();
	bool CanUse();
	
private:
#ifdef UNICODE
	HMODULE LoadDll(const WCHAR *pDllName);
#else
	HMODULE LoadDll(const char *pDllName);
#endif	
	FARPROC LoadAPI(HMODULE dllHandle, const char *pAPIName);

	HMODULE m_hDbhHelp;
	HMODULE m_hToolhelp;

	bool m_bCanUse;
};


const DWORD STACKWALK_MAX_NAMELEN = 1024;

class CStackWalker
{
public:
	CStackWalker(void);
	~CStackWalker(void);

	BOOL GetCallstack(std::vector<std::string>& callStacks, DWORD dwThreadId);
	BOOL GetCallstack(std::vector<std::string>& callStacks);

private:
	StackWalkerInterface m_swi;

	HANDLE m_hProcess;
	DWORD m_dwProcessId;
	HANDLE m_hThread;
	DWORD m_dwThreadId;

	//当前堆栈信息
	char m_StackInfo[STACKWALK_MAX_NAMELEN];

	//模块基址-名称映射表
	std::map<DWORD64, std::string> m_ModuleList;
	BOOL GetModuleList();
};

extern CStackWalker g_StackWalker;

#endif

CStackWalker.cpp：

#include "CStackWalker.h"

StackWalkerInterface::StackWalkerInterface()
{
	m_hDbhHelp = NULL;
	m_hToolhelp = NULL;

	m_fpCreateToolhelp32Snapshot = NULL;
	m_fpModule32First = NULL;
	m_fpModule32Next = NULL;
	m_fpThread32First = NULL;
	m_fpThread32Next = NULL;

	m_fpSymInitialize = NULL;
	m_fpSymCleanup = NULL;

	m_fpStackWalk64 = NULL;
	m_fpSymSetContext = NULL;
	m_fpSymEnumSymbols = NULL;

	m_fpSymGetOptions = NULL;
	m_fpSymSetOptions = NULL;

	m_fpSymGetModuleBase64 = NULL;

	m_fpSymFunctionTableAccess64 = NULL;

	m_fpSymGetLineFromAddr64 = NULL;

	m_fpSymGetSymFromAddr64 = NULL;

	m_fpSymLoadModule64 = NULL;

	m_fpUnDecorateSymbolName = NULL;

	m_bCanUse = false;
}

StackWalkerInterface::~StackWalkerInterface()
{
	if (m_hDbhHelp != NULL)
	{
		FreeLibrary(m_hDbhHelp);
		m_hDbhHelp = NULL;
	}
	if (m_hToolhelp != NULL)
	{
		FreeLibrary(m_hToolhelp);
		m_hToolhelp = NULL;
	}
}

#ifdef UNICODE
HMODULE StackWalkerInterface::LoadDll(const WCHAR *pDllName)
#else
HMODULE StackWalkerInterface::LoadDll(const char *pDllName)
#endif
{
	HMODULE dllHandle = LoadLibrary(pDllName);
	if (NULL != dllHandle)
	{
		return dllHandle;
	}
	else
	{
		printf("StackWalkerInterface LoadLibrary \"%s\" Error code 0x%08x!\n", pDllName, GetLastError());
		return NULL;
	}
}

FARPROC StackWalkerInterface::LoadAPI(HMODULE dllHandle, const char *pAPIName)
{
	FARPROC apiAddr = GetProcAddress(dllHandle, pAPIName);
	if (NULL != apiAddr)
	{
		return apiAddr;
	}
	else
	{
		printf("StackWalkerInterface GetProcAddress \"%s\" Error code 0x%08x!\n", pAPIName, GetLastError());
		return NULL;
	}
}

bool StackWalkerInterface::Init()
{
	bool res = false;
	
	// 加载dbghelp.dll >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	m_hDbhHelp = LoadDll(_T("dbghelp.dll"));
	if (NULL == m_hDbhHelp)
	{
		return false;
	}
	
	m_fpSymInitialize = (fpSymInitialize) LoadAPI(m_hDbhHelp, "SymInitialize" );
	if (NULL == m_fpSymInitialize)
	{
		return false;
	}
	
	m_fpSymCleanup = (fpSymCleanup) LoadAPI(m_hDbhHelp, "SymCleanup" );
	if (NULL == m_fpSymCleanup)
	{
		return false;
	}

	m_fpStackWalk64 = (fpStackWalk64) LoadAPI(m_hDbhHelp, "StackWalk64" );
	if (NULL == m_fpStackWalk64)
	{
		return false;
	}

	m_fpSymSetContext = (fpSymSetContext) LoadAPI(m_hDbhHelp, "SymSetContext" );
	if (NULL == m_fpSymSetContext)
	{
		return false;
	}

	m_fpSymEnumSymbols = (fpSymEnumSymbols) LoadAPI(m_hDbhHelp, "SymEnumSymbols" );
	if (NULL == m_fpSymEnumSymbols)
	{
		return false;
	}

	m_fpSymGetOptions = (fpSymGetOptions) LoadAPI(m_hDbhHelp, "SymGetOptions" );
	if (NULL == m_fpSymGetOptions)
	{
		return false;
	}

	m_fpSymSetOptions = (fpSymSetOptions) LoadAPI(m_hDbhHelp, "SymSetOptions" );
	if (NULL == m_fpSymSetOptions)
	{
		return false;
	}

	m_fpSymFunctionTableAccess64 = (fpSymFunctionTableAccess64) LoadAPI(m_hDbhHelp, "SymFunctionTableAccess64" );
	if (NULL == m_fpSymFunctionTableAccess64)
	{
		return false;
	}

	m_fpSymGetLineFromAddr64 = (fpSymGetLineFromAddr64) LoadAPI(m_hDbhHelp, "SymGetLineFromAddr64" );
	if (NULL == m_fpSymGetLineFromAddr64)
	{
		return false;
	}

	m_fpSymGetModuleBase64 = (fpSymGetModuleBase64) LoadAPI(m_hDbhHelp, "SymGetModuleBase64" );
	if (NULL == m_fpSymGetModuleBase64)
	{
		return false;
	}

	m_fpSymGetSymFromAddr64 = (fpSymGetSymFromAddr64) LoadAPI(m_hDbhHelp, "SymGetSymFromAddr64" );
	if (NULL == m_fpSymGetSymFromAddr64)
	{
		return false;
	}

	m_fpUnDecorateSymbolName = (fpUnDecorateSymbolName) LoadAPI(m_hDbhHelp, "UnDecorateSymbolName" );
	if (NULL == m_fpUnDecorateSymbolName)
	{
		return false;
	}

	m_fpSymLoadModule64 = (fpSymLoadModule64) LoadAPI(m_hDbhHelp, "SymLoadModule64" );
	if (NULL == m_fpSymLoadModule64)
	{
		return false;
	}

	// 加载kernel32.dll >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	m_hToolhelp = LoadDll(_T("kernel32.dll"));
	if (NULL == m_hToolhelp)
	{
		return false;
	}
	
	m_fpCreateToolhelp32Snapshot = (fpCreateToolhelp32Snapshot)LoadAPI(m_hToolhelp, "CreateToolhelp32Snapshot");
	if (NULL == m_fpCreateToolhelp32Snapshot)
	{
		return false;
	}

	m_fpModule32First = (fpModule32First) LoadAPI(m_hToolhelp, "Module32First");
	if (NULL == m_fpModule32First)
	{
		return false;
	}

	m_fpModule32Next = (fpModule32Next) LoadAPI(m_hToolhelp, "Module32Next");
	if (NULL == m_fpModule32Next)
	{
		return false;
	}

	m_fpThread32First = (fpThread32First) LoadAPI(m_hToolhelp, "Thread32First");
	if (NULL == m_fpThread32First)
	{
		return false;
	}

	m_fpThread32Next = (fpThread32Next) LoadAPI(m_hToolhelp, "Thread32Next");
	if (NULL == m_fpThread32Next)
	{
		return false;
	}

	m_bCanUse = true;
	return true;
}

bool StackWalkerInterface::CanUse()
{
	return m_bCanUse;
}

CStackWalker::CStackWalker(void)
{
	m_hProcess = GetCurrentProcess();
	m_dwProcessId = GetCurrentProcessId();
	
	BOOL res = m_swi.Init();
	if (!res)
	{
		printf("StackWalkerInterface Init() Error!\n");
		return;
	}

	res = m_swi.m_fpSymInitialize(m_hProcess, NULL, TRUE);
	if (!res)
	{
		printf("SymInitialize() Error code 0x%08x!\n", GetLastError());
		return;
	}

	DWORD symOptions = m_swi.m_fpSymGetOptions();
	symOptions |= SYMOPT_LOAD_LINES;
	symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS;
	symOptions = m_swi.m_fpSymSetOptions(symOptions);

	GetModuleList();
}

CStackWalker::~CStackWalker(void)
{
	m_swi.m_fpSymCleanup(m_hProcess);
	m_ModuleList.clear();
}

BOOL CStackWalker::GetModuleList()
{
	m_ModuleList.clear();

	HANDLE hSnap = INVALID_HANDLE_VALUE;
	hSnap = m_swi.m_fpCreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_dwProcessId);
	if (hSnap == INVALID_HANDLE_VALUE)
	{
		printf("CreateToolhelp32Snapshot() Error code 0x%08x!\n", GetLastError());
		return FALSE;
	}

	MODULEENTRY32 me;
	memset(&me, 0, sizeof(me));
	me.dwSize = sizeof(me);

	BOOL res = FALSE;
	int cnt = 0;
	res = m_swi.m_fpModule32First(hSnap, &me);
	while (res)
	{
		m_swi.m_fpSymLoadModule64(m_hProcess, 0, me.szExePath, me.szModule, 
			(DWORD64) me.modBaseAddr, me.modBaseSize);

		std::string name = me.szModule;
		m_ModuleList[(DWORD64)me.modBaseAddr] = name;
		
		cnt++;
		res = m_swi.m_fpModule32Next( hSnap, &me );
	}

	CloseHandle(hSnap);

	if (cnt > 0)
	{
		res = TRUE;
	}

	return res;
}

BOOL CStackWalker::GetCallstack(std::vector<std::string>& callStacks, DWORD dwThreadId)
{
	if (!m_swi.CanUse())
	{
		return FALSE;
	}

	HANDLE hSnap = m_swi.m_fpCreateToolhelp32Snapshot(TH32CS_SNAPALL, m_dwProcessId);
	if (hSnap == INVALID_HANDLE_VALUE)
	{
		printf("CreateToolhelp32Snapshot() Error code 0x%08x!\n", GetLastError());
		return FALSE;
	}
	
	HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, dwThreadId);
	DWORD hCurrThreadId = ::GetCurrentThreadId();
	if (hThread != NULL)
	{
		CONTEXT context;
		if (dwThreadId != hCurrThreadId)
		{
			SuspendThread(hThread);
			memset(&context, 0, sizeof(CONTEXT));
			context.ContextFlags = CONTEXT_FULL;
			if (!GetThreadContext(hThread, &context))
			{
				ResumeThread(hThread);
				return FALSE;
			}
		}
		else
		{
			memset(&context, 0, sizeof(CONTEXT));
			context.ContextFlags = CONTEXT_FULL;
			__asm    call x 
			__asm x: pop eax 
			__asm    mov context.Eip, eax 
			__asm    mov context.Ebp, ebp 
			__asm    mov context.Esp, esp 
		}

		STACKFRAME64 stackframe;
		memset(&stackframe, 0, sizeof(stackframe));
		DWORD imageType;

#ifdef _M_IX86
		imageType = IMAGE_FILE_MACHINE_I386;
		stackframe.AddrPC.Offset = context.Eip;
		stackframe.AddrPC.Mode = AddrModeFlat;
		stackframe.AddrFrame.Offset = context.Ebp;
		stackframe.AddrFrame.Mode = AddrModeFlat;
		stackframe.AddrStack.Offset = context.Esp;
		stackframe.AddrStack.Mode = AddrModeFlat;
#elif _M_X64
		imageType = IMAGE_FILE_MACHINE_AMD64;
		stackframe.AddrPC.Offset = context.Rip;
		stackframe.AddrPC.Mode = AddrModeFlat;
		stackframe.AddrFrame.Offset = context.Rsp;
		stackframe.AddrFrame.Mode = AddrModeFlat;
		stackframe.AddrStack.Offset = context.Rsp;
		stackframe.AddrStack.Mode = AddrModeFlat;
#else
#error "Not Supported!"
#endif

		char sysbuff[sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN];
		IMAGEHLP_SYMBOL64 *pSym = (IMAGEHLP_SYMBOL64 *)sysbuff;
		memset(pSym, 0x00, sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN);
		pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
		pSym->MaxNameLength = STACKWALK_MAX_NAMELEN;

		IMAGEHLP_LINE64 line;
		memset(&line, 0x00, sizeof(line));
		line.SizeOfStruct = sizeof(line);

		while (true)
		{
			if (!m_swi.m_fpStackWalk64(imageType, m_hProcess, hThread, &stackframe, &context, 
				NULL, m_swi.m_fpSymFunctionTableAccess64, m_swi.m_fpSymGetModuleBase64, NULL) )
			{
				printf("StackWalk64() Error code 0x%08x!\n", GetLastError());
				return FALSE;
			}

			if (stackframe.AddrPC.Offset == stackframe.AddrReturn.Offset)
			{
				break;
			}
			
			if (stackframe.AddrPC.Offset != 0)
			{
				memset(m_StackInfo, 0x00, sizeof(char) * STACKWALK_MAX_NAMELEN);

				//函数对应的模块名 查m_ModuleList表
				DWORD64 moduleBase = m_swi.m_fpSymGetModuleBase64(m_hProcess, stackframe.AddrPC.Offset);
				std::map<DWORD64, std::string>::iterator module = m_ModuleList.find(moduleBase);
				if (module != m_ModuleList.end())
				{
					const char *name = module->second.c_str();
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, name);
				}
				else
				{
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, "unknow module");
				}
				strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, ": ");

				//函数对应的代码文件 以及行号
				DWORD dwDisplacementFromLine;
				if (m_swi.m_fpSymGetLineFromAddr64(m_hProcess, stackframe.AddrPC.Offset, &dwDisplacementFromLine, &line))
				{
					char name[50] = {0};
					_itoa_s(line.LineNumber, name, 50, 10);
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, line.FileName);
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, "(");
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, name);
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, ")");
				}
				else
				{
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, "unknow file");
				}
				strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, ": ");

				//函数名
				DWORD64 dwDisplacementFromFunc;
				if (m_swi.m_fpSymGetSymFromAddr64(m_hProcess, stackframe.AddrPC.Offset, &dwDisplacementFromFunc, pSym))
				{
					if(pSym->Name[0] == '?')
					{
						//修饰名 -> 函数签名
						char name[STACKWALK_MAX_NAMELEN] = {0};
						m_swi.m_fpUnDecorateSymbolName(pSym->Name, name, STACKWALK_MAX_NAMELEN, UNDNAME_NAME_ONLY);
						strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, name);
					}
					else
					{
						strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, pSym->Name);
					}
				}
				else
				{
					strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, "unknow func");
				}
				strcat_s(m_StackInfo, STACKWALK_MAX_NAMELEN, ": ");
	
				std::string oneCallStack = m_StackInfo;
				callStacks.push_back(oneCallStack);
			}

			if (stackframe.AddrReturn.Offset == 0)
			{
				break;
			}
		}

		if (dwThreadId != hCurrThreadId)
		{
			ResumeThread(hThread);
		}
		CloseHandle(hThread);

		callStacks.push_back("\n");
	}

	CloseHandle(hSnap);
	return TRUE;
}

BOOL CStackWalker::GetCallstack(std::vector<std::string>& callStacks)
{
	if (!m_swi.CanUse())
	{
		return FALSE;
	}

	HANDLE hSnap = m_swi.m_fpCreateToolhelp32Snapshot(TH32CS_SNAPALL, m_dwProcessId);
	if (hSnap == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}

	THREADENTRY32 te;
	memset(&te, 0, sizeof(te));
	te.dwSize = sizeof(te);
	BOOL res = m_swi.m_fpThread32First(hSnap, &te);
	while (res)
	{
		if (te.th32OwnerProcessID == m_dwProcessId)
		{
			GetCallstack(callStacks, te.th32ThreadID);
		}
		res = m_swi.m_fpThread32Next(hSnap, &te);
	}

	CloseHandle(hSnap);

	return TRUE;
}

CStackWalker g_StackWalker;

测试程序：

创建两个线程，每个线程里面进行FunA跟FunB的循环调用，线程执行1s后打印当前进程下所有线程的当前调用堆栈

#include "CStackWalker.h"

DWORD WINAPI Run(LPVOID lpParam);
void FunB();
void FunA(int a);

int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hThread[2] = {0};
	for (int i = 0; i < 2; i++)
	{
		hThread[i] = CreateThread(NULL, 0, Run, 0, 0, NULL);
	}

	Sleep(1000);

	std::vector<std::string> callStacks;
	g_StackWalker.GetCallstack(callStacks);
	for (int i = 0; i < callStacks.size(); i++)
	{
		printf("%s\n", callStacks[i].c_str());
	}

	return 0;
}

void FunB()
{
	Sleep(100);
	FunA(rand());
}

void FunA(int a)
{
	Sleep(100);
	FunB();

}

DWORD WINAPI Run(LPVOID lpParam)
{
	FunB();
	return 0;
}

测试结果



zilaishuichina
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Linux下获取调用堆栈地址
凌风的博客
06-14 1485
#include #include #include void get_stack_info(char *buf, int len) { #define MAX_BACK_TRACE_DEPTH 100 #define MAX_STACK_SIZE 64 if (buf == NULL || len <= 0) { return; }
[源码]WIN32汇编语言实现的经典俄罗斯方块游戏
11-12
开发者可以直接调用系统函数，如窗口创建、事件处理、图形绘制等，这使得汇编语言也能实现复杂的图形用户界面应用，例如我们的俄罗斯方块游戏。 俄罗斯方块是一款简单而引人入胜的益智游戏，其基本元素包括不同形状...
C++高效获取函数调用堆栈
07-24
C++ 获取函数调用堆栈的 高效实现代码
C++获取当前线程堆栈信息
gaojunhuiwww的专栏
12-05 1410
windows下使用Dbghelp获取堆栈信息
StackWalker：深入调用栈的探索工具
最新发布
gitblog_00049的博客
05-17 429
StackWalker：深入调用栈的探索工具 项目地址:https://gitcode.com/JochenKalmbach/StackWalker 项目简介 StackWalker 是一个轻量级但功能强大的库，它允许您在任何线程（包括自己的、其他线程和远程线程）上查看和分析调用栈。这个项目最初发布在 CodeProject 上，但由于维护需求，作者将其迁移到了更易于管理的 GitHub 平台。S...
跟踪API
七七八八
07-19 2594
今天无意中发现彭春华写的一些关于跟踪API的方法，特别是调试函数的使用，惊叹! 以前居然没有发现!                                                                     跟踪监视方案概览当我们对某一目标程序进行API函数的跟踪监视分析时，根据跟踪监视的目标，基本上有以下几种途径实现对API函数的跟踪监视：  写Log记录分析 如果
老外写的StackWalk64的封装类StackWalker。继承其并且重载onOutput可以得到堆栈。
我用CV我自豪。
04-10 3870
http://www.codeproject.com/Articles/11132/Walking-the-callstack Introduction In some cases you need to display the callstack of the current thread or your are just interested in the call
C与C++的函数调用约定
冷剑魂的专栏——垃圾场
03-06 1400
在C语言中，假设我们有这样的一个函数：int function(int a,int b)调用时只要用result = function(1,2)这样的方式就可以使用这个函数。但是，当高级语言被编译成计算机可以识别的机器码时，有一个问题就凸现出来：在CPU中，计算机没有办法知道一个函数调用需要多少个、什么样的参数，也没有硬件可以保存这些参数。也就是说，计算机不知道怎么给这个函数传递参数，传递
C++ 调用 DmReg.dll 加载 大漠 笔记
m0_46135508的博客
04-10 2142
VS2019 编译通过 // 初始化COM(mta) CoInitializeEx(NULL, 0); // 声明 指针函数 typedef BOOL (_stdcall *Dm_SetPath)(char *Path, BOOL Number); // 获取exe 根目录 char Temp[MAX_PATH] = { 0 }; GetModuleFileName(NULL, Temp, MAX_PATH); ExePath.Format("%s", Temp); ExePath = ExePath.
cpp/java 函数调用栈 堆栈打印方法
JCYAO_的博客
10-12 1056
cpp层打印调用栈 方法一 一、在需要加堆栈的文件(*.cpp)里 #if defined(ENABLE_MBACKTRACE) && (ENABLE_MBACKTRACE == 1) #include "MBacktrace.h" #endif 二、查找调用函数(此cpp的某个函数某个位置) #if defined(ENABLE_MBACKTRACE) &&amp...
libunwind-1.0.tar
04-19
《libunwind库详解——深入理解程序调用堆栈》 libunwind是一个开源的C库，用于在Unix-like系统中实现程序调用堆栈的展开。它的主要目标是为开发人员提供一种标准且高效的方式来获取运行时的调用堆栈信息。在...
Linux操作系统课程指导：Ch5SystemCalls.pptx
11-17
- `asmlinkage`关键字指示编译器从堆栈中获取函数参数，这是Linux系统调用中常见的约定。 - 系统调用通常返回`long`类型值，在用户空间可能被转换为`int`。 - 例如，`sys_sched_yield`是通过`sys_sched_yield`...
Keil.STM32F1xx_DFP.2.3.0
08-08
3. **HAL（Hardware Abstraction Layer）库**：STMicroelectronics提供的高级库，为STM32F1系列提供了与硬件无关的函数调用，使得开发者可以更专注于应用程序逻辑，而非底层硬件细节。 4. **示例代码**：这些预编译...
多线程编程一.pdf
10-19
创建成功后，线程默认立即开始执行，除非`CREATE_SUSPENDED`标志被设置，此时线程会被挂起，待`ResumeThread`函数调用后才开始运行。线程优先级可通过`SetThreadPriority`函数调整。线程在函数返回后自动终止，也可...
[Win32]一个调试器的实现（五）调试符号
zhangyanquen的技术专栏
12-10 938
一个调试器应该可以跟踪被调试程序执行到了什么地方，显示下一条将要执行的语句，显示各个变量的值，设置断点，进行单步执行等等，这些功能都需要一个基础设施的支持，那就是调试符号。   什么是调试符号 我们知道，在exe、dll等可执行文件中保存的数据大部分都是二进制指令，CPU直接读取这些指令并执行。那么调试器是如何知道每条指令对应哪个源文件的哪一行代码呢？它又是如何知道每个变量和函数的名称，并显
dll内获取自身路径的方法（windows)
风居住的城市
04-19 2033
include &lt;windows.h&gt; bool GetSelfModulePath(char* path) { MEMORY_BASIC_INFORMATION mbi; HMODULE dllHandle = ((::VirtualQuery(GetSelfModulePath, &amp;mbi, sizeof(mbi)) != 0) ? (HMODULE)...
vtk 错误整理
pengqilu1987的博客
09-03 613
一 开发环境 （1）VTK-8.2.0 （2）Visual Studio 2017 二 ITK错误整理 2.1 （1）问题： ITK读写PNG、BMP、JPG等格式的图像失败。抛出异常如下： “Could not create IO object for writing file xxx.png There are no registered IO factories.”。 （2）解决方案： 若ITK读写png、bmp、jpg图像失败，则添加以下头文件： #include &lt..
获取任意线程调用栈的那些事
weixin_34268610的博客
08-28 428
BSBacktraceLogger 是一个轻量级的框架，可以获取任意线程的调用栈，开源在我的 GitHub，建议下载下来结合本文阅读。 我们知道 NSThread 有一个类方法 callstackSymbols 可以获取调用栈，但是它输出的是当前线程的调用栈。在利用 Runloop 检测卡顿时，子线程检测到了主线程发生卡顿，需要通过主线程的调用栈来分析具体是哪个方法导致了阻塞，这时系统提供的方...
linux查看进程函数调用栈,Linux下多线程程序崩溃时如何提取出所有线程的函数调用栈...
weixin_39761573的博客
04-29 471
尝试过三种方法都不凑效1.libc中的backtrace函数2.内联汇编，提取出ebp寄存器的值再回溯出函数调用栈(会有兼容性问题，x86下试过可以，一移植到其他平台就用不了，本人菜鸟，汇编不熟)3.gcc内建的两个函数Built-inFunction:void*__builtin_return_address(unsignedintlevel)Built-inFunction...
js获取函数调用的堆栈用来干嘛
09-02
获取函数调用的堆栈可以用来进行调试和错误追踪。当程序发生错误或者异常时，堆栈信息可以提供有关错误发生位置和调用链的详细信息，帮助开发人员快速定位问题所在。 通过获取堆栈信息，你可以了解函数调用的顺序、函数的参数值、调用函数的文件和行数等。这对于理解程序的执行流程、查找错误源头以及优化代码都非常有帮助。 在 JavaScript 中，你可以使用 `Error` 对象来获取堆栈信息。`Error` 对象提供了 `stack` 属性，它包含了调用堆栈的字符串表示。你可以将这个字符串打印出来或者进行进一步的处理，以便在调试过程中使用。 以下是一个示例： ```javascript function func1() { func2(); } function func2() { throw new Error('Custom error message'); } try { func1(); } catch (error) { console.error(error.stack); } ``` 运行上述代码，你将会得到类似以下的输出： ``` Error: Custom error message at func2 (<anonymous>:7:9) at func1 (<anonymous>:3:3) at <anonymous>:10:3 ``` 这个输出展示了函数调用的堆栈信息，从最上层的调用开始，依次往下展示每个调用的文件和行数。在实际开发中，你可以利用这些信息来定位错误并进行调试。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值