ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

winedbg: Fix a number of 64-bit pointer truncation issues.

This commit is contained in:
Alexandre Julliard 2009-12-10 15:23:45 +01:00
parent 0f0d92bf13
commit ec73f0b71a
15 changed files with 151 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
programs/winedbg/be_i386.c
View File

@ -253,40 +253,40 @@ static void be_i386_print_segment_info(HANDLE hThread, const CONTEXT* ctx)
static struct dbg_internal_var be_i386_ctx[] =
{
{CV_REG_AL, "AL", (DWORD*)FIELD_OFFSET(CONTEXT, Eax), dbg_itype_unsigned_char_int},
{CV_REG_CL, "CL", (DWORD*)FIELD_OFFSET(CONTEXT, Ecx), dbg_itype_unsigned_char_int},
{CV_REG_DL, "DL", (DWORD*)FIELD_OFFSET(CONTEXT, Edx), dbg_itype_unsigned_char_int},
{CV_REG_BL, "BL", (DWORD*)FIELD_OFFSET(CONTEXT, Ebx), dbg_itype_unsigned_char_int},
{CV_REG_AH, "AH", (DWORD*)(FIELD_OFFSET(CONTEXT, Eax)+1), dbg_itype_unsigned_char_int},
{CV_REG_CH, "CH", (DWORD*)(FIELD_OFFSET(CONTEXT, Ecx)+1), dbg_itype_unsigned_char_int},
{CV_REG_DH, "DH", (DWORD*)(FIELD_OFFSET(CONTEXT, Edx)+1), dbg_itype_unsigned_char_int},
{CV_REG_BH, "BH", (DWORD*)(FIELD_OFFSET(CONTEXT, Ebx)+1), dbg_itype_unsigned_char_int},
{CV_REG_AX, "AX", (DWORD*)FIELD_OFFSET(CONTEXT, Eax), dbg_itype_unsigned_short_int},
{CV_REG_CX, "CX", (DWORD*)FIELD_OFFSET(CONTEXT, Ecx), dbg_itype_unsigned_short_int},
{CV_REG_DX, "DX", (DWORD*)FIELD_OFFSET(CONTEXT, Edx), dbg_itype_unsigned_short_int},
{CV_REG_BX, "BX", (DWORD*)FIELD_OFFSET(CONTEXT, Ebx), dbg_itype_unsigned_short_int},
{CV_REG_SP, "SP", (DWORD*)FIELD_OFFSET(CONTEXT, Esp), dbg_itype_unsigned_short_int},
{CV_REG_BP, "BP", (DWORD*)FIELD_OFFSET(CONTEXT, Ebp), dbg_itype_unsigned_short_int},
{CV_REG_SI, "SI", (DWORD*)FIELD_OFFSET(CONTEXT, Esi), dbg_itype_unsigned_short_int},
{CV_REG_DI, "DI", (DWORD*)FIELD_OFFSET(CONTEXT, Edi), dbg_itype_unsigned_short_int},
{CV_REG_EAX, "EAX", (DWORD*)FIELD_OFFSET(CONTEXT, Eax), dbg_itype_unsigned_int},
{CV_REG_ECX, "ECX", (DWORD*)FIELD_OFFSET(CONTEXT, Ecx), dbg_itype_unsigned_int},
{CV_REG_EDX, "EDX", (DWORD*)FIELD_OFFSET(CONTEXT, Edx), dbg_itype_unsigned_int},
{CV_REG_EBX, "EBX", (DWORD*)FIELD_OFFSET(CONTEXT, Ebx), dbg_itype_unsigned_int},
{CV_REG_ESP, "ESP", (DWORD*)FIELD_OFFSET(CONTEXT, Esp), dbg_itype_unsigned_int},
{CV_REG_EBP, "EBP", (DWORD*)FIELD_OFFSET(CONTEXT, Ebp), dbg_itype_unsigned_int},
{CV_REG_ESI, "ESI", (DWORD*)FIELD_OFFSET(CONTEXT, Esi), dbg_itype_unsigned_int},
{CV_REG_EDI, "EDI", (DWORD*)FIELD_OFFSET(CONTEXT, Edi), dbg_itype_unsigned_int},
{CV_REG_ES, "ES", (DWORD*)FIELD_OFFSET(CONTEXT, SegEs), dbg_itype_unsigned_short_int},
{CV_REG_CS, "CS", (DWORD*)FIELD_OFFSET(CONTEXT, SegCs), dbg_itype_unsigned_short_int},
{CV_REG_SS, "SS", (DWORD*)FIELD_OFFSET(CONTEXT, SegSs), dbg_itype_unsigned_short_int},
{CV_REG_DS, "DS", (DWORD*)FIELD_OFFSET(CONTEXT, SegDs), dbg_itype_unsigned_short_int},
{CV_REG_FS, "FS", (DWORD*)FIELD_OFFSET(CONTEXT, SegFs), dbg_itype_unsigned_short_int},
{CV_REG_GS, "GS", (DWORD*)FIELD_OFFSET(CONTEXT, SegGs), dbg_itype_unsigned_short_int},
{CV_REG_IP, "IP", (DWORD*)FIELD_OFFSET(CONTEXT, Eip), dbg_itype_unsigned_short_int},
{CV_REG_FLAGS, "FLAGS", (DWORD*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_short_int},
{CV_REG_EIP, "EIP", (DWORD*)FIELD_OFFSET(CONTEXT, Eip), dbg_itype_unsigned_int},
{CV_REG_EFLAGS, "EFLAGS", (DWORD*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_int},
{CV_REG_AL, "AL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Eax), dbg_itype_unsigned_char_int},
{CV_REG_CL, "CL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ecx), dbg_itype_unsigned_char_int},
{CV_REG_DL, "DL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Edx), dbg_itype_unsigned_char_int},
{CV_REG_BL, "BL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ebx), dbg_itype_unsigned_char_int},
{CV_REG_AH, "AH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Eax)+1), dbg_itype_unsigned_char_int},
{CV_REG_CH, "CH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Ecx)+1), dbg_itype_unsigned_char_int},
{CV_REG_DH, "DH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Edx)+1), dbg_itype_unsigned_char_int},
{CV_REG_BH, "BH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Ebx)+1), dbg_itype_unsigned_char_int},
{CV_REG_AX, "AX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Eax), dbg_itype_unsigned_short_int},
{CV_REG_CX, "CX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ecx), dbg_itype_unsigned_short_int},
{CV_REG_DX, "DX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Edx), dbg_itype_unsigned_short_int},
{CV_REG_BX, "BX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ebx), dbg_itype_unsigned_short_int},
{CV_REG_SP, "SP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Esp), dbg_itype_unsigned_short_int},
{CV_REG_BP, "BP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ebp), dbg_itype_unsigned_short_int},
{CV_REG_SI, "SI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Esi), dbg_itype_unsigned_short_int},
{CV_REG_DI, "DI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Edi), dbg_itype_unsigned_short_int},
{CV_REG_EAX, "EAX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Eax), dbg_itype_unsigned_int},
{CV_REG_ECX, "ECX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ecx), dbg_itype_unsigned_int},
{CV_REG_EDX, "EDX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Edx), dbg_itype_unsigned_int},
{CV_REG_EBX, "EBX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ebx), dbg_itype_unsigned_int},
{CV_REG_ESP, "ESP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Esp), dbg_itype_unsigned_int},
{CV_REG_EBP, "EBP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Ebp), dbg_itype_unsigned_int},
{CV_REG_ESI, "ESI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Esi), dbg_itype_unsigned_int},
{CV_REG_EDI, "EDI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Edi), dbg_itype_unsigned_int},
{CV_REG_ES, "ES", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegEs), dbg_itype_unsigned_short_int},
{CV_REG_CS, "CS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegCs), dbg_itype_unsigned_short_int},
{CV_REG_SS, "SS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegSs), dbg_itype_unsigned_short_int},
{CV_REG_DS, "DS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegDs), dbg_itype_unsigned_short_int},
{CV_REG_FS, "FS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegFs), dbg_itype_unsigned_short_int},
{CV_REG_GS, "GS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegGs), dbg_itype_unsigned_short_int},
{CV_REG_IP, "IP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Eip), dbg_itype_unsigned_short_int},
{CV_REG_FLAGS, "FLAGS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_short_int},
{CV_REG_EIP, "EIP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Eip), dbg_itype_unsigned_int},
{CV_REG_EFLAGS, "EFLAGS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_int},
{0, NULL, 0, dbg_itype_none}
};
@ -295,7 +295,7 @@ static const struct dbg_internal_var* be_i386_init_registers(CONTEXT* ctx)
struct dbg_internal_var* div;
for (div = be_i386_ctx; div->name; div++)
div->pval = (DWORD*)((char*)ctx + (DWORD)div->pval);
div->pval = (DWORD_PTR*)((char*)ctx + (DWORD)div->pval);
return be_i386_ctx;
}

100
programs/winedbg/be_x86_64.c
View File

@ -97,55 +97,55 @@ static void be_x86_64_print_segment_info(HANDLE hThread, const CONTEXT* ctx)
static struct dbg_internal_var be_x86_64_ctx[] =
{
{CV_AMD64_AL, "AL", (DWORD*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_char_int},
{CV_AMD64_BL, "BL", (DWORD*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_char_int},
{CV_AMD64_CL, "CL", (DWORD*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_char_int},
{CV_AMD64_DL, "DL", (DWORD*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_char_int},
{CV_AMD64_AH, "AH", (DWORD*)(FIELD_OFFSET(CONTEXT, Rax)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_BH, "BH", (DWORD*)(FIELD_OFFSET(CONTEXT, Rbx)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_CH, "CH", (DWORD*)(FIELD_OFFSET(CONTEXT, Rcx)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_DH, "DH", (DWORD*)(FIELD_OFFSET(CONTEXT, Rdx)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_AX, "AX", (DWORD*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_short_int},
{CV_AMD64_BX, "BX", (DWORD*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_short_int},
{CV_AMD64_CX, "CX", (DWORD*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_short_int},
{CV_AMD64_DX, "DX", (DWORD*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_short_int},
{CV_AMD64_SP, "SP", (DWORD*)FIELD_OFFSET(CONTEXT, Rsp), dbg_itype_unsigned_short_int},
{CV_AMD64_BP, "BP", (DWORD*)FIELD_OFFSET(CONTEXT, Rbp), dbg_itype_unsigned_short_int},
{CV_AMD64_SI, "SI", (DWORD*)FIELD_OFFSET(CONTEXT, Rsi), dbg_itype_unsigned_short_int},
{CV_AMD64_DI, "DI", (DWORD*)FIELD_OFFSET(CONTEXT, Rdi), dbg_itype_unsigned_short_int},
{CV_AMD64_EAX, "EAX", (DWORD*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_int},
{CV_AMD64_EBX, "EBX", (DWORD*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_int},
{CV_AMD64_ECX, "ECX", (DWORD*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_int},
{CV_AMD64_EDX, "EDX", (DWORD*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_int},
{CV_AMD64_ESP, "ESP", (DWORD*)FIELD_OFFSET(CONTEXT, Rsp), dbg_itype_unsigned_int},
{CV_AMD64_EBP, "EBP", (DWORD*)FIELD_OFFSET(CONTEXT, Rbp), dbg_itype_unsigned_int},
{CV_AMD64_ESI, "ESI", (DWORD*)FIELD_OFFSET(CONTEXT, Rsi), dbg_itype_unsigned_int},
{CV_AMD64_EDI, "EDI", (DWORD*)FIELD_OFFSET(CONTEXT, Rdi), dbg_itype_unsigned_int},
{CV_AMD64_ES, "ES", (DWORD*)FIELD_OFFSET(CONTEXT, SegEs), dbg_itype_unsigned_short_int},
{CV_AMD64_CS, "CS", (DWORD*)FIELD_OFFSET(CONTEXT, SegCs), dbg_itype_unsigned_short_int},
{CV_AMD64_SS, "SS", (DWORD*)FIELD_OFFSET(CONTEXT, SegSs), dbg_itype_unsigned_short_int},
{CV_AMD64_DS, "DS", (DWORD*)FIELD_OFFSET(CONTEXT, SegDs), dbg_itype_unsigned_short_int},
{CV_AMD64_FS, "FS", (DWORD*)FIELD_OFFSET(CONTEXT, SegFs), dbg_itype_unsigned_short_int},
{CV_AMD64_GS, "GS", (DWORD*)FIELD_OFFSET(CONTEXT, SegGs), dbg_itype_unsigned_short_int},
{CV_AMD64_FLAGS, "FLAGS", (DWORD*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_short_int},
{CV_AMD64_EFLAGS, "EFLAGS", (DWORD*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_int},
{CV_AMD64_RIP, "RIP", (DWORD*)FIELD_OFFSET(CONTEXT, Rip), dbg_itype_unsigned_int},
{CV_AMD64_RAX, "RAX", (DWORD*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_long_int},
{CV_AMD64_RBX, "RBX", (DWORD*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_long_int},
{CV_AMD64_RCX, "RCX", (DWORD*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_long_int},
{CV_AMD64_RDX, "RDX", (DWORD*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_long_int},
{CV_AMD64_RSP, "RSP", (DWORD*)FIELD_OFFSET(CONTEXT, Rsp), dbg_itype_unsigned_long_int},
{CV_AMD64_RBP, "RBP", (DWORD*)FIELD_OFFSET(CONTEXT, Rbp), dbg_itype_unsigned_long_int},
{CV_AMD64_RSI, "RSI", (DWORD*)FIELD_OFFSET(CONTEXT, Rsi), dbg_itype_unsigned_long_int},
{CV_AMD64_RDI, "RDI", (DWORD*)FIELD_OFFSET(CONTEXT, Rdi), dbg_itype_unsigned_long_int},
{CV_AMD64_R8, "R8", (DWORD*)FIELD_OFFSET(CONTEXT, R8), dbg_itype_unsigned_long_int},
{CV_AMD64_R9, "R9", (DWORD*)FIELD_OFFSET(CONTEXT, R9), dbg_itype_unsigned_long_int},
{CV_AMD64_R10, "R10", (DWORD*)FIELD_OFFSET(CONTEXT, R10), dbg_itype_unsigned_long_int},
{CV_AMD64_R11, "R11", (DWORD*)FIELD_OFFSET(CONTEXT, R11), dbg_itype_unsigned_long_int},
{CV_AMD64_R12, "R12", (DWORD*)FIELD_OFFSET(CONTEXT, R12), dbg_itype_unsigned_long_int},
{CV_AMD64_R13, "R13", (DWORD*)FIELD_OFFSET(CONTEXT, R13), dbg_itype_unsigned_long_int},
{CV_AMD64_R14, "R14", (DWORD*)FIELD_OFFSET(CONTEXT, R14), dbg_itype_unsigned_long_int},
{CV_AMD64_R15, "R15", (DWORD*)FIELD_OFFSET(CONTEXT, R15), dbg_itype_unsigned_long_int},
{CV_AMD64_AL, "AL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_char_int},
{CV_AMD64_BL, "BL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_char_int},
{CV_AMD64_CL, "CL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_char_int},
{CV_AMD64_DL, "DL", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_char_int},
{CV_AMD64_AH, "AH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Rax)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_BH, "BH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Rbx)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_CH, "CH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Rcx)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_DH, "DH", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, Rdx)+1), dbg_itype_unsigned_char_int},
{CV_AMD64_AX, "AX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_short_int},
{CV_AMD64_BX, "BX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_short_int},
{CV_AMD64_CX, "CX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_short_int},
{CV_AMD64_DX, "DX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_short_int},
{CV_AMD64_SP, "SP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rsp), dbg_itype_unsigned_short_int},
{CV_AMD64_BP, "BP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbp), dbg_itype_unsigned_short_int},
{CV_AMD64_SI, "SI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rsi), dbg_itype_unsigned_short_int},
{CV_AMD64_DI, "DI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdi), dbg_itype_unsigned_short_int},
{CV_AMD64_EAX, "EAX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_int},
{CV_AMD64_EBX, "EBX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_int},
{CV_AMD64_ECX, "ECX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_int},
{CV_AMD64_EDX, "EDX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_int},
{CV_AMD64_ESP, "ESP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rsp), dbg_itype_unsigned_int},
{CV_AMD64_EBP, "EBP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbp), dbg_itype_unsigned_int},
{CV_AMD64_ESI, "ESI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rsi), dbg_itype_unsigned_int},
{CV_AMD64_EDI, "EDI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdi), dbg_itype_unsigned_int},
{CV_AMD64_ES, "ES", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegEs), dbg_itype_unsigned_short_int},
{CV_AMD64_CS, "CS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegCs), dbg_itype_unsigned_short_int},
{CV_AMD64_SS, "SS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegSs), dbg_itype_unsigned_short_int},
{CV_AMD64_DS, "DS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegDs), dbg_itype_unsigned_short_int},
{CV_AMD64_FS, "FS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegFs), dbg_itype_unsigned_short_int},
{CV_AMD64_GS, "GS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, SegGs), dbg_itype_unsigned_short_int},
{CV_AMD64_FLAGS, "FLAGS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_short_int},
{CV_AMD64_EFLAGS, "EFLAGS", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, EFlags), dbg_itype_unsigned_int},
{CV_AMD64_RIP, "RIP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rip), dbg_itype_unsigned_int},
{CV_AMD64_RAX, "RAX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rax), dbg_itype_unsigned_long_int},
{CV_AMD64_RBX, "RBX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbx), dbg_itype_unsigned_long_int},
{CV_AMD64_RCX, "RCX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rcx), dbg_itype_unsigned_long_int},
{CV_AMD64_RDX, "RDX", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdx), dbg_itype_unsigned_long_int},
{CV_AMD64_RSP, "RSP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rsp), dbg_itype_unsigned_long_int},
{CV_AMD64_RBP, "RBP", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rbp), dbg_itype_unsigned_long_int},
{CV_AMD64_RSI, "RSI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rsi), dbg_itype_unsigned_long_int},
{CV_AMD64_RDI, "RDI", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, Rdi), dbg_itype_unsigned_long_int},
{CV_AMD64_R8, "R8", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R8), dbg_itype_unsigned_long_int},
{CV_AMD64_R9, "R9", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R9), dbg_itype_unsigned_long_int},
{CV_AMD64_R10, "R10", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R10), dbg_itype_unsigned_long_int},
{CV_AMD64_R11, "R11", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R11), dbg_itype_unsigned_long_int},
{CV_AMD64_R12, "R12", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R12), dbg_itype_unsigned_long_int},
{CV_AMD64_R13, "R13", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R13), dbg_itype_unsigned_long_int},
{CV_AMD64_R14, "R14", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R14), dbg_itype_unsigned_long_int},
{CV_AMD64_R15, "R15", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, R15), dbg_itype_unsigned_long_int},
{0, NULL, 0, dbg_itype_none}
};
@ -154,7 +154,7 @@ static const struct dbg_internal_var* be_x86_64_init_registers(CONTEXT* ctx)
struct dbg_internal_var* div;
for (div = be_x86_64_ctx; div->name; div++)
div->pval = (DWORD*)((char*)ctx + (DWORD_PTR)div->pval);
div->pval = (DWORD_PTR*)((char*)ctx + (DWORD_PTR)div->pval);
return be_x86_64_ctx;
}

14
programs/winedbg/break.c
View File

@ -303,12 +303,12 @@ void break_add_break_from_lineno(int lineno, BOOL swbp)
DWORD disp;
DWORD linear = (DWORD)memory_to_linear_addr(&bkln.addr);
DWORD_PTR linear = (DWORD_PTR)memory_to_linear_addr(&bkln.addr);
il.SizeOfStruct = sizeof(il);
if (!SymGetLineFromAddr(dbg_curr_process->handle, linear, &disp, &il))
{
dbg_printf("Unable to add breakpoint (unknown address %x)\n", linear);
dbg_printf("Unable to add breakpoint (unknown address %lx)\n", linear);
return;
}
bkln.addr.Offset = 0;
@ -475,8 +475,8 @@ static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr,
const IMAGEHLP_MODULE* wmod_child)
{
return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
(DWORD)wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
(DWORD)wmod_child->BaseOfImage + wmod_child->ImageSize;
wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
wmod_child->BaseOfImage + wmod_child->ImageSize;
}
/******************************************************************
@ -488,7 +488,7 @@ void break_delete_xpoints_from_module(unsigned long base)
{
IMAGEHLP_MODULE im, im_elf;
int i;
DWORD linear;
DWORD_PTR linear;
struct dbg_breakpoint* bp = dbg_curr_process->bp;
/* FIXME: should do it also on the ELF sibbling if any */
@ -499,12 +499,12 @@ void break_delete_xpoints_from_module(unsigned long base)
/* try to get in fact the underlying ELF module (if any) */
if (SymGetModuleInfo(dbg_curr_process->handle, im.BaseOfImage - 1, &im_elf) &&
im_elf.BaseOfImage <= im.BaseOfImage &&
(DWORD)im_elf.BaseOfImage + im_elf.ImageSize >= (DWORD)im.BaseOfImage + im.ImageSize)
im_elf.BaseOfImage + im_elf.ImageSize >= im.BaseOfImage + im.ImageSize)
im = im_elf;
for (i = 0; i < dbg_curr_process->next_bp; i++)
{
linear = (DWORD)memory_to_linear_addr(&bp[i].addr);
linear = (DWORD_PTR)memory_to_linear_addr(&bp[i].addr);
if (bp[i].refcount && bp[i].enabled &&
im.BaseOfImage <= linear && linear < im.BaseOfImage + im.ImageSize)
{

2
programs/winedbg/dbg.y
View File

@ -45,7 +45,7 @@ static void parser(const char*);
{
struct dbg_lvalue lvalue;
char* string;
int integer;
INT_PTR integer;
IMAGEHLP_LINE listing;
struct expr* expression;
struct type_expr_t type;

4
programs/winedbg/debug.l
View File

@ -149,8 +149,8 @@ STRING \"[^\n"]+\"
"[" { return *yytext; }
"]" { return *yytext; }
"0x"{HEXDIGIT}+ { sscanf(yytext, "%x", &dbg_lval.integer); return tNUM; }
{DIGIT}+ { sscanf(yytext, "%d", &dbg_lval.integer); return tNUM; }
"0x"{HEXDIGIT}+ { sscanf(yytext, "%lx", &dbg_lval.integer); return tNUM; }
{DIGIT}+ { sscanf(yytext, "%ld", &dbg_lval.integer); return tNUM; }
<FORMAT_EXPECTED>"/"{DIGIT}+{FORMAT} { char* last;
dbg_lval.integer = strtol(yytext+1, &last, 0) << 8;

22
programs/winedbg/debugger.h
View File

@ -186,9 +186,9 @@ struct dbg_thread
ADDRESS64 addr_pc;
ADDRESS64 addr_frame;
ADDRESS64 addr_stack;
DWORD linear_pc;
DWORD linear_frame;
DWORD linear_stack;
DWORD_PTR linear_pc;
DWORD_PTR linear_frame;
DWORD_PTR linear_stack;
}* frames;
int num_frames;
int curr_frame;
@ -243,17 +243,17 @@ struct be_process_io
};
extern struct dbg_process* dbg_curr_process;
extern DWORD dbg_curr_pid;
extern DWORD_PTR dbg_curr_pid;
extern struct dbg_thread* dbg_curr_thread;
extern DWORD dbg_curr_tid;
extern DWORD_PTR dbg_curr_tid;
extern CONTEXT dbg_context;
extern BOOL dbg_interactiveP;
struct dbg_internal_var
{
DWORD val;
DWORD_PTR val;
const char* name;
LPDWORD pval;
DWORD_PTR *pval;
unsigned long typeid; /* always internal type */
};
@ -362,7 +362,7 @@ extern BOOL memory_get_current_stack(ADDRESS64* address);
extern BOOL memory_get_current_frame(ADDRESS64* address);
extern BOOL memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee, BOOL unicode, char* buffer, int size);
extern BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, WCHAR* buffer, int size);
extern BOOL memory_get_register(DWORD regno, DWORD** value, char* buffer, int len);
extern BOOL memory_get_register(DWORD regno, DWORD_PTR** value, char* buffer, int len);
extern void memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int instruction_count);
extern BOOL memory_disasm_one_insn(ADDRESS64* addr);
#define MAX_OFFSET_TO_STR_LEN 19
@ -384,7 +384,7 @@ extern void stack_info(void);
extern void stack_backtrace(DWORD threadID);
extern BOOL stack_set_frame(int newframe);
extern BOOL stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf);
extern BOOL stack_get_register_current_frame(unsigned regno, DWORD** pval);
extern BOOL stack_get_register_current_frame(unsigned regno, DWORD_PTR** pval);
extern unsigned stack_fetch_frames(void);
extern BOOL stack_get_current_symbol(SYMBOL_INFO* sym);
@ -394,7 +394,7 @@ extern void symbol_read_symtable(const char* filename, unsigned long
extern enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr);
extern BOOL symbol_get_line(const char* filename, const char* func, IMAGEHLP_LINE* ret);
extern void symbol_info(const char* str);
extern void symbol_print_local(const SYMBOL_INFO* sym, ULONG base, BOOL detailed);
extern void symbol_print_local(const SYMBOL_INFO* sym, ULONG_PTR base, BOOL detailed);
extern int symbol_info_locals(void);
extern BOOL symbol_is_local(const char* name);
struct sgv_data;
@ -457,7 +457,7 @@ struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid, HANDLE h, vo
extern struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid);
extern void dbg_del_thread(struct dbg_thread* t);
extern BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade);
extern BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD base, DWORD size);
extern BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD_PTR base, DWORD size);
extern BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod);
extern void dbg_set_option(const char*, const char*);
extern void dbg_start_interactive(HANDLE hFile);

15
programs/winedbg/gdbproxy.c
View File

@ -1396,7 +1396,7 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
{
if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
fprintf(stderr, "Wrong sizes %u <> %u\n",
ptr - gdbctx->in_packet + len * 2, gdbctx->in_packet_len);
(int)(ptr - gdbctx->in_packet) + len * 2, gdbctx->in_packet_len);
return packet_error;
}
if (gdbctx->trace & GDBPXY_TRC_COMMAND)
@ -1468,13 +1468,14 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx)
{
if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
fprintf(stderr, "Wrong sizes %u <> %u\n",
ptr + 8 - gdbctx->in_packet, gdbctx->in_packet_len);
(int)(ptr + 8 - gdbctx->in_packet), gdbctx->in_packet_len);
return packet_error;
}
if (gdbctx->trace & GDBPXY_TRC_COMMAND)
fprintf(stderr, "Writing reg %u <= %*.*s\n",
reg, gdbctx->in_packet_len - (ptr - gdbctx->in_packet),
gdbctx->in_packet_len - (ptr - gdbctx->in_packet), ptr);
{
int len = gdbctx->in_packet_len - (ptr - gdbctx->in_packet);
fprintf(stderr, "Writing reg %u <= %*.*s\n", reg, len, len, ptr );
}
if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
{
@ -1509,10 +1510,10 @@ static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWn
packet_reply_open(gdbctx);
packet_reply_catc(gdbctx, 'O');
snprintf(buffer, sizeof(buffer),
"%*s%04lx%*s%-17.17s %08x %08x %.14s\n",
"%*s%04lx%*s%-17.17s %08x %08lx %.14s\n",
indent, "", (ULONG_PTR)hWnd, 13 - indent, "",
clsName, GetWindowLongW(hWnd, GWL_STYLE),
GetWindowLongPtrW(hWnd, GWLP_WNDPROC), wndName);
(ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC), wndName);
packet_reply_hex_to_str(gdbctx, buffer);
packet_reply_close(gdbctx);

14
programs/winedbg/info.c
View File

@ -146,7 +146,7 @@ static const char* get_symtype_str(const IMAGEHLP_MODULE64* mi)
struct info_module
{
IMAGEHLP_MODULE64* mi;
DWORD base;
DWORD_PTR _base;
unsigned num_alloc;
unsigned num_used;
};
@ -371,10 +371,10 @@ static void info_window(HWND hWnd, int indent)
if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
strcpy(wndName, "-- Empty --");
dbg_printf("%*s%08lx%*s %-17.17s %08x %08x %08x %.14s\n",
dbg_printf("%*s%08lx%*s %-17.17s %08x %08lx %08x %.14s\n",
indent, "", (DWORD_PTR)hWnd, 12 - indent, "",
clsName, GetWindowLongW(hWnd, GWL_STYLE),
GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
(ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
GetWindowThreadProcessId(hWnd, NULL), wndName);
if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
@ -412,8 +412,8 @@ void info_win32_window(HWND hWnd, BOOL detailed)
/* FIXME missing fields: hmemTaskQ, hrgnUpdate, dce, flags, pProp, scroll */
dbg_printf("next=%p child=%p parent=%p owner=%p class='%s'\n"
"inst=%p active=%p idmenu=%08x\n"
"style=0x%08x exstyle=0x%08x wndproc=0x%08x text='%s'\n"
"inst=%p active=%p idmenu=%08lx\n"
"style=0x%08x exstyle=0x%08x wndproc=0x%08lx text='%s'\n"
"client=%d,%d-%d,%d window=%d,%d-%d,%d sysmenu=%p\n",
GetWindow(hWnd, GW_HWNDNEXT),
GetWindow(hWnd, GW_CHILD),
@ -422,10 +422,10 @@ void info_win32_window(HWND hWnd, BOOL detailed)
clsName,
(HINSTANCE)GetWindowLongPtrW(hWnd, GWLP_HINSTANCE),
GetLastActivePopup(hWnd),
GetWindowLongPtrW(hWnd, GWLP_ID),
(ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_ID),
GetWindowLongW(hWnd, GWL_STYLE),
GetWindowLongW(hWnd, GWL_EXSTYLE),
GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
(ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
wndName,
clientRect.left, clientRect.top, clientRect.right, clientRect.bottom,
windowRect.left, windowRect.top, windowRect.right, windowRect.bottom,

2
programs/winedbg/memory.c
View File

@ -639,7 +639,7 @@ void memory_disassemble(const struct dbg_lvalue* xstart,
memory_disasm_one_insn(&last);
}
BOOL memory_get_register(DWORD regno, DWORD** value, char* buffer, int len)
BOOL memory_get_register(DWORD regno, DWORD_PTR** value, char* buffer, int len)
{
const struct dbg_internal_var* div;

2
programs/winedbg/source.c
View File

@ -44,7 +44,7 @@ void source_show_path(void)
{
next = strchr(ptr, ';');
if (next)
dbg_printf("\t%.*s\n", next++ - ptr, ptr);
dbg_printf("\t%.*s\n", (int)(next++ - ptr), ptr);
else
dbg_printf("\t%s\n", ptr);
}

12
programs/winedbg/stack.c
View File

@ -96,7 +96,7 @@ BOOL stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf)
return stack_get_frame(dbg_curr_thread->curr_frame, ihsf);
}
BOOL stack_get_register_current_frame(unsigned regno, DWORD** pval)
BOOL stack_get_register_current_frame(unsigned regno, DWORD_PTR** pval)
{
enum be_cpu_addr kind;
@ -194,11 +194,11 @@ unsigned stack_fetch_frames(void)
(nf + 1) * sizeof(dbg_curr_thread->frames[0]));
dbg_curr_thread->frames[nf].addr_pc = sf.AddrPC;
dbg_curr_thread->frames[nf].linear_pc = (DWORD)memory_to_linear_addr(&sf.AddrPC);
dbg_curr_thread->frames[nf].linear_pc = (DWORD_PTR)memory_to_linear_addr(&sf.AddrPC);
dbg_curr_thread->frames[nf].addr_frame = sf.AddrFrame;
dbg_curr_thread->frames[nf].linear_frame = (DWORD)memory_to_linear_addr(&sf.AddrFrame);
dbg_curr_thread->frames[nf].linear_frame = (DWORD_PTR)memory_to_linear_addr(&sf.AddrFrame);
dbg_curr_thread->frames[nf].addr_stack = sf.AddrStack;
dbg_curr_thread->frames[nf].linear_stack = (DWORD)memory_to_linear_addr(&sf.AddrStack);
dbg_curr_thread->frames[nf].linear_stack = (DWORD_PTR)memory_to_linear_addr(&sf.AddrStack);
nf++;
/* we've probably gotten ourselves into an infinite loop so bail */
if (nf > 200) break;
@ -211,7 +211,7 @@ unsigned stack_fetch_frames(void)
struct sym_enum
{
DWORD frame;
DWORD_PTR frame;
BOOL first;
};
@ -390,7 +390,7 @@ static void backtrace_all(void)
dbg_active_wait_for_first_exception();
}
dbg_printf("\nBacktracing for thread %04x in process %04x (%s):\n",
dbg_printf("\nBacktracing for thread %04x in process %04lx (%s):\n",
entry.th32ThreadID, dbg_curr_pid,
dbg_W2A(dbg_curr_process->imageName, -1));
backtrace_tid(dbg_curr_process, entry.th32ThreadID);

19
programs/winedbg/symbol.c
View File

@ -65,13 +65,13 @@ static BOOL symbol_get_debug_start(const struct dbg_type* func, ULONG64* start)
return FALSE;
}
static BOOL fill_sym_lvalue(const SYMBOL_INFO* sym, ULONG base,
static BOOL fill_sym_lvalue(const SYMBOL_INFO* sym, ULONG_PTR base,
struct dbg_lvalue* lvalue, char* buffer, size_t sz)
{
if (buffer) buffer[0] = '\0';
if (sym->Flags & SYMFLAG_REGISTER)
{
DWORD* pval;
DWORD_PTR* pval;
if (!memory_get_register(sym->Register, &pval, buffer, sz))
return FALSE;
@ -80,7 +80,7 @@ static BOOL fill_sym_lvalue(const SYMBOL_INFO* sym, ULONG base,
}
else if (sym->Flags & SYMFLAG_REGREL)
{
DWORD* pval;
DWORD_PTR* pval;
if (!memory_get_register(sym->Register, &pval, buffer, sz))
return FALSE;
@ -408,7 +408,7 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno,
il.SizeOfStruct = sizeof(il);
SymGetLineFromAddr(dbg_curr_process->handle,
(DWORD)memory_to_linear_addr(&sgv.syms[i].lvalue.addr),
(DWORD_PTR)memory_to_linear_addr(&sgv.syms[i].lvalue.addr),
&disp, &il);
do
{
@ -524,7 +524,7 @@ enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr)
IMAGEHLP_LINE il;
DWORD disp;
ULONG64 disp64, start;
DWORD lin = (DWORD)memory_to_linear_addr(addr);
DWORD_PTR lin = (DWORD_PTR)memory_to_linear_addr(addr);
char buffer[sizeof(SYMBOL_INFO) + 256];
SYMBOL_INFO* sym = (SYMBOL_INFO*)buffer;
struct dbg_type func;
@ -579,7 +579,7 @@ BOOL symbol_get_line(const char* filename, const char* name, IMAGEHLP_LINE* line
{
struct sgv_data sgv;
char buffer[512];
DWORD opt, disp, linear;
DWORD opt, disp;
unsigned i, found = FALSE;
IMAGEHLP_LINE il;
@ -616,7 +616,7 @@ BOOL symbol_get_line(const char* filename, const char* name, IMAGEHLP_LINE* line
for (i = 0; i < sgv.num; i++)
{
linear = (DWORD)memory_to_linear_addr(&sgv.syms[i].lvalue.addr);
DWORD_PTR linear = (DWORD_PTR)memory_to_linear_addr(&sgv.syms[i].lvalue.addr);
il.SizeOfStruct = sizeof(il);
if (!SymGetLineFromAddr(dbg_curr_process->handle, linear, &disp, &il))
@ -647,8 +647,7 @@ BOOL symbol_get_line(const char* filename, const char* name, IMAGEHLP_LINE* line
* <name>=<value> (local|pmt <where>) in detailed form
* Note <value> can be an error message in case of error
*/
void symbol_print_local(const SYMBOL_INFO* sym, ULONG base,
BOOL detailed)
void symbol_print_local(const SYMBOL_INFO* sym, ULONG_PTR base, BOOL detailed)
{
struct dbg_lvalue lvalue;
char buffer[64];
@ -682,7 +681,7 @@ static BOOL CALLBACK info_locals_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx)
types_print_type(&type, FALSE);
dbg_printf(" ");
symbol_print_local(sym, (ULONG)ctx, TRUE);
symbol_print_local(sym, (ULONG_PTR)ctx, TRUE);
dbg_printf("\n");
return TRUE;

10
programs/winedbg/tgt_active.c
View File

@ -676,12 +676,12 @@ static void dbg_resume_debuggee(DWORD cont)
if (dbg_curr_thread)
{
if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context))
dbg_printf("Cannot set ctx on %04x\n", dbg_curr_tid);
dbg_printf("Cannot set ctx on %04lx\n", dbg_curr_tid);
}
}
dbg_interactiveP = FALSE;
if (!ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, cont))
dbg_printf("Cannot continue on %04x (%08x)\n", dbg_curr_tid, cont);
dbg_printf("Cannot continue on %04lx (%08x)\n", dbg_curr_tid, cont);
}
static void wait_exception(void)
@ -796,7 +796,7 @@ void dbg_run_debuggee(const char* args)
}
}
static BOOL str2int(const char* str, DWORD* val)
static BOOL str2int(const char* str, DWORD_PTR* val)
{
char* ptr;
@ -813,7 +813,7 @@ static BOOL str2int(const char* str, DWORD* val)
*/
enum dbg_start dbg_active_attach(int argc, char* argv[])
{
DWORD pid, evt;
DWORD_PTR pid, evt;
/* try the form <myself> pid */
if (argc == 1 && str2int(argv[0], &pid) && pid != 0)
@ -833,7 +833,7 @@ enum dbg_start dbg_active_attach(int argc, char* argv[])
}
if (!SetEvent((HANDLE)evt))
{
WINE_ERR("Invalid event handle: %x\n", evt);
WINE_ERR("Invalid event handle: %lx\n", evt);
return start_error_init;
}
CloseHandle((HANDLE)evt);

4
programs/winedbg/types.c
View File

@ -567,7 +567,7 @@ static BOOL CALLBACK print_types_cb(PSYMBOL_INFO sym, ULONG size, void* ctx)
return TRUE;
}
static BOOL CALLBACK print_types_mod_cb(PCSTR mod_name, ULONG base, PVOID ctx)
static BOOL CALLBACK print_types_mod_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
{
return SymEnumTypes(dbg_curr_process->handle, base, print_types_cb, ctx);
}
@ -579,7 +579,7 @@ int print_types(void)
dbg_printf("No known process, cannot print types\n");
return 0;
}
SymEnumerateModules(dbg_curr_process->handle, print_types_mod_cb, NULL);
SymEnumerateModules64(dbg_curr_process->handle, print_types_mod_cb, NULL);
return 0;
}

12
programs/winedbg/winedbg.c
View File

@ -88,8 +88,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
struct dbg_process* dbg_curr_process = NULL;
struct dbg_thread* dbg_curr_thread = NULL;
DWORD dbg_curr_tid;
DWORD dbg_curr_pid;
DWORD_PTR dbg_curr_tid = 0;
DWORD_PTR dbg_curr_pid = 0;
CONTEXT dbg_context;
BOOL dbg_interactiveP = FALSE;
@ -402,7 +402,7 @@ struct mod_loader_info
IMAGEHLP_MODULE* imh_mod;
};
static BOOL CALLBACK mod_loader_cb(PCSTR mod_name, ULONG base, PVOID ctx)
static BOOL CALLBACK mod_loader_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
{
struct mod_loader_info* mli = ctx;
@ -429,13 +429,13 @@ BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod)
* enumeration
*/
SymSetOptions((opt = SymGetOptions()) | 0x40000000);
SymEnumerateModules(hProcess, mod_loader_cb, (void*)&mli);
SymEnumerateModules64(hProcess, mod_loader_cb, (void*)&mli);
SymSetOptions(opt);
return imh_mod->BaseOfImage != 0;
}
BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD base, DWORD size)
BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD_PTR base, DWORD size)
{
BOOL ret = SymLoadModuleExW(hProc, NULL, name, NULL, base, size, NULL, 0);
if (ret)
@ -594,7 +594,7 @@ void dbg_start_interactive(HANDLE hFile)
{
if (dbg_curr_process)
{
dbg_printf("WineDbg starting on pid %04x\n", dbg_curr_pid);
dbg_printf("WineDbg starting on pid %04lx\n", dbg_curr_pid);
if (dbg_curr_process->active_debuggee) dbg_active_wait_for_first_exception();
}