1 /* 2 * Stack walking 3 * 4 * Copyright 1995 Alexandre Julliard 5 * Copyright 1996 Eric Youngdale 6 * Copyright 1999 Ove Kåven 7 * Copyright 2004 Eric Pouech 8 * 9 * This library is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * This library is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with this library; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 22 */ 23 24 #include <stdlib.h> 25 #include <stdio.h> 26 #include <string.h> 27 #include <assert.h> 28 29 #include "dbghelp_private.h" 30 #include "wine/debug.h" 31 32 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); 33 34 static DWORD64 WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS64* addr) 35 { 36 LDT_ENTRY le; 37 38 switch (addr->Mode) 39 { 40 case AddrMode1616: 41 if (GetThreadSelectorEntry(hThread, addr->Segment, &le)) 42 return (le.HighWord.Bits.BaseHi << 24) + 43 (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + LOWORD(addr->Offset); 44 break; 45 case AddrMode1632: 46 if (GetThreadSelectorEntry(hThread, addr->Segment, &le)) 47 return (le.HighWord.Bits.BaseHi << 24) + 48 (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + addr->Offset; 49 break; 50 case AddrModeReal: 51 return (DWORD)(LOWORD(addr->Segment) << 4) + addr->Offset; 52 case AddrModeFlat: 53 return addr->Offset; 54 default: 55 FIXME("Unsupported (yet) mode (%x)\n", addr->Mode); 56 return 0; 57 } 58 FIXME("Failed to linearize address %04x:%s (mode %x)\n", 59 addr->Segment, wine_dbgstr_longlong(addr->Offset), addr->Mode); 60 return 0; 61 } 62 63 static BOOL CALLBACK read_mem(HANDLE hProcess, DWORD addr, void* buffer, 64 DWORD size, LPDWORD nread) 65 { 66 SIZE_T r; 67 if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE; 68 if (nread) *nread = r; 69 return TRUE; 70 } 71 72 static BOOL CALLBACK read_mem64(HANDLE hProcess, DWORD64 addr, void* buffer, 73 DWORD size, LPDWORD nread) 74 { 75 SIZE_T r; 76 if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE; 77 if (nread) *nread = r; 78 return TRUE; 79 } 80 81 static inline void addr_32to64(const ADDRESS* addr32, ADDRESS64* addr64) 82 { 83 addr64->Offset = (ULONG64)addr32->Offset; 84 addr64->Segment = addr32->Segment; 85 addr64->Mode = addr32->Mode; 86 } 87 88 static inline void addr_64to32(const ADDRESS64* addr64, ADDRESS* addr32) 89 { 90 addr32->Offset = (ULONG)addr64->Offset; 91 addr32->Segment = addr64->Segment; 92 addr32->Mode = addr64->Mode; 93 } 94 95 BOOL sw_read_mem(struct cpu_stack_walk* csw, DWORD64 addr, void* ptr, DWORD sz) 96 { 97 DWORD bytes_read = 0; 98 if (csw->is32) 99 return csw->u.s32.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read); 100 else 101 return csw->u.s64.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read); 102 } 103 104 DWORD64 sw_xlat_addr(struct cpu_stack_walk* csw, ADDRESS64* addr) 105 { 106 if (addr->Mode == AddrModeFlat) return addr->Offset; 107 if (csw->is32) 108 { 109 ADDRESS addr32; 110 111 addr_64to32(addr, &addr32); 112 return csw->u.s32.f_xlat_adr(csw->hProcess, csw->hThread, &addr32); 113 } 114 else if (csw->u.s64.f_xlat_adr) 115 return csw->u.s64.f_xlat_adr(csw->hProcess, csw->hThread, addr); 116 return addr_to_linear(csw->hProcess, csw->hThread, addr); 117 } 118 119 void* sw_table_access(struct cpu_stack_walk* csw, DWORD64 addr) 120 { 121 if (csw->is32) 122 return csw->u.s32.f_tabl_acs(csw->hProcess, addr); 123 else 124 return csw->u.s64.f_tabl_acs(csw->hProcess, addr); 125 } 126 127 DWORD64 sw_module_base(struct cpu_stack_walk* csw, DWORD64 addr) 128 { 129 if (csw->is32) 130 return csw->u.s32.f_modl_bas(csw->hProcess, addr); 131 else 132 return csw->u.s64.f_modl_bas(csw->hProcess, addr); 133 } 134 135 /*********************************************************************** 136 * StackWalk (DBGHELP.@) 137 */ 138 BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, 139 LPSTACKFRAME frame32, PVOID ctx, 140 PREAD_PROCESS_MEMORY_ROUTINE f_read_mem, 141 PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, 142 PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, 143 PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr) 144 { 145 struct cpu_stack_walk csw; 146 STACKFRAME64 frame64; 147 BOOL ret; 148 struct cpu* cpu; 149 150 TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n", 151 MachineType, hProcess, hThread, frame32, ctx, 152 f_read_mem, FunctionTableAccessRoutine, 153 GetModuleBaseRoutine, f_xlat_adr); 154 155 if (!(cpu = cpu_find(MachineType))) 156 { 157 SetLastError(ERROR_INVALID_PARAMETER); 158 return FALSE; 159 } 160 161 addr_32to64(&frame32->AddrPC, &frame64.AddrPC); 162 addr_32to64(&frame32->AddrReturn, &frame64.AddrReturn); 163 addr_32to64(&frame32->AddrFrame, &frame64.AddrFrame); 164 addr_32to64(&frame32->AddrStack, &frame64.AddrStack); 165 addr_32to64(&frame32->AddrBStore, &frame64.AddrBStore); 166 frame64.FuncTableEntry = frame32->FuncTableEntry; /* FIXME */ 167 frame64.Far = frame32->Far; 168 frame64.Virtual = frame32->Virtual; 169 frame64.Reserved[0] = frame32->Reserved[0]; 170 frame64.Reserved[1] = frame32->Reserved[1]; 171 frame64.Reserved[2] = frame32->Reserved[2]; 172 /* we don't handle KdHelp */ 173 174 csw.hProcess = hProcess; 175 csw.hThread = hThread; 176 csw.is32 = TRUE; 177 csw.cpu = cpu; 178 /* sigh... MS isn't even consistent in the func prototypes */ 179 csw.u.s32.f_read_mem = (f_read_mem) ? f_read_mem : read_mem; 180 csw.u.s32.f_xlat_adr = f_xlat_adr; 181 csw.u.s32.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess; 182 csw.u.s32.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase; 183 184 if ((ret = cpu->stack_walk(&csw, &frame64, ctx))) 185 { 186 addr_64to32(&frame64.AddrPC, &frame32->AddrPC); 187 addr_64to32(&frame64.AddrReturn, &frame32->AddrReturn); 188 addr_64to32(&frame64.AddrFrame, &frame32->AddrFrame); 189 addr_64to32(&frame64.AddrStack, &frame32->AddrStack); 190 addr_64to32(&frame64.AddrBStore, &frame32->AddrBStore); 191 frame32->FuncTableEntry = frame64.FuncTableEntry; /* FIXME */ 192 frame32->Params[0] = frame64.Params[0]; 193 frame32->Params[1] = frame64.Params[1]; 194 frame32->Params[2] = frame64.Params[2]; 195 frame32->Params[3] = frame64.Params[3]; 196 frame32->Far = frame64.Far; 197 frame32->Virtual = frame64.Virtual; 198 frame32->Reserved[0] = frame64.Reserved[0]; 199 frame32->Reserved[1] = frame64.Reserved[1]; 200 frame32->Reserved[2] = frame64.Reserved[2]; 201 } 202 203 return ret; 204 } 205 206 207 /*********************************************************************** 208 * StackWalk64 (DBGHELP.@) 209 */ 210 BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread, 211 LPSTACKFRAME64 frame, PVOID ctx, 212 PREAD_PROCESS_MEMORY_ROUTINE64 f_read_mem, 213 PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, 214 PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, 215 PTRANSLATE_ADDRESS_ROUTINE64 f_xlat_adr) 216 { 217 struct cpu_stack_walk csw; 218 struct cpu* cpu; 219 220 TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n", 221 MachineType, hProcess, hThread, frame, ctx, 222 f_read_mem, FunctionTableAccessRoutine, 223 GetModuleBaseRoutine, f_xlat_adr); 224 225 if (!(cpu = cpu_find(MachineType))) 226 { 227 SetLastError(ERROR_INVALID_PARAMETER); 228 return FALSE; 229 } 230 231 csw.hProcess = hProcess; 232 csw.hThread = hThread; 233 csw.is32 = FALSE; 234 csw.cpu = cpu; 235 /* sigh... MS isn't even consistent in the func prototypes */ 236 csw.u.s64.f_read_mem = (f_read_mem) ? f_read_mem : read_mem64; 237 csw.u.s64.f_xlat_adr = (f_xlat_adr) ? f_xlat_adr : addr_to_linear; 238 csw.u.s64.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess64; 239 csw.u.s64.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase64; 240 241 if (!cpu->stack_walk(&csw, frame, ctx)) return FALSE; 242 243 /* we don't handle KdHelp */ 244 245 return TRUE; 246 } 247 248 /****************************************************************** 249 * SymRegisterFunctionEntryCallback (DBGHELP.@) 250 * 251 * 252 */ 253 BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE hProc, 254 PSYMBOL_FUNCENTRY_CALLBACK cb, PVOID user) 255 { 256 FIXME("(%p %p %p): stub!\n", hProc, cb, user); 257 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 258 return FALSE; 259 } 260 261 /****************************************************************** 262 * SymRegisterFunctionEntryCallback64 (DBGHELP.@) 263 * 264 * 265 */ 266 BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE hProc, 267 PSYMBOL_FUNCENTRY_CALLBACK64 cb, 268 ULONG64 user) 269 { 270 FIXME("(%p %p %s): stub!\n", hProc, cb, wine_dbgstr_longlong(user)); 271 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 272 return FALSE; 273 } 274