stack.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "dbghelp_private.h"
#include "wine/debug.h"

Include dependency graph for stack.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dbghelp)
static DWORD64 WINAPI	addr_to_linear (HANDLE hProcess, HANDLE hThread, ADDRESS64 *addr)
static BOOL CALLBACK	read_mem (HANDLE hProcess, DWORD addr, void *buffer, DWORD size, LPDWORD nread)
static BOOL CALLBACK	read_mem64 (HANDLE hProcess, DWORD64 addr, void *buffer, DWORD size, LPDWORD nread)
static void	addr_32to64 (const ADDRESS *addr32, ADDRESS64 *addr64)
static void	addr_64to32 (const ADDRESS64 *addr64, ADDRESS *addr32)
BOOL	sw_read_mem (struct cpu_stack_walk *csw, DWORD64 addr, void *ptr, DWORD sz)
DWORD64	sw_xlat_addr (struct cpu_stack_walk *csw, ADDRESS64 *addr)
void *	sw_table_access (struct cpu_stack_walk *csw, DWORD64 addr)
DWORD64	sw_module_base (struct cpu_stack_walk *csw, DWORD64 addr)
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)
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)
BOOL WINAPI	SymRegisterFunctionEntryCallback (HANDLE hProc, PSYMBOL_FUNCENTRY_CALLBACK cb, PVOID user)
BOOL WINAPI	SymRegisterFunctionEntryCallback64 (HANDLE hProc, PSYMBOL_FUNCENTRY_CALLBACK64 cb, ULONG64 user)

Function Documentation

addr_32to64()

static void addr_32to64 ( const ADDRESS *  addr32, ADDRESS64 *  addr64  )

inlinestatic

Definition at line 81 of file stack.c.

{
    addr64->Offset = (ULONG64)addr32->Offset;
    addr64->Segment = addr32->Segment;
    addr64->Mode = addr32->Mode;
}

Referenced by StackWalk().

addr_64to32()

static void addr_64to32 ( const ADDRESS64 *  addr64, ADDRESS *  addr32  )

inlinestatic

Definition at line 88 of file stack.c.

{
    addr32->Offset = (ULONG)addr64->Offset;
    addr32->Segment = addr64->Segment;
    addr32->Mode = addr64->Mode;
}

Referenced by StackWalk(), and sw_xlat_addr().

addr_to_linear()

static DWORD64 WINAPI addr_to_linear ( HANDLE  hProcess, HANDLE  hThread, ADDRESS64 *  addr  )

static

Definition at line 34 of file stack.c.

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

Referenced by StackWalk64(), and sw_xlat_addr().

read_mem()

static BOOL CALLBACK read_mem ( HANDLE  hProcess, DWORD  addr, void *  buffer, DWORD  size, LPDWORD  nread  )

static

Definition at line 63 of file stack.c.

{
    SIZE_T      r;
    if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE;
    if (nread) *nread = r;
    return TRUE;
}

Referenced by StackWalk().

read_mem64()

static BOOL CALLBACK read_mem64 ( HANDLE  hProcess, DWORD64  addr, void *  buffer, DWORD  size, LPDWORD  nread  )

static

Definition at line 72 of file stack.c.

{
    SIZE_T      r;
    if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE;
    if (nread) *nread = r;
    return TRUE;
}

Referenced by StackWalk64().

StackWalk()

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
	)

Definition at line 138 of file stack.c.

{
    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()

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
	)

Definition at line 210 of file stack.c.

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

Referenced by PrintStackBacktrace().

sw_module_base()

DWORD64 sw_module_base	(	struct cpu_stack_walk *	csw,
		DWORD64	addr
	)

Definition at line 127 of file stack.c.

{
    if (csw->is32)
        return csw->u.s32.f_modl_bas(csw->hProcess, addr);
    else
        return csw->u.s64.f_modl_bas(csw->hProcess, addr);
}

Referenced by i386_stack_walk().

sw_read_mem()

BOOL sw_read_mem	(	struct cpu_stack_walk *	csw,
		DWORD64	addr,
		void *	ptr,
		DWORD	sz
	)

Definition at line 95 of file stack.c.

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

Referenced by apply_frame_state(), eval_expression(), fetch_next_frame32(), i386_stack_walk(), pev_deref(), and set_context_reg().

sw_table_access()

void * sw_table_access	(	struct cpu_stack_walk *	csw,
		DWORD64	addr
	)

Definition at line 119 of file stack.c.

{
    if (csw->is32)
        return csw->u.s32.f_tabl_acs(csw->hProcess, addr);
    else
        return csw->u.s64.f_tabl_acs(csw->hProcess, addr);
}

Referenced by i386_stack_walk().

sw_xlat_addr()

DWORD64 sw_xlat_addr	(	struct cpu_stack_walk *	csw,
		ADDRESS64 *	addr
	)

Definition at line 104 of file stack.c.

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

Referenced by i386_stack_walk().

SymRegisterFunctionEntryCallback()

BOOL WINAPI SymRegisterFunctionEntryCallback	(	HANDLE	hProc,
		PSYMBOL_FUNCENTRY_CALLBACK	cb,
		PVOID	user
	)

Definition at line 253 of file stack.c.

{
    FIXME("(%p %p %p): stub!\n", hProc, cb, user);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

SymRegisterFunctionEntryCallback64()

BOOL WINAPI SymRegisterFunctionEntryCallback64	(	HANDLE	hProc,
		PSYMBOL_FUNCENTRY_CALLBACK64	cb,
		ULONG64	user
	)

Definition at line 266 of file stack.c.

{
    FIXME("(%p %p %s): stub!\n", hProc, cb, wine_dbgstr_longlong(user));
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dbghelp

)