wine-devel January 2022

wine-devel@winehq.org

86 participants
717 discussions

[PATCH] programs/cmd/test: don't output more data than available
by Eric Pouech 07 Jan '22

07 Jan '22

Signed-off-by: Eric Pouech <eric.pouech(a)gmail.com> --- programs/cmd/tests/batch.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/programs/cmd/tests/batch.c b/programs/cmd/tests/batch.c index 162e9cfa151..0b48d7fa039 100644 --- a/programs/cmd/tests/batch.c +++ b/programs/cmd/tests/batch.c @@ -344,8 +344,8 @@ static void test_output(const char *out_data, DWORD out_size, const char *exp_da } } - ok(exp_ptr >= exp_data+exp_size, "unexpected end of output in line %d, missing %s\n", line, exp_ptr); - ok(out_ptr >= out_data+out_size, "too long output, got additional %s\n", out_ptr); + ok(exp_ptr >= exp_data+exp_size, "unexpected end of output in line %d, missing %.*s\n", line, exp_data + exp_size - exp_ptr, exp_ptr); + ok(out_ptr >= out_data+out_size, "too long output, got additional %.*s\n", out_data + out_size - out_ptr, out_ptr); } static void run_test(const char *cmd_data, DWORD cmd_size, const char *exp_data, DWORD exp_size)

1 0

[PATCH 1/2] d2d1: Silence SetSegmentFlags FIXME when setting default value
by Stefan Brüns 07 Jan '22

07 Jan '22

Some software (Buhl Tax and variants) repeatedly calls SetSegmentFlags with D2D1_PATH_SEGMENT_NONE, which is just the default value and has no effect (unless the flags where already changed for the current segment, which still reports a FIXME). Signed-off-by: Stefan Brüns <stefan.bruens(a)rwth-aachen.de> --- dlls/d2d1/geometry.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c index a7074899fda..ac5f1019f3f 100644 --- a/dlls/d2d1/geometry.c +++ b/dlls/d2d1/geometry.c @@ -2773,6 +2773,8 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_SetFillMode(ID2D1GeometrySink *i static void STDMETHODCALLTYPE d2d_geometry_sink_SetSegmentFlags(ID2D1GeometrySink *iface, D2D1_PATH_SEGMENT flags) { + if (flags == D2D1_PATH_SEGMENT_NONE) + return; FIXME("iface %p, flags %#x stub!\n", iface, flags); } -- 2.34.1

3 5

[PATCH] Fix the widl extension that tries dllname.tlb if dllname.dll cannot be found
by Tom Ritter 07 Jan '22

07 Jan '22

1 0

[PATCH 1/2] ws2_32/tests: Test whether WSAEventSelect() modifies the event state.
by Zebediah Figura 07 Jan '22

07 Jan '22

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/ws2_32/tests/sock.c | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index 50f79e6adb8..db6819e77cf 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -5186,6 +5186,42 @@ static void test_accept_events(struct event_test_ctx *ctx) closesocket(server); closesocket(client); + /* As above, but select on a subset containing FD_ACCEPT first. */ + + if (!ctx->is_message) + { + select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT); + + client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError()); + ret = connect(client, (struct sockaddr *)&destaddr, sizeof(destaddr)); + ok(!ret, "failed to connect, error %u\n", WSAGetLastError()); + + ret = WaitForSingleObject(ctx->event, 200); + ok(!ret, "wait timed out\n"); + + select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB); + ret = WaitForSingleObject(ctx->event, 0); + ok(!ret, "wait timed out\n"); + + ResetEvent(ctx->event); + + select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB); + ret = WaitForSingleObject(ctx->event, 0); + ok(ret == WAIT_TIMEOUT, "expected timeout\n"); + + select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB | FD_ACCEPT); + ret = WaitForSingleObject(ctx->event, 0); + todo_wine ok(!ret, "wait timed out\n"); + if (!ret) + check_events(ctx, FD_ACCEPT, 0, 0); + + server = accept(listener, NULL, NULL); + ok(server != -1, "failed to accept, error %u\n", WSAGetLastError()); + closesocket(server); + closesocket(client); + } + /* As above, but select on a subset not containing FD_ACCEPT first. */ select_events(ctx, listener, FD_CONNECT | FD_READ | FD_OOB); -- 2.34.1

3 4

[PATCH vkd3d] vkd3d-compiler: Properly forward argument validation failures.
by Giovanni Mascellani 07 Jan '22

07 Jan '22

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- programs/vkd3d-compiler/main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/programs/vkd3d-compiler/main.c b/programs/vkd3d-compiler/main.c index 8ea3c132..c974c9a8 100644 --- a/programs/vkd3d-compiler/main.c +++ b/programs/vkd3d-compiler/main.c @@ -686,13 +686,13 @@ int main(int argc, char **argv) fprintf(stderr, "Target type '%s' is invalid for source type '%s'.\n", get_target_type_info(options.target_type)->name, get_source_type_info(options.source_type)->name); - return 0; + return 1; } if (!options.preprocess_only && options.source_type == VKD3D_SHADER_SOURCE_HLSL && !options.profile) { fprintf(stderr, "You need to specify a profile when compiling from HLSL source.\n"); - return 0; + return 1; } if (!options.filename && get_source_type_info(options.source_type)->is_binary && isatty(fileno(input))) -- 2.34.1

3 2

[PATCH vkd3d v2 1/4] vkd3d: Use a binary search for matching a descriptor to an allocation.
by Conor McCarthy 07 Jan '22

07 Jan '22

The performance improvement will be useful for Vulkan-backed heaps, where descriptor heaps must be found more often. Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- v2: Style changes, and vkd3d_gpu_descriptor_allocator_allocation_from_descriptor() is now an inline function which is not thread safe. Allocation objects should not be accessed while the allocator is unlocked, so locking occurs outside this function. --- libs/vkd3d/device.c | 70 +++++++++++++++++++++++++++++++++------------ 1 file changed, 52 insertions(+), 18 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 96ff7ae7..ec2eb73b 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2179,6 +2179,33 @@ static void vkd3d_gpu_va_allocator_cleanup(struct vkd3d_gpu_va_allocator *alloca pthread_mutex_destroy(&allocator->mutex); } +/* We could use bsearch() or recursion here, but it probably helps to omit + * all the extra function calls. */ +static struct vkd3d_gpu_descriptor_allocation *vkd3d_gpu_descriptor_allocator_binary_search( + const struct vkd3d_gpu_descriptor_allocator *allocator, const struct d3d12_desc *desc) +{ + struct vkd3d_gpu_descriptor_allocation *allocations = allocator->allocations; + const struct d3d12_desc *base; + size_t centre, count; + + for (count = allocator->allocation_count; count > 1; ) + { + centre = count >> 1; + base = allocations[centre].base; + if (base <= desc) + { + allocations += centre; + count -= centre; + } + else + { + count = centre; + } + } + + return allocations; +} + bool vkd3d_gpu_descriptor_allocator_register_range(struct vkd3d_gpu_descriptor_allocator *allocator, const struct d3d12_desc *base, size_t count) { @@ -2198,7 +2225,14 @@ bool vkd3d_gpu_descriptor_allocator_register_range(struct vkd3d_gpu_descriptor_a return false; } - allocation = &allocator->allocations[allocator->allocation_count++]; + if (allocator->allocation_count > 1) + allocation = vkd3d_gpu_descriptor_allocator_binary_search(allocator, base); + else + allocation = allocator->allocations; + allocation += allocator->allocation_count && base > allocation->base; + memmove(&allocation[1], allocation, (allocator->allocation_count++ - (allocation - allocator->allocations)) + * sizeof(*allocation)); + allocation->base = base; allocation->count = count; @@ -2225,8 +2259,8 @@ bool vkd3d_gpu_descriptor_allocator_unregister_range( if (allocator->allocations[i].base != base) continue; - if (i != --allocator->allocation_count) - allocator->allocations[i] = allocator->allocations[allocator->allocation_count]; + memmove(&allocator->allocations[i], &allocator->allocations[i + 1], + (--allocator->allocation_count - i) * sizeof(allocator->allocations[0])); found = true; break; @@ -2237,34 +2271,34 @@ bool vkd3d_gpu_descriptor_allocator_unregister_range( return found; } +static inline const struct vkd3d_gpu_descriptor_allocation *vkd3d_gpu_descriptor_allocator_allocation_from_descriptor( + const struct vkd3d_gpu_descriptor_allocator *allocator, const struct d3d12_desc *desc) +{ + const struct vkd3d_gpu_descriptor_allocation *allocation; + + allocation = vkd3d_gpu_descriptor_allocator_binary_search(allocator, desc); + return (desc >= allocation->base && desc - allocation->base < allocation->count) ? allocation : NULL; +} + /* Return the available size from the specified descriptor to the heap end. */ size_t vkd3d_gpu_descriptor_allocator_range_size_from_descriptor( struct vkd3d_gpu_descriptor_allocator *allocator, const struct d3d12_desc *desc) { - struct vkd3d_gpu_descriptor_allocation *allocation; - size_t remaining, offset, i; + const struct vkd3d_gpu_descriptor_allocation *allocation; + size_t remaining; int rc; + assert(allocator->allocation_count); + if ((rc = pthread_mutex_lock(&allocator->mutex))) { ERR("Failed to lock mutex, error %d.\n", rc); return 0; } - for (i = 0, remaining = 0; i < allocator->allocation_count; ++i) - { - allocation = &allocator->allocations[i]; - - if (desc < allocation->base) - continue; - - offset = desc - allocation->base; - if (offset >= allocation->count) - continue; - - remaining = allocation->count - offset; - break; - } + remaining = 0; + if ((allocation = vkd3d_gpu_descriptor_allocator_allocation_from_descriptor(allocator, desc))) + remaining = allocation->count - (desc - allocation->base); pthread_mutex_unlock(&allocator->mutex); -- 2.33.0

2 6

[PATCH vkd3d v5] vkd3d-shader/spirv: Support UAV counter descriptor arrays.
by Conor McCarthy 07 Jan '22

07 Jan '22

Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- v5: Also handle arrays in the SSBO UAV path. --- include/vkd3d_shader.h | 4 +- libs/vkd3d-shader/spirv.c | 90 +++++++++++++++++++-------------------- 2 files changed, 45 insertions(+), 49 deletions(-) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 791ac037..1eae0bbe 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -537,9 +537,7 @@ struct vkd3d_shader_descriptor_offset_info /** * Pointer to an array of offsets into the descriptor arrays referenced by * the 'uav_counters' array in struct vkd3d_shader_interface_info. This - * works the same way as \ref binding_offsets above. UAV counter arrays are - * not supported in this version of vkd3d-shader, and therefore this field - * must either be NULL or specify 0 offsets. + * works the same way as \ref binding_offsets above. */ const struct vkd3d_shader_descriptor_offset *uav_counter_offsets; }; diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index ab171b73..fa3ca67e 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1984,6 +1984,8 @@ struct vkd3d_symbol_resource_data bool raw; unsigned int binding_base_idx; uint32_t uav_counter_id; + const struct vkd3d_symbol *uav_counter_array; + unsigned int uav_counter_base_idx; }; struct vkd3d_symbol_sampler_data @@ -2405,8 +2407,6 @@ struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader if ((offset_info = vkd3d_find_struct(shader_interface->next, DESCRIPTOR_OFFSET_INFO))) { compiler->offset_info = *offset_info; - if (offset_info->uav_counter_offsets) - WARN("Ignoring UAV counter offsets %p.\n", offset_info->uav_counter_offsets); if (compiler->offset_info.descriptor_table_count && !(compiler->descriptor_offset_ids = vkd3d_calloc( compiler->offset_info.descriptor_table_count, sizeof(*compiler->descriptor_offset_ids)))) { @@ -2575,7 +2575,7 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor { const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface; unsigned int register_last = (range->last == ~0u) ? range->first : range->last; - const struct vkd3d_shader_descriptor_offset *binding_offsets = compiler->offset_info.binding_offsets; + const struct vkd3d_shader_descriptor_offset *binding_offsets; enum vkd3d_shader_descriptor_type descriptor_type; enum vkd3d_shader_binding_flag resource_type_flag; struct vkd3d_shader_descriptor_binding binding; @@ -2603,6 +2603,7 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor if (is_uav_counter) { assert(descriptor_type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV); + binding_offsets = compiler->offset_info.uav_counter_offsets; for (i = 0; i < shader_interface->uav_counter_count; ++i) { const struct vkd3d_shader_uav_counter_binding *current = &shader_interface->uav_counters[i]; @@ -2610,7 +2611,8 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor if (!vkd3d_dxbc_compiler_check_shader_visibility(compiler, current->shader_visibility)) continue; - if (current->register_space != range->space || current->register_index != range->first) + if (current->register_space != range->space || current->register_index > range->first + || current->binding.count <= register_last - current->register_index) continue; if (current->offset) @@ -2621,16 +2623,9 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor range->first, range->space, current->offset); } - if (current->binding.count != 1) - { - FIXME("Descriptor arrays are not supported.\n"); - vkd3d_dxbc_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING, - "Descriptor binding for UAV counter %u, space %u has unsupported ‘count’ %u.", - range->first, range->space, current->binding.count); - } - - binding_address->binding_base_idx = current->register_index; - binding_address->push_constant_index = ~0u; + binding_address->binding_base_idx = current->register_index + - (binding_offsets ? binding_offsets[i].static_offset : 0); + binding_address->push_constant_index = binding_offsets ? binding_offsets[i].dynamic_offset_index : ~0u; return current->binding; } if (shader_interface->uav_counter_count) @@ -2642,6 +2637,7 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor } else { + binding_offsets = compiler->offset_info.binding_offsets; for (i = 0; i < shader_interface->binding_count; ++i) { const struct vkd3d_shader_resource_binding *current = &shader_interface->bindings[i]; @@ -2693,18 +2689,6 @@ static void vkd3d_dxbc_compiler_emit_descriptor_binding(struct vkd3d_dxbc_compil vkd3d_spirv_build_op_decorate1(builder, variable_id, SpvDecorationBinding, binding->binding); } -static void vkd3d_dxbc_compiler_emit_descriptor_binding_for_reg(struct vkd3d_dxbc_compiler *compiler, - uint32_t variable_id, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, - enum vkd3d_shader_resource_type resource_type, bool is_uav_counter) -{ - struct vkd3d_shader_descriptor_binding binding; - struct vkd3d_descriptor_binding_address binding_address; /* Values not used. */ - - binding = vkd3d_dxbc_compiler_get_descriptor_binding(compiler, reg, range, resource_type, is_uav_counter, - &binding_address); - vkd3d_dxbc_compiler_emit_descriptor_binding(compiler, variable_id, &binding); -} - static void vkd3d_dxbc_compiler_decorate_nonuniform(struct vkd3d_dxbc_compiler *compiler, uint32_t expression_id) { @@ -2939,6 +2923,7 @@ static bool vkd3d_dxbc_compiler_get_register_name(char *buffer, unsigned int buf return true; } +/* TODO: UAV counters: vkd3d_spirv_build_op_name(builder, counter_var_id, "u%u_counter", reg->idx[0].offset); */ static void vkd3d_dxbc_compiler_emit_register_debug_name(struct vkd3d_spirv_builder *builder, uint32_t id, const struct vkd3d_shader_register *reg) { @@ -5629,7 +5614,7 @@ struct vkd3d_descriptor_variable_info static uint32_t vkd3d_dxbc_compiler_build_descriptor_variable(struct vkd3d_dxbc_compiler *compiler, SpvStorageClass storage_class, uint32_t type_id, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type, - struct vkd3d_descriptor_variable_info *var_info) + bool is_uav_counter, struct vkd3d_descriptor_variable_info *var_info) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; struct vkd3d_descriptor_binding_address binding_address; @@ -5639,7 +5624,7 @@ static uint32_t vkd3d_dxbc_compiler_build_descriptor_variable(struct vkd3d_dxbc_ struct rb_entry *entry; binding = vkd3d_dxbc_compiler_get_descriptor_binding(compiler, reg, range, - resource_type, false, &binding_address); + resource_type, is_uav_counter, &binding_address); var_info->binding_base_idx = binding_address.binding_base_idx; if (binding.count == 1 && range->first == binding_address.binding_base_idx && range->last != ~0u @@ -5729,7 +5714,7 @@ static void vkd3d_dxbc_compiler_emit_dcl_constant_buffer(struct vkd3d_dxbc_compi vkd3d_spirv_build_op_name(builder, struct_id, "cb%u_struct", cb->size); var_id = vkd3d_dxbc_compiler_build_descriptor_variable(compiler, storage_class, struct_id, - reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, &var_info); + reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, false, &var_info); vkd3d_symbol_make_register(&reg_symbol, reg); vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, @@ -5792,7 +5777,7 @@ static void vkd3d_dxbc_compiler_emit_dcl_sampler(struct vkd3d_dxbc_compiler *com type_id = vkd3d_spirv_get_op_type_sampler(builder); var_id = vkd3d_dxbc_compiler_build_descriptor_variable(compiler, storage_class, type_id, reg, - &sampler->range, VKD3D_SHADER_RESOURCE_NONE, &var_info); + &sampler->range, VKD3D_SHADER_RESOURCE_NONE, false, &var_info); vkd3d_symbol_make_register(&reg_symbol, reg); vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, @@ -5964,6 +5949,8 @@ static void vkd3d_dxbc_compiler_emit_combined_sampler_declarations(struct vkd3d_ symbol.info.resource.structure_stride = structure_stride; symbol.info.resource.raw = raw; symbol.info.resource.uav_counter_id = 0; + symbol.info.resource.uav_counter_array = NULL; + symbol.info.resource.uav_counter_base_idx = 0; vkd3d_dxbc_compiler_put_symbol(compiler, &symbol); } } @@ -5972,12 +5959,12 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type, enum vkd3d_data_type resource_data_type, unsigned int structure_stride, bool raw) { - uint32_t counter_type_id, type_id, ptr_type_id, var_id, counter_var_id = 0; + struct vkd3d_descriptor_variable_info var_info, counter_var_info; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; SpvStorageClass storage_class = SpvStorageClassUniformConstant; + uint32_t counter_type_id, type_id, var_id, counter_var_id = 0; const struct vkd3d_shader_register *reg = &resource->reg.reg; const struct vkd3d_spirv_resource_type *resource_type_info; - struct vkd3d_descriptor_variable_info var_info; enum vkd3d_shader_component_type sampled_type; struct vkd3d_symbol resource_symbol; bool is_uav; @@ -6022,7 +6009,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp } var_id = vkd3d_dxbc_compiler_build_descriptor_variable(compiler, storage_class, type_id, reg, - &resource->range, resource_type, &var_info); + &resource->range, resource_type, false, &var_info); if (is_uav) { @@ -6043,7 +6030,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp { vkd3d_spirv_enable_capability(builder, SpvCapabilityAtomicStorage); storage_class = SpvStorageClassAtomicCounter; - ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, counter_type_id); + type_id = counter_type_id; } else if (compiler->ssbo_uavs) { @@ -6058,20 +6045,11 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp vkd3d_spirv_build_op_member_decorate1(builder, struct_id, 0, SpvDecorationOffset, 0); storage_class = SpvStorageClassUniform; - ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, struct_id); + type_id = struct_id; } - else - { - ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id); - } - - counter_var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream, - ptr_type_id, storage_class, 0); - vkd3d_dxbc_compiler_emit_descriptor_binding_for_reg(compiler, - counter_var_id, reg, &resource->range, resource_type, true); - - vkd3d_spirv_build_op_name(builder, counter_var_id, "u%u_counter", reg->idx[0].offset); + counter_var_id = vkd3d_dxbc_compiler_build_descriptor_variable(compiler, storage_class, type_id, reg, + &resource->range, resource_type, true, &counter_var_info); } } @@ -6086,6 +6064,8 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp resource_symbol.info.resource.raw = raw; resource_symbol.info.resource.binding_base_idx = var_info.binding_base_idx; resource_symbol.info.resource.uav_counter_id = counter_var_id; + resource_symbol.info.resource.uav_counter_array = counter_var_info.array_symbol; + resource_symbol.info.resource.uav_counter_base_idx = counter_var_info.binding_base_idx; vkd3d_dxbc_compiler_put_symbol(compiler, &resource_symbol); } @@ -8887,6 +8867,24 @@ static void vkd3d_dxbc_compiler_emit_uav_counter_instruction(struct vkd3d_dxbc_c assert(counter_id); type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + + if (resource_symbol->info.resource.uav_counter_array) + { + const struct vkd3d_symbol_descriptor_array_data *array_data; + uint32_t index_id; + + index_id = vkd3d_dxbc_compiler_get_descriptor_index(compiler, &src->reg, + resource_symbol->info.resource.uav_counter_array, + resource_symbol->info.resource.uav_counter_base_idx, + resource_symbol->info.resource.resource_type_info->resource_type); + + array_data = &resource_symbol->info.resource.uav_counter_array->info.descriptor_array; + ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, array_data->storage_class, + array_data->contained_type_id); + + counter_id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, counter_id, &index_id, 1); + } + if (vkd3d_dxbc_compiler_is_opengl_target(compiler)) { pointer_id = counter_id; -- 2.33.0

2 1

[PATCH v3 vkd3d 1/3] vkd3d-shader/hlsl: Cast round() input to float.
by Nikolay Sivov 07 Jan '22

07 Jan '22

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- v3: handle conversion failures libs/vkd3d-shader/hlsl.y | 19 ++++++++++++++++++- tests/round.shader_test | 13 +++++++++++++ tests/shader_runner_d3d12.c | 13 +++++++++++++ 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 636882c..6c285c3 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1570,6 +1570,18 @@ static const struct hlsl_ir_function_decl *find_function_call(struct hlsl_ctx *c return args.decl; } +static struct hlsl_ir_node *intrinsic_float_convert_arg(struct hlsl_ctx *ctx, + const struct parse_initializer *params, struct hlsl_ir_node *arg, const struct vkd3d_shader_location *loc) +{ + struct hlsl_type *type = arg->data_type; + + if (type->base_type == HLSL_TYPE_FLOAT || type->base_type == HLSL_TYPE_HALF) + return arg; + + type = hlsl_get_numeric_type(ctx, type->type, HLSL_TYPE_FLOAT, type->dimx, type->dimy); + return add_implicit_conversion(ctx, params->instrs, arg, type, loc); +} + static bool intrinsic_abs(struct hlsl_ctx *ctx, const struct parse_initializer *params, const struct vkd3d_shader_location *loc) { @@ -1675,7 +1687,12 @@ static bool intrinsic_pow(struct hlsl_ctx *ctx, static bool intrinsic_round(struct hlsl_ctx *ctx, const struct parse_initializer *params, const struct vkd3d_shader_location *loc) { - return !!add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_ROUND, params->args[0], loc); + struct hlsl_ir_node *arg; + + if (!(arg = intrinsic_float_convert_arg(ctx, params, params->args[0], loc))) + return false; + + return !!add_unary_arithmetic_expr(ctx, params->instrs, HLSL_OP1_ROUND, arg, loc); } static bool intrinsic_saturate(struct hlsl_ctx *ctx, diff --git a/tests/round.shader_test b/tests/round.shader_test index d8eb11b..cc5a697 100644 --- a/tests/round.shader_test +++ b/tests/round.shader_test @@ -24,3 +24,16 @@ float4 main(uniform float4 u) : sv_target uniform 0 float4 -0.5 6.5 7.5 3.4 draw quad probe all rgba (6.0, 8.0, 0.0, 3.0) 4 + + + +[pixel shader] +float4 main(uniform int4 u) : sv_target +{ + return round(u); +} + +[test] +uniform 0 int4 -1 0 2 10 +draw quad +probe all rgba (-1.0, 0.0, 2.0, 10.0) 4 diff --git a/tests/shader_runner_d3d12.c b/tests/shader_runner_d3d12.c index 47f419b..c5992aa 100644 --- a/tests/shader_runner_d3d12.c +++ b/tests/shader_runner_d3d12.c @@ -552,6 +552,19 @@ static void parse_test_directive(struct shader_context *context, const char *lin } memcpy(context->uniforms + offset, &i, sizeof(i)); } + if (match_string(line, "int4", &line)) + { + int v[4]; + + if (sscanf(line, "%d %d %d %d", &v[0], &v[1], &v[2], &v[3]) < 4) + fatal_error("Malformed int4 constant '%s'.\n", line); + if (offset + 4 > context->uniform_count) + { + context->uniform_count = offset + 4; + context->uniforms = realloc(context->uniforms, context->uniform_count * sizeof(*context->uniforms)); + } + memcpy(context->uniforms + offset, v, sizeof(v)); + } else if (match_string(line, "uint", &line)) { unsigned int u; -- 2.34.1

2 5

[PATCH vkd3d 3/8] vkd3d-shader/hlsl: Move fold_constants() to a separate file.
by Francisco Casas 07 Jan '22

07 Jan '22

Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- Makefile.am | 1 + libs/vkd3d-shader/hlsl.h | 2 + libs/vkd3d-shader/hlsl_codegen.c | 106 --------------------- libs/vkd3d-shader/hlsl_constant_ops.c | 127 ++++++++++++++++++++++++++ 4 files changed, 130 insertions(+), 106 deletions(-) create mode 100644 libs/vkd3d-shader/hlsl_constant_ops.c diff --git a/Makefile.am b/Makefile.am index 20fee06d..d3dfc0a7 100644 --- a/Makefile.am +++ b/Makefile.am @@ -194,6 +194,7 @@ libvkd3d_shader_la_SOURCES = \ libs/vkd3d-shader/hlsl.c \ libs/vkd3d-shader/hlsl.h \ libs/vkd3d-shader/hlsl_codegen.c \ + libs/vkd3d-shader/hlsl_constant_ops.c \ libs/vkd3d-shader/hlsl_sm1.c \ libs/vkd3d-shader/hlsl_sm4.c \ libs/vkd3d-shader/preproc.h \ diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 530d12ad..f2cb0802 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -762,6 +762,8 @@ unsigned int hlsl_offset_from_deref_safe(struct hlsl_ctx *ctx, const struct hlsl struct hlsl_reg hlsl_reg_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, const struct hlsl_type *type); +bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context); + bool hlsl_sm1_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, bool output, D3DSHADER_PARAM_REGISTER_TYPE *type, unsigned int *reg); bool hlsl_sm1_usage_from_semantic(const struct hlsl_semantic *semantic, D3DDECLUSAGE *usage, uint32_t *usage_idx); diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 6cb4df8b..5f93c9a9 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -639,112 +639,6 @@ static bool lower_narrowing_casts(struct hlsl_ctx *ctx, struct hlsl_ir_node *ins return false; } -static bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) -{ - struct hlsl_ir_constant *arg1, *arg2 = NULL, *res; - struct hlsl_ir_expr *expr; - unsigned int i, dimx; - - if (instr->type != HLSL_IR_EXPR) - return false; - expr = hlsl_ir_expr(instr); - - for (i = 0; i < ARRAY_SIZE(expr->operands); ++i) - { - if (expr->operands[i].node && expr->operands[i].node->type != HLSL_IR_CONSTANT) - return false; - } - arg1 = hlsl_ir_constant(expr->operands[0].node); - if (expr->operands[1].node) - arg2 = hlsl_ir_constant(expr->operands[1].node); - dimx = instr->data_type->dimx; - - if (!(res = hlsl_alloc(ctx, sizeof(*res)))) - return false; - init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc); - - switch (instr->data_type->base_type) - { - case HLSL_TYPE_FLOAT: - { - switch (expr->op) - { - case HLSL_OP1_CAST: - if (instr->data_type->dimx != arg1->node.data_type->dimx - || instr->data_type->dimy != arg1->node.data_type->dimy) - { - FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), - debug_hlsl_type(ctx, instr->data_type)); - vkd3d_free(res); - return false; - } - - switch (arg1->node.data_type->base_type) - { - case HLSL_TYPE_INT: - for (i = 0; i < dimx; ++i) - res->value[i].f = arg1->value[i].i; - break; - - case HLSL_TYPE_UINT: - for (i = 0; i < dimx; ++i) - res->value[i].f = arg1->value[i].u; - break; - - default: - FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), - debug_hlsl_type(ctx, instr->data_type)); - vkd3d_free(res); - return false; - } - break; - - default: - FIXME("Fold float op %#x.\n", expr->op); - vkd3d_free(res); - return false; - } - break; - } - - case HLSL_TYPE_UINT: - { - switch (expr->op) - { - case HLSL_OP1_NEG: - for (i = 0; i < instr->data_type->dimx; ++i) - res->value[i].u = -arg1->value[i].u; - break; - - case HLSL_OP2_ADD: - for (i = 0; i < instr->data_type->dimx; ++i) - res->value[i].u = arg1->value[i].u + arg2->value[i].u; - break; - - case HLSL_OP2_MUL: - for (i = 0; i < instr->data_type->dimx; ++i) - res->value[i].u = arg1->value[i].u * arg2->value[i].u; - break; - - default: - FIXME("Fold uint op %#x.\n", expr->op); - vkd3d_free(res); - return false; - } - break; - } - - default: - FIXME("Fold type %#x op %#x.\n", instr->data_type->base_type, expr->op); - vkd3d_free(res); - return false; - } - - list_add_before(&expr->node.entry, &res->node.entry); - hlsl_replace_node(&expr->node, &res->node); - return true; -} - static bool remove_trivial_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) { struct hlsl_ir_swizzle *swizzle; diff --git a/libs/vkd3d-shader/hlsl_constant_ops.c b/libs/vkd3d-shader/hlsl_constant_ops.c new file mode 100644 index 00000000..924e0380 --- /dev/null +++ b/libs/vkd3d-shader/hlsl_constant_ops.c @@ -0,0 +1,127 @@ +/* + * HLSL constant value operations for constant folding + * + * Copyright 2022 Francisco Casas for CodeWeavers + * + * 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 + */ + +#include "hlsl.h" + +bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) +{ + struct hlsl_ir_constant *arg1, *arg2 = NULL, *res; + struct hlsl_ir_expr *expr; + unsigned int i, dimx; + + if (instr->type != HLSL_IR_EXPR) + return false; + expr = hlsl_ir_expr(instr); + + for (i = 0; i < ARRAY_SIZE(expr->operands); ++i) + { + if (expr->operands[i].node && expr->operands[i].node->type != HLSL_IR_CONSTANT) + return false; + } + arg1 = hlsl_ir_constant(expr->operands[0].node); + if (expr->operands[1].node) + arg2 = hlsl_ir_constant(expr->operands[1].node); + dimx = instr->data_type->dimx; + + if (!(res = hlsl_alloc(ctx, sizeof(*res)))) + return false; + init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc); + + switch (instr->data_type->base_type) + { + case HLSL_TYPE_FLOAT: + { + switch (expr->op) + { + case HLSL_OP1_CAST: + if (instr->data_type->dimx != arg1->node.data_type->dimx + || instr->data_type->dimy != arg1->node.data_type->dimy) + { + FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), + debug_hlsl_type(ctx, instr->data_type)); + vkd3d_free(res); + return false; + } + + switch (arg1->node.data_type->base_type) + { + case HLSL_TYPE_INT: + for (i = 0; i < dimx; ++i) + res->value[i].f = arg1->value[i].i; + break; + + case HLSL_TYPE_UINT: + for (i = 0; i < dimx; ++i) + res->value[i].f = arg1->value[i].u; + break; + + default: + FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), + debug_hlsl_type(ctx, instr->data_type)); + vkd3d_free(res); + return false; + } + break; + + default: + FIXME("Fold float op %#x.\n", expr->op); + vkd3d_free(res); + return false; + } + break; + } + + case HLSL_TYPE_UINT: + { + switch (expr->op) + { + case HLSL_OP1_NEG: + for (i = 0; i < instr->data_type->dimx; ++i) + res->value[i].u = -arg1->value[i].u; + break; + + case HLSL_OP2_ADD: + for (i = 0; i < instr->data_type->dimx; ++i) + res->value[i].u = arg1->value[i].u + arg2->value[i].u; + break; + + case HLSL_OP2_MUL: + for (i = 0; i < instr->data_type->dimx; ++i) + res->value[i].u = arg1->value[i].u * arg2->value[i].u; + break; + + default: + FIXME("Fold uint op %#x.\n", expr->op); + vkd3d_free(res); + return false; + } + break; + } + + default: + FIXME("Fold type %#x op %#x.\n", instr->data_type->base_type, expr->op); + vkd3d_free(res); + return false; + } + + list_add_before(&expr->node.entry, &res->node.entry); + hlsl_replace_node(&expr->node, &res->node); + return true; +} \ No newline at end of file -- 2.25.1

2 2

[PATCH] wined3d: Use GL_MAP_PERSISTENT_BIT even for non-persistent bo maps.
by Henri Verbeet 07 Jan '22

07 Jan '22

While the reason for doing this is to allow draws referencing mapped buffer resources to succeed, the behaviour of the application in the referenced bug report (FlatOut) appears to be slightly different; it does end up drawing while buffer objects are mapped due to reordering of map operations inside the command stream, but as far as I can tell those buffer objects are not referenced by the draw. The driver in question (fglrx/Catalyst) appears to simply be a bit overzealous with throwing errors, and unfortunately doesn't provide much more information than "glDrawElementsBaseVertex has generated an error (GL_INVALID_OPERATION)". The issue is not reproducible with Mesa radeonsi. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46118 Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context_gl.c | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/dlls/wined3d/context_gl.c b/dlls/wined3d/context_gl.c index c08e44ce372..9fd2ed67dcc 100644 --- a/dlls/wined3d/context_gl.c +++ b/dlls/wined3d/context_gl.c @@ -2711,7 +2711,7 @@ map: gl_info = context_gl->gl_info; wined3d_context_gl_bind_bo(context_gl, bo->binding, bo->id); - if (gl_info->supported[ARB_BUFFER_STORAGE] && wined3d_map_persistent()) + if (gl_info->supported[ARB_BUFFER_STORAGE]) { GLbitfield gl_flags; @@ -2719,15 +2719,28 @@ map: * used to create the bo, instead of the access flags passed to the * map call. Otherwise, if for example the initial map call that * caused the bo to be persistently mapped was a read-only map, - * subsequent write access to the bo would be undefined. */ - gl_flags = bo->flags & ~GL_CLIENT_STORAGE_BIT; + * subsequent write access to the bo would be undefined. + * + * Note that we use GL_MAP_PERSISTENT_BIT for non-persistent maps here + * as well, in order to allow draws to succeed while referenced buffer + * resources are mapped. On the other hand, we don't want to use the + * access flags used to create the bo for non-persistent maps, because + * that may imply dropping GL_MAP_UNSYNCHRONIZED_BIT. */ + if (wined3d_map_persistent()) + { + gl_flags = bo->flags & ~GL_CLIENT_STORAGE_BIT; + if (!(gl_flags & GL_MAP_READ_BIT)) + gl_flags |= GL_MAP_UNSYNCHRONIZED_BIT; + if (gl_flags & GL_MAP_WRITE_BIT) + gl_flags |= GL_MAP_FLUSH_EXPLICIT_BIT; + } + else + { + gl_flags = wined3d_resource_gl_map_flags(bo, flags); + } gl_flags |= GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT; - if (!(gl_flags & GL_MAP_READ_BIT)) - gl_flags |= GL_MAP_UNSYNCHRONIZED_BIT; - if (gl_flags & GL_MAP_WRITE_BIT) - gl_flags |= GL_MAP_FLUSH_EXPLICIT_BIT; - if ((map_ptr = GL_EXTCALL(glMapBufferRange(bo->binding, 0, bo->size, gl_flags)))) + if ((map_ptr = GL_EXTCALL(glMapBufferRange(bo->binding, 0, bo->size, gl_flags))) && wined3d_map_persistent()) bo->b.map_ptr = map_ptr; } else if (gl_info->supported[ARB_MAP_BUFFER_RANGE]) -- 2.30.2

1 0

← Newer
1
...
60
61
62
63
64
65
66
...
72
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel January 2022