Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274/* * Stack walking * * Copyright 1995 Alexandre Julliard * Copyright 1996 Eric Youngdale * Copyright 1999 Ove Kåven * Copyright 2004 Eric Pouech * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
#include <stdlib.h>#include <stdio.h>#include <string.h>#include <assert.h>
#include "dbghelp_private.h"#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
static DWORD64 WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS64* addr){ LDT_ENTRY le;
switch (addr->Mode) { case AddrMode1616: if (GetThreadSelectorEntry(hThread, addr->Segment, &le)) return (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + LOWORD(addr->Offset); break; case AddrMode1632: if (GetThreadSelectorEntry(hThread, addr->Segment, &le)) return (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + addr->Offset; break; case AddrModeReal: return (DWORD)(LOWORD(addr->Segment) << 4) + addr->Offset; case AddrModeFlat: return addr->Offset; default: FIXME("Unsupported (yet) mode (%x)\n", addr->Mode); return 0; } FIXME("Failed to linearize address %04x:%s (mode %x)\n", addr->Segment, wine_dbgstr_longlong(addr->Offset), addr->Mode); return 0;}
static BOOL CALLBACK read_mem(HANDLE hProcess, DWORD addr, void* buffer, DWORD size, LPDWORD nread){ SIZE_T r; if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE; if (nread) *nread = r; return TRUE;}
static BOOL CALLBACK read_mem64(HANDLE hProcess, DWORD64 addr, void* buffer, DWORD size, LPDWORD nread){ SIZE_T r; if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE; if (nread) *nread = r; return TRUE;}
static inline void addr_32to64(const ADDRESS* addr32, ADDRESS64* addr64){ addr64->Offset = (ULONG64)addr32->Offset; addr64->Segment = addr32->Segment; addr64->Mode = addr32->Mode;}
static inline void addr_64to32(const ADDRESS64* addr64, ADDRESS* addr32){ addr32->Offset = (ULONG)addr64->Offset; addr32->Segment = addr64->Segment; addr32->Mode = addr64->Mode;}
BOOL sw_read_mem(struct cpu_stack_walk* csw, DWORD64 addr, void* ptr, DWORD sz){ DWORD bytes_read = 0; if (csw->is32) return csw->u.s32.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read); else return csw->u.s64.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read);}
DWORD64 sw_xlat_addr(struct cpu_stack_walk* csw, ADDRESS64* addr){ if (addr->Mode == AddrModeFlat) return addr->Offset; if (csw->is32) { ADDRESS addr32;
addr_64to32(addr, &addr32); return csw->u.s32.f_xlat_adr(csw->hProcess, csw->hThread, &addr32); } else if (csw->u.s64.f_xlat_adr) return csw->u.s64.f_xlat_adr(csw->hProcess, csw->hThread, addr); return addr_to_linear(csw->hProcess, csw->hThread, addr);}
void* sw_table_access(struct cpu_stack_walk* csw, DWORD64 addr){ if (csw->is32) return csw->u.s32.f_tabl_acs(csw->hProcess, addr); else return csw->u.s64.f_tabl_acs(csw->hProcess, addr);}
DWORD64 sw_module_base(struct cpu_stack_walk* csw, DWORD64 addr){ if (csw->is32) return csw->u.s32.f_modl_bas(csw->hProcess, addr); else return csw->u.s64.f_modl_bas(csw->hProcess, addr);}
/*********************************************************************** * StackWalk (DBGHELP.@) */BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME frame32, PVOID ctx, PREAD_PROCESS_MEMORY_ROUTINE f_read_mem, PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr){ struct cpu_stack_walk csw; STACKFRAME64 frame64; BOOL ret; struct cpu* cpu;
TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n", MachineType, hProcess, hThread, frame32, ctx, f_read_mem, FunctionTableAccessRoutine, GetModuleBaseRoutine, f_xlat_adr);
if (!(cpu = cpu_find(MachineType))) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
addr_32to64(&frame32->AddrPC, &frame64.AddrPC); addr_32to64(&frame32->AddrReturn, &frame64.AddrReturn); addr_32to64(&frame32->AddrFrame, &frame64.AddrFrame); addr_32to64(&frame32->AddrStack, &frame64.AddrStack); addr_32to64(&frame32->AddrBStore, &frame64.AddrBStore); frame64.FuncTableEntry = frame32->FuncTableEntry; /* FIXME */ frame64.Far = frame32->Far; frame64.Virtual = frame32->Virtual; frame64.Reserved[0] = frame32->Reserved[0]; frame64.Reserved[1] = frame32->Reserved[1]; frame64.Reserved[2] = frame32->Reserved[2]; /* we don't handle KdHelp */
csw.hProcess = hProcess; csw.hThread = hThread; csw.is32 = TRUE; csw.cpu = cpu; /* sigh... MS isn't even consistent in the func prototypes */ csw.u.s32.f_read_mem = (f_read_mem) ? f_read_mem : read_mem; csw.u.s32.f_xlat_adr = f_xlat_adr; csw.u.s32.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess; csw.u.s32.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase;
if ((ret = cpu->stack_walk(&csw, &frame64, ctx))) { addr_64to32(&frame64.AddrPC, &frame32->AddrPC); addr_64to32(&frame64.AddrReturn, &frame32->AddrReturn); addr_64to32(&frame64.AddrFrame, &frame32->AddrFrame); addr_64to32(&frame64.AddrStack, &frame32->AddrStack); addr_64to32(&frame64.AddrBStore, &frame32->AddrBStore); frame32->FuncTableEntry = frame64.FuncTableEntry; /* FIXME */ frame32->Params[0] = frame64.Params[0]; frame32->Params[1] = frame64.Params[1]; frame32->Params[2] = frame64.Params[2]; frame32->Params[3] = frame64.Params[3]; frame32->Far = frame64.Far; frame32->Virtual = frame64.Virtual; frame32->Reserved[0] = frame64.Reserved[0]; frame32->Reserved[1] = frame64.Reserved[1]; frame32->Reserved[2] = frame64.Reserved[2]; }
return ret;}
/*********************************************************************** * StackWalk64 (DBGHELP.@) */BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 frame, PVOID ctx, PREAD_PROCESS_MEMORY_ROUTINE64 f_read_mem, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 f_xlat_adr){ struct cpu_stack_walk csw; struct cpu* cpu;
TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n", MachineType, hProcess, hThread, frame, ctx, f_read_mem, FunctionTableAccessRoutine, GetModuleBaseRoutine, f_xlat_adr);
if (!(cpu = cpu_find(MachineType))) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
csw.hProcess = hProcess; csw.hThread = hThread; csw.is32 = FALSE; csw.cpu = cpu; /* sigh... MS isn't even consistent in the func prototypes */ csw.u.s64.f_read_mem = (f_read_mem) ? f_read_mem : read_mem64; csw.u.s64.f_xlat_adr = (f_xlat_adr) ? f_xlat_adr : addr_to_linear; csw.u.s64.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess64; csw.u.s64.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase64;
if (!cpu->stack_walk(&csw, frame, ctx)) return FALSE;
/* we don't handle KdHelp */
return TRUE;}
/****************************************************************** * SymRegisterFunctionEntryCallback (DBGHELP.@) * * */BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE hProc, PSYMBOL_FUNCENTRY_CALLBACK cb, PVOID user){ FIXME("(%p %p %p): stub!\n", hProc, cb, user); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE;}
/****************************************************************** * SymRegisterFunctionEntryCallback64 (DBGHELP.@) * * */BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE hProc, PSYMBOL_FUNCENTRY_CALLBACK64 cb, ULONG64 user){ FIXME("(%p %p %s): stub!\n", hProc, cb, wine_dbgstr_longlong(user)); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE;}