stack.c 9.44 KB
Newer Older
1 2 3 4 5
/*
 * Stack walking
 *
 * Copyright 1995 Alexandre Julliard
 * Copyright 1996 Eric Youngdale
6
 * Copyright 1999 Ove Kåven
7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * 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
21
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 23 24 25 26 27 28 29 30 31 32 33 34
 */

#include "config.h"
#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);

35
static DWORD64 WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS64* addr)
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
{
    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;
    }
59 60
    FIXME("Failed to linearize address %04x:%s (mode %x)\n",
          addr->Segment, wine_dbgstr_longlong(addr->Offset), addr->Mode);
61 62 63
    return 0;
}

64 65 66
static BOOL CALLBACK read_mem(HANDLE hProcess, DWORD addr, void* buffer,
                              DWORD size, LPDWORD nread)
{
67
    SIZE_T      r;
68
    if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE;
69
    if (nread) *nread = r;
70
    return TRUE;
71 72
}

73 74 75
static BOOL CALLBACK read_mem64(HANDLE hProcess, DWORD64 addr, void* buffer,
                                DWORD size, LPDWORD nread)
{
76 77
    SIZE_T      r;
    if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE;
78
    if (nread) *nread = r;
79
    return TRUE;
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
}

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;
}

96
BOOL sw_read_mem(struct cpu_stack_walk* csw, DWORD64 addr, void* ptr, DWORD sz)
97
{
98
    DWORD bytes_read = 0;
99
    if (csw->is32)
100
        return csw->u.s32.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read);
101
    else
102
        return csw->u.s64.f_read_mem(csw->hProcess, addr, ptr, sz, &bytes_read);
103 104
}

105
DWORD64 sw_xlat_addr(struct cpu_stack_walk* csw, ADDRESS64* addr)
106
{
107
    if (addr->Mode == AddrModeFlat) return addr->Offset;
108
    if (csw->is32)
109
    {
110
        ADDRESS         addr32;
111

112
        addr_64to32(addr, &addr32);
113
        return csw->u.s32.f_xlat_adr(csw->hProcess, csw->hThread, &addr32);
114
    }
115 116 117
    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);
118 119
}

120
void* sw_table_access(struct cpu_stack_walk* csw, DWORD64 addr)
121
{
122 123
    if (csw->is32)
        return csw->u.s32.f_tabl_acs(csw->hProcess, addr);
124
    else
125
        return csw->u.s64.f_tabl_acs(csw->hProcess, addr);
126 127
}

128
DWORD64 sw_module_base(struct cpu_stack_walk* csw, DWORD64 addr)
129
{
130 131
    if (csw->is32)
        return csw->u.s32.f_modl_bas(csw->hProcess, addr);
132
    else
133
        return csw->u.s64.f_modl_bas(csw->hProcess, addr);
134
}
135

136 137 138 139
/***********************************************************************
 *		StackWalk (DBGHELP.@)
 */
BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
140
                      LPSTACKFRAME frame32, PVOID ctx,
141 142 143 144 145
                      PREAD_PROCESS_MEMORY_ROUTINE f_read_mem,
                      PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
                      PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
                      PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr)
{
146
    struct cpu_stack_walk       csw;
147 148
    STACKFRAME64                frame64;
    BOOL                        ret;
149
    struct cpu*                 cpu;
150

151
    TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n",
152
          MachineType, hProcess, hThread, frame32, ctx,
153 154 155
          f_read_mem, FunctionTableAccessRoutine,
          GetModuleBaseRoutine, f_xlat_adr);

156
    if (!(cpu = cpu_find(MachineType)))
157 158 159 160 161
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

162 163 164 165 166 167 168 169 170 171 172 173 174
    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 */

175 176 177
    csw.hProcess = hProcess;
    csw.hThread = hThread;
    csw.is32 = TRUE;
178
    csw.cpu = cpu;
179
    /* sigh... MS isn't even consistent in the func prototypes */
180 181 182 183
    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;
184

185
    if ((ret = cpu->stack_walk(&csw, &frame64, ctx)))
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
    {
        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];
    }
203 204

    return ret;
205 206 207
}


Vitaliy Margolen's avatar
Vitaliy Margolen committed
208 209 210 211
/***********************************************************************
 *		StackWalk64 (DBGHELP.@)
 */
BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
212
                        LPSTACKFRAME64 frame, PVOID ctx,
Vitaliy Margolen's avatar
Vitaliy Margolen committed
213 214 215 216 217
                        PREAD_PROCESS_MEMORY_ROUTINE64 f_read_mem,
                        PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
                        PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
                        PTRANSLATE_ADDRESS_ROUTINE64 f_xlat_adr)
{
218 219
    struct cpu_stack_walk       csw;
    struct cpu*                 cpu;
220

221
    TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n",
222
          MachineType, hProcess, hThread, frame, ctx,
Vitaliy Margolen's avatar
Vitaliy Margolen committed
223 224
          f_read_mem, FunctionTableAccessRoutine,
          GetModuleBaseRoutine, f_xlat_adr);
225

226
    if (!(cpu = cpu_find(MachineType)))
227 228 229 230 231
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

232 233 234
    csw.hProcess = hProcess;
    csw.hThread = hThread;
    csw.is32 = FALSE;
235
    csw.cpu = cpu;
236
    /* sigh... MS isn't even consistent in the func prototypes */
237 238 239 240
    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;
241

242
    if (!cpu->stack_walk(&csw, frame, ctx)) return FALSE;
243

244 245
    /* we don't handle KdHelp */

246
    return TRUE;
Vitaliy Margolen's avatar
Vitaliy Margolen committed
247 248
}

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
/******************************************************************
 *		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;
}