June 2018 - Wine-Devel - list.winehq.org

[PATCH 1/3] ndrtypes.h: Add more constants.

by Zebediah Figura

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- include/ndrtypes.h | 124 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) diff --git a/include/ndrtypes.h b/include/ndrtypes.h index b353ce5..938dc65 100644 --- a/include/ndrtypes.h +++ b/include/ndrtypes.h @@ -168,8 +168,113 @@ typedef enum FC_SMVARRAY, /* 0x1f */ /* small (<64k) varying array */ FC_LGVARRAY, /* 0x20 */ /* large (>= 64k) varying array */ FC_BOGUS_ARRAY, /* 0x21 */ /* complex array */ + + FC_C_CSTRING, /* 0x22 */ /* conformant char string */ + FC_C_BSTRING, /* 0x23 */ + FC_C_SSTRING, /* 0x24 */ + FC_C_WSTRING, /* 0x25 */ /* conformant wchar string */ + FC_CSTRING, /* 0x26 */ /* non-conformant char string */ + FC_BSTRING, /* 0x27 */ + FC_SSTRING, /* 0x28 */ + FC_WSTRING, /* 0x29 */ /* non-conformant wchar string */ + + FC_ENCAPSULATED_UNION, /* 0x2a */ + FC_NON_ENCAPSULATED_UNION, /* 0x2b */ + + FC_BYTE_COUNT_POINTER, /* 0x2c */ /* [byte_count] ACF attribute */ + + FC_TRANSMIT_AS, /* 0x2d */ + FC_REPRESENT_AS, /* 0x2e */ + + FC_IP, /* 0x2f */ /* interface pointer */ + + FC_BIND_CONTEXT, /* 0x30 */ + + FC_BIND_GENERIC, /* 0x31 */ + FC_BIND_PRIMITIVE, /* 0x32 */ + FC_AUTO_HANDLE, /* 0x33 */ + FC_CALLBACK_HANDLE, /* 0x34 */ + + FC_UNUSED1, /* 0x35 */ + + FC_POINTER, /* 0x36 */ + + FC_ALIGNM2, /* 0x37 */ + FC_ALIGNM4, /* 0x38 */ + FC_ALIGNM8, /* 0x39 */ + + FC_UNUSED2, /* 0x3a */ + FC_UNUSED3, /* 0x3b */ + FC_UNUSED4, /* 0x3c */ + + FC_STRUCTPAD1, /* 0x3d */ + FC_STRUCTPAD2, /* 0x3e */ + FC_STRUCTPAD3, /* 0x3f */ + FC_STRUCTPAD4, /* 0x40 */ + FC_STRUCTPAD5, /* 0x41 */ + FC_STRUCTPAD6, /* 0x42 */ + FC_STRUCTPAD7, /* 0x43 */ + + FC_STRING_SIZED, /* 0x44 */ + + FC_UNUSED5, /* 0x45 */ + + FC_NO_REPEAT, /* 0x46 */ + FC_FIXED_REPEAT, /* 0x47 */ + FC_VARIABLE_REPEAT, /* 0x48 */ + FC_FIXED_OFFSET, /* 0x49 */ + FC_VARIABLE_OFFSET, /* 0x4a */ + + FC_PP, /* 0x4b */ /* pointer layout */ +/* FC_PP: FC_PAD layouts */ +/* layouts: FC_NO_REPEAT FC_PAD instance */ +/* instance: NdrFcShort(memofs), NdrFcShort(bufofs), desc */ + + FC_EMBEDDED_COMPLEX, /* 0x4c */ + + FC_IN_PARAM, /* 0x4d */ + FC_IN_PARAM_BASETYPE, /* 0x4e */ + FC_IN_PARAM_NO_FREE_INST, /* 0x4f */ + FC_IN_OUT_PARAM, /* 0x50 */ + FC_OUT_PARAM, /* 0x51 */ + FC_RETURN_PARAM, /* 0x52 */ + FC_RETURN_PARAM_BASETYPE, /* 0x53 */ + + FC_DEREFERENCE, /* 0x54 */ + FC_DIV_2, /* 0x55 */ + FC_MULT_2, /* 0x56 */ + FC_ADD_1, /* 0x57 */ + FC_SUB_1, /* 0x58 */ + + FC_CALLBACK, /* 0x59 */ + + FC_CONSTANT_IID, /* 0x5a */ + + FC_END, /* 0x5b */ + FC_PAD, /* 0x5c */ + + FC_HARD_STRUCT = 0xb1, + + FC_TRANSMIT_AS_PTR, /* 0xb2 */ + FC_REPRESENT_AS_PTR, /* 0xb3 */ + + FC_USER_MARSHAL, /* 0xb4 */ + + FC_PIPE, /* 0xb5 */ + FC_BLKHOLE, /* 0xb6 */ + + FC_RANGE, /* 0xb7 */ + + FC_INT3264, /* 0xb8 */ + FC_UINT3264, /* 0xb9 */ } FORMAT_CHARACTER; +#define FC_ALLOCATE_ALL_NODES 0x01 +#define FC_DONT_FREE 0x02 +#define FC_ALLOCED_ON_STACK 0x04 +#define FC_SIMPLE_POINTER 0x08 +#define FC_POINTER_DEREF 0x10 + /* flags for all handle types */ #define HANDLE_PARAM_IS_VIA_PTR 0x80 #define HANDLE_PARAM_IS_IN 0x40 @@ -182,4 +287,23 @@ typedef enum #define NDR_CONTEXT_HANDLE_SERIALIZE 0x02 #define NDR_CONTEXT_HANDLE_CANNOT_BE_NULL 0x01 +#define Oi_FULL_PTR_USED 0x01 +#define Oi_RPCSS_ALLOC_USED 0x02 +#define Oi_OBJECT_PROC 0x04 +#define Oi_HAS_RPCFLAGS 0x08 +#define Oi_OBJ_USE_V2_INTERPRETER 0x20 +#define Oi_HAS_COMM_OR_FAULT 0x20 +#define Oi_USE_NEW_INIT_ROUTINES 0x40 + +#define FC_NORMAL_CONFORMANCE (unsigned char) 0x00 +#define FC_POINTER_CONFORMANCE (unsigned char) 0x10 +#define FC_TOP_LEVEL_CONFORMANCE (unsigned char) 0x20 +#define FC_CONSTANT_CONFORMANCE (unsigned char) 0x40 +#define FC_TOP_LEVEL_MULTID_CONFORMANCE (unsigned char) 0x80 + +#define USER_MARSHAL_UNIQUE 0x80 +#define USER_MARSHAL_REF 0x40 +#define USER_MARSHAL_POINTER 0xc0 +#define USER_MARSHAL_IID 0x20 + #endif -- 2.7.4

June 13, 2018

Wine staging 3.10 release

by Alistair Leslie-Hughes

Binary packages for various distributions will be available from: https://www.winehq.org/download Summary of the past few weeks * Rebased to current wine 3.10 (905 patches are applied to wine vanilla) * Reviewed and upstreamed patches. Added * d3d11: Align deferred map info buffers to a 16 byte boundry. * wintab32: Improved tablet/stylus support. * winex11: Detect Vulkan library at runtime. * UIAnimation: New dll. * bcypt32: BCryptGenerateKeyPair/BCryptFinalizeKeyPair stubs Where can you help * Run Steam/Battle.net/UPlay. * Try you favorite game: Assassin's Creed Syndicate, Gunsmith * Test your favorite applications. * Steal staging patches and get them accepted upstream. As always, if you find a bug, please report it via https://bugs.winehq.org Best Regards Alistair.

June 13, 2018

[PATCH v2 4/5] winedbg: Add a backend-specific vector for retrieving a thread's context.

by Zebediah Figura

This and the next patch remove references to specific context structs or fields elsewhere than in the backends. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- v2: fix copy/paste error (thanks Jozef). programs/winedbg/be_arm.c | 11 +++++++++++ programs/winedbg/be_arm64.c | 11 +++++++++++ programs/winedbg/be_cpu.h | 3 +++ programs/winedbg/be_i386.c | 7 +++++++ programs/winedbg/be_ppc.c | 11 +++++++++++ programs/winedbg/be_x86_64.c | 11 +++++++++++ programs/winedbg/gdbproxy.c | 2 +- programs/winedbg/stack.c | 4 +--- programs/winedbg/tgt_active.c | 14 +------------- 9 files changed, 57 insertions(+), 17 deletions(-) diff --git a/programs/winedbg/be_arm.c b/programs/winedbg/be_arm.c index b7e42e1..a0e8027 100644 --- a/programs/winedbg/be_arm.c +++ b/programs/winedbg/be_arm.c @@ -1889,6 +1889,16 @@ static BOOL be_arm_store_integer(const struct dbg_lvalue* lvalue, unsigned size, return memory_write_value(lvalue, size, &val); } +static BOOL be_arm_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __arm__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug an ARM process on this architecture.\n"); +#endif +} + struct backend_cpu be_arm = { IMAGE_FILE_MACHINE_ARMNT, @@ -1915,5 +1925,6 @@ struct backend_cpu be_arm = be_arm_fetch_integer, be_arm_fetch_float, be_arm_store_integer, + be_arm_get_context, }; #endif diff --git a/programs/winedbg/be_arm64.c b/programs/winedbg/be_arm64.c index dfeb552..6aa26a6 100644 --- a/programs/winedbg/be_arm64.c +++ b/programs/winedbg/be_arm64.c @@ -278,6 +278,16 @@ void be_arm64_disasm_one_insn(ADDRESS64 *addr, int display) dbg_printf("be_arm64_disasm_one_insn: not done\n"); } +static BOOL be_arm64_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __aarch64__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug an ARM64 process on this architecture.\n"); +#endif +} + struct backend_cpu be_arm64 = { IMAGE_FILE_MACHINE_ARM64, @@ -304,5 +314,6 @@ struct backend_cpu be_arm64 = be_arm64_fetch_integer, be_arm64_fetch_float, be_arm64_store_integer, + be_arm64_get_context, }; #endif diff --git a/programs/winedbg/be_cpu.h b/programs/winedbg/be_cpu.h index 03776d0..aa7d9f0 100644 --- a/programs/winedbg/be_cpu.h +++ b/programs/winedbg/be_cpu.h @@ -21,6 +21,7 @@ enum be_cpu_addr {be_cpu_addr_pc, be_cpu_addr_stack, be_cpu_addr_frame}; enum be_xpoint_type {be_xpoint_break, be_xpoint_watch_exec, be_xpoint_watch_read, be_xpoint_watch_write, be_xpoint_free=-1}; + struct backend_cpu { const DWORD machine; @@ -114,6 +115,8 @@ struct backend_cpu BOOL (*fetch_float)(const struct dbg_lvalue* lvalue, unsigned size, long double*); /* Writes an integer to memory */ BOOL (*store_integer)(const struct dbg_lvalue* lvalue, unsigned size, BOOL is_signed, LONGLONG); + + BOOL (*get_context)(HANDLE thread, dbg_ctx_t *ctx); }; /* some handy functions for non segmented CPUs */ diff --git a/programs/winedbg/be_i386.c b/programs/winedbg/be_i386.c index bdc2ece..c7f5ac1 100644 --- a/programs/winedbg/be_i386.c +++ b/programs/winedbg/be_i386.c @@ -853,6 +853,12 @@ static BOOL be_i386_store_integer(const struct dbg_lvalue* lvalue, unsigned size return memory_write_value(lvalue, size, &val); } +static BOOL be_i386_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ + ctx->x86.ContextFlags = WOW64_CONTEXT_ALL; + return Wow64GetThreadContext(thread, &ctx->x86); +} + struct backend_cpu be_i386 = { IMAGE_FILE_MACHINE_I386, @@ -879,5 +885,6 @@ struct backend_cpu be_i386 = be_i386_fetch_integer, be_i386_fetch_float, be_i386_store_integer, + be_i386_get_context, }; #endif diff --git a/programs/winedbg/be_ppc.c b/programs/winedbg/be_ppc.c index f1543bf..baf77dc 100644 --- a/programs/winedbg/be_ppc.c +++ b/programs/winedbg/be_ppc.c @@ -180,6 +180,16 @@ static BOOL be_ppc_store_integer(const struct dbg_lvalue* lvalue, unsigned size, return FALSE; } +static BOOL be_ppc_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __powerpc__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug a PowerPC process on this architecture.\n"); +#endif +} + struct backend_cpu be_ppc = { IMAGE_FILE_MACHINE_POWERPC, @@ -206,5 +216,6 @@ struct backend_cpu be_ppc = be_ppc_fetch_integer, be_ppc_fetch_float, be_ppc_store_integer, + be_ppc_get_context, }; #endif diff --git a/programs/winedbg/be_x86_64.c b/programs/winedbg/be_x86_64.c index 450cc87..434f007 100644 --- a/programs/winedbg/be_x86_64.c +++ b/programs/winedbg/be_x86_64.c @@ -674,6 +674,16 @@ static BOOL be_x86_64_store_integer(const struct dbg_lvalue* lvalue, unsigned si return memory_write_value(lvalue, size, &val); } +static BOOL be_x86_64_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __x86_64__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug an x86-64 process on this architecture.\n"); +#endif +} + struct backend_cpu be_x86_64 = { IMAGE_FILE_MACHINE_AMD64, @@ -700,5 +710,6 @@ struct backend_cpu be_x86_64 = be_x86_64_fetch_integer, be_x86_64_fetch_float, be_x86_64_store_integer, + be_x86_64_get_context, }; #endif diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index d5786b2..b11a8b0 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -552,7 +552,7 @@ static inline void cpu_register_hex_from(dbg_ctx_t* ctx, unsigned idx, const cha static BOOL fetch_context(struct gdb_context *gdbctx, HANDLE h, dbg_ctx_t *ctx) { - if (!GetThreadContext(h, &ctx->ctx)) + if (!gdbctx->process->be_cpu->get_context(h, ctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Can't get thread's context\n"); diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index a036107..820200d 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -354,11 +354,9 @@ static void backtrace_tid(struct dbg_process* pcs, DWORD tid) dbg_ctx_t ctx = {0}; dbg_curr_tid = dbg_curr_thread->tid; - - ctx.ctx.ContextFlags = CONTEXT_FULL; if (SuspendThread(dbg_curr_thread->handle) != -1) { - if (!GetThreadContext(dbg_curr_thread->handle, &ctx.ctx)) + if (!pcs->be_cpu->get_context(dbg_curr_thread->handle, &ctx)) { dbg_printf("Can't get context for thread %04x in current process\n", tid); diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 8c94402..fccae0c 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -91,19 +91,7 @@ BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe) static unsigned dbg_fetch_context(void) { - dbg_context.ctx.ContextFlags = CONTEXT_CONTROL - | CONTEXT_INTEGER -#ifdef CONTEXT_FLOATING_POINT - | CONTEXT_FLOATING_POINT -#endif -#ifdef CONTEXT_SEGMENTS - | CONTEXT_SEGMENTS -#endif -#ifdef CONTEXT_DEBUG_REGISTERS - | CONTEXT_DEBUG_REGISTERS -#endif - ; - if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx)) + if (!dbg_curr_process->be_cpu->get_context(dbg_curr_thread->handle, &dbg_context)) { WINE_WARN("Can't get thread's context\n"); return FALSE; -- 2.7.4

June 13, 2018

[PATCH 5/5] winedbg: Add a backend-specific vector for setting a thread's context.

by Zebediah Figura

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- programs/winedbg/be_arm.c | 5 +++++ programs/winedbg/be_arm64.c | 5 +++++ programs/winedbg/be_cpu.h | 1 + programs/winedbg/be_i386.c | 6 ++++++ programs/winedbg/be_ppc.c | 6 ++++++ programs/winedbg/be_x86_64.c | 6 ++++++ programs/winedbg/gdbproxy.c | 10 ++++++---- programs/winedbg/tgt_active.c | 6 +++--- programs/winedbg/tgt_minidump.c | 8 ++++++++ 9 files changed, 46 insertions(+), 7 deletions(-) diff --git a/programs/winedbg/be_arm.c b/programs/winedbg/be_arm.c index c320704..4aa7260 100644 --- a/programs/winedbg/be_arm.c +++ b/programs/winedbg/be_arm.c @@ -1899,6 +1899,11 @@ static BOOL be_arm_get_context(HANDLE thread, dbg_ctx_t *ctx) #endif } +static BOOL be_arm_set_context(HANDLE thread, const dbg_ctx_t *ctx) +{ + return SetThreadContext(thread, &ctx->ctx); +} + struct backend_cpu be_arm = { IMAGE_FILE_MACHINE_ARMNT, diff --git a/programs/winedbg/be_arm64.c b/programs/winedbg/be_arm64.c index 8ee4fb9..9cc05bb 100644 --- a/programs/winedbg/be_arm64.c +++ b/programs/winedbg/be_arm64.c @@ -288,6 +288,11 @@ static BOOL be_arm64_get_context(HANDLE thread, dbg_ctx_t *ctx) #endif } +static BOOL be_arm64_set_context(HANDLE thread, const dbg_ctx_t *ctx) +{ + return SetThreadContext(thread, &ctx->ctx); +} + struct backend_cpu be_arm64 = { IMAGE_FILE_MACHINE_ARM64, diff --git a/programs/winedbg/be_cpu.h b/programs/winedbg/be_cpu.h index aa7d9f0..1a67c06 100644 --- a/programs/winedbg/be_cpu.h +++ b/programs/winedbg/be_cpu.h @@ -117,6 +117,7 @@ struct backend_cpu BOOL (*store_integer)(const struct dbg_lvalue* lvalue, unsigned size, BOOL is_signed, LONGLONG); BOOL (*get_context)(HANDLE thread, dbg_ctx_t *ctx); + BOOL (*set_context)(HANDLE thread, const dbg_ctx_t *ctx); }; /* some handy functions for non segmented CPUs */ diff --git a/programs/winedbg/be_i386.c b/programs/winedbg/be_i386.c index c7f5ac1..f46ebb1 100644 --- a/programs/winedbg/be_i386.c +++ b/programs/winedbg/be_i386.c @@ -859,6 +859,11 @@ static BOOL be_i386_get_context(HANDLE thread, dbg_ctx_t *ctx) return Wow64GetThreadContext(thread, &ctx->x86); } +static BOOL be_i386_set_context(HANDLE thread, const dbg_ctx_t *ctx) +{ + return Wow64SetThreadContext(thread, &ctx->x86); +} + struct backend_cpu be_i386 = { IMAGE_FILE_MACHINE_I386, @@ -886,5 +891,6 @@ struct backend_cpu be_i386 = be_i386_fetch_float, be_i386_store_integer, be_i386_get_context, + be_i386_set_context, }; #endif diff --git a/programs/winedbg/be_ppc.c b/programs/winedbg/be_ppc.c index baf77dc..40aee55 100644 --- a/programs/winedbg/be_ppc.c +++ b/programs/winedbg/be_ppc.c @@ -190,6 +190,11 @@ static BOOL be_ppc_get_context(HANDLE thread, dbg_ctx_t *ctx) #endif } +static BOOL be_ppc_set_context(HANDLE thread, const dbg_ctx_t *ctx) +{ + return SetThreadContext(thread, &ctx->ctx); +} + struct backend_cpu be_ppc = { IMAGE_FILE_MACHINE_POWERPC, @@ -217,5 +222,6 @@ struct backend_cpu be_ppc = be_ppc_fetch_float, be_ppc_store_integer, be_ppc_get_context, + be_ppc_set_context, }; #endif diff --git a/programs/winedbg/be_x86_64.c b/programs/winedbg/be_x86_64.c index 434f007..15f84a6 100644 --- a/programs/winedbg/be_x86_64.c +++ b/programs/winedbg/be_x86_64.c @@ -684,6 +684,11 @@ static BOOL be_x86_64_get_context(HANDLE thread, dbg_ctx_t *ctx) #endif } +static BOOL be_x86_64_set_context(HANDLE thread, const dbg_ctx_t *ctx) +{ + return SetThreadContext(thread, &ctx->ctx); +} + struct backend_cpu be_x86_64 = { IMAGE_FILE_MACHINE_AMD64, @@ -711,5 +716,6 @@ struct backend_cpu be_x86_64 = be_x86_64_fetch_float, be_x86_64_store_integer, be_x86_64_get_context, + be_x86_64_set_context, }; #endif diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index b11a8b0..81cd7de 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -768,7 +768,7 @@ static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont) { if (dbg_curr_thread) { - if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context.ctx)) + if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context)) if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) @@ -788,7 +788,7 @@ static void resume_debuggee_thread(struct gdb_context* gdbctx, DWORD cont, unsig { if(dbg_curr_thread->tid == threadid){ /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */ - if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context.ctx)) + if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context)) if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) @@ -1478,7 +1478,8 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx) for (i = 0; i < cpu_num_regs; i++) cpu_register_hex_from(pctx, i, &ptr); - if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, &pctx->ctx)) + if (pctx != &gdbctx->context && + !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %04x\n", gdbctx->other_thread->tid); @@ -1677,7 +1678,8 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) } cpu_register_hex_from(pctx, reg, (const char**)&ptr); - if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, &pctx->ctx)) + if (pctx != &gdbctx->context && + !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context for thread %04x\n", gdbctx->other_thread->tid); diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index fccae0c..e5fd07d 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -344,7 +344,7 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de) de->u.Exception.dwFirstChance); if (cont && dbg_curr_thread) { - SetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx); + dbg_curr_process->be_cpu->set_context(dbg_curr_thread->handle, &dbg_context); } } break; @@ -527,7 +527,7 @@ static void dbg_resume_debuggee(DWORD cont) dbg_curr_thread->exec_count); if (dbg_curr_thread) { - if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx)) + if (!dbg_curr_process->be_cpu->set_context(dbg_curr_thread->handle, &dbg_context)) dbg_printf("Cannot set ctx on %04lx\n", dbg_curr_tid); } } @@ -989,7 +989,7 @@ static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill) dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); if (dbg_curr_thread->in_exception) { - SetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx); + dbg_curr_process->be_cpu->set_context(dbg_curr_thread->handle, &dbg_context); ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, DBG_CONTINUE); } } diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c index f168633..95af7a6 100644 --- a/programs/winedbg/tgt_minidump.c +++ b/programs/winedbg/tgt_minidump.c @@ -59,6 +59,14 @@ void minidump_write(const char* file, const EXCEPTION_RECORD* rec) MINIDUMP_EXCEPTION_INFORMATION mei; EXCEPTION_POINTERS ep; +#ifdef __x86_64__ + if (dbg_curr_process->be_cpu->machine != IMAGE_FILE_MACHINE_AMD64) + { + FIXME("Cannot write minidump for 32-bit process using 64-bit winedbg\n"); + return; + } +#endif + hFile = CreateFileA(file, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); -- 2.7.4

June 12, 2018

[PATCH 4/5] winedbg: Add a backend-specific vector for retrieving a thread's context.

by Zebediah Figura

This and the next patch remove references to specific context structs or fields elsewhere than in the backends. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- programs/winedbg/be_arm.c | 11 +++++++++++ programs/winedbg/be_arm64.c | 11 +++++++++++ programs/winedbg/be_cpu.h | 3 +++ programs/winedbg/be_i386.c | 7 +++++++ programs/winedbg/be_ppc.c | 11 +++++++++++ programs/winedbg/be_x86_64.c | 11 +++++++++++ programs/winedbg/gdbproxy.c | 2 +- programs/winedbg/stack.c | 4 +--- programs/winedbg/tgt_active.c | 14 +------------- 9 files changed, 57 insertions(+), 17 deletions(-) diff --git a/programs/winedbg/be_arm.c b/programs/winedbg/be_arm.c index b7e42e1..c320704 100644 --- a/programs/winedbg/be_arm.c +++ b/programs/winedbg/be_arm.c @@ -1889,6 +1889,16 @@ static BOOL be_arm_store_integer(const struct dbg_lvalue* lvalue, unsigned size, return memory_write_value(lvalue, size, &val); } +static BOOL be_arm_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __x86_64__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug an ARM process on this architecture.\n"); +#endif +} + struct backend_cpu be_arm = { IMAGE_FILE_MACHINE_ARMNT, @@ -1915,5 +1925,6 @@ struct backend_cpu be_arm = be_arm_fetch_integer, be_arm_fetch_float, be_arm_store_integer, + be_arm_get_context, }; #endif diff --git a/programs/winedbg/be_arm64.c b/programs/winedbg/be_arm64.c index dfeb552..8ee4fb9 100644 --- a/programs/winedbg/be_arm64.c +++ b/programs/winedbg/be_arm64.c @@ -278,6 +278,16 @@ void be_arm64_disasm_one_insn(ADDRESS64 *addr, int display) dbg_printf("be_arm64_disasm_one_insn: not done\n"); } +static BOOL be_arm64_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __x86_64__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug an ARM64 process on this architecture.\n"); +#endif +} + struct backend_cpu be_arm64 = { IMAGE_FILE_MACHINE_ARM64, @@ -304,5 +314,6 @@ struct backend_cpu be_arm64 = be_arm64_fetch_integer, be_arm64_fetch_float, be_arm64_store_integer, + be_arm64_get_context, }; #endif diff --git a/programs/winedbg/be_cpu.h b/programs/winedbg/be_cpu.h index 03776d0..aa7d9f0 100644 --- a/programs/winedbg/be_cpu.h +++ b/programs/winedbg/be_cpu.h @@ -21,6 +21,7 @@ enum be_cpu_addr {be_cpu_addr_pc, be_cpu_addr_stack, be_cpu_addr_frame}; enum be_xpoint_type {be_xpoint_break, be_xpoint_watch_exec, be_xpoint_watch_read, be_xpoint_watch_write, be_xpoint_free=-1}; + struct backend_cpu { const DWORD machine; @@ -114,6 +115,8 @@ struct backend_cpu BOOL (*fetch_float)(const struct dbg_lvalue* lvalue, unsigned size, long double*); /* Writes an integer to memory */ BOOL (*store_integer)(const struct dbg_lvalue* lvalue, unsigned size, BOOL is_signed, LONGLONG); + + BOOL (*get_context)(HANDLE thread, dbg_ctx_t *ctx); }; /* some handy functions for non segmented CPUs */ diff --git a/programs/winedbg/be_i386.c b/programs/winedbg/be_i386.c index bdc2ece..c7f5ac1 100644 --- a/programs/winedbg/be_i386.c +++ b/programs/winedbg/be_i386.c @@ -853,6 +853,12 @@ static BOOL be_i386_store_integer(const struct dbg_lvalue* lvalue, unsigned size return memory_write_value(lvalue, size, &val); } +static BOOL be_i386_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ + ctx->x86.ContextFlags = WOW64_CONTEXT_ALL; + return Wow64GetThreadContext(thread, &ctx->x86); +} + struct backend_cpu be_i386 = { IMAGE_FILE_MACHINE_I386, @@ -879,5 +885,6 @@ struct backend_cpu be_i386 = be_i386_fetch_integer, be_i386_fetch_float, be_i386_store_integer, + be_i386_get_context, }; #endif diff --git a/programs/winedbg/be_ppc.c b/programs/winedbg/be_ppc.c index f1543bf..baf77dc 100644 --- a/programs/winedbg/be_ppc.c +++ b/programs/winedbg/be_ppc.c @@ -180,6 +180,16 @@ static BOOL be_ppc_store_integer(const struct dbg_lvalue* lvalue, unsigned size, return FALSE; } +static BOOL be_ppc_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __powerpc__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug a PowerPC process on this architecture.\n"); +#endif +} + struct backend_cpu be_ppc = { IMAGE_FILE_MACHINE_POWERPC, @@ -206,5 +216,6 @@ struct backend_cpu be_ppc = be_ppc_fetch_integer, be_ppc_fetch_float, be_ppc_store_integer, + be_ppc_get_context, }; #endif diff --git a/programs/winedbg/be_x86_64.c b/programs/winedbg/be_x86_64.c index 450cc87..434f007 100644 --- a/programs/winedbg/be_x86_64.c +++ b/programs/winedbg/be_x86_64.c @@ -674,6 +674,16 @@ static BOOL be_x86_64_store_integer(const struct dbg_lvalue* lvalue, unsigned si return memory_write_value(lvalue, size, &val); } +static BOOL be_x86_64_get_context(HANDLE thread, dbg_ctx_t *ctx) +{ +#ifdef __x86_64__ + ctx->ctx.ContextFlags = CONTEXT_ALL; + return GetThreadContext(thread, &ctx->ctx); +#else + WINE_FIXME("Cannot debug an x86-64 process on this architecture.\n"); +#endif +} + struct backend_cpu be_x86_64 = { IMAGE_FILE_MACHINE_AMD64, @@ -700,5 +710,6 @@ struct backend_cpu be_x86_64 = be_x86_64_fetch_integer, be_x86_64_fetch_float, be_x86_64_store_integer, + be_x86_64_get_context, }; #endif diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index d5786b2..b11a8b0 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -552,7 +552,7 @@ static inline void cpu_register_hex_from(dbg_ctx_t* ctx, unsigned idx, const cha static BOOL fetch_context(struct gdb_context *gdbctx, HANDLE h, dbg_ctx_t *ctx) { - if (!GetThreadContext(h, &ctx->ctx)) + if (!gdbctx->process->be_cpu->get_context(h, ctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Can't get thread's context\n"); diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index a036107..820200d 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -354,11 +354,9 @@ static void backtrace_tid(struct dbg_process* pcs, DWORD tid) dbg_ctx_t ctx = {0}; dbg_curr_tid = dbg_curr_thread->tid; - - ctx.ctx.ContextFlags = CONTEXT_FULL; if (SuspendThread(dbg_curr_thread->handle) != -1) { - if (!GetThreadContext(dbg_curr_thread->handle, &ctx.ctx)) + if (!pcs->be_cpu->get_context(dbg_curr_thread->handle, &ctx)) { dbg_printf("Can't get context for thread %04x in current process\n", tid); diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 8c94402..fccae0c 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -91,19 +91,7 @@ BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe) static unsigned dbg_fetch_context(void) { - dbg_context.ctx.ContextFlags = CONTEXT_CONTROL - | CONTEXT_INTEGER -#ifdef CONTEXT_FLOATING_POINT - | CONTEXT_FLOATING_POINT -#endif -#ifdef CONTEXT_SEGMENTS - | CONTEXT_SEGMENTS -#endif -#ifdef CONTEXT_DEBUG_REGISTERS - | CONTEXT_DEBUG_REGISTERS -#endif - ; - if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx)) + if (!dbg_curr_process->be_cpu->get_context(dbg_curr_thread->handle, &dbg_context)) { WINE_WARN("Can't get thread's context\n"); return FALSE; -- 2.7.4

June 12, 2018

[PATCH 3/5] winedbg: Use WOW64_CONTEXT instead of CONTEXT for i386 backend.

by Zebediah Figura

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- programs/winedbg/be_cpu.h | 22 ++--- programs/winedbg/be_i386.c | 211 ++++++++++++++++++++-------------------- programs/winedbg/be_x86_64.c | 73 +++++++------- programs/winedbg/debugger.h | 12 ++- programs/winedbg/gdbproxy.c | 35 ++++--- programs/winedbg/memory.c | 2 +- programs/winedbg/stack.c | 16 +-- programs/winedbg/tgt_active.c | 10 +- programs/winedbg/tgt_minidump.c | 2 +- programs/winedbg/winedbg.c | 2 +- 10 files changed, 199 insertions(+), 186 deletions(-) diff --git a/programs/winedbg/be_cpu.h b/programs/winedbg/be_cpu.h index 751ac9d..03776d0 100644 --- a/programs/winedbg/be_cpu.h +++ b/programs/winedbg/be_cpu.h @@ -37,13 +37,13 @@ struct backend_cpu * in an ADDRESS64 (except an linear one). * Non segmented CPU shall use be_cpu_build_addr */ - BOOL (*build_addr)(HANDLE hThread, const CONTEXT* ctx, + BOOL (*build_addr)(HANDLE hThread, const dbg_ctx_t *ctx, ADDRESS64* addr, unsigned seg, unsigned long offset); /* Retrieves in addr an address related to the context (program counter, stack * pointer, frame pointer) */ - BOOL (*get_addr)(HANDLE hThread, const CONTEXT* ctx, + BOOL (*get_addr)(HANDLE hThread, const dbg_ctx_t *ctx, enum be_cpu_addr, ADDRESS64* addr); /* returns which kind of information a given register number refers to */ @@ -53,13 +53,13 @@ struct backend_cpu * context manipulation * ------------------------------------------------------------------------------- */ /* Enables/disables CPU single step mode (depending on enable) */ - void (*single_step)(CONTEXT* ctx, BOOL enable); + void (*single_step)(dbg_ctx_t *ctx, BOOL enable); /* Dumps out the content of the context */ - void (*print_context)(HANDLE hThread, const CONTEXT* ctx, int all_regs); + void (*print_context)(HANDLE hThread, const dbg_ctx_t *ctx, int all_regs); /* Prints information about segments. Non segmented CPU should leave this * function empty */ - void (*print_segment_info)(HANDLE hThread, const CONTEXT* ctx); + void (*print_segment_info)(HANDLE hThread, const dbg_ctx_t *ctx); /* all the CONTEXT's relative variables, bound to this CPU */ const struct dbg_internal_var* context_vars; @@ -89,22 +89,22 @@ struct backend_cpu * -------------------------------------------------------------------------------*/ /* Inserts an Xpoint in the CPU context and/or debuggee address space */ BOOL (*insert_Xpoint)(HANDLE hProcess, const struct be_process_io* pio, - CONTEXT* ctx, enum be_xpoint_type type, + dbg_ctx_t *ctx, enum be_xpoint_type type, void* addr, unsigned long* val, unsigned size); /* Removes an Xpoint in the CPU context and/or debuggee address space */ BOOL (*remove_Xpoint)(HANDLE hProcess, const struct be_process_io* pio, - CONTEXT* ctx, enum be_xpoint_type type, + dbg_ctx_t *ctx, enum be_xpoint_type type, void* addr, unsigned long val, unsigned size); /* Checks whether a given watchpoint has been triggered */ - BOOL (*is_watchpoint_set)(const CONTEXT* ctx, unsigned idx); + BOOL (*is_watchpoint_set)(const dbg_ctx_t *ctx, unsigned idx); /* Clears the watchpoint indicator */ - void (*clear_watchpoint)(CONTEXT* ctx, unsigned idx); + void (*clear_watchpoint)(dbg_ctx_t *ctx, unsigned idx); /* After a break instruction is executed, in the corresponding exception handler, * some CPUs report the address of the insn after the break insn, some others * report the address of the break insn itself. * This function lets adjust the context PC to reflect this behavior. */ - int (*adjust_pc_for_break)(CONTEXT* ctx, BOOL way); + int (*adjust_pc_for_break)(dbg_ctx_t *ctx, BOOL way); /* ------------------------------------------------------------------------------- * basic type read/write * -------------------------------------------------------------------------------*/ @@ -118,5 +118,5 @@ struct backend_cpu /* some handy functions for non segmented CPUs */ void* be_cpu_linearize(HANDLE hThread, const ADDRESS64*); -BOOL be_cpu_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, +BOOL be_cpu_build_addr(HANDLE hThread, const dbg_ctx_t *ctx, ADDRESS64* addr, unsigned seg, unsigned long offset); diff --git a/programs/winedbg/be_i386.c b/programs/winedbg/be_i386.c index 4d22708..bdc2ece 100644 --- a/programs/winedbg/be_i386.c +++ b/programs/winedbg/be_i386.c @@ -57,7 +57,7 @@ typedef struct _XMM_SAVE_AREA32 { BYTE Reserved4[96]; /* 1a0 */ } XMM_SAVE_AREA32, *PXMM_SAVE_AREA32; -static ADDRESS_MODE get_selector_type(HANDLE hThread, const CONTEXT* ctx, WORD sel) +static ADDRESS_MODE get_selector_type(HANDLE hThread, const WOW64_CONTEXT *ctx, WORD sel) { LDT_ENTRY le; @@ -93,7 +93,7 @@ static void* be_i386_linearize(HANDLE hThread, const ADDRESS64* addr) return NULL; } -static BOOL be_i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, +static BOOL be_i386_build_addr(HANDLE hThread, const dbg_ctx_t *ctx, ADDRESS64* addr, unsigned seg, unsigned long offset) { addr->Mode = AddrModeFlat; @@ -101,7 +101,7 @@ static BOOL be_i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* ad addr->Offset = offset; if (seg) { - addr->Mode = get_selector_type(hThread, ctx, seg); + addr->Mode = get_selector_type(hThread, &ctx->x86, seg); switch (addr->Mode) { case AddrModeReal: @@ -119,17 +119,17 @@ static BOOL be_i386_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* ad return TRUE; } -static BOOL be_i386_get_addr(HANDLE hThread, const CONTEXT* ctx, +static BOOL be_i386_get_addr(HANDLE hThread, const dbg_ctx_t *ctx, enum be_cpu_addr bca, ADDRESS64* addr) { switch (bca) { case be_cpu_addr_pc: - return be_i386_build_addr(hThread, ctx, addr, ctx->SegCs, ctx->Eip); + return be_i386_build_addr(hThread, ctx, addr, ctx->x86.SegCs, ctx->x86.Eip); case be_cpu_addr_stack: - return be_i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Esp); + return be_i386_build_addr(hThread, ctx, addr, ctx->x86.SegSs, ctx->x86.Esp); case be_cpu_addr_frame: - return be_i386_build_addr(hThread, ctx, addr, ctx->SegSs, ctx->Ebp); + return be_i386_build_addr(hThread, ctx, addr, ctx->x86.SegSs, ctx->x86.Ebp); } return FALSE; } @@ -145,16 +145,17 @@ static BOOL be_i386_get_register_info(int regno, enum be_cpu_addr* kind) return FALSE; } -static void be_i386_single_step(CONTEXT* ctx, BOOL enable) +static void be_i386_single_step(dbg_ctx_t *ctx, BOOL enable) { - if (enable) ctx->EFlags |= STEP_FLAG; - else ctx->EFlags &= ~STEP_FLAG; + if (enable) ctx->x86.EFlags |= STEP_FLAG; + else ctx->x86.EFlags &= ~STEP_FLAG; } -static void be_i386_all_print_context(HANDLE hThread, const CONTEXT* ctx) +static void be_i386_all_print_context(HANDLE hThread, const dbg_ctx_t *pctx) { static const char mxcsr_flags[16][4] = { "IE", "DE", "ZE", "OE", "UE", "PE", "DAZ", "IM", "DM", "ZM", "OM", "UM", "PM", "R-", "R+", "FZ" }; + const WOW64_CONTEXT *ctx = &pctx->x86; XMM_SAVE_AREA32 *xmm_area; long double ST[8]; /* These are for floating regs */ int cnt; @@ -245,9 +246,10 @@ static void be_i386_all_print_context(HANDLE hThread, const CONTEXT* ctx) dbg_printf("\n"); } -static void be_i386_print_context(HANDLE hThread, const CONTEXT* ctx, int all_regs) +static void be_i386_print_context(HANDLE hThread, const dbg_ctx_t *pctx, int all_regs) { static const char flags[] = "aVR-N--ODITSZ-A-P-C"; + const WOW64_CONTEXT *ctx = &pctx->x86; int i; char buf[33]; @@ -287,72 +289,73 @@ static void be_i386_print_context(HANDLE hThread, const CONTEXT* ctx, int all_re break; } - if (all_regs) be_i386_all_print_context(hThread, ctx); /* print floating regs */ + if (all_regs) be_i386_all_print_context(hThread, pctx); } -static void be_i386_print_segment_info(HANDLE hThread, const CONTEXT* ctx) +static void be_i386_print_segment_info(HANDLE hThread, const dbg_ctx_t *ctx) { - if (get_selector_type(hThread, ctx, ctx->SegCs) == AddrMode1616) + if (get_selector_type(hThread, &ctx->x86, ctx->x86.SegCs) == AddrMode1616) { - info_win32_segments(ctx->SegDs >> 3, 1); - if (ctx->SegEs != ctx->SegDs) info_win32_segments(ctx->SegEs >> 3, 1); + info_win32_segments(ctx->x86.SegDs >> 3, 1); + if (ctx->x86.SegEs != ctx->x86.SegDs) + info_win32_segments(ctx->x86.SegEs >> 3, 1); } - info_win32_segments(ctx->SegFs >> 3, 1); + info_win32_segments(ctx->x86.SegFs >> 3, 1); } static struct dbg_internal_var be_i386_ctx[] = { - {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}, - {CV_REG_ST0, "ST0", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[ 0]), dbg_itype_long_real}, - {CV_REG_ST0+1, "ST1", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[10]), dbg_itype_long_real}, - {CV_REG_ST0+2, "ST2", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[20]), dbg_itype_long_real}, - {CV_REG_ST0+3, "ST3", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[30]), dbg_itype_long_real}, - {CV_REG_ST0+4, "ST4", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[40]), dbg_itype_long_real}, - {CV_REG_ST0+5, "ST5", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[50]), dbg_itype_long_real}, - {CV_REG_ST0+6, "ST6", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[60]), dbg_itype_long_real}, - {CV_REG_ST0+7, "ST7", (DWORD_PTR*)FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[70]), dbg_itype_long_real}, - {CV_AMD64_XMM0, "XMM0", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[0])), dbg_itype_m128a}, - {CV_AMD64_XMM0+1, "XMM1", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[1])), dbg_itype_m128a}, - {CV_AMD64_XMM0+2, "XMM2", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[2])), dbg_itype_m128a}, - {CV_AMD64_XMM0+3, "XMM3", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[3])), dbg_itype_m128a}, - {CV_AMD64_XMM0+4, "XMM4", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[4])), dbg_itype_m128a}, - {CV_AMD64_XMM0+5, "XMM5", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[5])), dbg_itype_m128a}, - {CV_AMD64_XMM0+6, "XMM6", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[6])), dbg_itype_m128a}, - {CV_AMD64_XMM0+7, "XMM7", (DWORD_PTR*)(FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[7])), dbg_itype_m128a}, + {CV_REG_AL, "AL", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Eax), dbg_itype_unsigned_char_int}, + {CV_REG_CL, "CL", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ecx), dbg_itype_unsigned_char_int}, + {CV_REG_DL, "DL", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Edx), dbg_itype_unsigned_char_int}, + {CV_REG_BL, "BL", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ebx), dbg_itype_unsigned_char_int}, + {CV_REG_AH, "AH", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, Eax)+1), dbg_itype_unsigned_char_int}, + {CV_REG_CH, "CH", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, Ecx)+1), dbg_itype_unsigned_char_int}, + {CV_REG_DH, "DH", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, Edx)+1), dbg_itype_unsigned_char_int}, + {CV_REG_BH, "BH", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, Ebx)+1), dbg_itype_unsigned_char_int}, + {CV_REG_AX, "AX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Eax), dbg_itype_unsigned_short_int}, + {CV_REG_CX, "CX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ecx), dbg_itype_unsigned_short_int}, + {CV_REG_DX, "DX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Edx), dbg_itype_unsigned_short_int}, + {CV_REG_BX, "BX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ebx), dbg_itype_unsigned_short_int}, + {CV_REG_SP, "SP", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Esp), dbg_itype_unsigned_short_int}, + {CV_REG_BP, "BP", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ebp), dbg_itype_unsigned_short_int}, + {CV_REG_SI, "SI", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Esi), dbg_itype_unsigned_short_int}, + {CV_REG_DI, "DI", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Edi), dbg_itype_unsigned_short_int}, + {CV_REG_EAX, "EAX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Eax), dbg_itype_unsigned_int}, + {CV_REG_ECX, "ECX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ecx), dbg_itype_unsigned_int}, + {CV_REG_EDX, "EDX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Edx), dbg_itype_unsigned_int}, + {CV_REG_EBX, "EBX", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ebx), dbg_itype_unsigned_int}, + {CV_REG_ESP, "ESP", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Esp), dbg_itype_unsigned_int}, + {CV_REG_EBP, "EBP", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Ebp), dbg_itype_unsigned_int}, + {CV_REG_ESI, "ESI", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Esi), dbg_itype_unsigned_int}, + {CV_REG_EDI, "EDI", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Edi), dbg_itype_unsigned_int}, + {CV_REG_ES, "ES", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, SegEs), dbg_itype_unsigned_short_int}, + {CV_REG_CS, "CS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, SegCs), dbg_itype_unsigned_short_int}, + {CV_REG_SS, "SS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, SegSs), dbg_itype_unsigned_short_int}, + {CV_REG_DS, "DS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, SegDs), dbg_itype_unsigned_short_int}, + {CV_REG_FS, "FS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, SegFs), dbg_itype_unsigned_short_int}, + {CV_REG_GS, "GS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, SegGs), dbg_itype_unsigned_short_int}, + {CV_REG_IP, "IP", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Eip), dbg_itype_unsigned_short_int}, + {CV_REG_FLAGS, "FLAGS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, EFlags), dbg_itype_unsigned_short_int}, + {CV_REG_EIP, "EIP", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, Eip), dbg_itype_unsigned_int}, + {CV_REG_EFLAGS, "EFLAGS", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, EFlags), dbg_itype_unsigned_int}, + {CV_REG_ST0, "ST0", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[ 0]), dbg_itype_long_real}, + {CV_REG_ST0+1, "ST1", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[10]), dbg_itype_long_real}, + {CV_REG_ST0+2, "ST2", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[20]), dbg_itype_long_real}, + {CV_REG_ST0+3, "ST3", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[30]), dbg_itype_long_real}, + {CV_REG_ST0+4, "ST4", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[40]), dbg_itype_long_real}, + {CV_REG_ST0+5, "ST5", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[50]), dbg_itype_long_real}, + {CV_REG_ST0+6, "ST6", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[60]), dbg_itype_long_real}, + {CV_REG_ST0+7, "ST7", (DWORD_PTR*)FIELD_OFFSET(WOW64_CONTEXT, FloatSave.RegisterArea[70]), dbg_itype_long_real}, + {CV_AMD64_XMM0, "XMM0", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[0])), dbg_itype_m128a}, + {CV_AMD64_XMM0+1, "XMM1", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[1])), dbg_itype_m128a}, + {CV_AMD64_XMM0+2, "XMM2", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[2])), dbg_itype_m128a}, + {CV_AMD64_XMM0+3, "XMM3", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[3])), dbg_itype_m128a}, + {CV_AMD64_XMM0+4, "XMM4", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[4])), dbg_itype_m128a}, + {CV_AMD64_XMM0+5, "XMM5", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[5])), dbg_itype_m128a}, + {CV_AMD64_XMM0+6, "XMM6", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[6])), dbg_itype_m128a}, + {CV_AMD64_XMM0+7, "XMM7", (DWORD_PTR*)(FIELD_OFFSET(WOW64_CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[7])), dbg_itype_m128a}, {0, NULL, 0, dbg_itype_none} }; @@ -477,8 +480,8 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) unsigned operand_size; ADDRESS_MODE cs_addr_mode; - cs_addr_mode = get_selector_type(dbg_curr_thread->handle, &dbg_context, - dbg_context.SegCs); + cs_addr_mode = get_selector_type(dbg_curr_thread->handle, &dbg_context.x86, + dbg_context.x86.SegCs); operand_size = get_size(cs_addr_mode); /* get operand_size (also getting rid of the various prefixes */ @@ -498,7 +501,7 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) callee->Mode = cs_addr_mode; if (!fetch_value((const char*)insn + 1, operand_size, &delta)) return FALSE; - callee->Segment = dbg_context.SegCs; + callee->Segment = dbg_context.x86.SegCs; callee->Offset = (DWORD)insn + 1 + (operand_size / 8) + delta; return TRUE; @@ -506,7 +509,7 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) if (!dbg_read_memory((const char*)insn + 1 + operand_size / 8, &segment, sizeof(segment))) return FALSE; - callee->Mode = get_selector_type(dbg_curr_thread->handle, &dbg_context, + callee->Mode = get_selector_type(dbg_curr_thread->handle, &dbg_context.x86, segment); if (!fetch_value((const char*)insn + 1, operand_size, &delta)) return FALSE; @@ -521,7 +524,7 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) switch ((ch >> 3) & 0x07) { case 0x02: - segment = dbg_context.SegCs; + segment = dbg_context.x86.SegCs; break; case 0x03: if (!dbg_read_memory((const char*)insn + 1 + operand_size / 8, @@ -555,10 +558,10 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) if (!dbg_read_memory((const char*)addr + operand_size, &segment, sizeof(segment))) return FALSE; } - else segment = dbg_context.SegCs; + else segment = dbg_context.x86.SegCs; if (!dbg_read_memory((const char*)addr, &dst, sizeof(dst))) return FALSE; - callee->Mode = get_selector_type(dbg_curr_thread->handle, &dbg_context, segment); + callee->Mode = get_selector_type(dbg_curr_thread->handle, &dbg_context.x86, segment); callee->Segment = segment; callee->Offset = dst; return TRUE; @@ -567,14 +570,14 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) default: switch (ch & 0x07) { - case 0x00: dst = dbg_context.Eax; break; - case 0x01: dst = dbg_context.Ecx; break; - case 0x02: dst = dbg_context.Edx; break; - case 0x03: dst = dbg_context.Ebx; break; - case 0x04: dst = dbg_context.Esp; break; - case 0x05: dst = dbg_context.Ebp; break; - case 0x06: dst = dbg_context.Esi; break; - case 0x07: dst = dbg_context.Edi; break; + case 0x00: dst = dbg_context.x86.Eax; break; + case 0x01: dst = dbg_context.x86.Ecx; break; + case 0x02: dst = dbg_context.x86.Edx; break; + case 0x03: dst = dbg_context.x86.Ebx; break; + case 0x04: dst = dbg_context.x86.Esp; break; + case 0x05: dst = dbg_context.x86.Ebp; break; + case 0x06: dst = dbg_context.x86.Esi; break; + case 0x07: dst = dbg_context.x86.Edi; break; } if ((ch >> 6) != 0x03) /* indirect address */ { @@ -589,10 +592,10 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) if (!dbg_read_memory((const char*)dst + operand_size, &segment, sizeof(segment))) return FALSE; } - else segment = dbg_context.SegCs; + else segment = dbg_context.x86.SegCs; if (!dbg_read_memory((const char*)dst, &delta, sizeof(delta))) return FALSE; - callee->Mode = get_selector_type(dbg_curr_thread->handle, &dbg_context, + callee->Mode = get_selector_type(dbg_curr_thread->handle, &dbg_context.x86, segment); callee->Segment = segment; callee->Offset = delta; @@ -600,7 +603,7 @@ static BOOL be_i386_is_func_call(const void* insn, ADDRESS64* callee) else { callee->Mode = cs_addr_mode; - callee->Segment = dbg_context.SegCs; + callee->Segment = dbg_context.x86.SegCs; callee->Offset = dst; } } @@ -618,8 +621,8 @@ static BOOL be_i386_is_jump(const void* insn, ADDRESS64* jumpee) unsigned operand_size; ADDRESS_MODE cs_addr_mode; - cs_addr_mode = get_selector_type(dbg_curr_thread->handle, &dbg_context, - dbg_context.SegCs); + cs_addr_mode = get_selector_type(dbg_curr_thread->handle, &dbg_context.x86, + dbg_context.x86.SegCs); operand_size = get_size(cs_addr_mode); /* get operand_size (also getting rid of the various prefixes */ @@ -639,7 +642,7 @@ static BOOL be_i386_is_jump(const void* insn, ADDRESS64* jumpee) jumpee->Mode = cs_addr_mode; if (!fetch_value((const char*)insn + 1, operand_size, &delta)) return FALSE; - jumpee->Segment = dbg_context.SegCs; + jumpee->Segment = dbg_context.x86.SegCs; jumpee->Offset = (DWORD)insn + 1 + (operand_size / 8) + delta; return TRUE; default: WINE_FIXME("unknown %x\n", ch); return FALSE; @@ -672,8 +675,10 @@ static BOOL be_i386_is_jump(const void* insn, ADDRESS64* jumpee) #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr))) #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr)) -static inline int be_i386_get_unused_DR(CONTEXT* ctx, DWORD** r) +static inline int be_i386_get_unused_DR(dbg_ctx_t *pctx, DWORD** r) { + WOW64_CONTEXT *ctx = &pctx->x86; + if (!IS_DR7_SET(ctx->Dr7, 0)) { *r = &ctx->Dr0; @@ -700,7 +705,7 @@ static inline int be_i386_get_unused_DR(CONTEXT* ctx, DWORD** r) } static BOOL be_i386_insert_Xpoint(HANDLE hProcess, const struct be_process_io* pio, - CONTEXT* ctx, enum be_xpoint_type type, + dbg_ctx_t *ctx, enum be_xpoint_type type, void* addr, unsigned long* val, unsigned size) { unsigned char ch; @@ -738,10 +743,10 @@ static BOOL be_i386_insert_Xpoint(HANDLE hProcess, const struct be_process_io* p } *val = reg; /* clear old values */ - ctx->Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg)); + ctx->x86.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg)); /* set the correct ones */ - ctx->Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg); - ctx->Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN; + ctx->x86.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg); + ctx->x86.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN; break; default: dbg_printf("Unknown bp type %c\n", type); @@ -751,7 +756,7 @@ static BOOL be_i386_insert_Xpoint(HANDLE hProcess, const struct be_process_io* p } static BOOL be_i386_remove_Xpoint(HANDLE hProcess, const struct be_process_io* pio, - CONTEXT* ctx, enum be_xpoint_type type, + dbg_ctx_t *ctx, enum be_xpoint_type type, void* addr, unsigned long val, unsigned size) { SIZE_T sz; @@ -772,7 +777,7 @@ static BOOL be_i386_remove_Xpoint(HANDLE hProcess, const struct be_process_io* p case be_xpoint_watch_read: case be_xpoint_watch_write: /* simply disable the entry */ - ctx->Dr7 &= ~DR7_ENABLE_MASK(val); + ctx->x86.Dr7 &= ~DR7_ENABLE_MASK(val); break; default: dbg_printf("Unknown bp type %c\n", type); @@ -781,24 +786,24 @@ static BOOL be_i386_remove_Xpoint(HANDLE hProcess, const struct be_process_io* p return TRUE; } -static BOOL be_i386_is_watchpoint_set(const CONTEXT* ctx, unsigned idx) +static BOOL be_i386_is_watchpoint_set(const dbg_ctx_t *ctx, unsigned idx) { - return ctx->Dr6 & (1 << idx); + return ctx->x86.Dr6 & (1 << idx); } -static void be_i386_clear_watchpoint(CONTEXT* ctx, unsigned idx) +static void be_i386_clear_watchpoint(dbg_ctx_t *ctx, unsigned idx) { - ctx->Dr6 &= ~(1 << idx); + ctx->x86.Dr6 &= ~(1 << idx); } -static int be_i386_adjust_pc_for_break(CONTEXT* ctx, BOOL way) +static int be_i386_adjust_pc_for_break(dbg_ctx_t *ctx, BOOL way) { if (way) { - ctx->Eip--; + ctx->x86.Eip--; return -1; } - ctx->Eip++; + ctx->x86.Eip++; return 1; } diff --git a/programs/winedbg/be_x86_64.c b/programs/winedbg/be_x86_64.c index 280cdec..450cc87 100644 --- a/programs/winedbg/be_x86_64.c +++ b/programs/winedbg/be_x86_64.c @@ -31,23 +31,23 @@ WINE_DEFAULT_DEBUG_CHANNEL(winedbg); #define STEP_FLAG 0x00000100 /* single step flag */ -static BOOL be_x86_64_get_addr(HANDLE hThread, const CONTEXT* ctx, +static BOOL be_x86_64_get_addr(HANDLE hThread, const dbg_ctx_t *ctx, enum be_cpu_addr bca, ADDRESS64* addr) { addr->Mode = AddrModeFlat; switch (bca) { case be_cpu_addr_pc: - addr->Segment = ctx->SegCs; - addr->Offset = ctx->Rip; + addr->Segment = ctx->ctx.SegCs; + addr->Offset = ctx->ctx.Rip; return TRUE; case be_cpu_addr_stack: - addr->Segment = ctx->SegSs; - addr->Offset = ctx->Rsp; + addr->Segment = ctx->ctx.SegSs; + addr->Offset = ctx->ctx.Rsp; return TRUE; case be_cpu_addr_frame: - addr->Segment = ctx->SegSs; - addr->Offset = ctx->Rbp; + addr->Segment = ctx->ctx.SegSs; + addr->Offset = ctx->ctx.Rbp; return TRUE; default: addr->Mode = -1; @@ -67,10 +67,10 @@ static BOOL be_x86_64_get_register_info(int regno, enum be_cpu_addr* kind) return FALSE; } -static void be_x86_64_single_step(CONTEXT* ctx, BOOL enable) +static void be_x86_64_single_step(dbg_ctx_t *ctx, BOOL enable) { - if (enable) ctx->EFlags |= STEP_FLAG; - else ctx->EFlags &= ~STEP_FLAG; + if (enable) ctx->ctx.EFlags |= STEP_FLAG; + else ctx->ctx.EFlags &= ~STEP_FLAG; } static inline long double m128a_to_longdouble(const M128A m) @@ -81,12 +81,13 @@ static inline long double m128a_to_longdouble(const M128A m) return *(long double*)&m; } -static void be_x86_64_print_context(HANDLE hThread, const CONTEXT* ctx, +static void be_x86_64_print_context(HANDLE hThread, const dbg_ctx_t *pctx, int all_regs) { static const char mxcsr_flags[16][4] = { "IE", "DE", "ZE", "OE", "UE", "PE", "DAZ", "IM", "DM", "ZM", "OM", "UM", "PM", "R-", "R+", "FZ" }; static const char flags[] = "aVR-N--ODITSZ-A-P-C"; + const CONTEXT *ctx = &pctx->ctx; char buf[33]; int i; @@ -183,7 +184,7 @@ static void be_x86_64_print_context(HANDLE hThread, const CONTEXT* ctx, } } -static void be_x86_64_print_segment_info(HANDLE hThread, const CONTEXT* ctx) +static void be_x86_64_print_segment_info(HANDLE hThread, const dbg_ctx_t *ctx) { } @@ -390,7 +391,7 @@ static BOOL be_x86_64_is_func_call(const void* insn, ADDRESS64* callee) /* that's the only mode we support anyway */ callee->Mode = AddrModeFlat; - callee->Segment = dbg_context.SegCs; + callee->Segment = dbg_context.ctx.SegCs; switch (ch) { @@ -435,14 +436,14 @@ static BOOL be_x86_64_is_func_call(const void* insn, ADDRESS64* callee) default: switch (f_rm(ch)) { - case 0x00: dst = dbg_context.Rax; break; - case 0x01: dst = dbg_context.Rcx; break; - case 0x02: dst = dbg_context.Rdx; break; - case 0x03: dst = dbg_context.Rbx; break; - case 0x04: dst = dbg_context.Rsp; break; - case 0x05: dst = dbg_context.Rbp; break; - case 0x06: dst = dbg_context.Rsi; break; - case 0x07: dst = dbg_context.Rdi; break; + case 0x00: dst = dbg_context.ctx.Rax; break; + case 0x01: dst = dbg_context.ctx.Rcx; break; + case 0x02: dst = dbg_context.ctx.Rdx; break; + case 0x03: dst = dbg_context.ctx.Rbx; break; + case 0x04: dst = dbg_context.ctx.Rsp; break; + case 0x05: dst = dbg_context.ctx.Rbp; break; + case 0x06: dst = dbg_context.ctx.Rsi; break; + case 0x07: dst = dbg_context.ctx.Rdi; break; } if (f_mod(ch) != 0x03) WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) at %p\n", ch, insn); @@ -494,8 +495,10 @@ extern void be_x86_64_disasm_one_insn(ADDRESS64* addr, int display); #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr))) #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr)) -static inline int be_x86_64_get_unused_DR(CONTEXT* ctx, DWORD64** r) +static inline int be_x86_64_get_unused_DR(dbg_ctx_t *pctx, DWORD64** r) { + CONTEXT *ctx = &pctx->ctx; + if (!IS_DR7_SET(ctx->Dr7, 0)) { *r = &ctx->Dr0; @@ -522,7 +525,7 @@ static inline int be_x86_64_get_unused_DR(CONTEXT* ctx, DWORD64** r) } static BOOL be_x86_64_insert_Xpoint(HANDLE hProcess, const struct be_process_io* pio, - CONTEXT* ctx, enum be_xpoint_type type, + dbg_ctx_t *ctx, enum be_xpoint_type type, void* addr, unsigned long* val, unsigned size) { unsigned char ch; @@ -561,10 +564,10 @@ static BOOL be_x86_64_insert_Xpoint(HANDLE hProcess, const struct be_process_io* } *val = reg; /* clear old values */ - ctx->Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg)); + ctx->ctx.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg)); /* set the correct ones */ - ctx->Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg); - ctx->Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN; + ctx->ctx.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg); + ctx->ctx.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN; break; default: dbg_printf("Unknown bp type %c\n", type); @@ -574,7 +577,7 @@ static BOOL be_x86_64_insert_Xpoint(HANDLE hProcess, const struct be_process_io* } static BOOL be_x86_64_remove_Xpoint(HANDLE hProcess, const struct be_process_io* pio, - CONTEXT* ctx, enum be_xpoint_type type, + dbg_ctx_t *ctx, enum be_xpoint_type type, void* addr, unsigned long val, unsigned size) { SIZE_T sz; @@ -594,7 +597,7 @@ static BOOL be_x86_64_remove_Xpoint(HANDLE hProcess, const struct be_process_io* case be_xpoint_watch_read: case be_xpoint_watch_write: /* simply disable the entry */ - ctx->Dr7 &= ~DR7_ENABLE_MASK(val); + ctx->ctx.Dr7 &= ~DR7_ENABLE_MASK(val); break; default: dbg_printf("Unknown bp type %c\n", type); @@ -603,24 +606,24 @@ static BOOL be_x86_64_remove_Xpoint(HANDLE hProcess, const struct be_process_io* return TRUE; } -static BOOL be_x86_64_is_watchpoint_set(const CONTEXT* ctx, unsigned idx) +static BOOL be_x86_64_is_watchpoint_set(const dbg_ctx_t *ctx, unsigned idx) { - return ctx->Dr6 & (1 << idx); + return ctx->ctx.Dr6 & (1 << idx); } -static void be_x86_64_clear_watchpoint(CONTEXT* ctx, unsigned idx) +static void be_x86_64_clear_watchpoint(dbg_ctx_t *ctx, unsigned idx) { - ctx->Dr6 &= ~(1 << idx); + ctx->ctx.Dr6 &= ~(1 << idx); } -static int be_x86_64_adjust_pc_for_break(CONTEXT* ctx, BOOL way) +static int be_x86_64_adjust_pc_for_break(dbg_ctx_t *ctx, BOOL way) { if (way) { - ctx->Rip--; + ctx->ctx.Rip--; return -1; } - ctx->Rip++; + ctx->ctx.Rip++; return 1; } diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index 0ceb150..490bd06 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -170,6 +170,12 @@ typedef struct tagTHREADNAME_INFO DWORD dwFlags; /* Reserved for future use. Must be zero. */ } THREADNAME_INFO; +typedef union dbg_ctx +{ + CONTEXT ctx; + WOW64_CONTEXT x86; +} dbg_ctx_t; + struct dbg_thread { struct list entry; @@ -196,7 +202,7 @@ struct dbg_thread DWORD_PTR linear_pc; DWORD_PTR linear_frame; DWORD_PTR linear_stack; - CONTEXT context; /* context we got out of stackwalk for this frame */ + dbg_ctx_t context; /* context we got out of stackwalk for this frame */ BOOL is_ctx_valid; /* is the context above valid */ }* frames; int num_frames; @@ -255,7 +261,7 @@ extern struct dbg_process* dbg_curr_process; extern DWORD_PTR dbg_curr_pid; extern struct dbg_thread* dbg_curr_thread; extern DWORD_PTR dbg_curr_tid; -extern CONTEXT dbg_context; +extern dbg_ctx_t dbg_context; extern BOOL dbg_interactiveP; extern HANDLE dbg_houtput; @@ -396,7 +402,7 @@ 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_frame(const struct dbg_internal_var* div, DWORD_PTR** pval); -extern unsigned stack_fetch_frames(const CONTEXT* ctx); +extern unsigned stack_fetch_frames(const dbg_ctx_t *ctx); extern BOOL stack_get_current_symbol(SYMBOL_INFO* sym); /* symbol.c */ diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 8742135..d5786b2 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -95,7 +95,7 @@ struct gdb_context /* current Win32 trap env */ unsigned last_sig; BOOL in_trap; - CONTEXT context; + dbg_ctx_t context; /* Win32 information */ struct dbg_process* process; /* Unix environment */ @@ -497,13 +497,13 @@ static struct cpu_register cpu_register_map[] = { static const size_t cpu_num_regs = (sizeof(cpu_register_map) / sizeof(cpu_register_map[0])); -static inline void* cpu_register_ptr(CONTEXT* ctx, unsigned idx) +static inline void* cpu_register_ptr(dbg_ctx_t *ctx, unsigned idx) { assert(idx < cpu_num_regs); return (char*)ctx + cpu_register_map[idx].ctx_offset; } -static inline DWORD64 cpu_register(CONTEXT* ctx, unsigned idx) +static inline DWORD64 cpu_register(dbg_ctx_t *ctx, unsigned idx) { switch (cpu_register_map[idx].ctx_length) { @@ -518,7 +518,7 @@ static inline DWORD64 cpu_register(CONTEXT* ctx, unsigned idx) } } -static inline void cpu_register_hex_from(CONTEXT* ctx, unsigned idx, const char** phex) +static inline void cpu_register_hex_from(dbg_ctx_t* ctx, unsigned idx, const char **phex) { if (cpu_register_map[idx].gdb_length == cpu_register_map[idx].ctx_length) hex_from(cpu_register_ptr(ctx, idx), *phex, cpu_register_map[idx].gdb_length); @@ -550,10 +550,9 @@ static inline void cpu_register_hex_from(CONTEXT* ctx, unsigned idx, const * =============================================== * */ -static BOOL fetch_context(struct gdb_context* gdbctx, HANDLE h, CONTEXT* ctx) +static BOOL fetch_context(struct gdb_context *gdbctx, HANDLE h, dbg_ctx_t *ctx) { - ctx->ContextFlags = CONTEXT_ALL; - if (!GetThreadContext(h, ctx)) + if (!GetThreadContext(h, &ctx->ctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Can't get thread's context\n"); @@ -769,7 +768,7 @@ static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont) { if (dbg_curr_thread) { - if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context)) + if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context.ctx)) if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) @@ -789,7 +788,7 @@ static void resume_debuggee_thread(struct gdb_context* gdbctx, DWORD cont, unsig { if(dbg_curr_thread->tid == threadid){ /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */ - if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context)) + if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context.ctx)) if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %04x\n", dbg_curr_thread->tid); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) @@ -1443,7 +1442,7 @@ static enum packet_return packet_detach(struct gdb_context* gdbctx) static enum packet_return packet_read_registers(struct gdb_context* gdbctx) { int i; - CONTEXT ctx; + dbg_ctx_t ctx; assert(gdbctx->in_trap); @@ -1463,8 +1462,8 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx) static enum packet_return packet_write_registers(struct gdb_context* gdbctx) { unsigned i; - CONTEXT ctx; - CONTEXT* pctx = &gdbctx->context; + dbg_ctx_t ctx; + dbg_ctx_t *pctx = &gdbctx->context; const char* ptr; assert(gdbctx->in_trap); @@ -1479,7 +1478,7 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx) for (i = 0; i < cpu_num_regs; i++) cpu_register_hex_from(pctx, i, &ptr); - if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx)) + if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, &pctx->ctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %04x\n", gdbctx->other_thread->tid); @@ -1616,8 +1615,8 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx) static enum packet_return packet_read_register(struct gdb_context* gdbctx) { unsigned reg; - CONTEXT ctx; - CONTEXT* pctx = &gdbctx->context; + dbg_ctx_t ctx; + dbg_ctx_t *pctx = &gdbctx->context; assert(gdbctx->in_trap); reg = hex_to_int(gdbctx->in_packet, gdbctx->in_packet_len); @@ -1650,8 +1649,8 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) { unsigned reg; char* ptr; - CONTEXT ctx; - CONTEXT* pctx = &gdbctx->context; + dbg_ctx_t ctx; + dbg_ctx_t *pctx = &gdbctx->context; assert(gdbctx->in_trap); @@ -1678,7 +1677,7 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) } cpu_register_hex_from(pctx, reg, (const char**)&ptr); - if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx)) + if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, &pctx->ctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context for thread %04x\n", gdbctx->other_thread->tid); diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index 6e65fa6..f3585f2 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -39,7 +39,7 @@ void* be_cpu_linearize(HANDLE hThread, const ADDRESS64* addr) return (void*)(DWORD_PTR)addr->Offset; } -BOOL be_cpu_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, +BOOL be_cpu_build_addr(HANDLE hThread, const dbg_ctx_t *ctx, ADDRESS64* addr, unsigned seg, unsigned long offset) { addr->Mode = AddrModeFlat; diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index 2ab4e60..a036107 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -184,14 +184,14 @@ static BOOL CALLBACK stack_read_mem(HANDLE hProc, DWORD64 addr, * * Do a backtrace on the current thread */ -unsigned stack_fetch_frames(const CONTEXT* _ctx) +unsigned stack_fetch_frames(const dbg_ctx_t* _ctx) { STACKFRAME64 sf; unsigned nf = 0; /* as native stackwalk can modify the context passed to it, simply copy * it to avoid any damage */ - CONTEXT ctx = *_ctx; + dbg_ctx_t ctx = *_ctx; BOOL ret; HeapFree(GetProcessHeap(), 0, dbg_curr_thread->frames); @@ -351,21 +351,21 @@ static void backtrace_tid(struct dbg_process* pcs, DWORD tid) dbg_printf("Unknown thread id (%04x) in process (%04x)\n", tid, pcs->pid); else { - CONTEXT context; + dbg_ctx_t ctx = {0}; dbg_curr_tid = dbg_curr_thread->tid; - memset(&context, 0, sizeof(context)); - context.ContextFlags = CONTEXT_FULL; + + ctx.ctx.ContextFlags = CONTEXT_FULL; if (SuspendThread(dbg_curr_thread->handle) != -1) { - if (!GetThreadContext(dbg_curr_thread->handle, &context)) + if (!GetThreadContext(dbg_curr_thread->handle, &ctx.ctx)) { dbg_printf("Can't get context for thread %04x in current process\n", tid); } else { - stack_fetch_frames(&context); + stack_fetch_frames(&ctx); backtrace(); } ResumeThread(dbg_curr_thread->handle); @@ -386,7 +386,7 @@ static void backtrace_all(void) { struct dbg_process* process = dbg_curr_process; struct dbg_thread* thread = dbg_curr_thread; - CONTEXT ctx = dbg_context; + dbg_ctx_t ctx = dbg_context; DWORD cpid = dbg_curr_pid; THREADENTRY32 entry; HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index d891cfe..8c94402 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -91,7 +91,7 @@ BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe) static unsigned dbg_fetch_context(void) { - dbg_context.ContextFlags = CONTEXT_CONTROL + dbg_context.ctx.ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER #ifdef CONTEXT_FLOATING_POINT | CONTEXT_FLOATING_POINT @@ -103,7 +103,7 @@ static unsigned dbg_fetch_context(void) | CONTEXT_DEBUG_REGISTERS #endif ; - if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context)) + if (!GetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx)) { WINE_WARN("Can't get thread's context\n"); return FALSE; @@ -356,7 +356,7 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de) de->u.Exception.dwFirstChance); if (cont && dbg_curr_thread) { - SetThreadContext(dbg_curr_thread->handle, &dbg_context); + SetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx); } } break; @@ -539,7 +539,7 @@ static void dbg_resume_debuggee(DWORD cont) dbg_curr_thread->exec_count); if (dbg_curr_thread) { - if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context)) + if (!SetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx)) dbg_printf("Cannot set ctx on %04lx\n", dbg_curr_tid); } } @@ -1001,7 +1001,7 @@ static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill) dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); if (dbg_curr_thread->in_exception) { - SetThreadContext(dbg_curr_thread->handle, &dbg_context); + SetThreadContext(dbg_curr_thread->handle, &dbg_context.ctx); ContinueDebugEvent(dbg_curr_pid, dbg_curr_tid, DBG_CONTINUE); } } diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c index a17f32b..f168633 100644 --- a/programs/winedbg/tgt_minidump.c +++ b/programs/winedbg/tgt_minidump.c @@ -69,7 +69,7 @@ void minidump_write(const char* file, const EXCEPTION_RECORD* rec) mei.ThreadId = dbg_curr_thread->tid; mei.ExceptionPointers = &ep; ep.ExceptionRecord = (EXCEPTION_RECORD*)rec; - ep.ContextRecord = &dbg_context; + ep.ContextRecord = &dbg_context.ctx; mei.ClientPointers = FALSE; } MiniDumpWriteDump(dbg_curr_process->handle, dbg_curr_process->pid, diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c index b32b24c..b5ffd76 100644 --- a/programs/winedbg/winedbg.c +++ b/programs/winedbg/winedbg.c @@ -87,7 +87,7 @@ struct dbg_process* dbg_curr_process = NULL; struct dbg_thread* dbg_curr_thread = NULL; DWORD_PTR dbg_curr_tid = 0; DWORD_PTR dbg_curr_pid = 0; -CONTEXT dbg_context; +dbg_ctx_t dbg_context; BOOL dbg_interactiveP = FALSE; HANDLE dbg_houtput = 0; -- 2.7.4

June 12, 2018

[PATCH 2/5] winedbg/gdbproxy: Remove unnecessary checks for supported context flags.

by Zebediah Figura

And simplify the assignment to use CONTEXT_ALL instead. If we don't support reading from a register then we just ignore its value. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- programs/winedbg/gdbproxy.c | 478 ++++++++++++++++++++------------------------ 1 file changed, 222 insertions(+), 256 deletions(-) diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index a9a65c2..8742135 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -199,10 +199,9 @@ struct cpu_register size_t ctx_offset; size_t ctx_length; size_t gdb_length; - ULONG ctx_flags; }; -#define REG(r,gs,m) {FIELD_OFFSET(CONTEXT, r), sizeof(((CONTEXT*)NULL)->r), gs, m} +#define REG(r,gs) {FIELD_OFFSET(CONTEXT, r), sizeof(((CONTEXT*)NULL)->r), gs} #ifdef __i386__ typedef struct DECLSPEC_ALIGN(16) _M128A { @@ -231,185 +230,185 @@ typedef struct _XMM_SAVE_AREA32 { static const char target_xml[] = ""; static struct cpu_register cpu_register_map[] = { - REG(Eax, 4, CONTEXT_INTEGER), - REG(Ecx, 4, CONTEXT_INTEGER), - REG(Edx, 4, CONTEXT_INTEGER), - REG(Ebx, 4, CONTEXT_INTEGER), - REG(Esp, 4, CONTEXT_CONTROL), - REG(Ebp, 4, CONTEXT_CONTROL), - REG(Esi, 4, CONTEXT_INTEGER), - REG(Edi, 4, CONTEXT_INTEGER), - REG(Eip, 4, CONTEXT_CONTROL), - REG(EFlags, 4, CONTEXT_CONTROL), - REG(SegCs, 4, CONTEXT_CONTROL), - REG(SegSs, 4, CONTEXT_SEGMENTS), - REG(SegDs, 4, CONTEXT_SEGMENTS), - REG(SegEs, 4, CONTEXT_SEGMENTS), - REG(SegFs, 4, CONTEXT_SEGMENTS), - REG(SegGs, 4, CONTEXT_SEGMENTS), - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[ 0]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[10]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[20]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[30]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[40]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[50]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[60]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[70]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.ControlWord), 2, 4, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.StatusWord), 2, 4, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.TagWord), 2, 4, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, FloatSave.ErrorSelector), 2, 4, CONTEXT_FLOATING_POINT }, - REG(FloatSave.ErrorOffset, 4, CONTEXT_FLOATING_POINT ), - { FIELD_OFFSET(CONTEXT, FloatSave.DataSelector), 2, 4, CONTEXT_FLOATING_POINT }, - REG(FloatSave.DataOffset, 4, CONTEXT_FLOATING_POINT ), - { FIELD_OFFSET(CONTEXT, FloatSave.ErrorSelector)+2, 2, 4, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[0]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[1]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[2]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[3]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[4]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[5]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[6]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[7]), 16, 16, CONTEXT_EXTENDED_REGISTERS }, - { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, MxCsr), 4, 4, CONTEXT_EXTENDED_REGISTERS }, + REG(Eax, 4), + REG(Ecx, 4), + REG(Edx, 4), + REG(Ebx, 4), + REG(Esp, 4), + REG(Ebp, 4), + REG(Esi, 4), + REG(Edi, 4), + REG(Eip, 4), + REG(EFlags, 4), + REG(SegCs, 4), + REG(SegSs, 4), + REG(SegDs, 4), + REG(SegEs, 4), + REG(SegFs, 4), + REG(SegGs, 4), + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[ 0]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[10]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[20]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[30]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[40]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[50]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[60]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.RegisterArea[70]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, FloatSave.ControlWord), 2, 4 }, + { FIELD_OFFSET(CONTEXT, FloatSave.StatusWord), 2, 4 }, + { FIELD_OFFSET(CONTEXT, FloatSave.TagWord), 2, 4 }, + { FIELD_OFFSET(CONTEXT, FloatSave.ErrorSelector), 2, 4 }, + REG(FloatSave.ErrorOffset, 4 ), + { FIELD_OFFSET(CONTEXT, FloatSave.DataSelector), 2, 4 }, + REG(FloatSave.DataOffset, 4 ), + { FIELD_OFFSET(CONTEXT, FloatSave.ErrorSelector)+2, 2, 4 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[0]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[1]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[2]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[3]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[4]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[5]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[6]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, XmmRegisters[7]), 16, 16 }, + { FIELD_OFFSET(CONTEXT, ExtendedRegisters) + FIELD_OFFSET(XMM_SAVE_AREA32, MxCsr), 4, 4 }, }; #elif defined(__powerpc__) static const char target_xml[] = ""; static struct cpu_register cpu_register_map[] = { - REG(Gpr0, 4, CONTEXT_INTEGER), - REG(Gpr1, 4, CONTEXT_INTEGER), - REG(Gpr2, 4, CONTEXT_INTEGER), - REG(Gpr3, 4, CONTEXT_INTEGER), - REG(Gpr4, 4, CONTEXT_INTEGER), - REG(Gpr5, 4, CONTEXT_INTEGER), - REG(Gpr6, 4, CONTEXT_INTEGER), - REG(Gpr7, 4, CONTEXT_INTEGER), - REG(Gpr8, 4, CONTEXT_INTEGER), - REG(Gpr9, 4, CONTEXT_INTEGER), - REG(Gpr10, 4, CONTEXT_INTEGER), - REG(Gpr11, 4, CONTEXT_INTEGER), - REG(Gpr12, 4, CONTEXT_INTEGER), - REG(Gpr13, 4, CONTEXT_INTEGER), - REG(Gpr14, 4, CONTEXT_INTEGER), - REG(Gpr15, 4, CONTEXT_INTEGER), - REG(Gpr16, 4, CONTEXT_INTEGER), - REG(Gpr17, 4, CONTEXT_INTEGER), - REG(Gpr18, 4, CONTEXT_INTEGER), - REG(Gpr19, 4, CONTEXT_INTEGER), - REG(Gpr20, 4, CONTEXT_INTEGER), - REG(Gpr21, 4, CONTEXT_INTEGER), - REG(Gpr22, 4, CONTEXT_INTEGER), - REG(Gpr23, 4, CONTEXT_INTEGER), - REG(Gpr24, 4, CONTEXT_INTEGER), - REG(Gpr25, 4, CONTEXT_INTEGER), - REG(Gpr26, 4, CONTEXT_INTEGER), - REG(Gpr27, 4, CONTEXT_INTEGER), - REG(Gpr28, 4, CONTEXT_INTEGER), - REG(Gpr29, 4, CONTEXT_INTEGER), - REG(Gpr30, 4, CONTEXT_INTEGER), - REG(Gpr31, 4, CONTEXT_INTEGER), - REG(Fpr0, 4, CONTEXT_FLOATING_POINT), - REG(Fpr1, 4, CONTEXT_FLOATING_POINT), - REG(Fpr2, 4, CONTEXT_FLOATING_POINT), - REG(Fpr3, 4, CONTEXT_FLOATING_POINT), - REG(Fpr4, 4, CONTEXT_FLOATING_POINT), - REG(Fpr5, 4, CONTEXT_FLOATING_POINT), - REG(Fpr6, 4, CONTEXT_FLOATING_POINT), - REG(Fpr7, 4, CONTEXT_FLOATING_POINT), - REG(Fpr8, 4, CONTEXT_FLOATING_POINT), - REG(Fpr9, 4, CONTEXT_FLOATING_POINT), - REG(Fpr10, 4, CONTEXT_FLOATING_POINT), - REG(Fpr11, 4, CONTEXT_FLOATING_POINT), - REG(Fpr12, 4, CONTEXT_FLOATING_POINT), - REG(Fpr13, 4, CONTEXT_FLOATING_POINT), - REG(Fpr14, 4, CONTEXT_FLOATING_POINT), - REG(Fpr15, 4, CONTEXT_FLOATING_POINT), - REG(Fpr16, 4, CONTEXT_FLOATING_POINT), - REG(Fpr17, 4, CONTEXT_FLOATING_POINT), - REG(Fpr18, 4, CONTEXT_FLOATING_POINT), - REG(Fpr19, 4, CONTEXT_FLOATING_POINT), - REG(Fpr20, 4, CONTEXT_FLOATING_POINT), - REG(Fpr21, 4, CONTEXT_FLOATING_POINT), - REG(Fpr22, 4, CONTEXT_FLOATING_POINT), - REG(Fpr23, 4, CONTEXT_FLOATING_POINT), - REG(Fpr24, 4, CONTEXT_FLOATING_POINT), - REG(Fpr25, 4, CONTEXT_FLOATING_POINT), - REG(Fpr26, 4, CONTEXT_FLOATING_POINT), - REG(Fpr27, 4, CONTEXT_FLOATING_POINT), - REG(Fpr28, 4, CONTEXT_FLOATING_POINT), - REG(Fpr29, 4, CONTEXT_FLOATING_POINT), - REG(Fpr30, 4, CONTEXT_FLOATING_POINT), - REG(Fpr31, 4, CONTEXT_FLOATING_POINT), + REG(Gpr0, 4), + REG(Gpr1, 4), + REG(Gpr2, 4), + REG(Gpr3, 4), + REG(Gpr4, 4), + REG(Gpr5, 4), + REG(Gpr6, 4), + REG(Gpr7, 4), + REG(Gpr8, 4), + REG(Gpr9, 4), + REG(Gpr10, 4), + REG(Gpr11, 4), + REG(Gpr12, 4), + REG(Gpr13, 4), + REG(Gpr14, 4), + REG(Gpr15, 4), + REG(Gpr16, 4), + REG(Gpr17, 4), + REG(Gpr18, 4), + REG(Gpr19, 4), + REG(Gpr20, 4), + REG(Gpr21, 4), + REG(Gpr22, 4), + REG(Gpr23, 4), + REG(Gpr24, 4), + REG(Gpr25, 4), + REG(Gpr26, 4), + REG(Gpr27, 4), + REG(Gpr28, 4), + REG(Gpr29, 4), + REG(Gpr30, 4), + REG(Gpr31, 4), + REG(Fpr0, 4), + REG(Fpr1, 4), + REG(Fpr2, 4), + REG(Fpr3, 4), + REG(Fpr4, 4), + REG(Fpr5, 4), + REG(Fpr6, 4), + REG(Fpr7, 4), + REG(Fpr8, 4), + REG(Fpr9, 4), + REG(Fpr10, 4), + REG(Fpr11, 4), + REG(Fpr12, 4), + REG(Fpr13, 4), + REG(Fpr14, 4), + REG(Fpr15, 4), + REG(Fpr16, 4), + REG(Fpr17, 4), + REG(Fpr18, 4), + REG(Fpr19, 4), + REG(Fpr20, 4), + REG(Fpr21, 4), + REG(Fpr22, 4), + REG(Fpr23, 4), + REG(Fpr24, 4), + REG(Fpr25, 4), + REG(Fpr26, 4), + REG(Fpr27, 4), + REG(Fpr28, 4), + REG(Fpr29, 4), + REG(Fpr30, 4), + REG(Fpr31, 4), - REG(Iar, 4, CONTEXT_CONTROL), - REG(Msr, 4, CONTEXT_CONTROL), - REG(Cr, 4, CONTEXT_INTEGER), - REG(Lr, 4, CONTEXT_CONTROL), - REG(Ctr, 4, CONTEXT_CONTROL), - REG(Xer, 4, CONTEXT_INTEGER), + REG(Iar, 4), + REG(Msr, 4), + REG(Cr, 4), + REG(Lr, 4), + REG(Ctr, 4), + REG(Xer, 4), /* FIXME: MQ is missing? FIELD_OFFSET(CONTEXT, Mq), */ /* see gdb/nlm/ppc.c */ }; #elif defined(__x86_64__) static const char target_xml[] = ""; static struct cpu_register cpu_register_map[] = { - REG(Rax, 8, CONTEXT_INTEGER), - REG(Rbx, 8, CONTEXT_INTEGER), - REG(Rcx, 8, CONTEXT_INTEGER), - REG(Rdx, 8, CONTEXT_INTEGER), - REG(Rsi, 8, CONTEXT_INTEGER), - REG(Rdi, 8, CONTEXT_INTEGER), - REG(Rbp, 8, CONTEXT_INTEGER), - REG(Rsp, 8, CONTEXT_INTEGER), - REG(R8, 8, CONTEXT_INTEGER), - REG(R9, 8, CONTEXT_INTEGER), - REG(R10, 8, CONTEXT_INTEGER), - REG(R11, 8, CONTEXT_INTEGER), - REG(R12, 8, CONTEXT_INTEGER), - REG(R13, 8, CONTEXT_INTEGER), - REG(R14, 8, CONTEXT_INTEGER), - REG(R15, 8, CONTEXT_INTEGER), - REG(Rip, 8, CONTEXT_CONTROL), - REG(EFlags, 4, CONTEXT_CONTROL), - REG(SegCs, 4, CONTEXT_CONTROL), - REG(SegSs, 4, CONTEXT_CONTROL), - REG(SegDs, 4, CONTEXT_SEGMENTS), - REG(SegEs, 4, CONTEXT_SEGMENTS), - REG(SegFs, 4, CONTEXT_SEGMENTS), - REG(SegGs, 4, CONTEXT_SEGMENTS), - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 0]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 1]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 2]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 3]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 4]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 5]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 6]), 10, 10, CONTEXT_FLOATING_POINT }, - { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 7]), 10, 10, CONTEXT_FLOATING_POINT }, - REG(u.FltSave.ControlWord, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.StatusWord, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.TagWord, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.ErrorSelector, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.ErrorOffset, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.DataSelector, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.DataOffset, 4, CONTEXT_FLOATING_POINT), - REG(u.FltSave.ErrorOpcode, 4, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm0, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm1, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm2, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm3, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm4, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm5, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm6, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm7, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm8, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm9, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm10, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm11, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm12, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm13, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm14, 16, CONTEXT_FLOATING_POINT), - REG(u.s.Xmm15, 16, CONTEXT_FLOATING_POINT), - REG(u.FltSave.MxCsr, 4, CONTEXT_FLOATING_POINT), + REG(Rax, 8), + REG(Rbx, 8), + REG(Rcx, 8), + REG(Rdx, 8), + REG(Rsi, 8), + REG(Rdi, 8), + REG(Rbp, 8), + REG(Rsp, 8), + REG(R8, 8), + REG(R9, 8), + REG(R10, 8), + REG(R11, 8), + REG(R12, 8), + REG(R13, 8), + REG(R14, 8), + REG(R15, 8), + REG(Rip, 8), + REG(EFlags, 4), + REG(SegCs, 4), + REG(SegSs, 4), + REG(SegDs, 4), + REG(SegEs, 4), + REG(SegFs, 4), + REG(SegGs, 4), + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 0]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 1]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 2]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 3]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 4]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 5]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 6]), 10, 10 }, + { FIELD_OFFSET(CONTEXT, u.FltSave.FloatRegisters[ 7]), 10, 10 }, + REG(u.FltSave.ControlWord, 4), + REG(u.FltSave.StatusWord, 4), + REG(u.FltSave.TagWord, 4), + REG(u.FltSave.ErrorSelector, 4), + REG(u.FltSave.ErrorOffset, 4), + REG(u.FltSave.DataSelector, 4), + REG(u.FltSave.DataOffset, 4), + REG(u.FltSave.ErrorOpcode, 4), + REG(u.s.Xmm0, 16), + REG(u.s.Xmm1, 16), + REG(u.s.Xmm2, 16), + REG(u.s.Xmm3, 16), + REG(u.s.Xmm4, 16), + REG(u.s.Xmm5, 16), + REG(u.s.Xmm6, 16), + REG(u.s.Xmm7, 16), + REG(u.s.Xmm8, 16), + REG(u.s.Xmm9, 16), + REG(u.s.Xmm10, 16), + REG(u.s.Xmm11, 16), + REG(u.s.Xmm12, 16), + REG(u.s.Xmm13, 16), + REG(u.s.Xmm14, 16), + REG(u.s.Xmm15, 16), + REG(u.FltSave.MxCsr, 4), }; #elif defined(__arm__) static const char target_xml[] = @@ -435,61 +434,61 @@ static const char target_xml[] = "</feature></target>\n"; static struct cpu_register cpu_register_map[] = { - REG(R0, 4, CONTEXT_INTEGER), - REG(R1, 4, CONTEXT_INTEGER), - REG(R2, 4, CONTEXT_INTEGER), - REG(R3, 4, CONTEXT_INTEGER), - REG(R4, 4, CONTEXT_INTEGER), - REG(R5, 4, CONTEXT_INTEGER), - REG(R6, 4, CONTEXT_INTEGER), - REG(R7, 4, CONTEXT_INTEGER), - REG(R8, 4, CONTEXT_INTEGER), - REG(R9, 4, CONTEXT_INTEGER), - REG(R10, 4, CONTEXT_INTEGER), - REG(R11, 4, CONTEXT_INTEGER), - REG(R12, 4, CONTEXT_INTEGER), - REG(Sp, 4, CONTEXT_CONTROL), - REG(Lr, 4, CONTEXT_CONTROL), - REG(Pc, 4, CONTEXT_CONTROL), - REG(Cpsr, 4, CONTEXT_CONTROL), + REG(R0, 4), + REG(R1, 4), + REG(R2, 4), + REG(R3, 4), + REG(R4, 4), + REG(R5, 4), + REG(R6, 4), + REG(R7, 4), + REG(R8, 4), + REG(R9, 4), + REG(R10, 4), + REG(R11, 4), + REG(R12, 4), + REG(Sp, 4), + REG(Lr, 4), + REG(Pc, 4), + REG(Cpsr, 4), }; #elif defined(__aarch64__) static const char target_xml[] = ""; static struct cpu_register cpu_register_map[] = { - REG(Cpsr, 4, CONTEXT_CONTROL), - REG(u.s.X0, 8, CONTEXT_INTEGER), - REG(u.s.X1, 8, CONTEXT_INTEGER), - REG(u.s.X2, 8, CONTEXT_INTEGER), - REG(u.s.X3, 8, CONTEXT_INTEGER), - REG(u.s.X4, 8, CONTEXT_INTEGER), - REG(u.s.X5, 8, CONTEXT_INTEGER), - REG(u.s.X6, 8, CONTEXT_INTEGER), - REG(u.s.X7, 8, CONTEXT_INTEGER), - REG(u.s.X8, 8, CONTEXT_INTEGER), - REG(u.s.X9, 8, CONTEXT_INTEGER), - REG(u.s.X10, 8, CONTEXT_INTEGER), - REG(u.s.X11, 8, CONTEXT_INTEGER), - REG(u.s.X12, 8, CONTEXT_INTEGER), - REG(u.s.X13, 8, CONTEXT_INTEGER), - REG(u.s.X14, 8, CONTEXT_INTEGER), - REG(u.s.X15, 8, CONTEXT_INTEGER), - REG(u.s.X16, 8, CONTEXT_INTEGER), - REG(u.s.X17, 8, CONTEXT_INTEGER), - REG(u.s.X18, 8, CONTEXT_INTEGER), - REG(u.s.X19, 8, CONTEXT_INTEGER), - REG(u.s.X20, 8, CONTEXT_INTEGER), - REG(u.s.X21, 8, CONTEXT_INTEGER), - REG(u.s.X22, 8, CONTEXT_INTEGER), - REG(u.s.X23, 8, CONTEXT_INTEGER), - REG(u.s.X24, 8, CONTEXT_INTEGER), - REG(u.s.X25, 8, CONTEXT_INTEGER), - REG(u.s.X26, 8, CONTEXT_INTEGER), - REG(u.s.X27, 8, CONTEXT_INTEGER), - REG(u.s.X28, 8, CONTEXT_INTEGER), - REG(u.s.Fp, 8, CONTEXT_INTEGER), - REG(u.s.Lr, 8, CONTEXT_INTEGER), - REG(Sp, 8, CONTEXT_CONTROL), - REG(Pc, 8, CONTEXT_CONTROL), + REG(Cpsr, 4), + REG(u.s.X0, 8), + REG(u.s.X1, 8), + REG(u.s.X2, 8), + REG(u.s.X3, 8), + REG(u.s.X4, 8), + REG(u.s.X5, 8), + REG(u.s.X6, 8), + REG(u.s.X7, 8), + REG(u.s.X8, 8), + REG(u.s.X9, 8), + REG(u.s.X10, 8), + REG(u.s.X11, 8), + REG(u.s.X12, 8), + REG(u.s.X13, 8), + REG(u.s.X14, 8), + REG(u.s.X15, 8), + REG(u.s.X16, 8), + REG(u.s.X17, 8), + REG(u.s.X18, 8), + REG(u.s.X19, 8), + REG(u.s.X20, 8), + REG(u.s.X21, 8), + REG(u.s.X22, 8), + REG(u.s.X23, 8), + REG(u.s.X24, 8), + REG(u.s.X25, 8), + REG(u.s.X26, 8), + REG(u.s.X27, 8), + REG(u.s.X28, 8), + REG(u.s.Fp, 8), + REG(u.s.Lr, 8), + REG(Sp, 8), + REG(Pc, 8), }; #else # error Define the registers map for your CPU @@ -553,21 +552,7 @@ static inline void cpu_register_hex_from(CONTEXT* ctx, unsigned idx, const static BOOL fetch_context(struct gdb_context* gdbctx, HANDLE h, CONTEXT* ctx) { - ctx->ContextFlags = CONTEXT_CONTROL - | CONTEXT_INTEGER -#if defined(__powerpc__) || defined(__i386__) || defined(__x86_64__) - | CONTEXT_FLOATING_POINT -#endif -#ifdef CONTEXT_SEGMENTS - | CONTEXT_SEGMENTS -#endif -#ifdef CONTEXT_DEBUG_REGISTERS - | CONTEXT_DEBUG_REGISTERS -#endif -#ifdef CONTEXT_EXTENDED_REGISTERS - | CONTEXT_EXTENDED_REGISTERS -#endif - ; + ctx->ContextFlags = CONTEXT_ALL; if (!GetThreadContext(h, ctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) @@ -1135,10 +1120,6 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx) for (i = 0; i < cpu_num_regs; i++) { - ULONG flags = cpu_register_map[i].ctx_flags; - if ((gdbctx->context.ContextFlags & flags) != flags) - break; - /* FIXME: this call will also grow the buffer... * unneeded, but not harmful */ @@ -1474,12 +1455,7 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx) packet_reply_open(gdbctx); for (i = 0; i < cpu_num_regs; i++) - { - ULONG flags = cpu_register_map[i].ctx_flags; - if ((gdbctx->context.ContextFlags & flags) != flags) - break; packet_reply_register_hex_to(gdbctx, i); - } packet_reply_close(gdbctx); return packet_done; } @@ -1501,12 +1477,8 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx) ptr = gdbctx->in_packet; for (i = 0; i < cpu_num_regs; i++) - { - ULONG flags = cpu_register_map[i].ctx_flags; - if ((pctx->ContextFlags & flags) != flags) - break; cpu_register_hex_from(pctx, i, &ptr); - } + if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx)) { if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) @@ -1704,12 +1676,6 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) return packet_error; } - if ((pctx->ContextFlags & cpu_register_map[reg].ctx_flags) != cpu_register_map[reg].ctx_flags) - { - if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) - fprintf(stderr, "Writing reg %u is not supported on this host\n", reg); - return packet_error; - } cpu_register_hex_from(pctx, reg, (const char**)&ptr); if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx)) -- 2.7.4

June 12, 2018

[PATCH 1/5] winedbg: Make be_cpu process-specific.

by Zebediah Figura

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- programs/winedbg/be_cpu.h | 2 -- programs/winedbg/break.c | 40 ++++++++++++++-------------- programs/winedbg/db_disasm.c | 4 +-- programs/winedbg/dbg.y | 4 +-- programs/winedbg/debugger.h | 3 ++- programs/winedbg/expr.c | 4 +-- programs/winedbg/gdbproxy.c | 17 ++++++------ programs/winedbg/info.c | 2 +- programs/winedbg/memory.c | 26 +++++++++--------- programs/winedbg/stack.c | 10 +++---- programs/winedbg/symbol.c | 2 +- programs/winedbg/tgt_active.c | 9 ++++--- programs/winedbg/tgt_minidump.c | 4 +-- programs/winedbg/types.c | 17 ++++++------ programs/winedbg/winedbg.c | 58 ++++++++++++++++++++--------------------- 15 files changed, 101 insertions(+), 101 deletions(-) diff --git a/programs/winedbg/be_cpu.h b/programs/winedbg/be_cpu.h index d62b517..751ac9d 100644 --- a/programs/winedbg/be_cpu.h +++ b/programs/winedbg/be_cpu.h @@ -116,8 +116,6 @@ struct backend_cpu BOOL (*store_integer)(const struct dbg_lvalue* lvalue, unsigned size, BOOL is_signed, LONGLONG); }; -extern struct backend_cpu* be_cpu; - /* some handy functions for non segmented CPUs */ void* be_cpu_linearize(HANDLE hThread, const ADDRESS64*); BOOL be_cpu_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, diff --git a/programs/winedbg/break.c b/programs/winedbg/break.c index cedeed7..2896c17 100644 --- a/programs/winedbg/break.c +++ b/programs/winedbg/break.c @@ -63,15 +63,13 @@ void break_set_xpoints(BOOL set) addr = memory_to_linear_addr(&bp[i].addr); if (set) - ret = be_cpu->insert_Xpoint(dbg_curr_process->handle, - dbg_curr_process->process_io, - &dbg_context, bp[i].xpoint_type, addr, - &bp[i].info, size); + ret = dbg_curr_process->be_cpu->insert_Xpoint(dbg_curr_process->handle, + dbg_curr_process->process_io, &dbg_context, bp[i].xpoint_type, + addr, &bp[i].info, size); else - ret = be_cpu->remove_Xpoint(dbg_curr_process->handle, - dbg_curr_process->process_io, - &dbg_context, bp[i].xpoint_type, addr, - bp[i].info, size); + ret = dbg_curr_process->be_cpu->remove_Xpoint(dbg_curr_process->handle, + dbg_curr_process->process_io, &dbg_context, bp[i].xpoint_type, + addr, bp[i].info, size); if (!ret) { dbg_printf("Invalid address ("); @@ -572,9 +570,9 @@ static int find_triggered_watch(void) DWORD64 val = 0; if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) && - (be_cpu->is_watchpoint_set(&dbg_context, bp[i].info))) + (dbg_curr_process->be_cpu->is_watchpoint_set(&dbg_context, bp[i].info))) { - be_cpu->clear_watchpoint(&dbg_context, bp[i].info); + dbg_curr_process->be_cpu->clear_watchpoint(&dbg_context, bp[i].info); if (get_watched_value(i, &val)) { @@ -599,7 +597,7 @@ static int find_triggered_watch(void) { if (val != bp[i].w.oldval) { - be_cpu->clear_watchpoint(&dbg_context, bp[i].info); + dbg_curr_process->be_cpu->clear_watchpoint(&dbg_context, bp[i].info); bp[i].w.oldval = val; found = i; /* cannot break, because two watch points may have been triggered on @@ -805,7 +803,7 @@ void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_br /* If not single-stepping, back up to the break instruction */ if (code == EXCEPTION_BREAKPOINT) - addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, TRUE); + addr->Offset += dbg_curr_process->be_cpu->adjust_pc_for_break(&dbg_context, TRUE); dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_break); dbg_curr_process->bp[0].enabled = FALSE; /* disable the step-over breakpoint */ @@ -821,7 +819,7 @@ void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_br { /* If not single-stepping, do not back up over the break instruction */ if (code == EXCEPTION_BREAKPOINT) - addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE); + addr->Offset += dbg_curr_process->be_cpu->adjust_pc_for_break(&dbg_context, FALSE); return; } } @@ -833,7 +831,7 @@ void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_br if (dbg_curr_thread->stopped_xpoint == -1 && code == EXCEPTION_BREAKPOINT) { *is_break = TRUE; - addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE); + addr->Offset += dbg_curr_process->be_cpu->adjust_pc_for_break(&dbg_context, FALSE); } } @@ -890,7 +888,7 @@ void break_restart_execution(int count) dbg_printf("Not stopped at any breakpoint; argument ignored.\n"); } - if (mode == dbg_exec_finish && be_cpu->is_function_return(linear)) + if (mode == dbg_exec_finish && dbg_curr_process->be_cpu->is_function_return(linear)) { mode = ret_mode = dbg_exec_step_into_insn; } @@ -901,7 +899,7 @@ void break_restart_execution(int count) * FIXME - we need to check for things like thunks or trampolines, * as the actual function may in fact have debug info. */ - if (be_cpu->is_function_call(linear, &callee)) + if (dbg_curr_process->be_cpu->is_function_call(linear, &callee)) { status = symbol_get_function_line_status(&callee); #if 0 @@ -936,7 +934,7 @@ void break_restart_execution(int count) switch (mode) { case dbg_exec_cont: /* Continuous execution */ - be_cpu->single_step(&dbg_context, FALSE); + dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); break_set_xpoints(TRUE); break; @@ -968,16 +966,16 @@ void break_restart_execution(int count) case dbg_exec_finish: case dbg_exec_step_over_insn: /* Stepping over a call */ case dbg_exec_step_over_line: /* Stepping over a call */ - if (be_cpu->is_step_over_insn(linear)) + if (dbg_curr_process->be_cpu->is_step_over_insn(linear)) { - be_cpu->disasm_one_insn(&addr, FALSE); + dbg_curr_process->be_cpu->disasm_one_insn(&addr, FALSE); dbg_curr_process->bp[0].addr = addr; dbg_curr_process->bp[0].enabled = TRUE; dbg_curr_process->bp[0].refcount = 1; dbg_curr_process->bp[0].skipcount = 0; dbg_curr_process->bp[0].xpoint_type = be_xpoint_break; dbg_curr_process->bp[0].condition = NULL; - be_cpu->single_step(&dbg_context, FALSE); + dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); break_set_xpoints(TRUE); break; } @@ -985,7 +983,7 @@ void break_restart_execution(int count) case dbg_exec_step_into_line: /* Single-stepping a line */ case dbg_exec_step_into_insn: /* Single-stepping an instruction */ - be_cpu->single_step(&dbg_context, TRUE); + dbg_curr_process->be_cpu->single_step(&dbg_context, TRUE); break; default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); } diff --git a/programs/winedbg/db_disasm.c b/programs/winedbg/db_disasm.c index fc25e1c..9bdfb90 100644 --- a/programs/winedbg/db_disasm.c +++ b/programs/winedbg/db_disasm.c @@ -1800,8 +1800,8 @@ void be_i386_disasm_one_insn(ADDRESS64 *addr, int display) short_addr ? 2 : 4, FALSE ); get_value_inc( address.Segment, addr, /* segment */ 2, FALSE ); - be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, - &address, address.Segment, address.Offset); + dbg_curr_process->be_cpu->build_addr(dbg_curr_thread->handle, + &dbg_context, &address, address.Segment, address.Offset); if( db_display ) { print_address( &address, TRUE ); diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 61acb90..6b080a5 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -270,8 +270,8 @@ info_command: tINFO tBREAK { break_info(); } | tINFO tSHARE { info_win32_module(0); } | tINFO tSHARE expr_rvalue { info_win32_module($3); } - | tINFO tREGS { be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); } - | tINFO tALLREGS { be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 1); } + | tINFO tREGS { dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); } + | tINFO tALLREGS { dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 1); } | tINFO tSEGMENTS expr_rvalue { info_win32_segments($3 >> 3, 1); } | tINFO tSEGMENTS { info_win32_segments(0, -1); } | tINFO tSTACK tNUM { stack_info($3); } diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index a1aac82..0ceb150 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -39,7 +39,7 @@ #include "oaidl.h" #include <wine/list.h> -#define ADDRSIZE (be_cpu->pointer_size) +#define ADDRSIZE (dbg_curr_process->be_cpu->pointer_size) #define ADDRWIDTH (ADDRSIZE * 2) /* the debugger uses these exceptions for its internal use */ @@ -228,6 +228,7 @@ struct dbg_process void* pio_data; const WCHAR* imageName; struct list threads; + struct backend_cpu* be_cpu; BOOL continue_on_first_exception : 1, active_debuggee : 1; struct dbg_breakpoint bp[MAX_BREAKPOINTS]; diff --git a/programs/winedbg/expr.c b/programs/winedbg/expr.c index 96a617c..d18ff8d 100644 --- a/programs/winedbg/expr.c +++ b/programs/winedbg/expr.c @@ -546,8 +546,8 @@ struct dbg_lvalue expr_eval(struct expr* exp) case EXP_OP_SEG: rtn.type.id = dbg_itype_segptr; rtn.type.module = 0; - be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, &rtn.addr, - types_extract_as_integer(&exp1), types_extract_as_integer(&exp2)); + dbg_curr_process->be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, &rtn.addr, + types_extract_as_integer(&exp1), types_extract_as_integer(&exp2)); break; case EXP_OP_LOR: exp->un.binop.result = (types_extract_as_integer(&exp1) || types_extract_as_integer(&exp2)); diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 3ecf629..a9a65c2 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -886,7 +886,8 @@ static void wait_for_debuggee(struct gdb_context* gdbctx) static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill) { - be_cpu->single_step(&gdbctx->context, FALSE); + assert(gdbctx->process->be_cpu); + gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); resume_debuggee(gdbctx, DBG_CONTINUE); if (!kill) DebugActiveProcessStop(gdbctx->process->pid); @@ -1309,13 +1310,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) switch (gdbctx->in_packet[actionIndex[i] + 1]) { case 's': /* step */ - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through*/ case 'c': /* continue */ resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); break; case 'S': /* step Sig, */ - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through */ case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1); @@ -1352,13 +1353,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) switch (gdbctx->in_packet[actionIndex[defaultAction] + 1]) { case 's': /* step */ - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through */ case 'c': /* continue */ resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); break; case 'S': - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); /* fall through */ case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1); @@ -1375,7 +1376,7 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) } /* if(defaultAction >=0) */ wait_for_debuggee(gdbctx); - be_cpu->single_step(&gdbctx->context, FALSE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); return packet_reply_status(gdbctx); } @@ -2090,10 +2091,10 @@ static enum packet_return packet_step(struct gdb_context* gdbctx) if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) fprintf(stderr, "NIY: step on %04x, while last thread is %04x\n", gdbctx->exec_thread->tid, dbg_curr_thread->tid); - be_cpu->single_step(&gdbctx->context, TRUE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); - be_cpu->single_step(&gdbctx->context, FALSE); + gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); return packet_reply_status(gdbctx); } diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c index 83341c0..c965759 100644 --- a/programs/winedbg/info.c +++ b/programs/winedbg/info.c @@ -974,7 +974,7 @@ void info_win32_exception(void) { case AddrModeFlat: dbg_printf(" in %d-bit code (%s)", - be_cpu->pointer_size * 8, + dbg_curr_process->be_cpu->pointer_size * 8, memory_offset_to_string(hexbuf, addr.Offset, 0)); break; case AddrModeReal: diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index 970e81a..6e65fa6 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -50,20 +50,20 @@ BOOL be_cpu_build_addr(HANDLE hThread, const CONTEXT* ctx, ADDRESS64* addr, void* memory_to_linear_addr(const ADDRESS64* addr) { - return be_cpu->linearize(dbg_curr_thread->handle, addr); + return dbg_curr_process->be_cpu->linearize(dbg_curr_thread->handle, addr); } BOOL memory_get_current_pc(ADDRESS64* addr) { - assert(be_cpu->get_addr); - return be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, + assert(dbg_curr_process->be_cpu->get_addr); + return dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, be_cpu_addr_pc, addr); } BOOL memory_get_current_stack(ADDRESS64* addr) { - assert(be_cpu->get_addr); - return be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, + assert(dbg_curr_process->be_cpu->get_addr); + return dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context, be_cpu_addr_stack, addr); } @@ -374,17 +374,17 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) { case btInt: case btLong: - if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; if (size == 1) goto print_char; dbg_print_hex(size, val_int); break; case btUInt: case btULong: - if (!be_cpu->fetch_integer(lvalue, size, FALSE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, FALSE, &val_int)) return; dbg_print_hex(size, val_int); break; case btFloat: - if (!be_cpu->fetch_float(lvalue, size, &val_real)) return; + if (!dbg_curr_process->be_cpu->fetch_float(lvalue, size, &val_real)) return; dbg_printf("%Lf", val_real); break; case btChar: @@ -392,7 +392,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) /* sometimes WCHAR is defined as btChar with size = 2, so discrimate * Ansi/Unicode based on size, not on basetype */ - if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; print_char: if (size == 1 && isprint((char)val_int)) dbg_printf("'%c'", (char)val_int); @@ -407,7 +407,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) dbg_printf("%d", (int)val_int); break; case btBool: - if (!be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, size, TRUE, &val_int)) return; dbg_printf("%s", val_int ? "true" : "false"); break; default: @@ -455,7 +455,7 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) * (not supported yet in dbghelp) * Assuming 4 as for an int */ - if (!be_cpu->fetch_integer(lvalue, 4, TRUE, &val_int)) return; + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, 4, TRUE, &val_int)) return; if (types_get_info(&type, TI_GET_CHILDRENCOUNT, &count)) { @@ -631,7 +631,7 @@ BOOL memory_disasm_one_insn(ADDRESS64* addr) dbg_printf("-- no code accessible --\n"); return FALSE; } - be_cpu->disasm_one_insn(addr, TRUE); + dbg_curr_process->be_cpu->disasm_one_insn(addr, TRUE); dbg_printf("\n"); return TRUE; } @@ -685,7 +685,7 @@ BOOL memory_get_register(DWORD regno, DWORD_PTR** value, char* buffer, int len) return FALSE; } - for (div = be_cpu->context_vars; div->name; div++) + for (div = dbg_curr_process->be_cpu->context_vars; div->name; div++) { if (div->val == regno) { diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c index f49480a..2ab4e60 100644 --- a/programs/winedbg/stack.c +++ b/programs/winedbg/stack.c @@ -121,7 +121,7 @@ BOOL stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pv { enum be_cpu_addr kind; - if (!be_cpu->get_register_info(div->val, &kind)) return FALSE; + if (!dbg_curr_process->be_cpu->get_register_info(div->val, &kind)) return FALSE; /* reuse some known registers directly out of stackwalk details */ switch (kind) @@ -198,9 +198,9 @@ unsigned stack_fetch_frames(const CONTEXT* _ctx) dbg_curr_thread->frames = NULL; memset(&sf, 0, sizeof(sf)); - be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_frame, &sf.AddrFrame); - be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_pc, &sf.AddrPC); - be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_stack, &sf.AddrStack); + dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_frame, &sf.AddrFrame); + dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_pc, &sf.AddrPC); + dbg_curr_process->be_cpu->get_addr(dbg_curr_thread->handle, &ctx, be_cpu_addr_stack, &sf.AddrStack); /* don't confuse StackWalk by passing in inconsistent addresses */ if ((sf.AddrPC.Mode == AddrModeFlat) && (sf.AddrFrame.Mode != AddrModeFlat)) @@ -209,7 +209,7 @@ unsigned stack_fetch_frames(const CONTEXT* _ctx) sf.AddrFrame.Mode = AddrModeFlat; } - while ((ret = StackWalk64(be_cpu->machine, dbg_curr_process->handle, + while ((ret = StackWalk64(dbg_curr_process->be_cpu->machine, dbg_curr_process->handle, dbg_curr_thread->handle, &sf, &ctx, stack_read_mem, SymFunctionTableAccess64, SymGetModuleBase64, NULL)) || nf == 0) /* we always register first frame information */ diff --git a/programs/winedbg/symbol.c b/programs/winedbg/symbol.c index 1040187..aa88ffc 100644 --- a/programs/winedbg/symbol.c +++ b/programs/winedbg/symbol.c @@ -590,7 +590,7 @@ enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr) /* some compilers insert thunks in their code without debug info associated * take care of this situation */ - if (be_cpu->is_jump((void*)lin, &jumpee)) + if (dbg_curr_process->be_cpu->is_jump((void*)lin, &jumpee)) return symbol_get_function_line_status(&jumpee); return dbg_no_line_info; } diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 07edccc..d891cfe 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -148,7 +148,8 @@ static BOOL dbg_exception_prolog(BOOL is_debug, const EXCEPTION_RECORD* rec) case AddrMode1616: name = "16 bit"; break; case AddrMode1632: name = "segmented 32 bit"; break; case AddrModeReal: name = "vm86"; break; - case AddrModeFlat: name = be_cpu->pointer_size == 4 ? "32 bit" : "64 bit"; break; + case AddrModeFlat: name = dbg_curr_process->be_cpu->pointer_size == 4 + ? "32 bit" : "64 bit"; break; } dbg_printf("In %s mode.\n", name); dbg_curr_thread->addr_mode = addr.Mode; @@ -158,9 +159,9 @@ static BOOL dbg_exception_prolog(BOOL is_debug, const EXCEPTION_RECORD* rec) if (!is_debug) { /* This is a real crash, dump some info */ - be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); + dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); stack_info(-1); - be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); + dbg_curr_process->be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); stack_backtrace(dbg_curr_tid); } else @@ -997,7 +998,7 @@ static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill) /* needed for single stepping (ugly). * should this be handled inside the server ??? */ - be_cpu->single_step(&dbg_context, FALSE); + dbg_curr_process->be_cpu->single_step(&dbg_context, FALSE); if (dbg_curr_thread->in_exception) { SetThreadContext(dbg_curr_thread->handle, &dbg_context); diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c index 5bf5a60..a17f32b 100644 --- a/programs/winedbg/tgt_minidump.c +++ b/programs/winedbg/tgt_minidump.c @@ -477,9 +477,9 @@ static enum dbg_start minidump_do_reload(struct tgt_process_minidump_data* data) min(sizeof(dbg_context), mes->ThreadContext.DataSize)); memory_get_current_pc(&addr); stack_fetch_frames(&dbg_context); - be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); + dbg_curr_process->be_cpu->print_context(dbg_curr_thread->handle, &dbg_context, 0); stack_info(-1); - be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); + dbg_curr_process->be_cpu->print_segment_info(dbg_curr_thread->handle, &dbg_context); stack_backtrace(mes->ThreadId); source_list_from_addr(&addr, 0); } diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index 3268d7e..696a9fd 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -92,11 +92,11 @@ LONGLONG types_extract_as_longlong(const struct dbg_lvalue* lvalue, { case btChar: case btInt: - if (!be_cpu->fetch_integer(lvalue, (unsigned)size, s = TRUE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, (unsigned)size, s = TRUE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case btUInt: - if (!be_cpu->fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, (unsigned)size, s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case btFloat: @@ -106,17 +106,17 @@ LONGLONG types_extract_as_longlong(const struct dbg_lvalue* lvalue, if (issigned) *issigned = s; break; case SymTagPointerType: - if (!be_cpu->fetch_integer(lvalue, sizeof(void*), s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, sizeof(void*), s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case SymTagArrayType: case SymTagUDT: - if (!be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case SymTagEnum: /* FIXME: we don't handle enum size */ - if (!be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) + if (!dbg_curr_process->be_cpu->fetch_integer(lvalue, sizeof(unsigned), s = FALSE, &rtn)) RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL); break; case SymTagFunctionType: @@ -173,7 +173,7 @@ BOOL types_store_value(struct dbg_lvalue* lvalue_to, const struct dbg_lvalue* lv } /* FIXME: should support floats as well */ val = types_extract_as_longlong(lvalue_from, NULL, &is_signed); - return be_cpu->store_integer(lvalue_to, size, is_signed, val); + return dbg_curr_process->be_cpu->store_integer(lvalue_to, size, is_signed, val); } /****************************************************************** @@ -302,9 +302,10 @@ BOOL types_array_index(const struct dbg_lvalue* lvalue, int index, struct dbg_lv result->addr = lvalue->addr; break; case SymTagPointerType: - if (!memory_read_value(lvalue, be_cpu->pointer_size, &result->addr.Offset)) return FALSE; + if (!memory_read_value(lvalue, dbg_curr_process->be_cpu->pointer_size, &result->addr.Offset)) + return FALSE; result->addr.Mode = AddrModeFlat; - switch (be_cpu->pointer_size) + switch (dbg_curr_process->be_cpu->pointer_size) { case 4: result->addr.Offset = (DWORD)result->addr.Offset; break; case 8: break; diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c index e0ad4d8..b32b24c 100644 --- a/programs/winedbg/winedbg.c +++ b/programs/winedbg/winedbg.c @@ -241,7 +241,7 @@ const struct dbg_internal_var* dbg_get_internal_var(const char* name) { if (!strcmp(div->name, name)) return div; } - for (div = be_cpu->context_vars; div->name; div++) + for (div = dbg_curr_process->be_cpu->context_vars; div->name; div++) { if (!strcasecmp(div->name, name)) { @@ -279,6 +279,20 @@ struct dbg_process* dbg_get_process_h(HANDLE h) return NULL; } +#ifdef __i386__ +extern struct backend_cpu be_i386; +#elif defined(__powerpc__) +extern struct backend_cpu be_ppc; +#elif defined(__x86_64__) +extern struct backend_cpu be_x86_64; +#elif defined(__arm__) && !defined(__ARMEB__) +extern struct backend_cpu be_arm; +#elif defined(__aarch64__) && !defined(__AARCH64EB__) +extern struct backend_cpu be_arm64; +#else +# error CPU unknown +#endif + struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h) { struct dbg_process* p; @@ -318,6 +332,20 @@ struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, p->source_end_line = -1; list_add_head(&dbg_process_list, &p->entry); + +#ifdef __i386__ + p->be_cpu = &be_i386; +#elif defined(__powerpc__) + p->be_cpu = &be_ppc; +#elif defined(__x86_64__) + p->be_cpu = &be_x86_64; +#elif defined(__arm__) && !defined(__ARMEB__) + p->be_cpu = &be_arm; +#elif defined(__aarch64__) && !defined(__AARCH64EB__) + p->be_cpu = &be_arm64; +#else +# error CPU unknown +#endif return p; } @@ -609,40 +637,12 @@ static LONG CALLBACK top_filter( EXCEPTION_POINTERS *ptr ) return EXCEPTION_EXECUTE_HANDLER; } -struct backend_cpu* be_cpu; -#ifdef __i386__ -extern struct backend_cpu be_i386; -#elif defined(__powerpc__) -extern struct backend_cpu be_ppc; -#elif defined(__x86_64__) -extern struct backend_cpu be_x86_64; -#elif defined(__arm__) && !defined(__ARMEB__) -extern struct backend_cpu be_arm; -#elif defined(__aarch64__) && !defined(__AARCH64EB__) -extern struct backend_cpu be_arm64; -#else -# error CPU unknown -#endif - int main(int argc, char** argv) { int retv = 0; HANDLE hFile = INVALID_HANDLE_VALUE; enum dbg_start ds; -#ifdef __i386__ - be_cpu = &be_i386; -#elif defined(__powerpc__) - be_cpu = &be_ppc; -#elif defined(__x86_64__) - be_cpu = &be_x86_64; -#elif defined(__arm__) && !defined(__ARMEB__) - be_cpu = &be_arm; -#elif defined(__aarch64__) && !defined(__AARCH64EB__) - be_cpu = &be_arm64; -#else -# error CPU unknown -#endif /* Initialize the output */ dbg_houtput = GetStdHandle(STD_OUTPUT_HANDLE); -- 2.7.4

June 12, 2018

[PATCH] msi/tests: Avoid ARRAY_SIZE-like macros

by Michael Stefaniuc

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/msi/tests/db.c | 4 +--- dlls/msi/tests/install.c | 4 +--- dlls/msi/tests/patch.c | 12 +++--------- 3 files changed, 5 insertions(+), 15 deletions(-) diff --git a/dlls/msi/tests/db.c b/dlls/msi/tests/db.c index 477ab0ad39..ff54a95ab1 100644 --- a/dlls/msi/tests/db.c +++ b/dlls/msi/tests/db.c @@ -3033,8 +3033,6 @@ static const struct { { name9, data9, sizeof data9 }, }; -#define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0]) - static void generate_transform_manual(void) { IStorage *stg = NULL; @@ -3056,7 +3054,7 @@ static void generate_transform_manual(void) r = IStorage_SetClass( stg, &CLSID_MsiTransform ); ok(r == S_OK, "failed to set storage type\n"); - for (i=0; i<NUM_TRANSFORM_TABLES; i++) + for (i=0; i<ARRAY_SIZE(table_transform_data); i++) { r = IStorage_CreateStream( stg, table_transform_data[i].name, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm ); diff --git a/dlls/msi/tests/install.c b/dlls/msi/tests/install.c index 3eb6c80422..951f0e7222 100644 --- a/dlls/msi/tests/install.c +++ b/dlls/msi/tests/install.c @@ -3671,8 +3671,6 @@ static const struct { { name3, data3, sizeof data3 }, }; -#define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0]) - static void generate_transform_manual(void) { IStorage *stg = NULL; @@ -3694,7 +3692,7 @@ static void generate_transform_manual(void) r = IStorage_SetClass(stg, &CLSID_MsiTransform); ok(r == S_OK, "failed to set storage type\n"); - for (i=0; i<NUM_TRANSFORM_TABLES; i++) + for (i=0; i<ARRAY_SIZE(table_transform_data); i++) { r = IStorage_CreateStream(stg, table_transform_data[i].name, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm); diff --git a/dlls/msi/tests/patch.c b/dlls/msi/tests/patch.c index b6e990b461..a09084002e 100644 --- a/dlls/msi/tests/patch.c +++ b/dlls/msi/tests/patch.c @@ -446,8 +446,6 @@ static const struct table_data table_patch_data[] = { { p_name6, p_data6, sizeof p_data6 } }; -#define NUM_PATCH_TABLES (sizeof table_patch_data/sizeof table_patch_data[0]) - static const WCHAR t1_name0[] = { 0x4840, 0x430f, 0x422f, 0 }; /* File */ static const WCHAR t1_name1[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */ static const WCHAR t1_name2[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */ @@ -519,8 +517,6 @@ static const struct table_data table_transform1_data[] = { { t1_name3, t1_data3, sizeof t1_data3 } }; -#define NUM_TRANSFORM1_TABLES (sizeof table_transform1_data/sizeof table_transform1_data[0]) - static const WCHAR t2_name0[] = { 0x4840, 0x430f, 0x422f, 0 }; /* File */ static const WCHAR t2_name1[] = { 0x4840, 0x4216, 0x4327, 0x4824, 0 }; /* Media */ static const WCHAR t2_name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */ @@ -644,8 +640,6 @@ static const struct table_data table_transform2_data[] = { { t2_name9, t2_data9, sizeof t2_data9 } }; -#define NUM_TRANSFORM2_TABLES (sizeof table_transform2_data/sizeof table_transform2_data[0]) - static void write_tables( IStorage *stg, const struct table_data *tables, UINT num_tables ) { IStream *stm; @@ -692,7 +686,7 @@ static void create_patch( const char *filename ) r = IStorage_SetClass( stg, &CLSID_MsiPatch ); ok( r == S_OK, "failed to set storage type 0x%08x\n", r ); - write_tables( stg, table_patch_data, NUM_PATCH_TABLES ); + write_tables( stg, table_patch_data, ARRAY_SIZE( table_patch_data )); r = IStorage_CreateStorage( stg, p_name7, mode, 0, 0, &stg1 ); ok( r == S_OK, "failed to create substorage 0x%08x\n", r ); @@ -700,7 +694,7 @@ static void create_patch( const char *filename ) r = IStorage_SetClass( stg1, &CLSID_MsiTransform ); ok( r == S_OK, "failed to set storage type 0x%08x\n", r ); - write_tables( stg1, table_transform1_data, NUM_TRANSFORM1_TABLES ); + write_tables( stg1, table_transform1_data, ARRAY_SIZE( table_transform1_data )); IStorage_Release( stg1 ); r = IStorage_CreateStorage( stg, p_name8, mode, 0, 0, &stg2 ); @@ -709,7 +703,7 @@ static void create_patch( const char *filename ) r = IStorage_SetClass( stg2, &CLSID_MsiTransform ); ok( r == S_OK, "failed to set storage type 0x%08x\n", r ); - write_tables( stg2, table_transform2_data, NUM_TRANSFORM2_TABLES ); + write_tables( stg2, table_transform2_data, ARRAY_SIZE( table_transform2_data )); IStorage_Release( stg2 ); IStorage_Release( stg ); } -- 2.14.4

June 12, 2018

Problems in winemaker.1

by esr＠thyrsus.com

This is automatically generated email about markup problems in a man page for which you appear to be responsible. If you are not the right person or list, please tell me so I can correct my database. See http://catb.org/~esr/doclifter/bugs.html for details on how and why these patches were generated. Feel free to email me with any questions. Note: These patches do not change the modification date of any manual page. You may wish to do that by hand. I apologize if this message seems spammy or impersonal. The volume of markup bugs I am tracking is over five hundred - there is no real alternative to generating bugmail from a database and template. -- Eric S. Raymond Problems with winemaker.1: Unbalanced group in command synopsis. You probably forgot to open or close a [ ] or { } group properly. --- winemaker.1-unpatched 2014-06-02 09:52:02.517334795 -0400 +++ winemaker.1 2014-06-02 09:54:21.272566508 -0400 @@ -29,7 +29,6 @@ .br [ .BR "--generated-files " "] [ " "--nogenerated-files " "] -] .br [ .BR "--wine32 " "]

June 12, 2018

Re: [PATCH v2 5/5] wined3d: Set stream stride and offset even when buffer is NULL.

by Marvin

Hi, While running your changed tests on Windows, I think I found new failures. Being a bot and all I'm not very good at pattern recognition, so I might be wrong, but could you please double-check? Full results can be found at https://testbot.winehq.org/JobDetails.pl?Key=39087 Your paranoid android. === w1064 (64 bit visual) === visual.c:8592: Test failed: Got unexpected color 0x00007580 for quad 2 (different colors).

June 12, 2018

[PATCH v2 5/5] wined3d: Set stream stride and offset even when buffer is NULL.

by Matteo Bruni

Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- v2: Get rid of more todo_wine. dlls/d3d10core/tests/device.c | 4 ++-- dlls/d3d11/tests/d3d11.c | 3 --- dlls/d3d8/device.c | 8 ++++++++ dlls/d3d9/device.c | 8 ++++++++ dlls/d3d9/tests/device.c | 2 +- dlls/d3d9/tests/visual.c | 2 +- dlls/d3dx10_43/tests/d3dx10.c | 4 ++-- dlls/wined3d/device.c | 6 ++---- 8 files changed, 24 insertions(+), 13 deletions(-) diff --git a/dlls/d3d10core/tests/device.c b/dlls/d3d10core/tests/device.c index 2687ec52b76..8fba7a3badd 100644 --- a/dlls/d3d10core/tests/device.c +++ b/dlls/d3d10core/tests/device.c @@ -5493,8 +5493,8 @@ float4 main(float4 color : COLOR) : SV_TARGET for (i = 0; i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i) { ok(!tmp_buffer[i], "Got unexpected vertex buffer %p in slot %u.\n", tmp_buffer[i], i); - todo_wine ok(!stride[i], "Got unexpected stride %u in slot %u.\n", stride[i], i); - todo_wine ok(!offset[i], "Got unexpected offset %u in slot %u.\n", offset[i], i); + ok(!stride[i], "Got unexpected stride %u in slot %u.\n", stride[i], i); + ok(!offset[i], "Got unexpected offset %u in slot %u.\n", offset[i], i); } ID3D10Device_IAGetIndexBuffer(device, tmp_buffer, &format, offset); ok(!tmp_buffer[0], "Got unexpected index buffer %p.\n", tmp_buffer[0]); diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index c641372bc8e..ee8d465cb4e 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -10647,11 +10647,8 @@ static void test_clear_state(void) for (i = 0; i < D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i) { ok(!tmp_buffer[i], "Got unexpected vertex buffer %p in slot %u.\n", tmp_buffer[i], i); - todo_wine_if(i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT) - { ok(!stride[i], "Got unexpected stride %u in slot %u.\n", stride[i], i); ok(!offset[i], "Got unexpected offset %u in slot %u.\n", offset[i], i); - } } ID3D11DeviceContext_IAGetIndexBuffer(context, tmp_buffer, &format, offset); ok(!tmp_buffer[0], "Got unexpected index buffer %p.\n", tmp_buffer[0]); diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c index 616886bcafa..e4869c2618e 100644 --- a/dlls/d3d8/device.c +++ b/dlls/d3d8/device.c @@ -3102,6 +3102,14 @@ static HRESULT WINAPI d3d8_device_SetStreamSource(IDirect3DDevice8 *iface, iface, stream_idx, buffer, stride); wined3d_mutex_lock(); + if (!stride) + { + struct wined3d_buffer *wined3d_buffer; + unsigned int cur_offset; + + hr = wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, + &cur_offset, &stride); + } hr = wined3d_device_set_stream_source(device->wined3d_device, stream_idx, buffer_impl ? buffer_impl->wined3d_buffer : NULL, 0, stride); wined3d_mutex_unlock(); diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index 5d0f5071836..e32bc14af5b 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -3348,6 +3348,14 @@ static HRESULT WINAPI d3d9_device_SetStreamSource(IDirect3DDevice9Ex *iface, iface, stream_idx, buffer, offset, stride); wined3d_mutex_lock(); + if (!stride) + { + struct wined3d_buffer *wined3d_buffer; + unsigned int cur_offset; + + hr = wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, + &cur_offset, &stride); + } hr = wined3d_device_set_stream_source(device->wined3d_device, stream_idx, buffer_impl ? buffer_impl->wined3d_buffer : NULL, offset, stride); wined3d_mutex_unlock(); diff --git a/dlls/d3d9/tests/device.c b/dlls/d3d9/tests/device.c index b71058de486..66bf5b00c50 100644 --- a/dlls/d3d9/tests/device.c +++ b/dlls/d3d9/tests/device.c @@ -2973,7 +2973,7 @@ static void test_draw_primitive(void) ok(SUCCEEDED(hr), "GetStreamSource failed, hr %#x.\n", hr); ok(!current_vb, "Unexpected vb %p.\n", current_vb); ok(!offset, "Unexpected offset %u.\n", offset); - todo_wine ok(!stride, "Unexpected stride %u.\n", stride); + ok(!stride, "Unexpected stride %u.\n", stride); /* NULL index buffer, valid vertex declaration, NULL stream source. */ hr = IDirect3DDevice9_SetIndices(device, NULL); diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index 1e213abeb18..95982e05155 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -23132,7 +23132,7 @@ static void test_drawindexedprimitiveup(void) ok(SUCCEEDED(hr), "GetStreamSource failed, hr %#x.\n", hr); ok(!vb, "Unexpected vb %p.\n", vb); ok(!offset, "Unexpected offset %u.\n", offset); - todo_wine ok(!stride, "Unexpected stride %u.\n", stride); + ok(!stride, "Unexpected stride %u.\n", stride); hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0f, 0); ok(SUCCEEDED(hr), "Failed to clear, hr %#x.\n", hr); diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c index 2bf92cdb589..cd61d766e8e 100644 --- a/dlls/d3dx10_43/tests/d3dx10.c +++ b/dlls/d3dx10_43/tests/d3dx10.c @@ -480,8 +480,8 @@ float4 main(float4 color : COLOR) : SV_TARGET for (i = 0; i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i) { ok(!tmp_buffer[i], "Got unexpected vertex buffer %p in slot %u.\n", tmp_buffer[i], i); - todo_wine ok(!stride[i], "Got unexpected stride %u in slot %u.\n", stride[i], i); - todo_wine ok(!offset[i], "Got unexpected offset %u in slot %u.\n", offset[i], i); + ok(!stride[i], "Got unexpected stride %u in slot %u.\n", stride[i], i); + ok(!offset[i], "Got unexpected offset %u in slot %u.\n", offset[i], i); } ID3D10Device_IAGetIndexBuffer(device, tmp_buffer, &format, offset); ok(!tmp_buffer[0], "Got unexpected index buffer %p.\n", tmp_buffer[0]); diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 8ef74b6ef0f..6776c5c5e0c 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1389,12 +1389,10 @@ HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UI } stream->buffer = buffer; + stream->stride = stride; + stream->offset = offset; if (buffer) - { - stream->stride = stride; - stream->offset = offset; wined3d_buffer_incref(buffer); - } if (!device->recording) wined3d_cs_emit_set_stream_source(device->cs, stream_idx, buffer, offset, stride); -- 2.16.1

June 12, 2018

[PATCH v2 4/5] wined3d: Declare the correct number and type of fragment shader color outputs.

by Matteo Bruni

Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- v2: Reuse shader_glsl_sprintf_cast() in shader_glsl_generate_color_output(), avoid semantic string comparison. Let me know if you prefer the old version after all (and the old patch doesn't apply anymore). dlls/wined3d/glsl_shader.c | 128 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 111 insertions(+), 17 deletions(-) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index cd4780a6419..d5dc8be136a 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -3318,12 +3318,12 @@ static void shader_glsl_get_swizzle(const struct wined3d_shader_src_param *param shader_glsl_swizzle_to_str(param->swizzle, fixup, mask, swizzle_str); } -static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, const char *src_param, +static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *buffer, const char *arg, enum wined3d_component_type dst_type, enum wined3d_component_type src_type) { if (dst_type == src_type) { - string_buffer_sprintf(dst_param, "%s", src_param); + string_buffer_sprintf(buffer, "%s", arg); return; } @@ -3332,10 +3332,10 @@ static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, co switch (dst_type) { case WINED3D_TYPE_INT: - string_buffer_sprintf(dst_param, "floatBitsToInt(%s)", src_param); + string_buffer_sprintf(buffer, "floatBitsToInt(%s)", arg); return; case WINED3D_TYPE_UINT: - string_buffer_sprintf(dst_param, "floatBitsToUint(%s)", src_param); + string_buffer_sprintf(buffer, "floatBitsToUint(%s)", arg); return; default: break; @@ -3344,18 +3344,18 @@ static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, co if (src_type == WINED3D_TYPE_UINT && dst_type == WINED3D_TYPE_FLOAT) { - string_buffer_sprintf(dst_param, "uintBitsToFloat(%s)", src_param); + string_buffer_sprintf(buffer, "uintBitsToFloat(%s)", arg); return; } if (src_type == WINED3D_TYPE_INT && dst_type == WINED3D_TYPE_FLOAT) { - string_buffer_sprintf(dst_param, "intBitsToFloat(%s)", src_param); + string_buffer_sprintf(buffer, "intBitsToFloat(%s)", arg); return; } FIXME("Unhandled cast from %#x to %#x.\n", src_type, dst_type); - string_buffer_sprintf(dst_param, "%s", src_param); + string_buffer_sprintf(buffer, "%s", arg); } /* From a given parameter token, generate the corresponding GLSL string. @@ -7616,9 +7616,48 @@ static void shader_glsl_enable_extensions(struct wined3d_string_buffer *buffer, shader_addline(buffer, "#extension GL_EXT_texture_array : enable\n"); } +static void shader_glsl_generate_color_output(struct wined3d_string_buffer *buffer, + const struct wined3d_gl_info *gl_info, const struct wined3d_shader *shader, + struct wined3d_string_buffer_list *string_buffers) +{ + const struct wined3d_shader_signature *output_signature = &shader->output_signature; + struct wined3d_string_buffer *src, *assignment; + unsigned int i; + + if (output_signature->element_count) + { + src = string_buffer_get(string_buffers); + assignment = string_buffer_get(string_buffers); + for (i = 0; i < output_signature->element_count; ++i) + { + const struct wined3d_shader_signature_element *output = &output_signature->elements[i]; + + /* register_idx is set to ~0u for non-color outputs. */ + if (output->register_idx == ~0u) + continue; + shader_addline(buffer, "color_out%u = ", output->semantic_idx); + string_buffer_sprintf(src, "ps_out[%u]", output->semantic_idx); + shader_glsl_sprintf_cast(assignment, src->buffer, output->component_type, WINED3D_TYPE_FLOAT); + shader_addline(buffer, "%s;\n", assignment->buffer); + } + string_buffer_release(string_buffers, src); + string_buffer_release(string_buffers, assignment); + } + else + { + DWORD mask = shader->reg_maps.rt_mask; + + while (mask) + { + i = wined3d_bit_scan(&mask); + shader_addline(buffer, "color_out%u = ps_out[%u];\n", i, i); + } + } +} + static void shader_glsl_generate_ps_epilogue(const struct wined3d_gl_info *gl_info, struct wined3d_string_buffer *buffer, const struct wined3d_shader *shader, - const struct ps_compile_args *args) + const struct ps_compile_args *args, struct wined3d_string_buffer_list *string_buffers) { const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps; @@ -7637,6 +7676,26 @@ static void shader_glsl_generate_ps_epilogue(const struct wined3d_gl_info *gl_in if (reg_maps->sample_mask) shader_addline(buffer, "gl_SampleMask[0] = floatBitsToInt(sample_mask);\n"); + + if (!needs_legacy_glsl_syntax(gl_info)) + shader_glsl_generate_color_output(buffer, gl_info, shader, string_buffers); +} + +static const char *shader_glsl_get_ps_output_format(enum wined3d_component_type component_type) +{ + static const char formats[][6] = + { + "", /* WINED3D_TYPE_UNKNOWN */ + "uvec4", /* WINED3D_TYPE_UINT */ + "ivec4", /* WINED3D_TYPE_INT */ + "vec4", /* WINED3D_TYPE_FLOAT */ + }; + if (component_type < WINED3D_TYPE_UNKNOWN || component_type > WINED3D_TYPE_FLOAT) + { + WARN("Unexpected component_type %#x.\n", component_type); + return formats[WINED3D_TYPE_FLOAT]; + } + return formats[component_type]; } /* Context activation is done by the caller. */ @@ -7819,9 +7878,35 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context if (!needs_legacy_glsl_syntax(gl_info)) { - if (shader_glsl_use_explicit_attrib_location(gl_info)) - shader_addline(buffer, "layout(location = 0) "); - shader_addline(buffer, "out vec4 ps_out[%u];\n", gl_info->limits.buffers); + const struct wined3d_shader_signature *output_signature = &shader->output_signature; + + shader_addline(buffer, "vec4 ps_out[%u];\n", gl_info->limits.buffers); + if (output_signature->element_count) + { + for (i = 0; i < output_signature->element_count; ++i) + { + const struct wined3d_shader_signature_element *output = &output_signature->elements[i]; + + if (output->register_idx == ~0u) + continue; + if (shader_glsl_use_explicit_attrib_location(gl_info)) + shader_addline(buffer, "layout(location = %u) ", output->semantic_idx); + shader_addline(buffer, "out %s color_out%u;\n", + shader_glsl_get_ps_output_format(output->component_type), output->semantic_idx); + } + } + else + { + DWORD mask = reg_maps->rt_mask; + + while (mask) + { + i = wined3d_bit_scan(&mask); + if (shader_glsl_use_explicit_attrib_location(gl_info)) + shader_addline(buffer, "layout(location = %u) ", i); + shader_addline(buffer, "out vec4 color_out%u;\n", i); + } + } } if (shader->limits->constant_float + extra_constants_needed >= gl_info->limits.glsl_ps_float_constants) @@ -7906,7 +7991,7 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context /* In SM4+ the shader epilogue is generated by the "ret" instruction. */ if (reg_maps->shader_version.major < 4) - shader_glsl_generate_ps_epilogue(gl_info, buffer, shader, args); + shader_glsl_generate_ps_epilogue(gl_info, buffer, shader, args, string_buffers); shader_addline(buffer, "}\n"); @@ -8403,7 +8488,7 @@ static void shader_glsl_generate_shader_epilogue(const struct wined3d_shader_con switch (shader->reg_maps.shader_version.type) { case WINED3D_SHADER_TYPE_PIXEL: - shader_glsl_generate_ps_epilogue(gl_info, buffer, shader, priv->cur_ps_args); + shader_glsl_generate_ps_epilogue(gl_info, buffer, shader, priv->cur_ps_args, priv->string_buffers); break; case WINED3D_SHADER_TYPE_VERTEX: shader_glsl_generate_vs_epilogue(gl_info, buffer, shader, priv->cur_vs_args); @@ -9539,9 +9624,10 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv * if (!needs_legacy_glsl_syntax(gl_info)) { + shader_addline(buffer, "vec4 ps_out[1];\n"); if (shader_glsl_use_explicit_attrib_location(gl_info)) shader_addline(buffer, "layout(location = 0) "); - shader_addline(buffer, "out vec4 ps_out[1];\n"); + shader_addline(buffer, "out vec4 color_out0;\n"); } shader_addline(buffer, "vec4 tmp0, tmp1;\n"); @@ -9881,6 +9967,8 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv * shader_glsl_generate_fog_code(buffer, gl_info, settings->fog); shader_glsl_generate_alpha_test(buffer, gl_info, alpha_test_func); + if (!needs_legacy_glsl_syntax(gl_info)) + shader_addline(buffer, "color_out0 = ps_out[0];\n"); shader_addline(buffer, "}\n"); @@ -10422,13 +10510,17 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const } } checkGLcall("glBindAttribLocation"); - string_buffer_release(&priv->string_buffers, tmp_name); if (!needs_legacy_glsl_syntax(gl_info)) { - GL_EXTCALL(glBindFragDataLocation(program_id, 0, "ps_out")); - checkGLcall("glBindFragDataLocation"); + for (i = 0; i < MAX_RENDER_TARGET_VIEWS; ++i) + { + string_buffer_sprintf(tmp_name, "color_out%u", i); + GL_EXTCALL(glBindFragDataLocation(program_id, i, tmp_name->buffer)); + checkGLcall("glBindFragDataLocation"); + } } + string_buffer_release(&priv->string_buffers, tmp_name); } if (hshader) @@ -12796,6 +12888,8 @@ static GLuint glsl_blitter_generate_program(struct wined3d_glsl_blitter *blitter shader_glsl_add_version_declaration(buffer, gl_info); shader_addline(buffer, "uniform sampler%s sampler;\n", tex_type); declare_in_varying(gl_info, buffer, FALSE, "vec3 out_texcoord;\n"); + /* TODO: Declare the out variable with the correct type (and put it in the + * blitter args). */ if (!needs_legacy_glsl_syntax(gl_info)) shader_addline(buffer, "out vec4 ps_out[1];\n"); -- 2.16.1

June 12, 2018

[PATCH 3/5] wined3d: Get rid of enum wined3d_data_type.

by Matteo Bruni

Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- With the previous patch it became a subset of the public enum wined3d_component_type. dlls/wined3d/glsl_shader.c | 96 +++++++++++++++++++++--------------------- dlls/wined3d/shader.c | 28 ++++++------ dlls/wined3d/shader_sm1.c | 14 +++--- dlls/wined3d/shader_sm4.c | 72 +++++++++++++++---------------- dlls/wined3d/wined3d_private.h | 13 ++---- 5 files changed, 108 insertions(+), 115 deletions(-) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index ffe0c2d7e14..cd4780a6419 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -88,7 +88,7 @@ struct glsl_sample_function struct wined3d_string_buffer *name; unsigned int coord_mask; unsigned int deriv_mask; - enum wined3d_data_type data_type; + enum wined3d_component_type data_type; BOOL output_single_component; unsigned int offset_size; }; @@ -2522,15 +2522,15 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont switch (reg_maps->resource_info[entry->resource_idx].data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: sampler_type_prefix = ""; break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: sampler_type_prefix = "i"; break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: sampler_type_prefix = "u"; break; @@ -2638,17 +2638,17 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont switch (reg_maps->uav_resource_info[i].data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: image_type_prefix = ""; read_format = "r32f"; break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: image_type_prefix = "i"; read_format = "r32i"; break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: image_type_prefix = "u"; read_format = "r32ui"; break; @@ -2844,7 +2844,7 @@ static void shader_glsl_fixup_scalar_register_variable(char *register_name, /** Writes the GLSL variable name that corresponds to the register that the * DX opcode parameter is trying to access */ static void shader_glsl_get_register_name(const struct wined3d_shader_register *reg, - enum wined3d_data_type data_type, char *register_name, BOOL *is_color, + enum wined3d_component_type data_type, char *register_name, BOOL *is_color, const struct wined3d_shader_instruction *ins) { /* oPos, oFog and oPts in D3D */ @@ -3080,16 +3080,16 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register * case WINED3D_IMMCONST_SCALAR: switch (data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: if (gl_info->supported[ARB_SHADER_BIT_ENCODING]) sprintf(register_name, "uintBitsToFloat(%#xu)", reg->u.immconst_data[0]); else wined3d_ftoa(*(const float *)reg->u.immconst_data, register_name); break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: sprintf(register_name, "%#x", reg->u.immconst_data[0]); break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: sprintf(register_name, "%#xu", reg->u.immconst_data[0]); break; default: @@ -3101,7 +3101,7 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register * case WINED3D_IMMCONST_VEC4: switch (data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: if (gl_info->supported[ARB_SHADER_BIT_ENCODING]) { sprintf(register_name, "uintBitsToFloat(uvec4(%#xu, %#xu, %#xu, %#xu))", @@ -3118,12 +3118,12 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register * imm_str[0], imm_str[1], imm_str[2], imm_str[3]); } break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: sprintf(register_name, "ivec4(%#x, %#x, %#x, %#x)", reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[2], reg->u.immconst_data[3]); break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: sprintf(register_name, "uvec4(%#xu, %#xu, %#xu, %#xu)", reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[2], reg->u.immconst_data[3]); @@ -3319,22 +3319,22 @@ static void shader_glsl_get_swizzle(const struct wined3d_shader_src_param *param } static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, const char *src_param, - enum wined3d_data_type dst_data_type, enum wined3d_data_type src_data_type) + enum wined3d_component_type dst_type, enum wined3d_component_type src_type) { - if (dst_data_type == src_data_type) + if (dst_type == src_type) { string_buffer_sprintf(dst_param, "%s", src_param); return; } - if (src_data_type == WINED3D_DATA_FLOAT) + if (src_type == WINED3D_TYPE_FLOAT) { - switch (dst_data_type) + switch (dst_type) { - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: string_buffer_sprintf(dst_param, "floatBitsToInt(%s)", src_param); return; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: string_buffer_sprintf(dst_param, "floatBitsToUint(%s)", src_param); return; default: @@ -3342,19 +3342,19 @@ static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, co } } - if (src_data_type == WINED3D_DATA_UINT && dst_data_type == WINED3D_DATA_FLOAT) + if (src_type == WINED3D_TYPE_UINT && dst_type == WINED3D_TYPE_FLOAT) { string_buffer_sprintf(dst_param, "uintBitsToFloat(%s)", src_param); return; } - if (src_data_type == WINED3D_DATA_INT && dst_data_type == WINED3D_DATA_FLOAT) + if (src_type == WINED3D_TYPE_INT && dst_type == WINED3D_TYPE_FLOAT) { string_buffer_sprintf(dst_param, "intBitsToFloat(%s)", src_param); return; } - FIXME("Unhandled cast from %#x to %#x.\n", src_data_type, dst_data_type); + FIXME("Unhandled cast from %#x to %#x.\n", src_type, dst_type); string_buffer_sprintf(dst_param, "%s", src_param); } @@ -3363,11 +3363,11 @@ static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, co * caller needs this information as well. */ static void shader_glsl_add_src_param_ext(const struct wined3d_shader_instruction *ins, const struct wined3d_shader_src_param *wined3d_src, DWORD mask, struct glsl_src_param *glsl_src, - enum wined3d_data_type data_type) + enum wined3d_component_type data_type) { struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data; struct wined3d_string_buffer *reg_name = string_buffer_get(priv->string_buffers); - enum wined3d_data_type param_data_type; + enum wined3d_component_type param_data_type; BOOL is_color = FALSE; char swizzle_str[6]; @@ -3392,10 +3392,10 @@ static void shader_glsl_add_src_param_ext(const struct wined3d_shader_instructio case WINED3DSPR_PRIMID: case WINED3DSPR_THREADGROUPID: case WINED3DSPR_THREADID: - param_data_type = WINED3D_DATA_INT; + param_data_type = WINED3D_TYPE_INT; break; default: - param_data_type = WINED3D_DATA_FLOAT; + param_data_type = WINED3D_TYPE_FLOAT; break; } @@ -3430,7 +3430,7 @@ static DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction * /* Append the destination part of the instruction to the buffer, return the effective write mask */ static DWORD shader_glsl_append_dst_ext(struct wined3d_string_buffer *buffer, const struct wined3d_shader_instruction *ins, const struct wined3d_shader_dst_param *dst, - enum wined3d_data_type data_type) + enum wined3d_component_type data_type) { struct glsl_dst_param glsl_dst; DWORD mask; @@ -3439,15 +3439,15 @@ static DWORD shader_glsl_append_dst_ext(struct wined3d_string_buffer *buffer, { switch (data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: shader_addline(buffer, "%s%s = %s(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]); break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: shader_addline(buffer, "%s%s = %sintBitsToFloat(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]); break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: shader_addline(buffer, "%s%s = %suintBitsToFloat(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]); break; @@ -4009,7 +4009,7 @@ static void shader_glsl_udiv(const struct wined3d_shader_instruction *ins) shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param); shader_addline(buffer, "%s %% %s);\n", src0_param.param_str, src1_param.param_str); - shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0], WINED3D_DATA_FLOAT); + shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0], WINED3D_TYPE_FLOAT); shader_addline(buffer, "tmp0%s);\n", dst_mask); } else @@ -4287,7 +4287,7 @@ static void shader_glsl_bitwise_op(const struct wined3d_shader_instruction *ins) dst.write_mask = ins->dst[0].write_mask & (WINED3DSP_WRITEMASK_0 << i); if (tmp_dst && (write_mask = shader_glsl_get_write_mask(&dst, mask_char))) shader_addline(buffer, "tmp0%s = %sBitsToFloat(", mask_char, - dst.reg.data_type == WINED3D_DATA_INT ? "int" : "uint"); + dst.reg.data_type == WINED3D_TYPE_INT ? "int" : "uint"); else if (!(write_mask = shader_glsl_append_dst_ext(buffer, ins, &dst, dst.reg.data_type))) continue; @@ -4301,7 +4301,7 @@ static void shader_glsl_bitwise_op(const struct wined3d_shader_instruction *ins) if (tmp_dst) { - shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0], WINED3D_DATA_FLOAT); + shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0], WINED3D_TYPE_FLOAT); shader_glsl_get_write_mask(&ins->dst[0], mask_char); shader_addline(buffer, "tmp0%s);\n", mask_char); } @@ -5441,7 +5441,7 @@ static void shader_glsl_atomic(const struct wined3d_shader_instruction *ins) struct wined3d_string_buffer *buffer = ins->ctx->buffer; enum wined3d_shader_resource_type resource_type; struct wined3d_string_buffer *address; - enum wined3d_data_type data_type; + enum wined3d_component_type data_type; unsigned int resource_idx, stride; const char *op, *resource; DWORD coord_mask; @@ -5457,7 +5457,7 @@ static void shader_glsl_atomic(const struct wined3d_shader_instruction *ins) return; } resource = "g"; - data_type = WINED3D_DATA_UINT; + data_type = WINED3D_TYPE_UINT; coord_mask = 1; stride = reg_maps->tgsm[resource_idx].stride; } @@ -5509,7 +5509,7 @@ static void shader_glsl_atomic(const struct wined3d_shader_instruction *ins) op = "atomicMax"; else op = "imageAtomicMax"; - if (data_type != WINED3D_DATA_INT) + if (data_type != WINED3D_TYPE_INT) { FIXME("Unhandled opcode %#x for unsigned integers.\n", ins->handler_idx); return; @@ -5521,7 +5521,7 @@ static void shader_glsl_atomic(const struct wined3d_shader_instruction *ins) op = "atomicMin"; else op = "imageAtomicMin"; - if (data_type != WINED3D_DATA_INT) + if (data_type != WINED3D_TYPE_INT) { FIXME("Unhandled opcode %#x for unsigned integers.\n", ins->handler_idx); return; @@ -5540,7 +5540,7 @@ static void shader_glsl_atomic(const struct wined3d_shader_instruction *ins) op = "atomicMax"; else op = "imageAtomicMax"; - if (data_type != WINED3D_DATA_UINT) + if (data_type != WINED3D_TYPE_UINT) { FIXME("Unhandled opcode %#x for signed integers.\n", ins->handler_idx); return; @@ -5552,7 +5552,7 @@ static void shader_glsl_atomic(const struct wined3d_shader_instruction *ins) op = "atomicMin"; else op = "imageAtomicMin"; - if (data_type != WINED3D_DATA_UINT) + if (data_type != WINED3D_TYPE_UINT) { FIXME("Unhandled opcode %#x for signed integers.\n", ins->handler_idx); return; @@ -5636,7 +5636,7 @@ static void shader_glsl_ld_uav(const struct wined3d_shader_instruction *ins) const struct wined3d_shader_version *version = &reg_maps->shader_version; enum wined3d_shader_resource_type resource_type; struct glsl_src_param image_coord_param; - enum wined3d_data_type data_type; + enum wined3d_component_type data_type; DWORD coord_mask, write_mask; unsigned int uav_idx; char dst_swizzle[6]; @@ -5757,7 +5757,7 @@ static void shader_glsl_store_uav(const struct wined3d_shader_instruction *ins) const struct wined3d_shader_version *version = &reg_maps->shader_version; struct glsl_src_param image_coord_param, image_data_param; enum wined3d_shader_resource_type resource_type; - enum wined3d_data_type data_type; + enum wined3d_component_type data_type; unsigned int uav_idx; DWORD coord_mask; @@ -5947,7 +5947,7 @@ static void shader_glsl_resinfo(const struct wined3d_shader_instruction *ins) enum wined3d_shader_resource_type resource_type; enum wined3d_shader_register_type reg_type; unsigned int resource_idx, bind_idx, i; - enum wined3d_data_type dst_data_type; + enum wined3d_component_type dst_data_type; struct glsl_src_param lod_param; BOOL supports_mipmaps; char dst_swizzle[6]; @@ -5955,7 +5955,7 @@ static void shader_glsl_resinfo(const struct wined3d_shader_instruction *ins) dst_data_type = ins->dst[0].reg.data_type; if (ins->flags == WINED3DSI_RESINFO_UINT) - dst_data_type = WINED3D_DATA_UINT; + dst_data_type = WINED3D_TYPE_UINT; else if (ins->flags) FIXME("Unhandled flags %#x.\n", ins->flags); @@ -5983,7 +5983,7 @@ static void shader_glsl_resinfo(const struct wined3d_shader_instruction *ins) write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0], dst_data_type); shader_glsl_get_swizzle(&ins->src[1], FALSE, write_mask, dst_swizzle); - if (dst_data_type == WINED3D_DATA_UINT) + if (dst_data_type == WINED3D_TYPE_UINT) shader_addline(buffer, "uvec4("); else shader_addline(buffer, "vec4("); @@ -6036,21 +6036,21 @@ static void shader_glsl_sample_info(const struct wined3d_shader_instruction *ins const struct wined3d_shader_dst_param *dst = ins->dst; const struct wined3d_shader_src_param *src = ins->src; enum wined3d_shader_resource_type resource_type; - enum wined3d_data_type dst_data_type; + enum wined3d_component_type dst_data_type; unsigned int resource_idx, bind_idx; char dst_swizzle[6]; DWORD write_mask; dst_data_type = dst->reg.data_type; if (ins->flags == WINED3DSI_SAMPLE_INFO_UINT) - dst_data_type = WINED3D_DATA_UINT; + dst_data_type = WINED3D_TYPE_UINT; else if (ins->flags) FIXME("Unhandled flags %#x.\n", ins->flags); write_mask = shader_glsl_append_dst_ext(buffer, ins, dst, dst_data_type); shader_glsl_get_swizzle(src, FALSE, write_mask, dst_swizzle); - if (dst_data_type == WINED3D_DATA_UINT) + if (dst_data_type == WINED3D_TYPE_UINT) shader_addline(buffer, "uvec4("); else shader_addline(buffer, "vec4("); diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index a2c3f00559a..192e95f4473 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -1270,7 +1270,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co break; } reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER; - reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT; + reg_maps->resource_info[reg_idx].data_type = WINED3D_TYPE_UINT; reg_maps->resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW; } else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_STRUCTURED) @@ -1282,7 +1282,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co break; } reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER; - reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT; + reg_maps->resource_info[reg_idx].data_type = WINED3D_TYPE_UINT; reg_maps->resource_info[reg_idx].flags = 0; reg_maps->resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4; } @@ -1356,7 +1356,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co if (ins.flags) FIXME("Ignoring raw UAV flags %#x.\n", ins.flags); reg_maps->uav_resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER; - reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_DATA_UINT; + reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_TYPE_UINT; reg_maps->uav_resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW; } else if (ins.handler_idx == WINED3DSIH_DCL_UAV_STRUCTURED) @@ -1370,7 +1370,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co if (ins.flags) FIXME("Ignoring structured UAV flags %#x.\n", ins.flags); reg_maps->uav_resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER; - reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_DATA_UINT; + reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_TYPE_UINT; reg_maps->uav_resource_info[reg_idx].flags = 0; reg_maps->uav_resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4; } @@ -1609,7 +1609,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co TRACE("Setting fake 2D resource for 1.x pixelshader.\n"); reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_TEXTURE_2D; - reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_FLOAT; + reg_maps->resource_info[reg_idx].data_type = WINED3D_TYPE_FLOAT; shader_record_sample(reg_maps, reg_idx, reg_idx, reg_idx); /* texbem is only valid with < 1.4 pixel shaders */ @@ -2122,15 +2122,15 @@ static void shader_dump_decl_usage(struct wined3d_string_buffer *buffer, shader_dump_uav_flags(buffer, flags); switch (semantic->resource_data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: shader_addline(buffer, " (float)"); break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: shader_addline(buffer, " (int)"); break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: shader_addline(buffer, " (uint)"); break; @@ -2434,13 +2434,13 @@ static void shader_dump_register(struct wined3d_string_buffer *buffer, case WINED3D_IMMCONST_SCALAR: switch (reg->data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: shader_addline(buffer, "%.8e", *(const float *)reg->u.immconst_data); break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: shader_addline(buffer, "%d", reg->u.immconst_data[0]); break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: shader_addline(buffer, "%u", reg->u.immconst_data[0]); break; default: @@ -2452,17 +2452,17 @@ static void shader_dump_register(struct wined3d_string_buffer *buffer, case WINED3D_IMMCONST_VEC4: switch (reg->data_type) { - case WINED3D_DATA_FLOAT: + case WINED3D_TYPE_FLOAT: shader_addline(buffer, "%.8e, %.8e, %.8e, %.8e", *(const float *)&reg->u.immconst_data[0], *(const float *)&reg->u.immconst_data[1], *(const float *)&reg->u.immconst_data[2], *(const float *)&reg->u.immconst_data[3]); break; - case WINED3D_DATA_INT: + case WINED3D_TYPE_INT: shader_addline(buffer, "%d, %d, %d, %d", reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[2], reg->u.immconst_data[3]); break; - case WINED3D_DATA_UINT: + case WINED3D_TYPE_UINT: shader_addline(buffer, "%u, %u, %u, %u", reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[2], reg->u.immconst_data[3]); diff --git a/dlls/wined3d/shader_sm1.c b/dlls/wined3d/shader_sm1.c index 0c6bb933174..b57b67b8dcc 100644 --- a/dlls/wined3d/shader_sm1.c +++ b/dlls/wined3d/shader_sm1.c @@ -468,7 +468,7 @@ static void shader_parse_src_param(DWORD param, const struct wined3d_shader_src_ { src->reg.type = ((param & WINED3D_SM1_REGISTER_TYPE_MASK) >> WINED3D_SM1_REGISTER_TYPE_SHIFT) | ((param & WINED3D_SM1_REGISTER_TYPE_MASK2) >> WINED3D_SM1_REGISTER_TYPE_SHIFT2); - src->reg.data_type = WINED3D_DATA_FLOAT; + src->reg.data_type = WINED3D_TYPE_FLOAT; src->reg.idx[0].offset = param & WINED3D_SM1_REGISTER_NUMBER_MASK; src->reg.idx[0].rel_addr = rel_addr; src->reg.idx[1].offset = ~0U; @@ -482,7 +482,7 @@ static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_ { dst->reg.type = ((param & WINED3D_SM1_REGISTER_TYPE_MASK) >> WINED3D_SM1_REGISTER_TYPE_SHIFT) | ((param & WINED3D_SM1_REGISTER_TYPE_MASK2) >> WINED3D_SM1_REGISTER_TYPE_SHIFT2); - dst->reg.data_type = WINED3D_DATA_FLOAT; + dst->reg.data_type = WINED3D_TYPE_FLOAT; dst->reg.idx[0].offset = param & WINED3D_SM1_REGISTER_NUMBER_MASK; dst->reg.idx[0].rel_addr = rel_addr; dst->reg.idx[1].offset = ~0U; @@ -645,12 +645,12 @@ static void shader_sm1_read_semantic(const DWORD **ptr, struct wined3d_shader_se { semantic->resource_type = resource_type_table[resource_type]; } - semantic->resource_data_type = WINED3D_DATA_FLOAT; + semantic->resource_data_type = WINED3D_TYPE_FLOAT; shader_parse_dst_param(dst_token, NULL, &semantic->reg); } static void shader_sm1_read_immconst(const DWORD **ptr, struct wined3d_shader_src_param *src_param, - enum wined3d_immconst_type type, enum wined3d_data_type data_type) + enum wined3d_immconst_type type, enum wined3d_component_type data_type) { unsigned int count = type == WINED3D_IMMCONST_VEC4 ? 4 : 1; src_param->reg.type = WINED3DSPR_IMMCONST; @@ -761,17 +761,17 @@ static void shader_sm1_read_instruction(void *data, const DWORD **ptr, struct wi else if (ins->handler_idx == WINED3DSIH_DEF) { shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr); - shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_FLOAT); + shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_TYPE_FLOAT); } else if (ins->handler_idx == WINED3DSIH_DEFB) { shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr); - shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_SCALAR, WINED3D_DATA_UINT); + shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_SCALAR, WINED3D_TYPE_UINT); } else if (ins->handler_idx == WINED3DSIH_DEFI) { shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr); - shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_INT); + shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_TYPE_INT); } else { diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c index 69947d21c14..338bae3a8dd 100644 --- a/dlls/wined3d/shader_sm4.c +++ b/dlls/wined3d/shader_sm4.c @@ -506,26 +506,26 @@ static const enum wined3d_shader_resource_type resource_type_table[] = /* WINED3D_SM4_RESOURCE_TEXTURE_CUBEARRAY */ WINED3D_SHADER_RESOURCE_TEXTURE_CUBEARRAY, }; -static const enum wined3d_data_type data_type_table[] = -{ - /* 0 */ WINED3D_DATA_FLOAT, - /* WINED3D_SM4_DATA_UNORM */ WINED3D_DATA_FLOAT, - /* WINED3D_SM4_DATA_SNORM */ WINED3D_DATA_FLOAT, - /* WINED3D_SM4_DATA_INT */ WINED3D_DATA_INT, - /* WINED3D_SM4_DATA_UINT */ WINED3D_DATA_UINT, - /* WINED3D_SM4_DATA_FLOAT */ WINED3D_DATA_FLOAT, +static const enum wined3d_component_type data_type_table[] = +{ + /* 0 */ WINED3D_TYPE_FLOAT, + /* WINED3D_SM4_DATA_UNORM */ WINED3D_TYPE_FLOAT, + /* WINED3D_SM4_DATA_SNORM */ WINED3D_TYPE_FLOAT, + /* WINED3D_SM4_DATA_INT */ WINED3D_TYPE_INT, + /* WINED3D_SM4_DATA_UINT */ WINED3D_TYPE_UINT, + /* WINED3D_SM4_DATA_FLOAT */ WINED3D_TYPE_FLOAT, }; static BOOL shader_sm4_read_src_param(struct wined3d_sm4_data *priv, const DWORD **ptr, const DWORD *end, - enum wined3d_data_type data_type, struct wined3d_shader_src_param *src_param); + enum wined3d_component_type data_type, struct wined3d_shader_src_param *src_param); static BOOL shader_sm4_read_dst_param(struct wined3d_sm4_data *priv, const DWORD **ptr, const DWORD *end, - enum wined3d_data_type data_type, struct wined3d_shader_dst_param *dst_param); + enum wined3d_component_type data_type, struct wined3d_shader_dst_param *dst_param); static void shader_sm4_read_conditional_op(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &priv->src_param[0]); + shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &priv->src_param[0]); ins->flags = (opcode_token & WINED3D_SM4_CONDITIONAL_NZ) ? WINED3D_SHADER_CONDITIONAL_OP_NZ : WINED3D_SHADER_CONDITIONAL_OP_Z; } @@ -579,7 +579,7 @@ static void shader_sm4_read_dcl_resource(struct wined3d_shader_instruction *ins, ins->declaration.semantic.resource_type = resource_type_table[resource_type]; } uav = opcode != WINED3D_SM4_OP_DCL_RESOURCE; - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.semantic.reg); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.semantic.reg); components = *tokens++; if ((components & 0xfff0) != (components & 0xf) * 0x1110) @@ -589,7 +589,7 @@ static void shader_sm4_read_dcl_resource(struct wined3d_shader_instruction *ins, if (!data_type || (data_type >= ARRAY_SIZE(data_type_table))) { FIXME("Unhandled data type %#x.\n", data_type); - ins->declaration.semantic.resource_data_type = WINED3D_DATA_FLOAT; + ins->declaration.semantic.resource_data_type = WINED3D_TYPE_FLOAT; } else { @@ -604,7 +604,7 @@ static void shader_sm4_read_dcl_constant_buffer(struct wined3d_shader_instructio DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, &ins->declaration.src); + shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.src); if (opcode_token & WINED3D_SM4_INDEX_TYPE_MASK) ins->flags |= WINED3DSI_INDEXED_DYNAMIC; } @@ -616,14 +616,14 @@ static void shader_sm4_read_dcl_sampler(struct wined3d_shader_instruction *ins, ins->flags = (opcode_token & WINED3D_SM4_SAMPLER_MODE_MASK) >> WINED3D_SM4_SAMPLER_MODE_SHIFT; if (ins->flags & ~WINED3D_SM4_SAMPLER_COMPARISON) FIXME("Unhandled sampler mode %#x.\n", ins->flags); - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.dst); } static void shader_sm4_read_dcl_index_range(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.index_range.first_register); ins->declaration.index_range.last_register = *tokens; } @@ -680,14 +680,14 @@ static void shader_sm4_read_declaration_dst(struct wined3d_shader_instruction *i DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.dst); } static void shader_sm4_read_declaration_register_semantic(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.register_semantic.reg); ins->declaration.register_semantic.sysval_semantic = *tokens; } @@ -697,7 +697,7 @@ static void shader_sm4_read_dcl_input_ps(struct wined3d_shader_instruction *ins, struct wined3d_sm4_data *priv) { ins->flags = (opcode_token & WINED3D_SM4_INTERPOLATION_MODE_MASK) >> WINED3D_SM4_INTERPOLATION_MODE_SHIFT; - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.dst); } static void shader_sm4_read_dcl_input_ps_siv(struct wined3d_shader_instruction *ins, @@ -705,7 +705,7 @@ static void shader_sm4_read_dcl_input_ps_siv(struct wined3d_shader_instruction * struct wined3d_sm4_data *priv) { ins->flags = (opcode_token & WINED3D_SM4_INTERPOLATION_MODE_MASK) >> WINED3D_SM4_INTERPOLATION_MODE_SHIFT; - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.register_semantic.reg); ins->declaration.register_semantic.sysval_semantic = *tokens; } @@ -731,7 +731,7 @@ static void shader_sm5_read_fcall(struct wined3d_shader_instruction *ins, struct wined3d_sm4_data *priv) { priv->src_param[0].reg.u.fp_body_idx = *tokens++; - shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &priv->src_param[0]); + shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &priv->src_param[0]); } static void shader_sm5_read_dcl_function_body(struct wined3d_shader_instruction *ins, @@ -812,7 +812,7 @@ static void shader_sm5_read_dcl_uav_raw(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.dst); ins->flags = (opcode_token & WINED3D_SM5_UAV_FLAGS_MASK) >> WINED3D_SM5_UAV_FLAGS_SHIFT; } @@ -820,7 +820,7 @@ static void shader_sm5_read_dcl_uav_structured(struct wined3d_shader_instruction DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.structured_resource.reg); ins->flags = (opcode_token & WINED3D_SM5_UAV_FLAGS_MASK) >> WINED3D_SM5_UAV_FLAGS_SHIFT; ins->declaration.structured_resource.byte_stride = *tokens; @@ -832,7 +832,7 @@ static void shader_sm5_read_dcl_tgsm_raw(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, &ins->declaration.tgsm_raw.reg); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.tgsm_raw.reg); ins->declaration.tgsm_raw.byte_count = *tokens; if (ins->declaration.tgsm_raw.byte_count % 4) FIXME("Byte count %u is not multiple of 4.\n", ins->declaration.tgsm_raw.byte_count); @@ -842,7 +842,7 @@ static void shader_sm5_read_dcl_tgsm_structured(struct wined3d_shader_instructio DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_FLOAT, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_FLOAT, &ins->declaration.tgsm_structured.reg); ins->declaration.tgsm_structured.byte_stride = *tokens++; ins->declaration.tgsm_structured.structure_count = *tokens; @@ -854,7 +854,7 @@ static void shader_sm5_read_dcl_resource_structured(struct wined3d_shader_instru DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.structured_resource.reg); ins->declaration.structured_resource.byte_stride = *tokens; if (ins->declaration.structured_resource.byte_stride % 4) @@ -865,7 +865,7 @@ static void shader_sm5_read_dcl_resource_raw(struct wined3d_shader_instruction * DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_TYPE_UINT, &ins->declaration.dst); } static void shader_sm5_read_sync(struct wined3d_shader_instruction *ins, @@ -1196,23 +1196,23 @@ static void map_register(const struct wined3d_sm4_data *priv, struct wined3d_sha } } -static enum wined3d_data_type map_data_type(char t) +static enum wined3d_component_type map_data_type(char t) { switch (t) { case 'f': - return WINED3D_DATA_FLOAT; + return WINED3D_TYPE_FLOAT; case 'i': - return WINED3D_DATA_INT; + return WINED3D_TYPE_INT; case 'u': case 'O': case 'R': case 'S': case 'U': - return WINED3D_DATA_UINT; + return WINED3D_TYPE_UINT; default: ERR("Invalid data type '%c'.\n", t); - return WINED3D_DATA_FLOAT; + return WINED3D_TYPE_FLOAT; } } @@ -1376,7 +1376,7 @@ static BOOL shader_sm4_read_reg_idx(struct wined3d_sm4_data *priv, const DWORD * reg_idx->offset = *(*ptr)++; else reg_idx->offset = 0; - shader_sm4_read_src_param(priv, ptr, end, WINED3D_DATA_INT, rel_addr); + shader_sm4_read_src_param(priv, ptr, end, WINED3D_TYPE_INT, rel_addr); } else { @@ -1388,7 +1388,7 @@ static BOOL shader_sm4_read_reg_idx(struct wined3d_sm4_data *priv, const DWORD * } static BOOL shader_sm4_read_param(struct wined3d_sm4_data *priv, const DWORD **ptr, const DWORD *end, - enum wined3d_data_type data_type, struct wined3d_shader_register *param, + enum wined3d_component_type data_type, struct wined3d_shader_register *param, enum wined3d_shader_src_modifier *modifier) { enum wined3d_sm4_register_type register_type; @@ -1520,7 +1520,7 @@ static BOOL shader_sm4_read_param(struct wined3d_sm4_data *priv, const DWORD **p } static BOOL shader_sm4_read_src_param(struct wined3d_sm4_data *priv, const DWORD **ptr, const DWORD *end, - enum wined3d_data_type data_type, struct wined3d_shader_src_param *src_param) + enum wined3d_component_type data_type, struct wined3d_shader_src_param *src_param) { DWORD token; @@ -1571,7 +1571,7 @@ static BOOL shader_sm4_read_src_param(struct wined3d_sm4_data *priv, const DWORD } static BOOL shader_sm4_read_dst_param(struct wined3d_sm4_data *priv, const DWORD **ptr, const DWORD *end, - enum wined3d_data_type data_type, struct wined3d_shader_dst_param *dst_param) + enum wined3d_component_type data_type, struct wined3d_shader_dst_param *dst_param) { enum wined3d_shader_src_modifier modifier; DWORD token; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 3d637005353..9c72ffdbe85 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -499,13 +499,6 @@ enum wined3d_shader_register_type WINED3DSPR_RASTERIZER, }; -enum wined3d_data_type -{ - WINED3D_DATA_FLOAT, - WINED3D_DATA_INT, - WINED3D_DATA_UINT, -}; - enum wined3d_immconst_type { WINED3D_IMMCONST_SCALAR, @@ -930,7 +923,7 @@ struct wined3d_shader_version struct wined3d_shader_resource_info { enum wined3d_shader_resource_type type; - enum wined3d_data_type data_type; + enum wined3d_component_type data_type; unsigned int flags; unsigned int stride; }; @@ -1068,7 +1061,7 @@ struct wined3d_shader_register_index struct wined3d_shader_register { enum wined3d_shader_register_type type; - enum wined3d_data_type data_type; + enum wined3d_component_type data_type; struct wined3d_shader_register_index idx[2]; enum wined3d_immconst_type immconst_type; union @@ -1104,7 +1097,7 @@ struct wined3d_shader_semantic enum wined3d_decl_usage usage; UINT usage_idx; enum wined3d_shader_resource_type resource_type; - enum wined3d_data_type resource_data_type; + enum wined3d_component_type resource_data_type; struct wined3d_shader_dst_param reg; }; -- 2.16.1

June 12, 2018

[PATCH 2/5] wined3d: Get rid of unnecessary enum wined3d_data_type values.

by Matteo Bruni

Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- This is what eventually came out of trying to rework https://source.winehq.org/patches/data/147005 to use shader_glsl_sprintf_cast(). Tests seem to still pass. Aside from that, I don't know if there is any plan to use the values I'm dropping in this patch in the future. If so, just shoot this patch (and the next) down. dlls/wined3d/glsl_shader.c | 12 ----------- dlls/wined3d/shader.c | 12 ----------- dlls/wined3d/shader_sm4.c | 48 ++++++++++++++++++------------------------ dlls/wined3d/wined3d_private.h | 6 ------ 4 files changed, 21 insertions(+), 57 deletions(-) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 86259ae4755..ffe0c2d7e14 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -2523,8 +2523,6 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont switch (reg_maps->resource_info[entry->resource_idx].data_type) { case WINED3D_DATA_FLOAT: - case WINED3D_DATA_UNORM: - case WINED3D_DATA_SNORM: sampler_type_prefix = ""; break; @@ -2641,8 +2639,6 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont switch (reg_maps->uav_resource_info[i].data_type) { case WINED3D_DATA_FLOAT: - case WINED3D_DATA_UNORM: - case WINED3D_DATA_SNORM: image_type_prefix = ""; read_format = "r32f"; break; @@ -3093,8 +3089,6 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register * case WINED3D_DATA_INT: sprintf(register_name, "%#x", reg->u.immconst_data[0]); break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: case WINED3D_DATA_UINT: sprintf(register_name, "%#xu", reg->u.immconst_data[0]); break; @@ -3129,8 +3123,6 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register * reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[2], reg->u.immconst_data[3]); break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: case WINED3D_DATA_UINT: sprintf(register_name, "uvec4(%#xu, %#xu, %#xu, %#xu)", reg->u.immconst_data[0], reg->u.immconst_data[1], @@ -3342,8 +3334,6 @@ static void shader_glsl_sprintf_cast(struct wined3d_string_buffer *dst_param, co case WINED3D_DATA_INT: string_buffer_sprintf(dst_param, "floatBitsToInt(%s)", src_param); return; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: case WINED3D_DATA_UINT: string_buffer_sprintf(dst_param, "floatBitsToUint(%s)", src_param); return; @@ -3457,8 +3447,6 @@ static DWORD shader_glsl_append_dst_ext(struct wined3d_string_buffer *buffer, shader_addline(buffer, "%s%s = %sintBitsToFloat(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]); break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: case WINED3D_DATA_UINT: shader_addline(buffer, "%s%s = %suintBitsToFloat(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]); diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 20d4f0773dd..a2c3f00559a 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -2134,14 +2134,6 @@ static void shader_dump_decl_usage(struct wined3d_string_buffer *buffer, shader_addline(buffer, " (uint)"); break; - case WINED3D_DATA_UNORM: - shader_addline(buffer, " (unorm)"); - break; - - case WINED3D_DATA_SNORM: - shader_addline(buffer, " (snorm)"); - break; - default: shader_addline(buffer, " (unknown)"); break; @@ -2448,8 +2440,6 @@ static void shader_dump_register(struct wined3d_string_buffer *buffer, case WINED3D_DATA_INT: shader_addline(buffer, "%d", reg->u.immconst_data[0]); break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: case WINED3D_DATA_UINT: shader_addline(buffer, "%u", reg->u.immconst_data[0]); break; @@ -2472,8 +2462,6 @@ static void shader_dump_register(struct wined3d_string_buffer *buffer, reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[2], reg->u.immconst_data[3]); break; - case WINED3D_DATA_RESOURCE: - case WINED3D_DATA_SAMPLER: case WINED3D_DATA_UINT: shader_addline(buffer, "%u, %u, %u, %u", reg->u.immconst_data[0], reg->u.immconst_data[1], diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c index b119e8feaa8..69947d21c14 100644 --- a/dlls/wined3d/shader_sm4.c +++ b/dlls/wined3d/shader_sm4.c @@ -509,8 +509,8 @@ static const enum wined3d_shader_resource_type resource_type_table[] = static const enum wined3d_data_type data_type_table[] = { /* 0 */ WINED3D_DATA_FLOAT, - /* WINED3D_SM4_DATA_UNORM */ WINED3D_DATA_UNORM, - /* WINED3D_SM4_DATA_SNORM */ WINED3D_DATA_SNORM, + /* WINED3D_SM4_DATA_UNORM */ WINED3D_DATA_FLOAT, + /* WINED3D_SM4_DATA_SNORM */ WINED3D_DATA_FLOAT, /* WINED3D_SM4_DATA_INT */ WINED3D_DATA_INT, /* WINED3D_SM4_DATA_UINT */ WINED3D_DATA_UINT, /* WINED3D_SM4_DATA_FLOAT */ WINED3D_DATA_FLOAT, @@ -565,8 +565,8 @@ static void shader_sm4_read_dcl_resource(struct wined3d_shader_instruction *ins, { enum wined3d_sm4_resource_type resource_type; enum wined3d_sm4_data_type data_type; - enum wined3d_data_type reg_data_type; DWORD components; + BOOL uav; resource_type = (opcode_token & WINED3D_SM4_RESOURCE_TYPE_MASK) >> WINED3D_SM4_RESOURCE_TYPE_SHIFT; if (!resource_type || (resource_type >= ARRAY_SIZE(resource_type_table))) @@ -578,8 +578,8 @@ static void shader_sm4_read_dcl_resource(struct wined3d_shader_instruction *ins, { ins->declaration.semantic.resource_type = resource_type_table[resource_type]; } - reg_data_type = opcode == WINED3D_SM4_OP_DCL_RESOURCE ? WINED3D_DATA_RESOURCE : WINED3D_DATA_UAV; - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], reg_data_type, &ins->declaration.semantic.reg); + uav = opcode != WINED3D_SM4_OP_DCL_RESOURCE; + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.semantic.reg); components = *tokens++; if ((components & 0xfff0) != (components & 0xf) * 0x1110) @@ -596,7 +596,7 @@ static void shader_sm4_read_dcl_resource(struct wined3d_shader_instruction *ins, ins->declaration.semantic.resource_data_type = data_type_table[data_type]; } - if (reg_data_type == WINED3D_DATA_UAV) + if (uav) ins->flags = (opcode_token & WINED3D_SM5_UAV_FLAGS_MASK) >> WINED3D_SM5_UAV_FLAGS_SHIFT; } @@ -616,14 +616,14 @@ static void shader_sm4_read_dcl_sampler(struct wined3d_shader_instruction *ins, ins->flags = (opcode_token & WINED3D_SM4_SAMPLER_MODE_MASK) >> WINED3D_SM4_SAMPLER_MODE_SHIFT; if (ins->flags & ~WINED3D_SM4_SAMPLER_COMPARISON) FIXME("Unhandled sampler mode %#x.\n", ins->flags); - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_SAMPLER, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.dst); } static void shader_sm4_read_dcl_index_range(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_OPAQUE, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.index_range.first_register); ins->declaration.index_range.last_register = *tokens; } @@ -731,7 +731,7 @@ static void shader_sm5_read_fcall(struct wined3d_shader_instruction *ins, struct wined3d_sm4_data *priv) { priv->src_param[0].reg.u.fp_body_idx = *tokens++; - shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_OPAQUE, &priv->src_param[0]); + shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &priv->src_param[0]); } static void shader_sm5_read_dcl_function_body(struct wined3d_shader_instruction *ins, @@ -812,7 +812,7 @@ static void shader_sm5_read_dcl_uav_raw(struct wined3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UAV, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.dst); ins->flags = (opcode_token & WINED3D_SM5_UAV_FLAGS_MASK) >> WINED3D_SM5_UAV_FLAGS_SHIFT; } @@ -820,7 +820,7 @@ static void shader_sm5_read_dcl_uav_structured(struct wined3d_shader_instruction DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UAV, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.structured_resource.reg); ins->flags = (opcode_token & WINED3D_SM5_UAV_FLAGS_MASK) >> WINED3D_SM5_UAV_FLAGS_SHIFT; ins->declaration.structured_resource.byte_stride = *tokens; @@ -854,7 +854,7 @@ static void shader_sm5_read_dcl_resource_structured(struct wined3d_shader_instru DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_RESOURCE, + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.structured_resource.reg); ins->declaration.structured_resource.byte_stride = *tokens; if (ins->declaration.structured_resource.byte_stride % 4) @@ -865,7 +865,7 @@ static void shader_sm5_read_dcl_resource_raw(struct wined3d_shader_instruction * DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct wined3d_sm4_data *priv) { - shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_RESOURCE, &ins->declaration.dst); + shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], WINED3D_DATA_UINT, &ins->declaration.dst); } static void shader_sm5_read_sync(struct wined3d_shader_instruction *ins, @@ -875,15 +875,13 @@ static void shader_sm5_read_sync(struct wined3d_shader_instruction *ins, ins->flags = (opcode_token & WINED3D_SM5_SYNC_FLAGS_MASK) >> WINED3D_SM5_SYNC_FLAGS_SHIFT; } -/* - * f -> WINED3D_DATA_FLOAT - * i -> WINED3D_DATA_INT - * u -> WINED3D_DATA_UINT - * O -> WINED3D_DATA_OPAQUE - * R -> WINED3D_DATA_RESOURCE - * S -> WINED3D_DATA_SAMPLER - * U -> WINED3D_DATA_UAV - */ +/* f -> FLOAT + * i -> INT + * u -> UINT + * O -> OPAQUE + * R -> RESOURCE + * S -> SAMPLER + * U -> UAV */ static const struct wined3d_sm4_opcode_info opcode_table[] = { {WINED3D_SM4_OP_ADD, WINED3DSIH_ADD, "f", "ff"}, @@ -1207,15 +1205,11 @@ static enum wined3d_data_type map_data_type(char t) case 'i': return WINED3D_DATA_INT; case 'u': - return WINED3D_DATA_UINT; case 'O': - return WINED3D_DATA_OPAQUE; case 'R': - return WINED3D_DATA_RESOURCE; case 'S': - return WINED3D_DATA_SAMPLER; case 'U': - return WINED3D_DATA_UAV; + return WINED3D_DATA_UINT; default: ERR("Invalid data type '%c'.\n", t); return WINED3D_DATA_FLOAT; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index d190f7ccfd6..3d637005353 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -503,13 +503,7 @@ enum wined3d_data_type { WINED3D_DATA_FLOAT, WINED3D_DATA_INT, - WINED3D_DATA_RESOURCE, - WINED3D_DATA_SAMPLER, - WINED3D_DATA_UAV, WINED3D_DATA_UINT, - WINED3D_DATA_UNORM, - WINED3D_DATA_SNORM, - WINED3D_DATA_OPAQUE, }; enum wined3d_immconst_type -- 2.16.1

June 12, 2018

[PATCH 1/5] wined3d: Generate shader epilogue before conditional returns.

by Matteo Bruni

Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- dlls/wined3d/glsl_shader.c | 33 ++++++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index a99762b151f..86259ae4755 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -5131,20 +5131,20 @@ static void shader_glsl_default(const struct wined3d_shader_instruction *ins) shader_addline(ins->ctx->buffer, "default:\n"); } -static void shader_glsl_generate_conditional_op(const struct wined3d_shader_instruction *ins, - const char *op) +static void shader_glsl_generate_condition(const struct wined3d_shader_instruction *ins) { struct glsl_src_param src_param; const char *condition; condition = ins->flags == WINED3D_SHADER_CONDITIONAL_OP_NZ ? "bool" : "!bool"; shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src_param); - shader_addline(ins->ctx->buffer, "if (%s(%s)) %s\n", condition, src_param.param_str, op); + shader_addline(ins->ctx->buffer, "if (%s(%s))\n", condition, src_param.param_str); } static void shader_glsl_if(const struct wined3d_shader_instruction *ins) { - shader_glsl_generate_conditional_op(ins, "{"); + shader_glsl_generate_condition(ins); + shader_addline(ins->ctx->buffer, "{\n"); } static void shader_glsl_ifc(const struct wined3d_shader_instruction *ins) @@ -5203,15 +5203,29 @@ static void shader_glsl_conditional_op(const struct wined3d_shader_instruction * switch (ins->handler_idx) { - case WINED3DSIH_BREAKP: op = "break;"; break; - case WINED3DSIH_CONTINUEP: op = "continue;"; break; - case WINED3DSIH_RETP: op = "return;"; break; + case WINED3DSIH_BREAKP: + op = "break;"; + break; + case WINED3DSIH_CONTINUEP: + op = "continue;"; + break; + case WINED3DSIH_RETP: + op = "return;"; + break; default: ERR("Unhandled opcode %#x.\n", ins->handler_idx); return; } - shader_glsl_generate_conditional_op(ins, op); + shader_glsl_generate_condition(ins); + if (ins->handler_idx == WINED3DSIH_RETP) + { + shader_addline(ins->ctx->buffer, "{\n"); + shader_glsl_generate_shader_epilogue(ins->ctx); + } + shader_addline(ins->ctx->buffer, " %s\n", op); + if (ins->handler_idx == WINED3DSIH_RETP) + shader_addline(ins->ctx->buffer, "}\n"); } static void shader_glsl_continue(const struct wined3d_shader_instruction *ins) @@ -6764,7 +6778,8 @@ static void shader_glsl_texkill(const struct wined3d_shader_instruction *ins) { if (ins->ctx->reg_maps->shader_version.major >= 4) { - shader_glsl_generate_conditional_op(ins, "discard;"); + shader_glsl_generate_condition(ins); + shader_addline(ins->ctx->buffer, " discard;\n"); } else { -- 2.16.1

June 12, 2018

[PATCH 2/2] schedsvc: Retry opening a .job file only in case of sharing violation. (v2)

by Dmitry Timoshkov

And turn loud ERR() into a TRACE() like it is in other places. v2: fix a copy/paste typo. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/schedsvc/atsvc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/schedsvc/atsvc.c b/dlls/schedsvc/atsvc.c index f6ea0f0e23..b8adc7279d 100644 --- a/dlls/schedsvc/atsvc.c +++ b/dlls/schedsvc/atsvc.c @@ -558,7 +558,7 @@ static BOOL load_job(const WCHAR *name, struct job_t *info) if (file == INVALID_HANDLE_VALUE) { TRACE("Failed to open %s, error %u\n", debugstr_w(name), GetLastError()); - if (try++ >= 3) break; + if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3) break; Sleep(100); continue; } @@ -872,9 +872,9 @@ static void update_job_status(struct job_t *job) hfile = CreateFileW(job->name, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); if (hfile != INVALID_HANDLE_VALUE) break; - if (try++ >= 3) + if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3) { - ERR("Failed to update %s, error %u\n", debugstr_w(job->name), GetLastError()); + TRACE("Failed to update %s, error %u\n", debugstr_w(job->name), GetLastError()); return; } Sleep(100); -- 2.16.3

June 12, 2018

[PATCH 1/2] mstask: Retry opening a .job file only in case of sharing violation.

by Dmitry Timoshkov

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/mstask/task.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mstask/task.c b/dlls/mstask/task.c index 7499826937..69f1e5f95c 100644 --- a/dlls/mstask/task.c +++ b/dlls/mstask/task.c @@ -1444,7 +1444,7 @@ static HRESULT WINAPI MSTASK_IPersistFile_Load(IPersistFile *iface, LPCOLESTR fi file = CreateFileW(file_name, access, sharing, NULL, OPEN_EXISTING, 0, 0); if (file != INVALID_HANDLE_VALUE) break; - if (try++ >= 3) + if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3) { TRACE("Failed to open %s, error %u\n", debugstr_w(file_name), GetLastError()); return HRESULT_FROM_WIN32(GetLastError()); -- 2.16.3

June 12, 2018

[PATCH 2/2] schedsvc: Retry opening a .job file only in case of sharing violation.

by Dmitry Timoshkov

And turn loud ERR() into a TRACE() like it is in other places. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/schedsvc/atsvc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/schedsvc/atsvc.c b/dlls/schedsvc/atsvc.c index f6ea0f0e23..91a6af2e2f 100644 --- a/dlls/schedsvc/atsvc.c +++ b/dlls/schedsvc/atsvc.c @@ -558,7 +558,7 @@ static BOOL load_job(const WCHAR *name, struct job_t *info) if (file == INVALID_HANDLE_VALUE) { TRACE("Failed to open %s, error %u\n", debugstr_w(name), GetLastError()); - if (try++ >= 3) break; + if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3) Sleep(100); continue; } @@ -872,9 +872,9 @@ static void update_job_status(struct job_t *job) hfile = CreateFileW(job->name, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); if (hfile != INVALID_HANDLE_VALUE) break; - if (try++ >= 3) + if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3) { - ERR("Failed to update %s, error %u\n", debugstr_w(job->name), GetLastError()); + TRACE("Failed to update %s, error %u\n", debugstr_w(job->name), GetLastError()); return; } Sleep(100); -- 2.16.3

June 12, 2018

[PATCH 1/2] mstask: Retry opening a .job file only in case of sharing violation.

by Dmitry Timoshkov

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/mstask/task.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mstask/task.c b/dlls/mstask/task.c index 7499826937..69f1e5f95c 100644 --- a/dlls/mstask/task.c +++ b/dlls/mstask/task.c @@ -1444,7 +1444,7 @@ static HRESULT WINAPI MSTASK_IPersistFile_Load(IPersistFile *iface, LPCOLESTR fi file = CreateFileW(file_name, access, sharing, NULL, OPEN_EXISTING, 0, 0); if (file != INVALID_HANDLE_VALUE) break; - if (try++ >= 3) + if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3) { TRACE("Failed to open %s, error %u\n", debugstr_w(file_name), GetLastError()); return HRESULT_FROM_WIN32(GetLastError()); -- 2.16.3

June 12, 2018

[PATCH] msvcr100: Fix lldiv implementation

by Piotr Caban

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 9 ++++----- dlls/ucrtbase/tests/misc.c | 4 ++-- 2 files changed, 6 insertions(+), 7 deletions(-)

June 12, 2018

Re: [PATCH v2 2/2] msvcrt: Don't reimplement call_unwind_func().

by Piotr Caban

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com>

June 12, 2018

Re: [PATCH v2 1/2] msvcrt: Avoid using inline assembly in call_unwind_func().

by Piotr Caban

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com>

June 12, 2018

Re: [PATCH 3/3] msvcrt: Implement quick_exit and _crt_at_quick_exit

by Piotr Caban

On 06/12/18 09:43, Fabian Maurer wrote: > > Why don't you just call onexit functions instead of reimplementing it? > > > Note that you don't need to call MSVCRT__initialize_onexit_table when > > > quick_exit table is declared static. > > What do you mean? AFAIK the onquickexit functions are different > functions than the one registered onexit, no? So I need to have a second > function that uses a different table. Or put the shared functionality > into a shared function. atexit and at_quick_exit needs to manage similar table of functions. Because of that there's a set of helper functions that can be used to accomplish it (*_onexit_table functions). It's even documented that it's used internally: https://msdn.microsoft.com/en-us/library/mt670601.aspx Thanks, Piotr

June 12, 2018

Re: [PATCH 2/3] msvcrt: Add quick_exit

by Piotr Caban

On 06/12/18 09:40, Fabian Maurer wrote: > > quick_exit function should not call exit. I'm attaching a test that > > > shows that atexit callbacks should not be called. > > I know, and MSVCRT__exit only calls ExitProcess, not calling any callbacks. I've misread the patch, sorry for that (MSVCRT_exit / MSVCRT__exit). Thanks, Piotr

June 12, 2018