April 2020 - Wine-Commits - list.winehq.org

Jacek Caban : dbghelp: Use local fat header declaration.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 8230889f1f2e545222f3a51ba9b47fa02196eb98 URL: https://source.winehq.org/git/wine.git/?a=commit;h=8230889f1f2e545222f3a51b… Author: Jacek Caban <jacek(a)codeweavers.com> Date: Wed Apr 1 20:28:58 2020 +0200 dbghelp: Use local fat header declaration. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/dbghelp/macho_module.c | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/dlls/dbghelp/macho_module.c b/dlls/dbghelp/macho_module.c index 0e532c354b..6710385a88 100644 --- a/dlls/dbghelp/macho_module.c +++ b/dlls/dbghelp/macho_module.c @@ -54,7 +54,6 @@ #ifdef HAVE_MACH_O_LOADER_H -#include <mach-o/fat.h> #include <mach-o/loader.h> #include <mach-o/nlist.h> #include <mach-o/dyld.h> @@ -111,6 +110,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_macho); memory by dyld. */ #define MACHO_DYLD_IN_SHARED_CACHE 0x80000000 +#define MACHO_FAT_MAGIC 0xcafebabe #define UUID_STRING_LEN 37 /* 16 bytes at 2 hex digits apiece, 4 dashes, and the null terminator */ @@ -682,7 +682,6 @@ static BOOL macho_map_file(struct process *pcs, const WCHAR *filenameW, BOOL split_segs, struct image_file_map* ifm) { struct macho_file_map* fmap = &ifm->u.macho; - struct fat_header fat_header; struct mach_header mach_header; int i; WCHAR* filename; @@ -693,6 +692,12 @@ static BOOL macho_map_file(struct process *pcs, const WCHAR *filenameW, uint32_t target_cmd = (pcs->is_64bit) ? LC_SEGMENT_64 : LC_SEGMENT; DWORD bytes_read; + struct + { + UINT32 magic; /* FAT_MAGIC or FAT_MAGIC_64 */ + UINT32 nfat_arch; /* number of structs that follow */ + } fat_header; + TRACE("(%s, %p)\n", debugstr_w(filenameW), fmap); reset_file_map(ifm); @@ -721,12 +726,20 @@ static BOOL macho_map_file(struct process *pcs, const WCHAR *filenameW, TRACE("... got possible fat header\n"); /* Fat header is always in big-endian order. */ - if (swap_ulong_be_to_host(fat_header.magic) == FAT_MAGIC) + if (swap_ulong_be_to_host(fat_header.magic) == MACHO_FAT_MAGIC) { int narch = swap_ulong_be_to_host(fat_header.nfat_arch); for (i = 0; i < narch; i++) { - struct fat_arch fat_arch; + struct + { + UINT32 cputype; /* cpu specifier (int) */ + UINT32 cpusubtype; /* machine specifier (int) */ + UINT32 offset; /* file offset to this object file */ + UINT32 size; /* size of this object file */ + UINT32 align; /* alignment as a power of 2 */ + } fat_arch; + if (!ReadFile(fmap->handle, &fat_arch, sizeof(fat_arch), &bytes_read, NULL) || bytes_read != sizeof(fat_arch)) goto done; if (swap_ulong_be_to_host(fat_arch.cputype) == target_cpu)

1 0

Nikolay Sivov : comctl32/button: Use duplicated image for drawing.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 5fcd20396fb29a1f2ce87645cbb0d045ce5cf2d8 URL: https://source.winehq.org/git/wine.git/?a=commit;h=5fcd20396fb29a1f2ce87645… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Wed Apr 1 15:17:50 2020 +0300 comctl32/button: Use duplicated image for drawing. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47794 Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/comctl32/button.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/dlls/comctl32/button.c b/dlls/comctl32/button.c index 0078bd0fc6..b615df4a16 100644 --- a/dlls/comctl32/button.c +++ b/dlls/comctl32/button.c @@ -90,11 +90,12 @@ typedef struct _BUTTON_INFO HIMAGELIST glyph; /* this is a font character code when split_style doesn't have BCSS_IMAGE */ SIZE glyph_size; RECT text_margin; + HANDLE image; /* Original handle set with BM_SETIMAGE and returned with BM_GETIMAGE. */ union { HICON icon; HBITMAP bitmap; - HANDLE image; + HANDLE image; /* Duplicated handle used for drawing. */ } u; } BUTTON_INFO; @@ -488,6 +489,10 @@ static LRESULT CALLBACK BUTTON_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, L case WM_NCDESTROY: SetWindowLongPtrW( hWnd, 0, 0 ); + if (infoPtr->image_type == IMAGE_BITMAP) + DeleteObject(infoPtr->u.bitmap); + else if (infoPtr->image_type == IMAGE_ICON) + DestroyIcon(infoPtr->u.icon); heap_free(infoPtr->note); heap_free(infoPtr); break; @@ -859,13 +864,14 @@ static LRESULT CALLBACK BUTTON_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, L case BM_SETIMAGE: infoPtr->image_type = (DWORD)wParam; - oldHbitmap = infoPtr->u.image; - infoPtr->u.image = (HANDLE)lParam; - InvalidateRect( hWnd, NULL, FALSE ); - return (LRESULT)oldHbitmap; + oldHbitmap = infoPtr->image; + infoPtr->u.image = CopyImage((HANDLE)lParam, infoPtr->image_type, 0, 0, 0); + infoPtr->image = (HANDLE)lParam; + InvalidateRect( hWnd, NULL, FALSE ); + return (LRESULT)oldHbitmap; case BM_GETIMAGE: - return (LRESULT)infoPtr->u.image; + return (LRESULT)infoPtr->image; case BCM_SETIMAGELIST: {

1 0

Rémi Bernon : winedbg: Simplify and fix register read/write handlers.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 1ccd2c2be1f8857e12dde0d891127f7c223c0aff URL: https://source.winehq.org/git/wine.git/?a=commit;h=1ccd2c2be1f8857e12dde0d8… Author: Rémi Bernon <rbernon(a)codeweavers.com> Date: Wed Apr 1 17:03:23 2020 +0200 winedbg: Simplify and fix register read/write handlers. This was using some conditional context read and dbg_curr_thread checks, we can just read the context of the selected thread and write it back as needed. Also, packet_reply_register_hex_to was using gdbctx->context, which is not always the context we want to read. We still need to keep changes in sync with gdbctx->context as it may be still be used for step / continue, but step / continue doesn't work well and we will rewrite it later. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- programs/winedbg/gdbproxy.c | 145 +++++++++++++++++++++++++------------------- 1 file changed, 81 insertions(+), 64 deletions(-) diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 059564d866..0c9872d931 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -786,16 +786,16 @@ static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int err return packet_done; } -static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, unsigned idx) +static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_ctx_t* ctx, unsigned idx) { const struct gdb_register *cpu_register_map = gdbctx->process->be_cpu->gdb_register_map; if (cpu_register_map[idx].gdb_length == cpu_register_map[idx].ctx_length) - packet_reply_hex_to(gdbctx, cpu_register_ptr(gdbctx, &gdbctx->context, idx), + packet_reply_hex_to(gdbctx, cpu_register_ptr(gdbctx, ctx, idx), cpu_register_map[idx].gdb_length); else { - DWORD64 val = cpu_register(gdbctx, &gdbctx->context, idx); + DWORD64 val = cpu_register(gdbctx, ctx, idx); unsigned i; for (i = 0; i < cpu_register_map[idx].gdb_length; i++) @@ -829,12 +829,9 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx) for (i = 0; i < gdbctx->process->be_cpu->gdb_num_regs; i++) { - /* FIXME: this call will also grow the buffer... - * unneeded, but not harmful - */ packet_reply_val(gdbctx, i, 1); packet_reply_add(gdbctx, ":"); - packet_reply_register_hex_to(gdbctx, i); + packet_reply_register_hex_to(gdbctx, &gdbctx->context, i); packet_reply_add(gdbctx, ";"); } @@ -1090,20 +1087,24 @@ static enum packet_return packet_detach(struct gdb_context* gdbctx) static enum packet_return packet_read_registers(struct gdb_context* gdbctx) { - int i; + struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct backend_cpu *backend; dbg_ctx_t ctx; + size_t i; assert(gdbctx->in_trap); - if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) - { - if (!fetch_context(gdbctx, gdbctx->other_thread->handle, &ctx)) - return packet_error; - } + if (!thread) return packet_error; + if (!thread->process) return packet_error; + if (!(backend = thread->process->be_cpu)) return packet_error; + + if (!backend->get_context(thread->handle, &ctx)) + return packet_error; + if (thread == dbg_curr_thread) ctx = gdbctx->context; packet_reply_open(gdbctx); - for (i = 0; i < gdbctx->process->be_cpu->gdb_num_regs; i++) - packet_reply_register_hex_to(gdbctx, i); + for (i = 0; i < backend->gdb_num_regs; i++) + packet_reply_register_hex_to(gdbctx, &ctx, i); packet_reply_close(gdbctx); return packet_done; @@ -1111,31 +1112,36 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx) static enum packet_return packet_write_registers(struct gdb_context* gdbctx) { - const size_t cpu_num_regs = gdbctx->process->be_cpu->gdb_num_regs; - unsigned i; + struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct backend_cpu *backend; dbg_ctx_t ctx; - dbg_ctx_t *pctx = &gdbctx->context; - const char* ptr; + const char *ptr; + size_t i; assert(gdbctx->in_trap); - if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) - { - if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) - return packet_error; - } - if (gdbctx->in_packet_len < cpu_num_regs * 2) return packet_error; + + if (!thread) return packet_error; + if (!thread->process) return packet_error; + if (!(backend = thread->process->be_cpu)) return packet_error; + + if (!backend->get_context(thread->handle, &ctx)) + return packet_error; + if (thread == dbg_curr_thread) ctx = gdbctx->context; + + if (gdbctx->in_packet_len < backend->gdb_num_regs * 2) + return packet_error; ptr = gdbctx->in_packet; - for (i = 0; i < cpu_num_regs; i++) - cpu_register_hex_from(gdbctx, pctx, i, &ptr); + for (i = 0; i < backend->gdb_num_regs; i++) + cpu_register_hex_from(gdbctx, &ctx, i, &ptr); - if (pctx != &gdbctx->context && - !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx)) + if (!backend->set_context(thread->handle, &ctx)) { - ERR("Failed to set context for tid %04x, error %u\n", - gdbctx->other_thread->tid, GetLastError()); + ERR("Failed to set context for tid %04x, error %u\n", thread->tid, GetLastError()); return packet_error; } + + if (thread == dbg_curr_thread) gdbctx->context = ctx; return packet_ok; } @@ -1249,69 +1255,80 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx) static enum packet_return packet_read_register(struct gdb_context* gdbctx) { - unsigned reg; + struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct backend_cpu *backend; dbg_ctx_t ctx; - dbg_ctx_t *pctx = &gdbctx->context; + size_t reg; assert(gdbctx->in_trap); - reg = hex_to_int(gdbctx->in_packet, gdbctx->in_packet_len); - if (reg >= gdbctx->process->be_cpu->gdb_num_regs) - { - WARN("Unhandled register %u\n", reg); + + if (!thread) return packet_error; + if (!thread->process) return packet_error; + if (!(backend = thread->process->be_cpu)) return packet_error; + + if (!backend->get_context(thread->handle, &ctx)) return packet_error; - } - if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) + if (thread == dbg_curr_thread) ctx = gdbctx->context; + + if (sscanf(gdbctx->in_packet, "%zx", &reg) != 1) + return packet_error; + if (reg >= backend->gdb_num_regs) { - if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) - return packet_error; + WARN("Unhandled register %zu\n", reg); + return packet_error; } - TRACE("%u => %s\n", reg, wine_dbgstr_longlong(cpu_register(gdbctx, pctx, reg))); + TRACE("%zu => %s\n", reg, wine_dbgstr_longlong(cpu_register(gdbctx, &ctx, reg))); packet_reply_open(gdbctx); - packet_reply_register_hex_to(gdbctx, reg); + packet_reply_register_hex_to(gdbctx, &ctx, reg); packet_reply_close(gdbctx); return packet_done; } static enum packet_return packet_write_register(struct gdb_context* gdbctx) { - unsigned reg; - char* ptr; + struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct backend_cpu *backend; dbg_ctx_t ctx; - dbg_ctx_t *pctx = &gdbctx->context; + size_t reg; + char *ptr; assert(gdbctx->in_trap); - reg = strtoul(gdbctx->in_packet, &ptr, 16); - if (ptr == NULL || reg >= gdbctx->process->be_cpu->gdb_num_regs || *ptr++ != '=') + if (!thread) return packet_error; + if (!thread->process) return packet_error; + if (!(backend = thread->process->be_cpu)) return packet_error; + + if (!backend->get_context(thread->handle, &ctx)) + return packet_error; + if (thread == dbg_curr_thread) ctx = gdbctx->context; + + if (!(ptr = strchr(gdbctx->in_packet, '='))) + return packet_error; + *ptr++ = '\0'; + + if (sscanf(gdbctx->in_packet, "%zx", &reg) != 1) + return packet_error; + if (reg >= backend->gdb_num_regs) { - WARN("Unhandled register %s\n", - debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb * it wouldn't matter too much, and it fakes our support for all regs */ - return (ptr == NULL) ? packet_error : packet_ok; + WARN("Unhandled register %zu\n", reg); + return packet_ok; } - TRACE("%u <= %s\n", reg, - debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet)))); - - if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) - { - if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) - return packet_error; - } + TRACE("%zu <= %s\n", reg, debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet)))); - cpu_register_hex_from(gdbctx, pctx, reg, (const char**)&ptr); - if (pctx != &gdbctx->context && - !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx)) + cpu_register_hex_from(gdbctx, &ctx, reg, (const char**)&ptr); + if (!backend->set_context(thread->handle, &ctx)) { - ERR("Failed to set context for tid %04x, error %u\n", - gdbctx->other_thread->tid, GetLastError()); + ERR("Failed to set context for tid %04x, error %u\n", thread->tid, GetLastError()); return packet_error; } + if (thread == dbg_curr_thread) gdbctx->context = ctx; return packet_ok; }

1 0

Rémi Bernon : winedbg: Simplify individual thread single_step control.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 90e6a52563800c2320cd4fda973497338d3daf3e URL: https://source.winehq.org/git/wine.git/?a=commit;h=90e6a52563800c2320cd4fda… Author: Rémi Bernon <rbernon(a)codeweavers.com> Date: Wed Apr 1 17:03:24 2020 +0200 winedbg: Simplify individual thread single_step control. This is still some cleanup, and does not fix much wrt step / continue, but it introduces dbg_thread_set_single_step that is going to be useful for individual thread control and let us remove all remaining uses of gdbctx->context. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- programs/winedbg/gdbproxy.c | 71 +++++++++++++++++++++++---------------------- 1 file changed, 36 insertions(+), 35 deletions(-) diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index 0c9872d931..f20c8d2ea9 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -89,7 +89,6 @@ struct gdb_context /* current Win32 trap env */ unsigned last_sig; BOOL in_trap; - dbg_ctx_t context; /* Win32 information */ struct dbg_process* process; /* Unix environment */ @@ -271,14 +270,23 @@ static inline void cpu_register_hex_from(struct gdb_context *gdbctx, * =============================================== * */ -static BOOL fetch_context(struct gdb_context *gdbctx, HANDLE h, dbg_ctx_t *ctx) +static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable) { - if (!gdbctx->process->be_cpu->get_context(h, ctx)) + struct backend_cpu *backend; + dbg_ctx_t ctx; + + if (!thread) return; + if (!thread->process) return; + if (!(backend = thread->process->be_cpu)) return; + + if (!backend->get_context(thread->handle, &ctx)) { - ERR("Failed to get context, error %u\n", GetLastError()); - return FALSE; + ERR("get_context failed for thread %04x:%04x\n", thread->process->pid, thread->tid); + return; } - return TRUE; + backend->single_step(&ctx, enable); + if (!backend->set_context(thread->handle, &ctx)) + ERR("set_context failed for thread %04x:%04x\n", thread->process->pid, thread->tid); } static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc) @@ -438,10 +446,7 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) TRACE("%08x:%08x: exception code=0x%08x\n", de->dwProcessId, de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode); - if (fetch_context(gdbctx, dbg_curr_thread->handle, &gdbctx->context)) - { - gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception); - } + gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception); break; case CREATE_THREAD_DEBUG_EVENT: @@ -499,9 +504,6 @@ static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont) { if (dbg_curr_thread) { - if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context)) - ERR("Failed to set context for thread %04x, error %u\n", - dbg_curr_thread->tid, GetLastError()); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) ERR("Failed to continue thread %04x, error %u\n", dbg_curr_thread->tid, GetLastError()); @@ -518,9 +520,6 @@ 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 (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context)) - ERR("Failed to set context for thread %04x, error %u\n", - dbg_curr_thread->tid, GetLastError()); if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) ERR("Failed to continue thread %04x, error %u\n", dbg_curr_thread->tid, GetLastError()); @@ -594,7 +593,7 @@ static void wait_for_debuggee(struct gdb_context* gdbctx) static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill) { assert(gdbctx->process->be_cpu); - gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE); resume_debuggee(gdbctx, DBG_CONTINUE); if (!kill) DebugActiveProcessStop(gdbctx->process->pid); @@ -814,10 +813,19 @@ static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_ static enum packet_return packet_reply_status(struct gdb_context* gdbctx) { - if (gdbctx->process != NULL) + struct dbg_process *process = gdbctx->process; + struct backend_cpu *backend; + dbg_ctx_t ctx; + size_t i; + + if (process != NULL) { unsigned char sig; - unsigned i; + + if (!(backend = process->be_cpu)) return packet_error; + + if (!backend->get_context(dbg_curr_thread->handle, &ctx)) + return packet_error; packet_reply_open(gdbctx); packet_reply_add(gdbctx, "T"); @@ -827,11 +835,11 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx) packet_reply_val(gdbctx, dbg_curr_thread->tid, 4); packet_reply_add(gdbctx, ";"); - for (i = 0; i < gdbctx->process->be_cpu->gdb_num_regs; i++) + for (i = 0; i < backend->gdb_num_regs; i++) { packet_reply_val(gdbctx, i, 1); packet_reply_add(gdbctx, ":"); - packet_reply_register_hex_to(gdbctx, &gdbctx->context, i); + packet_reply_register_hex_to(gdbctx, &ctx, i); packet_reply_add(gdbctx, ";"); } @@ -978,13 +986,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) switch (gdbctx->in_packet[actionIndex[i] + 1]) { case 's': /* step */ - gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE); /* fall through*/ case 'c': /* continue */ resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); break; case 'S': /* step Sig, */ - gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE); /* fall through */ case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1); @@ -1020,13 +1028,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) switch (gdbctx->in_packet[actionIndex[defaultAction] + 1]) { case 's': /* step */ - gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE); /* fall through */ case 'c': /* continue */ resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); break; case 'S': - gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE); /* fall through */ case 'C': /* continue sig */ hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1); @@ -1042,8 +1050,7 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) } /* if(defaultAction >=0) */ wait_for_debuggee(gdbctx); - if (gdbctx->process) - gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); + if (gdbctx->process && dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE); return packet_reply_status(gdbctx); } @@ -1100,7 +1107,6 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx) if (!backend->get_context(thread->handle, &ctx)) return packet_error; - if (thread == dbg_curr_thread) ctx = gdbctx->context; packet_reply_open(gdbctx); for (i = 0; i < backend->gdb_num_regs; i++) @@ -1126,7 +1132,6 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx) if (!backend->get_context(thread->handle, &ctx)) return packet_error; - if (thread == dbg_curr_thread) ctx = gdbctx->context; if (gdbctx->in_packet_len < backend->gdb_num_regs * 2) return packet_error; @@ -1141,7 +1146,6 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx) return packet_error; } - if (thread == dbg_curr_thread) gdbctx->context = ctx; return packet_ok; } @@ -1268,7 +1272,6 @@ static enum packet_return packet_read_register(struct gdb_context* gdbctx) if (!backend->get_context(thread->handle, &ctx)) return packet_error; - if (thread == dbg_curr_thread) ctx = gdbctx->context; if (sscanf(gdbctx->in_packet, "%zx", &reg) != 1) return packet_error; @@ -1302,7 +1305,6 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) if (!backend->get_context(thread->handle, &ctx)) return packet_error; - if (thread == dbg_curr_thread) ctx = gdbctx->context; if (!(ptr = strchr(gdbctx->in_packet, '='))) return packet_error; @@ -1328,7 +1330,6 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx) return packet_error; } - if (thread == dbg_curr_thread) gdbctx->context = ctx; return packet_ok; } @@ -1672,10 +1673,10 @@ static enum packet_return packet_step(struct gdb_context* gdbctx) if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) FIXME("Can't single-step thread %04x while on thread %04x\n", gdbctx->exec_thread->tid, dbg_curr_thread->tid); - gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); - gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE); + if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE); return packet_reply_status(gdbctx); }

1 0

Rémi Bernon : winedbg: Use tid for other/exec thread operations.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: b434af6637ae5204fe7a0db2422ac28f18a9412b URL: https://source.winehq.org/git/wine.git/?a=commit;h=b434af6637ae5204fe7a0db2… Author: Rémi Bernon <rbernon(a)codeweavers.com> Date: Wed Apr 1 17:03:25 2020 +0200 winedbg: Use tid for other/exec thread operations. Looking up the thread makes us loose track of any/all (0/-1) tids, we need that for correct continue/step implementation. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- programs/winedbg/gdbproxy.c | 76 ++++++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 35 deletions(-) diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c index f20c8d2ea9..a2a6df91f3 100644 --- a/programs/winedbg/gdbproxy.c +++ b/programs/winedbg/gdbproxy.c @@ -84,8 +84,8 @@ struct gdb_context int out_len; int out_curr_packet; /* generic GDB thread information */ - struct dbg_thread* exec_thread; /* thread used in step & continue */ - struct dbg_thread* other_thread; /* thread to be used in any other operation */ + int exec_tid; /* tid used in step & continue */ + int other_tid; /* tid to be used in any other operation */ /* current Win32 trap env */ unsigned last_sig; BOOL in_trap; @@ -270,6 +270,23 @@ static inline void cpu_register_hex_from(struct gdb_context *gdbctx, * =============================================== * */ +static struct dbg_thread* dbg_thread_from_tid(struct gdb_context* gdbctx, int tid) +{ + struct dbg_process *process = gdbctx->process; + struct dbg_thread *thread; + + if (!process) return NULL; + + if (tid == 0) return dbg_curr_thread; + LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry) + { + if (tid > 0 && thread->tid != tid) continue; + return thread; + } + + return dbg_curr_thread; +} + static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable) { struct backend_cpu *backend; @@ -384,6 +401,8 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) } u; dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId); + gdbctx->exec_tid = de->dwThreadId; + gdbctx->other_tid = de->dwThreadId; switch (de->dwDebugEventCode) { @@ -464,8 +483,6 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode); assert(dbg_curr_thread); - if (dbg_curr_thread == gdbctx->exec_thread) gdbctx->exec_thread = NULL; - if (dbg_curr_thread == gdbctx->other_thread) gdbctx->other_thread = NULL; dbg_del_thread(dbg_curr_thread); break; @@ -865,9 +882,9 @@ static enum packet_return packet_continue(struct gdb_context* gdbctx) { /* FIXME: add support for address in packet */ assert(gdbctx->in_packet_len == 0); - if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) + if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid) FIXME("Can't continue thread %04x while on thread %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + gdbctx->exec_tid, dbg_curr_thread->tid); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); return packet_reply_status(gdbctx); @@ -962,9 +979,9 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx) /* Ok, now we have... actionIndex full of actions and we know what threads there are, so all * that remains is to apply the actions to the threads and the default action to any threads * left */ - if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) + if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid) FIXME("Can't continue thread %04x while on thread %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + gdbctx->exec_tid, dbg_curr_thread->tid); /* deal with the threaded stuff first */ for (i = 0; i < actions ; i++) @@ -1073,9 +1090,9 @@ static enum packet_return packet_continue_signal(struct gdb_context* gdbctx) /* FIXME: add support for address in packet */ assert(gdbctx->in_packet_len == 2); - if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) + if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid) FIXME("Can't continue thread %04x while on thread %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + gdbctx->exec_tid, dbg_curr_thread->tid); hex_from(&sig, gdbctx->in_packet, 1); /* cannot change signals on the fly */ TRACE("sigs: %u %u\n", sig, gdbctx->last_sig); @@ -1094,7 +1111,7 @@ static enum packet_return packet_detach(struct gdb_context* gdbctx) static enum packet_return packet_read_registers(struct gdb_context* gdbctx) { - struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid); struct backend_cpu *backend; dbg_ctx_t ctx; size_t i; @@ -1118,7 +1135,7 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx) static enum packet_return packet_write_registers(struct gdb_context* gdbctx) { - struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid); struct backend_cpu *backend; dbg_ctx_t ctx; const char *ptr; @@ -1157,28 +1174,16 @@ static enum packet_return packet_kill(struct gdb_context* gdbctx) static enum packet_return packet_thread(struct gdb_context* gdbctx) { - char* end; - unsigned thread; - switch (gdbctx->in_packet[0]) { case 'c': + if (sscanf(gdbctx->in_packet, "c%x", &gdbctx->exec_tid) == 1) + return packet_ok; + return packet_error; case 'g': - if (gdbctx->in_packet[1] == '-') - thread = -strtol(gdbctx->in_packet + 2, &end, 16); - else - thread = strtol(gdbctx->in_packet + 1, &end, 16); - if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len) - { - ERR("Failed to parse %s\n", - debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len)); - return packet_error; - } - if (gdbctx->in_packet[0] == 'c') - gdbctx->exec_thread = dbg_get_thread(gdbctx->process, thread); - else - gdbctx->other_thread = dbg_get_thread(gdbctx->process, thread); - return packet_ok; + if (sscanf(gdbctx->in_packet, "g%x", &gdbctx->other_tid) == 1) + return packet_ok; + return packet_error; default: FIXME("Unknown thread sub-command %c\n", gdbctx->in_packet[0]); return packet_error; @@ -1259,7 +1264,7 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx) static enum packet_return packet_read_register(struct gdb_context* gdbctx) { - struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid); struct backend_cpu *backend; dbg_ctx_t ctx; size_t reg; @@ -1291,7 +1296,7 @@ static enum packet_return packet_read_register(struct gdb_context* gdbctx) static enum packet_return packet_write_register(struct gdb_context* gdbctx) { - struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread; + struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid); struct backend_cpu *backend; dbg_ctx_t ctx; size_t reg; @@ -1670,9 +1675,9 @@ static enum packet_return packet_step(struct gdb_context* gdbctx) { /* FIXME: add support for address in packet */ assert(gdbctx->in_packet_len == 0); - if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) + if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid) FIXME("Can't single-step thread %04x while on thread %04x\n", - gdbctx->exec_thread->tid, dbg_curr_thread->tid); + gdbctx->exec_tid, dbg_curr_thread->tid); if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); @@ -1976,7 +1981,8 @@ static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigne gdbctx->out_len = 0; gdbctx->out_curr_packet = -1; - gdbctx->exec_thread = gdbctx->other_thread = NULL; + gdbctx->exec_tid = -1; + gdbctx->other_tid = -1; gdbctx->last_sig = 0; gdbctx->in_trap = FALSE; gdbctx->process = NULL;

1 0

Rémi Bernon : winedbg: Rewrite and simplify step / continue handlers.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 983d02c08ee399f18f155c27521fc55a56663dc4 URL: https://source.winehq.org/git/wine.git/?a=commit;h=983d02c08ee399f18f155c27… Author: Rémi Bernon <rbernon(a)codeweavers.com> Date: Wed Apr 1 17:03:27 2020 +0200 winedbg: Rewrite and simplify step / continue handlers. The vCont handler used some overcomplicated logic, we only need to iterate over the actions and apply them on the matching threads that didn't match yet. Thanks to DBG_REPLY_LATER we can now continue/step any thread regardless of whether it is the one that raised the debug event. Just suspend all active threads after debug event is raised and resume them one by one, according to the gdb request. If the thread that raised the debug event should not be resumed, reply with DBG_REPLY_LATER. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- programs/winedbg/debugger.h | 1 + programs/winedbg/gdbproxy.c | 289 ++++++++++++-------------------------------- programs/winedbg/winedbg.c | 1 + 3 files changed, 80 insertions(+), 211 deletions(-) Diff: https://source.winehq.org/git/wine.git/?a=commitdiff;h=983d02c08ee399f18f15…

1 0

Derek Lesho : include: Add codecapi.h.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 12c3177ed5cae39de8a9f9111a1cb450296cc8e6 URL: https://source.winehq.org/git/wine.git/?a=commit;h=12c3177ed5cae39de8a9f911… Author: Derek Lesho <dlesho(a)codeweavers.com> Date: Tue Mar 31 21:56:35 2020 +0300 include: Add codecapi.h. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- include/Makefile.in | 1 + include/codecapi.h | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+) diff --git a/include/Makefile.in b/include/Makefile.in index dc79d2ca24..eea1543822 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -61,6 +61,7 @@ SOURCES = \ cmdbas.idl \ cmdtxt.idl \ cmnquery.idl \ + codecapi.h \ colinf.idl \ colordlg.h \ comcat.idl \ diff --git a/include/codecapi.h b/include/codecapi.h new file mode 100644 index 0000000000..1d9fd7e255 --- /dev/null +++ b/include/codecapi.h @@ -0,0 +1,56 @@ +/* + * Copyright 2020 Derek Lesho + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __CODECAPI_H +#define __CODECAPI_H + +enum eAVEncH264VProfile +{ + eAVEncH264VProfile_unknown = 0, + eAVEncH264VProfile_Simple = 66, + eAVEncH264VProfile_Base = 66, + eAVEncH264VProfile_Main = 77, + eAVEncH264VProfile_High = 100, + eAVEncH264VProfile_422 = 122, + eAVEncH264VProfile_High10 = 110, + eAVEncH264VProfile_444 = 244, + eAVEncH264VProfile_Extended = 88, +}; + +enum eAVEncH264VLevel +{ + eAVEncH264VLevel1 = 10, + eAVEncH264VLevel1_b = 11, + eAVEncH264VLevel1_1 = 11, + eAVEncH264VLevel1_2 = 12, + eAVEncH264VLevel1_3 = 13, + eAVEncH264VLevel2 = 20, + eAVEncH264VLevel2_1 = 21, + eAVEncH264VLevel2_2 = 22, + eAVEncH264VLevel3 = 30, + eAVEncH264VLevel3_1 = 31, + eAVEncH264VLevel3_2 = 32, + eAVEncH264VLevel4 = 40, + eAVEncH264VLevel4_1 = 41, + eAVEncH264VLevel4_2 = 42, + eAVEncH264VLevel5 = 50, + eAVEncH264VLevel5_1 = 51, + eAVEncH264VLevel5_2 = 52 +}; + +#endif /* __CODECAPI_H */

1 0

Jacek Caban : dbghelp: Use local symtab and segment commands declarations.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 7b2e53f5b550e8a4d844c5e74941b02d1c770b0b URL: https://source.winehq.org/git/wine.git/?a=commit;h=7b2e53f5b550e8a4d844c5e7… Author: Jacek Caban <jacek(a)codeweavers.com> Date: Wed Apr 1 20:31:14 2020 +0200 dbghelp: Use local symtab and segment commands declarations. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/dbghelp/macho_module.c | 50 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 45 insertions(+), 5 deletions(-) diff --git a/dlls/dbghelp/macho_module.c b/dlls/dbghelp/macho_module.c index 6710385a88..4ca9bee48e 100644 --- a/dlls/dbghelp/macho_module.c +++ b/dlls/dbghelp/macho_module.c @@ -92,6 +92,46 @@ union wine_all_image_infos { struct dyld_all_image_infos64 infos64; }; +struct macho_segment_command +{ + UINT32 cmd; /* LC_SEGMENT_64 */ + UINT32 cmdsize; /* includes sizeof section_64 structs */ + char segname[16]; /* segment name */ + UINT64 vmaddr; /* memory address of this segment */ + UINT64 vmsize; /* memory size of this segment */ + UINT64 fileoff; /* file offset of this segment */ + UINT64 filesize; /* amount to map from the file */ + UINT32 maxprot; /* maximum VM protection */ + UINT32 initprot; /* initial VM protection */ + UINT32 nsects; /* number of sections in segment */ + UINT32 flags; /* flags */ +}; + +struct macho_segment_command32 +{ + UINT32 cmd; /* LC_SEGMENT */ + UINT32 cmdsize; /* includes sizeof section structs */ + char segname[16]; /* segment name */ + UINT32 vmaddr; /* memory address of this segment */ + UINT32 vmsize; /* memory size of this segment */ + UINT32 fileoff; /* file offset of this segment */ + UINT32 filesize; /* amount to map from the file */ + UINT32 maxprot; /* maximum VM protection */ + UINT32 initprot; /* initial VM protection */ + UINT32 nsects; /* number of sections in segment */ + UINT32 flags; /* flags */ +}; + +struct macho_symtab_command +{ + UINT32 cmd; /* LC_SYMTAB */ + UINT32 cmdsize; /* sizeof(struct symtab_command) */ + UINT32 symoff; /* symbol table offset */ + UINT32 nsyms; /* number of symbol table entries */ + UINT32 stroff; /* string table offset */ + UINT32 strsize; /* string table size in bytes */ +}; + #ifdef WORDS_BIGENDIAN #define swap_ulong_be_to_host(n) (n) #else @@ -535,13 +575,13 @@ static int macho_count_sections(struct image_file_map* ifm, const struct macho_l if (ifm->addr_size == 32) { - const struct segment_command *sc = (const struct segment_command *)lc; + const struct macho_segment_command32 *sc = (const struct macho_segment_command32 *)lc; memcpy(segname, sc->segname, sizeof(segname)); nsects = sc->nsects; } else { - const struct segment_command_64 *sc = (const struct segment_command_64 *)lc; + const struct macho_segment_command *sc = (const struct macho_segment_command *)lc; memcpy(segname, sc->segname, sizeof(segname)); nsects = sc->nsects; } @@ -574,7 +614,7 @@ static int macho_load_section_info(struct image_file_map* ifm, const struct mach if (ifm->addr_size == 32) { - const struct segment_command *sc = (const struct segment_command *)lc; + const struct macho_segment_command32 *sc = (const struct macho_segment_command32 *)lc; vmaddr = sc->vmaddr; vmsize = sc->vmsize; memcpy(segname, sc->segname, sizeof(segname)); @@ -583,7 +623,7 @@ static int macho_load_section_info(struct image_file_map* ifm, const struct mach } else { - const struct segment_command_64 *sc = (const struct segment_command_64 *)lc; + const struct macho_segment_command *sc = (const struct macho_segment_command *)lc; vmaddr = sc->vmaddr; vmsize = sc->vmsize; memcpy(segname, sc->segname, sizeof(segname)); @@ -943,7 +983,7 @@ static int macho_parse_symtab(struct image_file_map* ifm, const struct macho_load_command* lc, void* user) { struct macho_file_map* fmap = &ifm->u.macho; - const struct symtab_command* sc = (const struct symtab_command*)lc; + const struct macho_symtab_command* sc = (const struct macho_symtab_command*)lc; struct macho_debug_info* mdi = user; const char* stabstr; int ret = 0;

1 0

Zebediah Figura : d3dcompiler: Index instructions for liveness ranges.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 443b0e3efda8e35bf2369ee3d2cb0ab8ce08facc URL: https://source.winehq.org/git/wine.git/?a=commit;h=443b0e3efda8e35bf2369ee3… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Wed Apr 1 20:31:18 2020 +0200 d3dcompiler: Index instructions for liveness ranges. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/d3dcompiler_43/d3dcompiler_private.h | 2 + dlls/d3dcompiler_43/hlsl.y | 68 ++++++++++++++++++++++++++++--- dlls/d3dcompiler_43/utils.c | 2 +- 3 files changed, 65 insertions(+), 7 deletions(-) diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h index 2a92628212..0dee4129f0 100644 --- a/dlls/d3dcompiler_43/d3dcompiler_private.h +++ b/dlls/d3dcompiler_43/d3dcompiler_private.h @@ -658,6 +658,7 @@ struct hlsl_ir_node { struct list entry; enum hlsl_ir_node_type type; + unsigned int index; /* for liveness ranges */ struct hlsl_type *data_type; struct source_location loc; @@ -734,6 +735,7 @@ struct hlsl_ir_loop struct hlsl_ir_node node; /* loop condition is stored in the body (as "if (!condition) break;") */ struct list *body; + unsigned int next_index; /* liveness index of the end of the loop */ }; enum hlsl_ir_expr_op { diff --git a/dlls/d3dcompiler_43/hlsl.y b/dlls/d3dcompiler_43/hlsl.y index 4c3e96caa0..a434769462 100644 --- a/dlls/d3dcompiler_43/hlsl.y +++ b/dlls/d3dcompiler_43/hlsl.y @@ -915,6 +915,22 @@ static const struct hlsl_ir_function_decl *get_overloaded_func(struct wine_rb_tr return NULL; } +static struct hlsl_ir_function_decl *get_func_entry(const char *name) +{ + struct hlsl_ir_function_decl *decl; + struct hlsl_ir_function *func; + struct wine_rb_entry *entry; + + if ((entry = wine_rb_get(&hlsl_ctx.functions, name))) + { + func = WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry); + WINE_RB_FOR_EACH_ENTRY(decl, &func->overloads, struct hlsl_ir_function_decl, entry) + return decl; + } + + return NULL; +} + static struct list *append_unop(struct list *list, struct hlsl_ir_node *node) { list_add_tail(list, &node->entry); @@ -2545,9 +2561,37 @@ static void dump_function(struct wine_rb_entry *entry, void *context) wine_rb_for_each_entry(&func->overloads, dump_function_decl, NULL); } +/* Allocate a unique, ordered index to each instruction, which will be used for + * computing liveness ranges. */ +static unsigned int index_instructions(struct list *instrs, unsigned int index) +{ + struct hlsl_ir_node *instr; + + LIST_FOR_EACH_ENTRY(instr, instrs, struct hlsl_ir_node, entry) + { + instr->index = index++; + + if (instr->type == HLSL_IR_IF) + { + struct hlsl_ir_if *iff = if_from_node(instr); + index = index_instructions(iff->then_instrs, index); + if (iff->else_instrs) + index = index_instructions(iff->else_instrs, index); + } + else if (instr->type == HLSL_IR_LOOP) + { + index = index_instructions(loop_from_node(instr)->body, index); + loop_from_node(instr)->next_index = index; + } + } + + return index; +} + struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor, const char *entrypoint, char **messages) { + struct hlsl_ir_function_decl *entry_func; struct hlsl_scope *scope, *next_scope; struct hlsl_type *hlsl_type, *next_type; struct hlsl_ir_var *var, *next_var; @@ -2573,12 +2617,6 @@ struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD mino hlsl_parse(); - if (TRACE_ON(hlsl_parser)) - { - TRACE("IR dump.\n"); - wine_rb_for_each_entry(&hlsl_ctx.functions, dump_function, NULL); - } - TRACE("Compilation status = %d\n", hlsl_ctx.status); if (messages) { @@ -2597,6 +2635,24 @@ struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD mino d3dcompiler_free((void *)hlsl_ctx.source_files[i]); d3dcompiler_free(hlsl_ctx.source_files); + if (hlsl_ctx.status == PARSE_ERR) + goto out; + + if (!(entry_func = get_func_entry(entrypoint))) + { + hlsl_message("error: entry point %s is not defined\n", debugstr_a(entrypoint)); + goto out; + } + + index_instructions(entry_func->body, 1); + + if (TRACE_ON(hlsl_parser)) + { + TRACE("IR dump.\n"); + wine_rb_for_each_entry(&hlsl_ctx.functions, dump_function, NULL); + } + +out: TRACE("Freeing functions IR.\n"); wine_rb_destroy(&hlsl_ctx.functions, free_function_rb, NULL); diff --git a/dlls/d3dcompiler_43/utils.c b/dlls/d3dcompiler_43/utils.c index 6e9bb593e0..84323c334f 100644 --- a/dlls/d3dcompiler_43/utils.c +++ b/dlls/d3dcompiler_43/utils.c @@ -2156,7 +2156,7 @@ static void debug_dump_ir_loop(const struct hlsl_ir_loop *loop) static void debug_dump_instr(const struct hlsl_ir_node *instr) { - wine_dbg_printf("%p: ", instr); + wine_dbg_printf("%4u: %p: ", instr->index, instr); switch (instr->type) { case HLSL_IR_EXPR:

1 0

Zebediah Figura : d3dcompiler: Compute liveness ranges for variables.
by Alexandre Julliard April 1, 2020

April 1, 2020

Module: wine Branch: master Commit: 2738e5d2b8ed7d6ec44a88edd1ce76591a4cbac1 URL: https://source.winehq.org/git/wine.git/?a=commit;h=2738e5d2b8ed7d6ec44a88ed… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Sun Mar 29 21:53:17 2020 -0500 d3dcompiler: Compute liveness ranges for variables. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/d3dcompiler_43/d3dcompiler_private.h | 2 +- dlls/d3dcompiler_43/hlsl.y | 90 ++++++++++++++++++++++++++++++- 2 files changed, 90 insertions(+), 2 deletions(-) diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h index 0dee4129f0..e1cdd9a8ba 100644 --- a/dlls/d3dcompiler_43/d3dcompiler_private.h +++ b/dlls/d3dcompiler_43/d3dcompiler_private.h @@ -700,7 +700,7 @@ struct hlsl_ir_var const struct reg_reservation *reg_reservation; struct list scope_entry, param_entry; - struct hlsl_var_allocation *allocation; + unsigned int first_write, last_read; }; struct hlsl_ir_function diff --git a/dlls/d3dcompiler_43/hlsl.y b/dlls/d3dcompiler_43/hlsl.y index a434769462..14f94c04cd 100644 --- a/dlls/d3dcompiler_43/hlsl.y +++ b/dlls/d3dcompiler_43/hlsl.y @@ -21,6 +21,7 @@ %{ #include "wine/debug.h" +#include <limits.h> #include <stdio.h> #include "d3dcompiler_private.h" @@ -2588,6 +2589,90 @@ static unsigned int index_instructions(struct list *instrs, unsigned int index) return index; } +/* Walk the chain of derefs and retrieve the actual variable we care about. */ +static struct hlsl_ir_var *hlsl_var_from_deref(const struct hlsl_deref *deref) +{ + switch (deref->type) + { + case HLSL_IR_DEREF_VAR: + return deref->v.var; + case HLSL_IR_DEREF_ARRAY: + return hlsl_var_from_deref(&deref_from_node(deref->v.array.array)->src); + case HLSL_IR_DEREF_RECORD: + return hlsl_var_from_deref(&deref_from_node(deref->v.record.record)->src); + } + assert(0); + return NULL; +} + +/* Compute the earliest and latest liveness for each variable. In the case that + * a variable is accessed inside of a loop, we promote its liveness to extend + * to at least the range of the entire loop. */ +static void compute_liveness_recurse(struct list *instrs, unsigned int loop_first, unsigned int loop_last) +{ + struct hlsl_ir_node *instr; + struct hlsl_ir_var *var; + + LIST_FOR_EACH_ENTRY(instr, instrs, struct hlsl_ir_node, entry) + { + switch (instr->type) + { + case HLSL_IR_ASSIGNMENT: + { + struct hlsl_ir_assignment *assignment = assignment_from_node(instr); + var = hlsl_var_from_deref(&assignment->lhs); + if (!var->first_write) + var->first_write = loop_first ? min(instr->index, loop_first) : instr->index; + break; + } + case HLSL_IR_DEREF: + { + struct hlsl_ir_deref *deref = deref_from_node(instr); + var = hlsl_var_from_deref(&deref->src); + var->last_read = loop_last ? max(instr->index, loop_last) : instr->index; + break; + } + case HLSL_IR_IF: + { + struct hlsl_ir_if *iff = if_from_node(instr); + compute_liveness_recurse(iff->then_instrs, loop_first, loop_last); + if (iff->else_instrs) + compute_liveness_recurse(iff->else_instrs, loop_first, loop_last); + break; + } + case HLSL_IR_LOOP: + { + struct hlsl_ir_loop *loop = loop_from_node(instr); + compute_liveness_recurse(loop->body, loop_first ? loop_first : instr->index, + loop_last ? loop_last : loop->next_index); + break; + } + default: + break; + } + } +} + +static void compute_liveness(struct hlsl_ir_function_decl *entry_func) +{ + struct hlsl_ir_var *var; + + LIST_FOR_EACH_ENTRY(var, &hlsl_ctx.globals->vars, struct hlsl_ir_var, scope_entry) + { + var->first_write = 1; + } + + LIST_FOR_EACH_ENTRY(var, entry_func->parameters, struct hlsl_ir_var, param_entry) + { + if (var->modifiers & HLSL_STORAGE_IN) + var->first_write = 1; + if (var->modifiers & HLSL_STORAGE_OUT) + var->last_read = UINT_MAX; + } + + compute_liveness_recurse(entry_func->body, 0, 0); +} + struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor, const char *entrypoint, char **messages) { @@ -2644,7 +2729,8 @@ struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD mino goto out; } - index_instructions(entry_func->body, 1); + /* Index 0 means unused; index 1 means function entry, so start at 2. */ + index_instructions(entry_func->body, 2); if (TRACE_ON(hlsl_parser)) { @@ -2652,6 +2738,8 @@ struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD mino wine_rb_for_each_entry(&hlsl_ctx.functions, dump_function, NULL); } + compute_liveness(entry_func); + out: TRACE("Freeing functions IR.\n"); wine_rb_destroy(&hlsl_ctx.functions, free_function_rb, NULL);

1 0