__asm {    FLDZ;    FNSTENV [ESP-0xC];    POP ctx.Eip;}

CONTEXT ctx;DWORD thread_id = GetCurrentThreadId();HANDLE thread_handle = OpenThread(THREAD_ALL_ACCESS, false, thread_id);ctx.ContextFlags = CONTEXT_ALL;GetThreadContext(thread_handle, &ctx);CloseHandle(thread_handle);

// called for each stack frame found by walk_stack, passing information// about the frame and <user_arg>.// return INFO::CB_CONTINUE to continue, anything else to stop immediately// and return that value to walk_stack's caller.//// rationale: we can't just pass function's address to the callback -// dump_frame_cb needs the frame pointer for reg-relative variables.typedef LibError (*StackFrameCallback)(const STACKFRAME64*, void*);static void skip_this_frame(uint& skip, void* context){	if(!context)		skip++;}// iterate over a call stack, calling back for each frame encountered.// if <pcontext> != 0, we start there; otherwise, at the current context.// return an error if callback never succeeded (returned 0).//// lock must be held.static LibError walk_stack(StackFrameCallback cb, void* user_arg = 0, uint skip = 0, const CONTEXT* pcontext = 0){	// to function properly, StackWalk64 requires a CONTEXT on	// non-x86 systems (documented) or when in release mode (observed).	// exception handlers can call walk_stack with their context record;	// otherwise (e.g. dump_stack from debug_assert), we need to query it.	CONTEXT context;	// .. caller knows the context (most likely from an exception);	//    since StackWalk64 may modify it, copy to a local variable.	if(pcontext)		context = *pcontext;	// .. need to determine context ourselves.	else	{		skip_this_frame(skip, (void*)pcontext);		// there are 4 ways to do so, in order of preference:		// - asm (easy to use but currently only implemented on IA32)		// - RtlCaptureContext (only available on WinXP or above)		// - intentionally raise an SEH exception and capture its context		//   (spams us with "first chance exception")		// - GetThreadContext while suspended* (a bit tricky + slow).		//		// * it used to be common practice to query the current thread's context,		// but WinXP SP2 and above require it be suspended.		//		// this MUST be done inline and not in an external function because		// compiler-generated prolog code trashes some registers.#if CPU_IA32		ia32_asm_GetCurrentContext(&context);#else		// preferred implementation (was imported during module init)		if(pRtlCaptureContext)			pRtlCaptureContext(&context);		// not available: raise+handle an exception; grab the reported context.		else		{			__try			{				RaiseException(0xF001, 0, 0, 0);			}			__except(context = (GetExceptionInformation())->ContextRecord, EXCEPTION_CONTINUE_EXECUTION)			{			}		}#endif	}	pcontext = &context;	STACKFRAME64 sf;	memset(&sf, 0, sizeof(sf));	sf.AddrPC.Mode      = AddrModeFlat;	sf.AddrFrame.Mode   = AddrModeFlat;	sf.AddrStack.Mode   = AddrModeFlat;#if CPU_AMD64	sf.AddrPC.Offset    = pcontext->Rip;	sf.AddrFrame.Offset = pcontext->Rbp;	sf.AddrStack.Offset = pcontext->Rsp;#else	sf.AddrPC.Offset    = pcontext->Eip;	sf.AddrFrame.Offset = pcontext->Ebp;	sf.AddrStack.Offset = pcontext->Esp;#endif	// for each stack frame found:	LibError ret  = ERR::SYM_NO_STACK_FRAMES_FOUND;	for(;;)	{		// rationale:		// - provide a separate ia32 implementation so that simple		//   stack walks (e.g. to determine callers of malloc) do not		//   require firing up dbghelp. that takes tens of seconds when		//   OS symbols are installed (because symserv is wanting to access		//   inet), which is entirely unacceptable.		// - VC7.1 sometimes generates stack frames despite /Oy ;		//   ia32_walk_stack may appear to work, but it isn't reliable in		//   this case and therefore must not be used!		// - don't switch between ia32_stack_walk and StackWalk64 when one		//   of them fails: this needlessly complicates things. the ia32		//   code is authoritative provided its prerequisite (FP not omitted)		//   is met, otherwise totally unusable.		LibError err;#if CPU_IA32 && !CONFIG_OMIT_FP		err = ia32_walk_stack(&sf);#else		sym_init();		// note: unfortunately StackWalk64 doesn't always SetLastError,		// so we have to reset it and check for 0. *sigh*		SetLastError(0);		const HANDLE hThread = GetCurrentThread();		BOOL ok = StackWalk64(machine, hProcess, hThread, &sf, (PVOID)pcontext,			0, SymFunctionTableAccess64, SymGetModuleBase64, 0);		// note: don't use LibError_from_win32 because it raises a warning,		// and this "fails" commonly (when no stack frames are left).		err = ok? INFO::OK : ERR::FAIL;#endif		// no more frames found - abort. note: also test FP because		// StackWalk64 sometimes erroneously reports success.		void* fp = (void*)(uintptr_t)sf.AddrFrame.Offset;		if(err != INFO::OK || !fp)			return ret;		if(skip)		{			skip--;			continue;		}		ret = cb(&sf, user_arg);		// callback is allowing us to continue		if(ret == INFO::CB_CONTINUE)			ret = INFO::OK;	//  make sure this is never returned		// callback reports it's done; stop calling it and return that value.		// (can be either success or failure)		else		{			debug_assert(ret <= 0);	// shouldn't return > 0			return ret;		}	}}