wine-commits February 2024

wine-commits@winehq.org

1 participants
716 discussions

Henri Verbeet : vkd3d-common: Get rid of InterlockedDecrement().
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: 532e902a5630c8ac606c06bd25b1bcbab14f9dc3 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/532e902a5630c8ac606c06bd25b1b… Author: Henri Verbeet <hverbeet(a)codeweavers.com> Date: Tue Jan 30 12:59:02 2024 +0100 vkd3d-common: Get rid of InterlockedDecrement(). --- include/private/vkd3d_common.h | 7 ------- tests/vkd3d_api.c | 2 +- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index 6f878cce..8d6e7b37 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -304,13 +304,6 @@ static inline uint32_t vkd3d_atomic_increment_u32(uint32_t volatile *x) return vkd3d_atomic_add_fetch_u32(x, 1); } -#ifndef _WIN32 -static inline LONG InterlockedDecrement(LONG volatile *x) -{ - return vkd3d_atomic_decrement_u32((uint32_t *)x); -} -#endif /* _WIN32 */ - static inline void vkd3d_parse_version(const char *version, int *major, int *minor) { *major = atoi(version); diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index 29948783..62e30b47 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -658,7 +658,7 @@ static ULONG STDMETHODCALLTYPE parent_Release(IUnknown *iface) { struct parent *parent = parent_from_IUnknown(iface); - return InterlockedDecrement((LONG *)&parent->refcount); + return vkd3d_atomic_decrement_u32(&parent->refcount); } static const struct IUnknownVtbl parent_vtbl =

1 0

Henri Verbeet : vkd3d-common: Get rid of InterlockedIncrement().
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: c64921e79b5e26bf0e39cf2c188979db85f8d3b3 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/c64921e79b5e26bf0e39cf2c18897… Author: Henri Verbeet <hverbeet(a)codeweavers.com> Date: Tue Jan 30 12:54:54 2024 +0100 vkd3d-common: Get rid of InterlockedIncrement(). --- include/private/vkd3d_common.h | 5 ----- include/private/vkd3d_test.h | 40 +++++++++++++++++++--------------------- tests/vkd3d_api.c | 6 +++--- 3 files changed, 22 insertions(+), 29 deletions(-) diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index 01e219b3..6f878cce 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -305,11 +305,6 @@ static inline uint32_t vkd3d_atomic_increment_u32(uint32_t volatile *x) } #ifndef _WIN32 -static inline LONG InterlockedIncrement(LONG volatile *x) -{ - return vkd3d_atomic_increment_u32((uint32_t *)x); -} - static inline LONG InterlockedDecrement(LONG volatile *x) { return vkd3d_atomic_decrement_u32((uint32_t *)x); diff --git a/include/private/vkd3d_test.h b/include/private/vkd3d_test.h index 081443c4..a337ac07 100644 --- a/include/private/vkd3d_test.h +++ b/include/private/vkd3d_test.h @@ -101,12 +101,12 @@ static void vkd3d_test_end_todo(void); struct vkd3d_test_state { - LONG success_count; - LONG failure_count; - LONG skip_count; - LONG todo_count; - LONG todo_success_count; - LONG bug_count; + unsigned int success_count; + unsigned int failure_count; + unsigned int skip_count; + unsigned int todo_count; + unsigned int todo_success_count; + unsigned int bug_count; unsigned int debug_level; @@ -150,13 +150,13 @@ vkd3d_test_check_assert_that(unsigned int line, bool result, const char *fmt, va { if (result) { - InterlockedIncrement(&vkd3d_test_state.success_count); + vkd3d_atomic_increment_u32(&vkd3d_test_state.success_count); if (vkd3d_test_state.debug_level > 1) vkd3d_test_printf(line, "Test succeeded.\n"); } else { - InterlockedIncrement(&vkd3d_test_state.failure_count); + vkd3d_atomic_increment_u32(&vkd3d_test_state.failure_count); vkd3d_test_printf(line, "Test failed: "); vprintf(fmt, args); } @@ -180,7 +180,7 @@ vkd3d_test_check_ok(unsigned int line, bool result, const char *fmt, va_list arg if (is_bug && vkd3d_test_state.bug_enabled) { - InterlockedIncrement(&vkd3d_test_state.bug_count); + vkd3d_atomic_increment_u32(&vkd3d_test_state.bug_count); if (is_todo) result = !result; if (result) @@ -193,12 +193,12 @@ vkd3d_test_check_ok(unsigned int line, bool result, const char *fmt, va_list arg { if (result) { - InterlockedIncrement(&vkd3d_test_state.todo_success_count); + vkd3d_atomic_increment_u32(&vkd3d_test_state.todo_success_count); vkd3d_test_printf(line, "Todo succeeded: "); } else { - InterlockedIncrement(&vkd3d_test_state.todo_count); + vkd3d_atomic_increment_u32(&vkd3d_test_state.todo_count); vkd3d_test_printf(line, "Todo: "); } vprintf(fmt, args); @@ -227,7 +227,7 @@ vkd3d_test_skip(unsigned int line, const char *fmt, ...) vkd3d_test_printf(line, "Test skipped: "); vprintf(fmt, args); va_end(args); - InterlockedIncrement(&vkd3d_test_state.skip_count); + vkd3d_atomic_increment_u32(&vkd3d_test_state.skip_count); } static void VKD3D_PRINTF_FUNC(2, 3) VKD3D_UNUSED @@ -293,16 +293,14 @@ int main(int argc, char **argv) vkd3d_test_main(argc, argv); - printf("%s: %lu tests executed (%lu failures, %lu skipped, %lu todo, %lu bugs).\n", + printf("%s: %u tests executed (%u failures, %u skipped, %u todo, %u bugs).\n", vkd3d_test_name, - (unsigned long)(vkd3d_test_state.success_count - + vkd3d_test_state.failure_count + vkd3d_test_state.todo_count - + vkd3d_test_state.todo_success_count), - (unsigned long)(vkd3d_test_state.failure_count - + vkd3d_test_state.todo_success_count), - (unsigned long)vkd3d_test_state.skip_count, - (unsigned long)vkd3d_test_state.todo_count, - (unsigned long)vkd3d_test_state.bug_count); + vkd3d_test_state.success_count + vkd3d_test_state.failure_count + + vkd3d_test_state.todo_count + vkd3d_test_state.todo_success_count, + vkd3d_test_state.failure_count + vkd3d_test_state.todo_success_count, + vkd3d_test_state.skip_count, + vkd3d_test_state.todo_count, + vkd3d_test_state.bug_count); if (test_platform) free(test_platform); diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index 5a585fec..29948783 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -625,7 +625,7 @@ static void test_adapter_luid(void) struct parent { IUnknown IUnknown_iface; - LONG refcount; + unsigned int refcount; }; static struct parent *parent_from_IUnknown(IUnknown *iface) @@ -651,14 +651,14 @@ static ULONG STDMETHODCALLTYPE parent_AddRef(IUnknown *iface) { struct parent *parent = parent_from_IUnknown(iface); - return InterlockedIncrement(&parent->refcount); + return vkd3d_atomic_increment_u32(&parent->refcount); } static ULONG STDMETHODCALLTYPE parent_Release(IUnknown *iface) { struct parent *parent = parent_from_IUnknown(iface); - return InterlockedDecrement(&parent->refcount); + return InterlockedDecrement((LONG *)&parent->refcount); } static const struct IUnknownVtbl parent_vtbl =

1 0

Giovanni Mascellani : vkd3d-shader/ir: Introduce a simple control flow graph structurizer.
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: 51f13391e6117592a4c77bbb457302c8c3bfa606 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/51f13391e6117592a4c77bbb45730… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Tue Jan 16 23:56:43 2024 +0100 vkd3d-shader/ir: Introduce a simple control flow graph structurizer. The structurizer is implemented along the lines of what is usually called the "structured program theorem": the control flow is completely virtualized by mean of an additional TEMP register which stores the block index which is currently running. The whole program is then converted to a huge switch construction enclosed in a loop, executing at each iteration the appropriate block and updating the register depending on block jump instruction. The algorithm's generality is also its major weakness: it accepts any input program, even if its CFG is not reducible, but the output program lacks any useful convergence information. It satisfies the letter of the SPIR-V requirements, but it is expected that it will be very inefficient to run on a GPU (unless a downstream compiler is able to devirtualize the control flow and do a proper convergence analysis pass). The algorithm is however very simple, and good enough to at least pass tests, enabling further development. A better alternative is expected to be upstreamed incrementally. Side note: the structured program theorem is often called the Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation of it, but their algorithm is different from what is commontly attributed to them and implemented here, so I opted for not using their name. --- libs/vkd3d-shader/ir.c | 147 ++++++++++++++++++++++++++++++++- tests/hlsl/conditional.shader_test | 2 +- tests/hlsl/for.shader_test | 2 +- tests/hlsl/function-return.shader_test | 44 +++++----- tests/hlsl/loop.shader_test | 6 +- tests/hlsl/return.shader_test | 32 +++---- tests/hlsl/sm6-ternary.shader_test | 4 +- tests/hlsl/switch.shader_test | 40 ++++----- 8 files changed, 209 insertions(+), 68 deletions(-)

1 0

Giovanni Mascellani : vkd3d-shader/ir: Handle PHI nodes when materializing SSA registers.
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: 19aef21369c2e20d4239dd77c9c0c4e27b5dd18d URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/19aef21369c2e20d4239dd77c9c0c… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Tue Jan 9 15:56:45 2024 +0100 vkd3d-shader/ir: Handle PHI nodes when materializing SSA registers. PHI nodes cannot be used with TEMP registers, so they have to be converted to MOV/MOVC nodes and moved before the BRANCH node. --- libs/vkd3d-shader/ir.c | 170 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 163 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index b92a04b2..1f14f702 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -2666,27 +2666,110 @@ static void materialize_ssas_to_temps_process_src_param(struct vkd3d_shader_pars materialize_ssas_to_temps_process_reg(parser, &src->reg); } +static const struct vkd3d_shader_src_param *materialize_ssas_to_temps_compute_source(struct vkd3d_shader_instruction *ins, + unsigned int label) +{ + unsigned int i; + + assert(ins->handler_idx == VKD3DSIH_PHI); + + for (i = 0; i < ins->src_count; i += 2) + { + if (label_from_src_param(&ins->src[i + 1]) == label) + return &ins->src[i]; + } + + vkd3d_unreachable(); +} + +static bool materialize_ssas_to_temps_synthesize_mov(struct vkd3d_shader_parser *parser, + struct vkd3d_shader_instruction *instruction, const struct vkd3d_shader_location *loc, + const struct vkd3d_shader_dst_param *dest, const struct vkd3d_shader_src_param *cond, + const struct vkd3d_shader_src_param *source, bool invert) +{ + struct vkd3d_shader_src_param *src; + struct vkd3d_shader_dst_param *dst; + + if (!vsir_instruction_init_with_params(&parser->program, instruction, loc, + cond ? VKD3DSIH_MOVC : VKD3DSIH_MOV, 1, cond ? 3 : 1)) + return false; + + dst = instruction->dst; + src = instruction->src; + + dst[0] = *dest; + materialize_ssas_to_temps_process_dst_param(parser, &dst[0]); + + assert(dst[0].write_mask == VKD3DSP_WRITEMASK_0); + assert(dst[0].modifiers == 0); + assert(dst[0].shift == 0); + + if (cond) + { + src[0] = *cond; + src[1 + invert] = *source; + memset(&src[2 - invert], 0, sizeof(src[2 - invert])); + src[2 - invert].reg = dst[0].reg; + materialize_ssas_to_temps_process_src_param(parser, &src[1]); + materialize_ssas_to_temps_process_src_param(parser, &src[2]); + } + else + { + src[0] = *source; + materialize_ssas_to_temps_process_src_param(parser, &src[0]); + } + + return true; +} + static enum vkd3d_result materialize_ssas_to_temps(struct vkd3d_shader_parser *parser) { struct vkd3d_shader_instruction *instructions = NULL; + struct materialize_ssas_to_temps_block_data + { + size_t phi_begin; + size_t phi_count; + } *block_index = NULL; size_t ins_capacity = 0, ins_count = 0, i; + unsigned int current_label = 0; if (!reserve_instructions(&instructions, &ins_capacity, parser->program.instructions.count)) goto fail; + if (!(block_index = vkd3d_calloc(parser->program.block_count, sizeof(*block_index)))) + { + ERR("Failed to allocate block index.\n"); + goto fail; + } + for (i = 0; i < parser->program.instructions.count; ++i) { struct vkd3d_shader_instruction *ins = &parser->program.instructions.elements[i]; - size_t j; - if (ins->handler_idx == VKD3DSIH_PHI) + switch (ins->handler_idx) { - WARN("Unhandled PHI when materializing SSA registers.\n"); - vkd3d_shader_parser_error(parser, VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED, - "Unhandled PHI when materializing SSA registers."); - vkd3d_free(instructions); - return VKD3D_ERROR_NOT_IMPLEMENTED; + case VKD3DSIH_LABEL: + current_label = label_from_src_param(&ins->src[0]); + break; + + case VKD3DSIH_PHI: + assert(current_label != 0); + assert(i != 0); + if (block_index[current_label - 1].phi_begin == 0) + block_index[current_label - 1].phi_begin = i; + block_index[current_label - 1].phi_count += 1; + break; + + default: + current_label = 0; + break; } + } + + for (i = 0; i < parser->program.instructions.count; ++i) + { + struct vkd3d_shader_instruction *ins = &parser->program.instructions.elements[i]; + size_t j; for (j = 0; j < ins->dst_count; ++j) materialize_ssas_to_temps_process_dst_param(parser, &ins->dst[j]); @@ -2694,6 +2777,77 @@ static enum vkd3d_result materialize_ssas_to_temps(struct vkd3d_shader_parser *p for (j = 0; j < ins->src_count; ++j) materialize_ssas_to_temps_process_src_param(parser, &ins->src[j]); + switch (ins->handler_idx) + { + case VKD3DSIH_LABEL: + current_label = label_from_src_param(&ins->src[0]); + break; + + case VKD3DSIH_BRANCH: + { + if (vsir_register_is_label(&ins->src[0].reg)) + { + const struct materialize_ssas_to_temps_block_data *data = &block_index[label_from_src_param(&ins->src[0]) - 1]; + + if (!reserve_instructions(&instructions, &ins_capacity, ins_count + data->phi_count)) + goto fail; + + for (j = data->phi_begin; j < data->phi_begin + data->phi_count; ++j) + { + const struct vkd3d_shader_src_param *source; + + source = materialize_ssas_to_temps_compute_source(&parser->program.instructions.elements[j], current_label); + if (!materialize_ssas_to_temps_synthesize_mov(parser, &instructions[ins_count], &ins->location, + &parser->program.instructions.elements[j].dst[0], NULL, source, false)) + goto fail; + + ++ins_count; + } + } + else + { + struct materialize_ssas_to_temps_block_data *data_true = &block_index[label_from_src_param(&ins->src[1]) - 1], + *data_false = &block_index[label_from_src_param(&ins->src[2]) - 1]; + const struct vkd3d_shader_src_param *cond = &ins->src[0]; + + if (!reserve_instructions(&instructions, &ins_capacity, + ins_count + data_true->phi_count + data_false->phi_count)) + goto fail; + + for (j = data_true->phi_begin; j < data_true->phi_begin + data_true->phi_count; ++j) + { + const struct vkd3d_shader_src_param *source; + + source = materialize_ssas_to_temps_compute_source(&parser->program.instructions.elements[j], current_label); + if (!materialize_ssas_to_temps_synthesize_mov(parser, &instructions[ins_count], &ins->location, + &parser->program.instructions.elements[j].dst[0], cond, source, false)) + goto fail; + + ++ins_count; + } + + for (j = data_false->phi_begin; j < data_false->phi_begin + data_false->phi_count; ++j) + { + const struct vkd3d_shader_src_param *source; + + source = materialize_ssas_to_temps_compute_source(&parser->program.instructions.elements[j], current_label); + if (!materialize_ssas_to_temps_synthesize_mov(parser, &instructions[ins_count], &ins->location, + &parser->program.instructions.elements[j].dst[0], cond, source, true)) + goto fail; + + ++ins_count; + } + } + break; + } + + case VKD3DSIH_PHI: + continue; + + default: + break; + } + if (!reserve_instructions(&instructions, &ins_capacity, ins_count + 1)) goto fail; @@ -2701,6 +2855,7 @@ static enum vkd3d_result materialize_ssas_to_temps(struct vkd3d_shader_parser *p } vkd3d_free(parser->program.instructions.elements); + vkd3d_free(block_index); parser->program.instructions.elements = instructions; parser->program.instructions.capacity = ins_capacity; parser->program.instructions.count = ins_count; @@ -2711,6 +2866,7 @@ static enum vkd3d_result materialize_ssas_to_temps(struct vkd3d_shader_parser *p fail: vkd3d_free(instructions); + vkd3d_free(block_index); return VKD3D_ERROR_OUT_OF_MEMORY; }

1 0

Giovanni Mascellani : vkd3d-shader/ir: Materialize SSA registers to temporaries.
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: e0d3e9c376a9fc4f80bf9dc79201766030b191a7 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/e0d3e9c376a9fc4f80bf9dc792017… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Tue Jan 9 15:56:45 2024 +0100 vkd3d-shader/ir: Materialize SSA registers to temporaries. For simplicity PHI nodes are not currently handled. The goal for this pass is to make the CFG structurizer simpler, because it doesn't have to care about the more rigid rules SSA registers have to satisfy than TEMP registers. It is likely that the generated code will be harder for downstream compilers to optimize and execute efficiently, so once a complete structurizer is in place this pass should be removed, or at least greatly reduced in scope. --- libs/vkd3d-shader/ir.c | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index a0d6212c..b92a04b2 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -2637,6 +2637,84 @@ fail: return VKD3D_ERROR_OUT_OF_MEMORY; } +static void materialize_ssas_to_temps_process_src_param(struct vkd3d_shader_parser *parser, struct vkd3d_shader_src_param *src); + +/* This is idempotent: it can be safely applied more than once on the + * same register. */ +static void materialize_ssas_to_temps_process_reg(struct vkd3d_shader_parser *parser, struct vkd3d_shader_register *reg) +{ + unsigned int i; + + if (reg->type == VKD3DSPR_SSA) + { + reg->type = VKD3DSPR_TEMP; + reg->idx[0].offset += parser->program.temp_count; + } + + for (i = 0; i < reg->idx_count; ++i) + if (reg->idx[i].rel_addr) + materialize_ssas_to_temps_process_src_param(parser, reg->idx[i].rel_addr); +} + +static void materialize_ssas_to_temps_process_dst_param(struct vkd3d_shader_parser *parser, struct vkd3d_shader_dst_param *dst) +{ + materialize_ssas_to_temps_process_reg(parser, &dst->reg); +} + +static void materialize_ssas_to_temps_process_src_param(struct vkd3d_shader_parser *parser, struct vkd3d_shader_src_param *src) +{ + materialize_ssas_to_temps_process_reg(parser, &src->reg); +} + +static enum vkd3d_result materialize_ssas_to_temps(struct vkd3d_shader_parser *parser) +{ + struct vkd3d_shader_instruction *instructions = NULL; + size_t ins_capacity = 0, ins_count = 0, i; + + if (!reserve_instructions(&instructions, &ins_capacity, parser->program.instructions.count)) + goto fail; + + for (i = 0; i < parser->program.instructions.count; ++i) + { + struct vkd3d_shader_instruction *ins = &parser->program.instructions.elements[i]; + size_t j; + + if (ins->handler_idx == VKD3DSIH_PHI) + { + WARN("Unhandled PHI when materializing SSA registers.\n"); + vkd3d_shader_parser_error(parser, VKD3D_SHADER_ERROR_VSIR_NOT_IMPLEMENTED, + "Unhandled PHI when materializing SSA registers."); + vkd3d_free(instructions); + return VKD3D_ERROR_NOT_IMPLEMENTED; + } + + for (j = 0; j < ins->dst_count; ++j) + materialize_ssas_to_temps_process_dst_param(parser, &ins->dst[j]); + + for (j = 0; j < ins->src_count; ++j) + materialize_ssas_to_temps_process_src_param(parser, &ins->src[j]); + + if (!reserve_instructions(&instructions, &ins_capacity, ins_count + 1)) + goto fail; + + instructions[ins_count++] = *ins; + } + + vkd3d_free(parser->program.instructions.elements); + parser->program.instructions.elements = instructions; + parser->program.instructions.capacity = ins_capacity; + parser->program.instructions.count = ins_count; + parser->program.temp_count += parser->program.ssa_count; + parser->program.ssa_count = 0; + + return VKD3D_OK; + +fail: + vkd3d_free(instructions); + + return VKD3D_ERROR_OUT_OF_MEMORY; +} + enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, const struct vkd3d_shader_compile_info *compile_info) { @@ -2652,6 +2730,9 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, { if ((result = lower_switch_to_if_ladder(&parser->program)) < 0) return result; + + if ((result = materialize_ssas_to_temps(parser)) < 0) + return result; } else {

1 0

Giovanni Mascellani : vkd3d-shader/spirv: Support bool TEMP registers.
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: eb723a8d2bc5240c6f2c33a3e1b60863f5df8af1 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/eb723a8d2bc5240c6f2c33a3e1b60… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Wed Jan 17 13:31:45 2024 +0100 vkd3d-shader/spirv: Support bool TEMP registers. --- libs/vkd3d-shader/spirv.c | 37 +++++++++++++++++++++++++++++++++---- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index d836511c..e9437c6f 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -3844,8 +3844,21 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, if (component_type != reg_info->component_type) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); - val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); + if (component_type == VKD3D_SHADER_COMPONENT_BOOL) + { + if (reg_info->component_type != VKD3D_SHADER_COMPONENT_UINT) + { + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); + } + val_id = spirv_compiler_emit_int_to_bool(compiler, VKD3D_SHADER_CONDITIONAL_OP_NZ, + VKD3D_DATA_UINT, 1, val_id); + } + else + { + type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); + } } return val_id; @@ -4032,8 +4045,21 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, if (component_type != reg_info.component_type) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); - val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); + if (component_type == VKD3D_SHADER_COMPONENT_BOOL) + { + if (reg_info.component_type != VKD3D_SHADER_COMPONENT_UINT) + { + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, component_count); + val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); + } + val_id = spirv_compiler_emit_int_to_bool(compiler, VKD3D_SHADER_CONDITIONAL_OP_NZ, + VKD3D_DATA_UINT, component_count, val_id); + } + else + { + type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); + } } return val_id; @@ -4227,6 +4253,9 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler, { if (data_type_is_64_bit(reg->data_type)) src_write_mask = vsir_write_mask_32_from_64(write_mask); + if (component_type == VKD3D_SHADER_COMPONENT_BOOL) + val_id = spirv_compiler_emit_bool_to_int(compiler, + vsir_write_mask_component_count(src_write_mask), val_id, false); type_id = vkd3d_spirv_get_type_id(builder, reg_info.component_type, vsir_write_mask_component_count(src_write_mask)); val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id);

1 0

Giovanni Mascellani : vkd3d-shader/spirv: Move bool casting helpers above register loading helpers.
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: 49f0fd42b82b071a72dc98e129ced3b6061e0bc3 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/49f0fd42b82b071a72dc98e129ced… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Tue Jan 30 11:26:38 2024 +0100 vkd3d-shader/spirv: Move bool casting helpers above register loading helpers. --- libs/vkd3d-shader/spirv.c | 134 +++++++++++++++++++++++----------------------- 1 file changed, 67 insertions(+), 67 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 3cc20b5c..d836511c 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -3669,6 +3669,73 @@ static uint32_t spirv_compiler_emit_vector_shuffle(struct spirv_compiler *compil type_id, vector1_id, vector2_id, components, component_count); } +static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler, + enum vkd3d_shader_conditional_op condition, enum vkd3d_data_type data_type, + unsigned int component_count, uint32_t val_id) +{ + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + uint32_t type_id; + SpvOp op; + + assert(!(condition & ~(VKD3D_SHADER_CONDITIONAL_OP_NZ | VKD3D_SHADER_CONDITIONAL_OP_Z))); + + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); + op = condition & VKD3D_SHADER_CONDITIONAL_OP_Z ? SpvOpIEqual : SpvOpINotEqual; + return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, val_id, + data_type == VKD3D_DATA_UINT64 + ? spirv_compiler_get_constant_uint64_vector(compiler, 0, component_count) + : spirv_compiler_get_constant_uint_vector(compiler, 0, component_count)); +} + +static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler, + unsigned int component_count, uint32_t val_id, bool signedness) +{ + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + uint32_t type_id, true_id, false_id; + + true_id = spirv_compiler_get_constant_uint_vector(compiler, signedness ? 0xffffffff : 1, component_count); + false_id = spirv_compiler_get_constant_uint_vector(compiler, 0, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, component_count); + return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); +} + +static uint32_t spirv_compiler_emit_bool_to_int64(struct spirv_compiler *compiler, + unsigned int component_count, uint32_t val_id, bool signedness) +{ + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + uint32_t type_id, true_id, false_id; + + true_id = spirv_compiler_get_constant_uint64_vector(compiler, signedness ? UINT64_MAX : 1, + component_count); + false_id = spirv_compiler_get_constant_uint64_vector(compiler, 0, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT64, component_count); + return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); +} + +static uint32_t spirv_compiler_emit_bool_to_float(struct spirv_compiler *compiler, + unsigned int component_count, uint32_t val_id, bool signedness) +{ + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + uint32_t type_id, true_id, false_id; + + true_id = spirv_compiler_get_constant_float_vector(compiler, signedness ? -1.0f : 1.0f, component_count); + false_id = spirv_compiler_get_constant_float_vector(compiler, 0.0f, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, component_count); + return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); +} + +static uint32_t spirv_compiler_emit_bool_to_double(struct spirv_compiler *compiler, + unsigned int component_count, uint32_t val_id, bool signedness) +{ + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + uint32_t type_id, true_id, false_id; + + true_id = spirv_compiler_get_constant_double_vector(compiler, signedness ? -1.0 : 1.0, component_count); + false_id = spirv_compiler_get_constant_double_vector(compiler, 0.0, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_DOUBLE, component_count); + return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); +} + static uint32_t spirv_compiler_emit_load_constant(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, uint32_t swizzle, uint32_t write_mask) { @@ -4383,73 +4450,6 @@ static void spirv_compiler_emit_interpolation_decorations(struct spirv_compiler } } -static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler, - enum vkd3d_shader_conditional_op condition, enum vkd3d_data_type data_type, - unsigned int component_count, uint32_t val_id) -{ - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t type_id; - SpvOp op; - - assert(!(condition & ~(VKD3D_SHADER_CONDITIONAL_OP_NZ | VKD3D_SHADER_CONDITIONAL_OP_Z))); - - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); - op = condition & VKD3D_SHADER_CONDITIONAL_OP_Z ? SpvOpIEqual : SpvOpINotEqual; - return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, val_id, - data_type == VKD3D_DATA_UINT64 - ? spirv_compiler_get_constant_uint64_vector(compiler, 0, component_count) - : spirv_compiler_get_constant_uint_vector(compiler, 0, component_count)); -} - -static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler, - unsigned int component_count, uint32_t val_id, bool signedness) -{ - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t type_id, true_id, false_id; - - true_id = spirv_compiler_get_constant_uint_vector(compiler, signedness ? 0xffffffff : 1, component_count); - false_id = spirv_compiler_get_constant_uint_vector(compiler, 0, component_count); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, component_count); - return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); -} - -static uint32_t spirv_compiler_emit_bool_to_int64(struct spirv_compiler *compiler, - unsigned int component_count, uint32_t val_id, bool signedness) -{ - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t type_id, true_id, false_id; - - true_id = spirv_compiler_get_constant_uint64_vector(compiler, signedness ? UINT64_MAX : 1, - component_count); - false_id = spirv_compiler_get_constant_uint64_vector(compiler, 0, component_count); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT64, component_count); - return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); -} - -static uint32_t spirv_compiler_emit_bool_to_float(struct spirv_compiler *compiler, - unsigned int component_count, uint32_t val_id, bool signedness) -{ - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t type_id, true_id, false_id; - - true_id = spirv_compiler_get_constant_float_vector(compiler, signedness ? -1.0f : 1.0f, component_count); - false_id = spirv_compiler_get_constant_float_vector(compiler, 0.0f, component_count); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, component_count); - return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); -} - -static uint32_t spirv_compiler_emit_bool_to_double(struct spirv_compiler *compiler, - unsigned int component_count, uint32_t val_id, bool signedness) -{ - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - uint32_t type_id, true_id, false_id; - - true_id = spirv_compiler_get_constant_double_vector(compiler, signedness ? -1.0 : 1.0, component_count); - false_id = spirv_compiler_get_constant_double_vector(compiler, 0.0, component_count); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_DOUBLE, component_count); - return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); -} - typedef uint32_t (*vkd3d_spirv_builtin_fixup_pfn)(struct spirv_compiler *compiler, uint32_t val_id);

1 0

Giovanni Mascellani : vkd3d-shader/spirv: Convert the swizzle according to the source bit width.
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: ee994e95dd06d00cbf16fe4ca550c1f6bf1dd015 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/ee994e95dd06d00cbf16fe4ca550c… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Mon Feb 5 12:12:02 2024 +0100 vkd3d-shader/spirv: Convert the swizzle according to the source bit width. Fixes: 1f536238a89dc6bccb411c2db32d7b2010cc8fd7 --- libs/vkd3d-shader/spirv.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index d4333e6d..3cc20b5c 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -7082,7 +7082,7 @@ static void spirv_compiler_emit_mov(struct spirv_compiler *compiler, } write_mask32 = data_type_is_64_bit(dst->reg.data_type) ? vsir_write_mask_32_from_64(dst->write_mask) : dst->write_mask; - swizzle32 = data_type_is_64_bit(dst->reg.data_type) ? vsir_swizzle_32_from_64(src->swizzle) : src->swizzle; + swizzle32 = data_type_is_64_bit(src->reg.data_type) ? vsir_swizzle_32_from_64(src->swizzle) : src->swizzle; component_count = vsir_write_mask_component_count(write_mask32); if (component_count != 1 && component_count != VKD3D_VEC4_SIZE && dst_reg_info.write_mask == VKD3DSP_WRITEMASK_ALL)

1 0

Giovanni Mascellani : vkd3d-shader/dxil: Set the register before calling src_param_init_scalar().
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: vkd3d Branch: master Commit: 674f86042d67335603d3d1c4958b050ab697e9f4 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/674f86042d67335603d3d1c4958b0… Author: Giovanni Mascellani <gmascellani(a)codeweavers.com> Date: Tue Jan 30 11:22:45 2024 +0100 vkd3d-shader/dxil: Set the register before calling src_param_init_scalar(). Which uses the register to compute the appropriate swizzle. Fixes: 1f536238a89dc6bccb411c2db32d7b2010cc8fd7 --- libs/vkd3d-shader/dxil.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index ba951a6e..291012d1 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -4725,8 +4725,8 @@ static void sm6_parser_emit_extractval(struct sm6_parser *sm6, const struct dxil vsir_instruction_init(ins, &sm6->p.location, VKD3DSIH_MOV); src_param = instruction_src_params_alloc(ins, 1, sm6); - src_param_init_scalar(src_param, elem_idx); src_param->reg = src->u.reg; + src_param_init_scalar(src_param, elem_idx); instruction_dst_param_init_ssa_scalar(ins, sm6); }

1 0

Zhiyi Zhang : mf/tests: Test IMFMediaSession::Start().
by Alexandre Julliard 06 Feb '24

06 Feb '24

Module: wine Branch: master Commit: 6b853a9354dfe62df838b255b4af33b423e74642 URL: https://gitlab.winehq.org/wine/wine/-/commit/6b853a9354dfe62df838b255b4af33… Author: Zhiyi Zhang <zzhang(a)codeweavers.com> Date: Mon Aug 7 11:52:20 2023 +0800 mf/tests: Test IMFMediaSession::Start(). Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/mf/tests/mf.c | 960 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 952 insertions(+), 8 deletions(-)

1 0

← Newer
1
...
57
58
59
60
61
62
63
...
72
Older →

Jump to page:

2025

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-commits February 2024