December 2021 - Wine-Devel - list.winehq.org

[PATCH 1/2] ntdll: Set socket IO status before calling server if operation is completed.
by Paul Gofman Dec. 16, 2021

Dec. 16, 2021

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- If the operation is completed before the server call then the completion will be sent during the server call and another thread may receive it before the iosb status is set. It looks like we shouldn't normally have failure status from server once our operation already succeeded. dlls/ntdll/unix/socket.c | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 92374e39db7..6937a84df85 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -679,6 +679,7 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi struct WS_sockaddr *addr, int *addr_len, DWORD *ret_flags, int unix_flags, int force_async ) { struct async_recv_ioctl *async; + BOOL ioresult_set = FALSE; ULONG_PTR information; HANDLE wait_handle; DWORD async_size; @@ -736,8 +737,12 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi } status = try_recv( fd, async, &information ); - - if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW && status != STATUS_DEVICE_NOT_READY) + if (!status) + { + io->Status = 0; + io->Information = information; + ioresult_set = TRUE; + } else if (status != STATUS_BUFFER_OVERFLOW && status != STATUS_DEVICE_NOT_READY) { release_fileio( &async->io ); return status; @@ -755,7 +760,11 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); options = reply->options; - if ((!NT_ERROR(status) || wait_handle) && status != STATUS_PENDING) + + if (ioresult_set && status) + FIXME( "Server status %#x after successful receive.\n", status ); + + if ((!ioresult_set || status) && (!NT_ERROR(status) || wait_handle) && status != STATUS_PENDING) { io->Status = status; io->Information = information; @@ -865,6 +874,7 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi const struct WS_sockaddr *addr, unsigned int addr_len, int unix_flags, int force_async ) { struct async_send_ioctl *async; + BOOL ioresult_set = FALSE; HANDLE wait_handle; DWORD async_size; NTSTATUS status; @@ -905,7 +915,13 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi status = try_send( fd, async ); - if (status != STATUS_SUCCESS && status != STATUS_DEVICE_NOT_READY) + if (!status) + { + io->Status = 0; + io->Information = async->sent_len; + ioresult_set = TRUE; + } + else if (status != STATUS_DEVICE_NOT_READY) { release_fileio( &async->io ); return status; @@ -922,7 +938,11 @@ static NTSTATUS sock_send( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi status = wine_server_call( req ); wait_handle = wine_server_ptr_handle( reply->wait ); options = reply->options; - if ((!NT_ERROR(status) || wait_handle) && status != STATUS_PENDING) + + if (ioresult_set && status) + FIXME( "Server status %#x after successful send.\n", status ); + + if ((!ioresult_set || status) && (!NT_ERROR(status) || wait_handle) && status != STATUS_PENDING) { io->Status = status; io->Information = async->sent_len; -- 2.33.1

2 6

[PATCH] Cc: piotr@codeweavers.com
by Eric Pouech Dec. 16, 2021

Dec. 16, 2021

msvcrt*: fix double-free and memory leak in type_info destructor (spotted by toying with the gcc's static analyzer) Signed-off-by: Eric Pouech <eric.pouech(a)gmail.com> --- dlls/msvcp90/cxx.h | 2 +- dlls/msvcrt/cxx.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/msvcp90/cxx.h b/dlls/msvcp90/cxx.h index 29854d16bab..701ab02fc05 100644 --- a/dlls/msvcp90/cxx.h +++ b/dlls/msvcp90/cxx.h @@ -457,7 +457,7 @@ void * __thiscall type_info_vector_dtor(type_info * _this, unsigned int flags) \ /* we have an array, with the number of elements stored before the first object */ \ INT_PTR i, *ptr = (INT_PTR *)_this - 1; \ \ - for (i = *ptr - 1; i >= 0; i--) free(_this->name); \ + for (i = *ptr - 1; i >= 0; i--) free(_this[i].name); \ free(ptr); \ } \ else \ diff --git a/dlls/msvcrt/cxx.h b/dlls/msvcrt/cxx.h index 1a5442725ef..cacbb1524b6 100644 --- a/dlls/msvcrt/cxx.h +++ b/dlls/msvcrt/cxx.h @@ -291,7 +291,7 @@ void * __thiscall type_info_vector_dtor(type_info * _this, unsigned int flags) \ /* we have an array, with the number of elements stored before the first object */ \ INT_PTR i, *ptr = (INT_PTR *)_this - 1; \ \ - for (i = *ptr - 1; i >= 0; i--) free(_this->name); \ + for (i = *ptr - 1; i >= 0; i--) free(_this[i].name); \ free(ptr); \ } \ else \

2 1

[PATCH 1/2] user32: Call DestroyIcon() to delete icon handles in CopyImage().
by Zebediah Figura Dec. 16, 2021

Dec. 16, 2021

From: John Sullivan <jswinebz(a)kanargh.org.uk> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52207 Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/user32/cursoricon.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/user32/cursoricon.c b/dlls/user32/cursoricon.c index 827db302a30..35f13a1a91b 100644 --- a/dlls/user32/cursoricon.c +++ b/dlls/user32/cursoricon.c @@ -3180,7 +3180,7 @@ HANDLE WINAPI CopyImage( HANDLE hnd, UINT type, INT desiredx, release_icon_frame( icon, frame ); release_user_handle_ptr( icon ); - if (res && (flags & LR_COPYDELETEORG)) DeleteObject( hnd ); + if (res && (flags & LR_COPYDELETEORG)) DestroyIcon( hnd ); return res; } } -- 2.34.1

2 2

[PATCH 0/5] When loading gecko's PDB with WineDbg
by Eric Pouech Dec. 16, 2021

Dec. 16, 2021

Running ieplore with gecko's PDB installed [1] generates hundreds of FIXME:s. This serie fixes a couple of them: - a couple of missing Codeview basic types in dbghelp - enumeration can hold quad dword. Fix in dbghelp includes passing a VARIANT instead of integer for storage (which is already done with a VARIANT) It has been limited so that only msc could emit VT_I8 values (dwarf should also, but it's has to be done after code freeze) Some other fixme:s have just been silenced. They appear here with clang/pdb but have never been seen (to my knowledge) with neither gcc/dwarf nor msvc/pdb. Further investigation is required, but flooding the console with hundres of FIXME is not necessary. [1] https://bugs.winehq.org/show_bug.cgi?id=46028#c13 --- Eric Pouech (5): tools/winedump/msc: use the correct type for reading LF_(U)QUADWORD numeric leaves dbghelp/msc: silence some FIXME:s tools/winedump: support dumping quad word values in enumerations dbghelp: now passing VARIANT as enumerations values from debug-info backends dbghelp/msc: support and create a couple more of basic types dlls/dbghelp/dbghelp_private.h | 2 +- dlls/dbghelp/dwarf.c | 6 +++++- dlls/dbghelp/msc.c | 32 +++++++++++++++++++++++++++----- dlls/dbghelp/stabs.c | 5 ++++- dlls/dbghelp/symbol.c | 2 +- dlls/dbghelp/type.c | 5 ++--- include/wine/mscvpdb.h | 32 ++++++++++++++++++++++++++++++-- tools/winedump/msc.c | 17 +++++++++-------- 8 files changed, 79 insertions(+), 22 deletions(-)

2 6

[PATCH] winebuild: Allow using clang for as command.
by Jacek Caban Dec. 16, 2021

Dec. 16, 2021

Since a9b5bb326a1514e2c4185633ab34b22c9bbc9863, Wine needs get_as_command to work without cc_command available. While as is usually a GCC dependency, Clang toolchains may not contain it. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- I noticed it with Android builds. We could also pass --cc-cmd with makedep, but making winebuild more flexible seems interesting on its own. tools/winebuild/utils.c | 35 ++++++++++++++++++++++++++--------- 1 file changed, 26 insertions(+), 9 deletions(-)

1 0

[PATCH 1/3] inetmib1/tests: Limit the time spent in the loops.
by Bernhard Übelacker Dec. 16, 2021

Dec. 16, 2021

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52224 Signed-off-by: Bernhard Übelacker <bernhardu(a)mailbox.org> --- dlls/inetmib1/tests/main.c | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/dlls/inetmib1/tests/main.c b/dlls/inetmib1/tests/main.c index 32785fcc3fe..a4a1dbe7cdb 100644 --- a/dlls/inetmib1/tests/main.c +++ b/dlls/inetmib1/tests/main.c @@ -95,6 +95,8 @@ static void testQuery(void) UINT mib2UdpTable[] = { 1,3,6,1,2,1,7,5,1,1 }; SnmpVarBind vars[3], vars2[3], vars3[3]; UINT entry; + ULONGLONG start_time; + int timeout_reached; if (!pSnmpExtensionQuery) { @@ -189,6 +191,7 @@ if (0) /* crashes on native */ moreData = TRUE; noChange = FALSE; entry = 0; + start_time = GetTickCount64(); do { SetLastError(0xdeadbeef); error = 0xdeadbeef; @@ -259,7 +262,9 @@ if (0) /* crashes on native */ } else if (noChange) skip("no change in OID, no MIB2 IF table implementation\n"); - } while (moreData && !noChange); + timeout_reached = GetTickCount64() > start_time + 5000; + } while (moreData && !noChange && !timeout_reached); + ok(!timeout_reached, "loop finished not in time.\n"); SnmpUtilVarBindFree(&vars2[0]); SnmpUtilVarBindFree(&vars2[1]); SnmpUtilVarBindFree(&vars2[2]); @@ -296,6 +301,7 @@ if (0) /* crashes on native */ list.len = 1; list.list = vars2; moreData = TRUE; + start_time = GetTickCount64(); do { ret = pSnmpExtensionQuery(SNMP_PDU_GETNEXT, &list, &error, &index); ok(ret, "SnmpExtensionQuery failed: %d, %d\n", error, index); @@ -350,7 +356,9 @@ if (0) /* crashes on native */ } else if (noChange) skip("no change in OID, no MIB2 IP address table implementation\n"); - } while (moreData && !noChange); + timeout_reached = GetTickCount64() > start_time + 5000; + } while (moreData && !noChange && !timeout_reached); + ok(!timeout_reached, "loop finished not in time.\n"); SnmpUtilVarBindFree(&vars2[0]); /* Check the type and OIDs of the IP route table */ @@ -362,6 +370,7 @@ if (0) /* crashes on native */ list.list = vars2; moreData = TRUE; noChange = FALSE; + start_time = GetTickCount64(); do { ret = pSnmpExtensionQuery(SNMP_PDU_GETNEXT, &list, &error, &index); ok(ret, "SnmpExtensionQuery failed: %d, %d\n", error, index); @@ -416,7 +425,9 @@ if (0) /* crashes on native */ } else if (noChange) skip("no change in OID, no MIB2 IP route table implementation\n"); - } while (moreData && !noChange); + timeout_reached = GetTickCount64() > start_time + 5000; + } while (moreData && !noChange && !timeout_reached); + ok(!timeout_reached, "loop finished not in time.\n"); SnmpUtilVarBindFree(&vars2[0]); /* Check the type and OIDs of the UDP table */ @@ -428,6 +439,7 @@ if (0) /* crashes on native */ list.list = vars2; moreData = TRUE; noChange = FALSE; + start_time = GetTickCount64(); do { ret = pSnmpExtensionQuery(SNMP_PDU_GETNEXT, &list, &error, &index); ok(ret, "SnmpExtensionQuery failed: %d, %d\n", error, index); @@ -488,7 +500,9 @@ if (0) /* crashes on native */ } else if (noChange) skip("no change in OID, no MIB2 UDP table implementation\n"); - } while (moreData && !noChange); + timeout_reached = GetTickCount64() > start_time + 5000; + } while (moreData && !noChange && !timeout_reached); + ok(!timeout_reached, "loop finished not in time.\n"); SnmpUtilVarBindFree(&vars2[0]); } -- 2.34.1

2 5

[PATCH] inetmib1: Fix endianess issue with dwLocalAddr and dwLocalPort.
by Bernhard Übelacker Dec. 16, 2021

Dec. 16, 2021

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52224 Signed-off-by: Bernhard Übelacker <bernhardu(a)mailbox.org> --- dlls/inetmib1/main.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/dlls/inetmib1/main.c b/dlls/inetmib1/main.c index 6345573350e..c484e5390c4 100644 --- a/dlls/inetmib1/main.c +++ b/dlls/inetmib1/main.c @@ -27,6 +27,7 @@ #include "winbase.h" #include "snmp.h" #include "iphlpapi.h" +#include "winternl.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(inetmib1); @@ -1217,7 +1218,7 @@ static void oidToUdpRow(AsnObjectIdentifier *oid, void *dst) assert(oid && oid->idLength >= 5); row->dwLocalAddr = oidToIpAddr(oid); - row->dwLocalPort = oid->ids[4]; + row->dwLocalPort = RtlUshortByteSwap(oid->ids[4]); } static int __cdecl compareUdpRow(const void *a, const void *b) @@ -1225,9 +1226,9 @@ static int __cdecl compareUdpRow(const void *a, const void *b) const MIB_UDPROW *key = a, *value = b; int ret; - ret = key->dwLocalAddr - value->dwLocalAddr; + ret = RtlUlongByteSwap(key->dwLocalAddr) - RtlUlongByteSwap(value->dwLocalAddr); if (ret == 0) - ret = key->dwLocalPort - value->dwLocalPort; + ret = RtlUshortByteSwap(key->dwLocalPort) - RtlUshortByteSwap(value->dwLocalPort); return ret; } @@ -1269,8 +1270,10 @@ static BOOL mib2UdpEntryQuery(BYTE bPduType, SnmpVarBind *pVarBind, udpTable->table[tableIndex - 1].dwLocalAddr); if (ret) { + UINT id; oid.idLength = 1; - oid.ids = &udpTable->table[tableIndex - 1].dwLocalPort; + id = RtlUshortByteSwap(udpTable->table[tableIndex - 1].dwLocalPort); + oid.ids = &id; ret = SnmpUtilOidAppend(&pVarBind->name, &oid); } } -- 2.34.1

1 0

[PATCH vkd3d] vkd3d-shader: Remove duplicate initialization.
by Andrey Gusev Dec. 16, 2021

Dec. 16, 2021

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- libs/vkd3d-shader/d3dbc.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 267f960..c551875 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -878,8 +878,6 @@ static enum vkd3d_result shader_sm1_init(struct vkd3d_shader_sm1_parser *sm1, uint16_t shader_type; size_t token_count; - code = compile_info->source.code; - code_size = compile_info->source.size; token_count = code_size / sizeof(*sm1->start); if (token_count < 2) -- 2.33.1

2 1

[PATCH vkd3d 01/17] vkd3d-shader/hlsl: Introduce a copy propagation pass.
by Matteo Bruni Dec. 16, 2021

Dec. 16, 2021

From: Giovanni Mascellani <gmascellani(a)codeweavers.com> Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- changelog: Did a bunch of changes, mostly stylistic. I dropped the existing sign-offs here and in some of the following patches since I changed enough of the code that I wouldn't feel those would still be valid. Sorry it took me a while to review and fix up these patches and come up with a hopefully consistent patch series. I don't expect the whole series to go in in one go but I wanted to "show" the end result to possibly unblock anyone that wants to start preparing more patches on top (but I'd refrain from sending until this series is resolved one way or another :)). This series should supersede or otherwise render invalid all the other pending vkd3d-shader/hlsl patches. libs/vkd3d-shader/hlsl.c | 20 ++- libs/vkd3d-shader/hlsl.h | 1 + libs/vkd3d-shader/hlsl_codegen.c | 217 ++++++++++++++++++++++++++++++- 3 files changed, 232 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 9824c56d..8895f5bc 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1097,6 +1097,19 @@ const char *debug_hlsl_writemask(unsigned int writemask) return vkd3d_dbg_sprintf(".%s", string); } +const char *debug_hlsl_swizzle(unsigned int swizzle, unsigned int size) +{ + static const char components[] = {'x', 'y', 'z', 'w'}; + char string[5]; + unsigned int i; + + assert(size <= ARRAY_SIZE(components)); + for (i = 0; i < size; ++i) + string[i] = components[(swizzle >> i * 2) & 3]; + string[size] = 0; + return vkd3d_dbg_sprintf(".%s", string); +} + static void dump_ir_constant(struct vkd3d_string_buffer *buffer, const struct hlsl_ir_constant *constant) { struct hlsl_type *type = constant->node.data_type; @@ -1278,18 +1291,15 @@ static void dump_ir_swizzle(struct vkd3d_string_buffer *buffer, const struct hls unsigned int i; dump_src(buffer, &swizzle->val); - vkd3d_string_buffer_printf(buffer, "."); if (swizzle->val.node->data_type->dimy > 1) { + vkd3d_string_buffer_printf(buffer, "."); for (i = 0; i < swizzle->node.data_type->dimx; ++i) vkd3d_string_buffer_printf(buffer, "_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf); } else { - static const char c[] = {'x', 'y', 'z', 'w'}; - - for (i = 0; i < swizzle->node.data_type->dimx; ++i) - vkd3d_string_buffer_printf(buffer, "%c", c[(swizzle->swizzle >> i * 2) & 0x3]); + vkd3d_string_buffer_printf(buffer, "%s", debug_hlsl_swizzle(swizzle->swizzle, swizzle->node.data_type->dimx)); } } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index e7bdb45e..eb11b4ab 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -667,6 +667,7 @@ static inline struct hlsl_type *hlsl_get_numeric_type(const struct hlsl_ctx *ctx const char *debug_hlsl_expr_op(enum hlsl_ir_expr_op op); const char *debug_hlsl_type(struct hlsl_ctx *ctx, const struct hlsl_type *type); const char *debug_hlsl_writemask(unsigned int writemask); +const char *debug_hlsl_swizzle(unsigned int swizzle, unsigned int count); struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const struct hlsl_type *type); struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct hlsl_ctx *ctx, unsigned int modifiers); diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 8b0eb9b3..d3957f89 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -237,6 +237,216 @@ static void replace_node(struct hlsl_ir_node *old, struct hlsl_ir_node *new) hlsl_free_instr(old); } +struct copy_propagation_value +{ + struct hlsl_ir_node *node; + unsigned int component; +}; + +struct copy_propagation_var_def +{ + struct rb_entry entry; + struct hlsl_ir_var *var; + struct copy_propagation_value values[]; +}; + +struct copy_propagation_state +{ + struct rb_tree var_defs; +}; + +static int copy_propagation_var_def_compare(const void *key, const struct rb_entry *entry) +{ + struct copy_propagation_var_def *var_def = RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + uintptr_t key_int = (uintptr_t)key, entry_int = (uintptr_t)var_def->var; + + return (key_int > entry_int) - (key_int < entry_int); +} + +static void copy_propagation_var_def_destroy(struct rb_entry *entry, void *context) +{ + struct copy_propagation_var_def *var_def = RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + + vkd3d_free(var_def); +} + +static struct copy_propagation_var_def *copy_propagation_get_var_def(struct copy_propagation_state *state, + struct hlsl_ir_var *var) +{ + struct rb_entry *entry = rb_get(&state->var_defs, var); + + if (entry) + return RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + else + return NULL; +} + +static struct copy_propagation_var_def *copy_propagation_create_var_def(struct hlsl_ctx *ctx, + struct copy_propagation_state *state, struct hlsl_ir_var *var) +{ + struct rb_entry *entry = rb_get(&state->var_defs, var); + struct copy_propagation_var_def *var_def; + int res; + + if (entry) + return RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + + if (!(var_def = hlsl_alloc(ctx, offsetof(struct copy_propagation_var_def, values[var->data_type->reg_size])))) + return NULL; + + var_def->var = var; + + res = rb_put(&state->var_defs, var, &var_def->entry); + assert(!res); + + return var_def; +} + +static void copy_propagation_invalidate_whole_variable(struct copy_propagation_var_def *var_def) +{ + TRACE("Invalidate variable %s.\n", var_def->var->name); + memset(var_def->values, 0, sizeof(*var_def->values) * var_def->var->data_type->reg_size); +} + +static void copy_propagation_set_value(struct copy_propagation_var_def *var_def, unsigned int offset, + unsigned char writemask, struct hlsl_ir_node *node) +{ + unsigned int i, j = 0; + + for (i = 0; i < 4; ++i) + { + if (writemask & (1u << i)) + { + TRACE("Variable %s[%u] is written by instruction %p%s.\n", + var_def->var->name, offset + i, node, debug_hlsl_writemask(1u << i)); + var_def->values[offset + i].node = node; + var_def->values[offset + i].component = j++; + } + } +} + +static struct hlsl_ir_node *copy_propagation_compute_replacement(struct copy_propagation_var_def *var_def, + unsigned int offset, unsigned int count, unsigned int *swizzle) +{ + struct hlsl_ir_node *node = NULL; + unsigned int i; + + assert(offset + count <= var_def->var->data_type->reg_size); + + *swizzle = 0; + + for (i = 0; i < count; ++i) + { + if (!node) + node = var_def->values[offset + i].node; + else if (node != var_def->values[offset + i].node) + return NULL; + *swizzle |= var_def->values[offset + i].component << i * 2; + } + + return node; +} + +static bool copy_propagation_analyze_load(struct hlsl_ctx *ctx, struct hlsl_ir_load *load, + struct copy_propagation_state *state) +{ + struct hlsl_ir_node *node = &load->node, *new_node; + struct copy_propagation_var_def *var_def; + struct hlsl_type *type = node->data_type; + struct hlsl_ir_swizzle *swizzle_node; + struct hlsl_deref *src = &load->src; + struct hlsl_ir_var *var = src->var; + unsigned int offset, swizzle; + + if (type->type != HLSL_CLASS_SCALAR && type->type != HLSL_CLASS_VECTOR) + return false; + + if (!hlsl_offset_from_deref(src, &offset)) + return false; + + if (!(var_def = copy_propagation_get_var_def(state, var))) + return false; + + if (!(new_node = copy_propagation_compute_replacement(var_def, offset, type->dimx, &swizzle))) + { + TRACE("No single source for propagating load from %s[%u-%u].\n", var->name, offset, offset + type->dimx); + return false; + } + + TRACE("Load from %s[%u-%u] propagated as instruction %p%s.\n", + var->name, offset, offset + type->dimx, new_node, debug_hlsl_swizzle(swizzle, 4)); + if (!(swizzle_node = hlsl_new_swizzle(ctx, swizzle, type->dimx, new_node, &node->loc))) + return false; + list_add_before(&node->entry, &swizzle_node->node.entry); + replace_node(node, &swizzle_node->node); + return true; +} + +static void copy_propagation_record_store(struct hlsl_ctx *ctx, struct hlsl_ir_store *store, + struct copy_propagation_state *state) +{ + struct copy_propagation_var_def *var_def; + struct hlsl_deref *lhs = &store->lhs; + struct hlsl_ir_var *var = lhs->var; + unsigned int offset; + + if (!(var_def = copy_propagation_create_var_def(ctx, state, var))) + return; + + if (hlsl_offset_from_deref(lhs, &offset)) + copy_propagation_set_value(var_def, offset, store->writemask, store->rhs.node); + else + copy_propagation_invalidate_whole_variable(var_def); +} + +static bool copy_propagation_transform_block(struct hlsl_ctx *ctx, struct hlsl_block *block, + struct copy_propagation_state *state) +{ + struct hlsl_ir_node *instr, *next; + bool progress = false; + + LIST_FOR_EACH_ENTRY_SAFE(instr, next, &block->instrs, struct hlsl_ir_node, entry) + { + switch (instr->type) + { + case HLSL_IR_LOAD: + progress |= copy_propagation_analyze_load(ctx, hlsl_ir_load(instr), state); + break; + + case HLSL_IR_STORE: + copy_propagation_record_store(ctx, hlsl_ir_store(instr), state); + break; + + case HLSL_IR_IF: + FIXME("Copy propagation doesn't support conditionals yet, leaving.\n"); + return progress; + + case HLSL_IR_LOOP: + FIXME("Copy propagation doesn't support loops yet, leaving.\n"); + return progress; + + default: + break; + } + } + + return progress; +} + +static bool copy_propagation_execute(struct hlsl_ctx *ctx, struct hlsl_block *block) +{ + struct copy_propagation_state state; + bool progress; + + rb_init(&state.var_defs, copy_propagation_var_def_compare); + + progress = copy_propagation_transform_block(ctx, block, &state); + + rb_destroy(&state.var_defs, copy_propagation_var_def_destroy, NULL); + + return progress; +} + static bool is_vec1(const struct hlsl_type *type) { return (type->type == HLSL_CLASS_SCALAR) || (type->type == HLSL_CLASS_VECTOR && type->dimx == 1); @@ -1421,7 +1631,12 @@ int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun progress |= transform_ir(ctx, split_struct_copies, body, NULL); } while (progress); - while (transform_ir(ctx, fold_constants, body, NULL)); + do + { + progress = transform_ir(ctx, fold_constants, body, NULL); + progress |= copy_propagation_execute(ctx, body); + } + while (progress); transform_ir(ctx, remove_trivial_swizzles, body, NULL); if (ctx->profile->major_version < 4) -- 2.26.3

7 53

[PATCH v4 1/3] ntdll: sock_recv keeps message ordered
by Dongwan Kim Dec. 16, 2021

Dec. 16, 2021

Calling try_recv could make messages misordered. Suppose that a server program calls a overlapped WSARecv and its operation is pending. Another program sends a message and wineserver is busy. The server program calls another overlapped WSARecv and it intercepts the message for the pending WSARecv. The problem already had been discussed here https://www.winehq.org/pipermail/wine-devel/2021-May/186612.html To avoid this situation, this kind of approach can be applied. The server program needs to know if there are pending asyncs before calling try_recv. Wineserver notifies it whenever invoking APC_ASYNC_IO. Then, the server program updates it and check it before calling try_recv. Signed-off-by: Dongwan Kim <kdw6485(a)gmail.com> --- dlls/ntdll/unix/server.c | 8 +++---- dlls/ntdll/unix/socket.c | 42 +++++++++++++++++++++++++++++++++- include/wine/server_protocol.h | 1 + server/async.c | 8 +++++++ 4 files changed, 54 insertions(+), 5 deletions(-) diff --git a/dlls/ntdll/unix/server.c b/dlls/ntdll/unix/server.c index a388247beb2..047da6e0974 100644 --- a/dlls/ntdll/unix/server.c +++ b/dlls/ntdll/unix/server.c @@ -368,17 +368,17 @@ static void invoke_system_apc( const apc_call_t *call, apc_result_t *result, BOO case APC_ASYNC_IO: { struct async_fileio *user = wine_server_get_ptr( call->async_io.user ); - ULONG_PTR info = call->async_io.result; + ULONG_PTR info[2] = { call->async_io.result, call->async_io.async_wait }; NTSTATUS status; result->type = call->type; status = call->async_io.status; - if (user->callback( user, &info, &status )) + if (user->callback( user, info, &status )) { result->async_io.status = status; - result->async_io.total = info; + result->async_io.total = *info; /* the server will pass us NULL if a call failed synchronously */ - set_async_iosb( call->async_io.sb, result->async_io.status, info ); + set_async_iosb( call->async_io.sb, result->async_io.status, *info ); } else result->async_io.status = STATUS_PENDING; /* restart it */ break; diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 92374e39db7..73c92d26b5f 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -651,13 +651,45 @@ static NTSTATUS try_recv( int fd, struct async_recv_ioctl *async, ULONG_PTR *siz return status; } +struct async_queue{ + struct list entry; + HANDLE sock; + char read_q; + char write_q; +}; +static struct list async_queue_list = LIST_INIT(async_queue_list); + + +static struct async_queue* alloc_async_queue(HANDLE handle){ + struct async_queue *queue = + (struct async_queue*)malloc(sizeof(struct async_queue)); + memset(queue, 0, sizeof(struct async_queue)); + + queue->sock = handle; + list_add_head(&async_queue_list, &queue->entry); + return queue; +} + +static struct async_queue* find_async_queue(HANDLE handle){ + struct async_queue *queue; + + LIST_FOR_EACH_ENTRY(queue, &async_queue_list, struct async_queue, entry){ + if(queue->sock == handle) + return queue; + } + return NULL; +} static BOOL async_recv_proc( void *user, ULONG_PTR *info, NTSTATUS *status ) { struct async_recv_ioctl *async = user; + struct async_queue *queue; int fd, needs_close; TRACE( "%#x\n", *status ); + queue = find_async_queue(async->io.handle); + if(queue) + queue->read_q = info[1]; //store if waiting asyncs exist if (*status == STATUS_ALERTED) { if ((*status = server_get_unix_fd( async->io.handle, 0, &fd, &needs_close, NULL, NULL ))) @@ -679,6 +711,7 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi struct WS_sockaddr *addr, int *addr_len, DWORD *ret_flags, int unix_flags, int force_async ) { struct async_recv_ioctl *async; + struct async_queue *queue; ULONG_PTR information; HANDLE wait_handle; DWORD async_size; @@ -735,7 +768,13 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi } } - status = try_recv( fd, async, &information ); + queue = find_async_queue(handle); + if(!queue) + queue = alloc_async_queue(handle); + if(queue->read_q ) // if there are waiting asyncs, avoid cutting in line. + status = STATUS_DEVICE_NOT_READY; + else + status = try_recv( fd, async, &information ); if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW && status != STATUS_DEVICE_NOT_READY) { @@ -764,6 +803,7 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi SERVER_END_REQ; if (status != STATUS_PENDING) release_fileio( &async->io ); + else queue->read_q = 1; if (wait_handle) status = wait_async( wait_handle, options & FILE_SYNCHRONOUS_IO_ALERT ); return status; diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index 1d17a40530f..ce26240bc9a 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -492,6 +492,7 @@ typedef union client_ptr_t user; client_ptr_t sb; data_size_t result; + unsigned int async_wait; } async_io; struct { diff --git a/server/async.c b/server/async.c index 1a564ff1a69..5d6cc9770c3 100644 --- a/server/async.c +++ b/server/async.c @@ -164,6 +164,7 @@ static void async_destroy( struct object *obj ) void async_terminate( struct async *async, unsigned int status ) { struct iosb *iosb = async->iosb; + struct async* async_waiting; if (async->terminated) return; @@ -202,6 +203,13 @@ void async_terminate( struct async *async, unsigned int status ) else data.async_io.status = status; + async_waiting = find_pending_async(async->queue); + if(async_waiting) + { + data.async_io.async_wait = 1; + release_object(async_waiting); + } + thread_queue_apc( async->thread->process, async->thread, &async->obj, &data ); } -- 2.30.2

2 3