diff --git a/programs/winedbg/be_i386.c b/programs/winedbg/be_i386.c index c22ef145318..e3e7a8168e9 100644 --- a/programs/winedbg/be_i386.c +++ b/programs/winedbg/be_i386.c @@ -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; } diff --git a/programs/winedbg/be_x86_64.c b/programs/winedbg/be_x86_64.c index 56af50fad92..dc1f2277fa9 100644 --- a/programs/winedbg/be_x86_64.c +++ b/programs/winedbg/be_x86_64.c @@ -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; } diff --git a/programs/winedbg/break.c b/programs/winedbg/break.c index ddb75a2d188..accf17b3571 100644 --- a/programs/winedbg/break.c +++ b/programs/winedbg/break.c @@ -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) { diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index ffc2f78ff3b..ea4229d3459 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -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; diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index 0697f60aeab..9b1e4fa19a9 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -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; } "/"{DIGIT}+{FORMAT} { char* last; dbg_lval.integer = strtol(yytext+1, &last, 0) << 8; diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index d9d0fbb5d6c..d0a06748b61 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -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); diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 0bea8fe6339..4a632325e72 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -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); diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c index 3c560567624..87fbebdf51f 100644 --- a/programs/winedbg/info.c +++ b/programs/winedbg/info.c @@ -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, diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index c103c18837b..c33291080c2 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -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; diff --git a/programs/winedbg/source.c b/programs/winedbg/source.c index 40cd1a3d3e7..95ec209cc64 100644 --- a/programs/winedbg/source.c +++ b/programs/winedbg/source.c @@ -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); } diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index fbaf228c8ee..92ddd47ca2c 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -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); diff --git a/programs/winedbg/symbol.c b/programs/winedbg/symbol.c index abc7d2de12c..785e380876e 100644 --- a/programs/winedbg/symbol.c +++ b/programs/winedbg/symbol.c @@ -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 * = (local|pmt ) in detailed form * Note 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; diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 8e4f798a0ae..23917e0cdc3 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -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 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); diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index 4a14143bf8a..50695aaf984 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -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; } diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c index 54e4c657421..911cb6a5d26 100644 --- a/programs/winedbg/winedbg.c +++ b/programs/winedbg/winedbg.c @@ -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(); }