wine-commits July 2024

wine-commits@winehq.org

2 participants
519 discussions

Francisco Casas : tests: Test whether valid state block function names are case-sensitive.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: af7c4010f4dbd1b5f305fef6fd7e02fa00429ba3 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/af7c4010f4dbd1b5f305fef6fd7e0… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Thu Jun 6 18:08:34 2024 -0400 tests: Test whether valid state block function names are case-sensitive. --- tests/hlsl/state-block-function-syntax.shader_test | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/hlsl/state-block-function-syntax.shader_test b/tests/hlsl/state-block-function-syntax.shader_test index a615ca8e..da9387b0 100644 --- a/tests/hlsl/state-block-function-syntax.shader_test +++ b/tests/hlsl/state-block-function-syntax.shader_test @@ -36,6 +36,15 @@ sampler sam float4 main() : sv_target { return 0; } +[pixel shader fail(sm<6) todo] +sampler sam +{ + Setblendstate(1, 2, 3); // Test case-sensitivity. +}; + +float4 main() : sv_target { return 0; } + + % It is allowed to use functions together with assignment syntax. [pixel shader] sampler sam

1 0

Francisco Casas : vkd3d-shader/hlsl: Parse function call syntax on state blocks.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: b5f2e7daeb517ce4600d5668bb48b5adb8f3f7ed URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/b5f2e7daeb517ce4600d5668bb48b… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue Mar 19 16:06:12 2024 -0300 vkd3d-shader/hlsl: Parse function call syntax on state blocks. --- libs/vkd3d-shader/fx.c | 3 +++ libs/vkd3d-shader/hlsl.h | 17 ++++++++++---- libs/vkd3d-shader/hlsl.y | 26 ++++++++++++++++++++++ tests/hlsl/state-block-function-syntax.shader_test | 10 ++++----- 4 files changed, 47 insertions(+), 9 deletions(-) diff --git a/libs/vkd3d-shader/fx.c b/libs/vkd3d-shader/fx.c index 75f10a18..14ff9c4e 100644 --- a/libs/vkd3d-shader/fx.c +++ b/libs/vkd3d-shader/fx.c @@ -1290,6 +1290,9 @@ static bool state_block_contains_state(const char *name, unsigned int start, str for (i = start; i < block->count; ++i) { + if (block->entries[i]->is_function_call) + continue; + if (!ascii_strcasecmp(block->entries[i]->name, name)) return true; } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index fdd013dd..65e5ab17 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -507,22 +507,31 @@ struct hlsl_ir_var * name[lhs_index] = args[0] * - or - * name[lhs_index] = {args[0], args[1], ...}; + * + * This struct also represents function call syntax: + * name(args[0], args[1], ...) */ struct hlsl_state_block_entry { - /* For assignments, the name in the lhs. */ + /* Whether this entry is a function call. */ + bool is_function_call; + + /* For assignments, the name in the lhs. + * For functions, the name of the function. */ char *name; /* Resolved format-specific property identifier. */ unsigned int name_id; - /* Whether the lhs in the assignment is indexed and, in that case, its index. */ + /* For assignments, whether the lhs of an assignment is indexed and, in + * that case, its index. */ bool lhs_has_index; unsigned int lhs_index; - /* Instructions present in the rhs. */ + /* Instructions present in the rhs or the function arguments. */ struct hlsl_block *instrs; - /* For assignments, arguments of the rhs initializer. */ + /* For assignments, arguments of the rhs initializer. + * For function calls, the arguments themselves. */ struct hlsl_src *args; unsigned int args_count; }; diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index ba617346..7cba28cd 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -7379,6 +7379,32 @@ state_block: hlsl_src_from_node(&entry->args[i], $5.args[i]); vkd3d_free($5.args); + $$ = $1; + state_block_add_entry($$, entry); + } + | state_block any_identifier '(' func_arguments ')' ';' + { + struct hlsl_state_block_entry *entry; + unsigned int i; + + if (!(entry = hlsl_alloc(ctx, sizeof(*entry)))) + YYABORT; + + entry->is_function_call = true; + + entry->name = $2; + entry->lhs_has_index = false; + entry->lhs_index = 0; + + entry->instrs = $4.instrs; + + entry->args_count = $4.args_count; + if (!(entry->args = hlsl_alloc(ctx, sizeof(*entry->args) * entry->args_count))) + YYABORT; + for (i = 0; i < entry->args_count; ++i) + hlsl_src_from_node(&entry->args[i], $4.args[i]); + vkd3d_free($4.args); + $$ = $1; state_block_add_entry($$, entry); } diff --git a/tests/hlsl/state-block-function-syntax.shader_test b/tests/hlsl/state-block-function-syntax.shader_test index 53279a36..a615ca8e 100644 --- a/tests/hlsl/state-block-function-syntax.shader_test +++ b/tests/hlsl/state-block-function-syntax.shader_test @@ -1,6 +1,6 @@ % Unlike assignment syntax, only these names are allowed. % The parameter count is also checked. -[pixel shader todo] +[pixel shader] sampler sam { SetBlendState(foo, bar, baz); // 3 parameters @@ -27,7 +27,7 @@ sampler sam float4 main() : sv_target { return 0; } -[pixel shader fail(sm<6)] +[pixel shader fail(sm<6) todo] sampler sam { SetSomeotherState(); @@ -37,7 +37,7 @@ float4 main() : sv_target { return 0; } % It is allowed to use functions together with assignment syntax. -[pixel shader todo] +[pixel shader] sampler sam { SetDepthStencilState(foo, bar); @@ -48,7 +48,7 @@ float4 main() : sv_target { return 0; } % Test complex expression on the arguments, including function calls. -[pixel shader todo] +[pixel shader] float4 addition(float4 a, float4 b) { return a + b; @@ -63,7 +63,7 @@ float4 main() : sv_target { return 0; } % Test the same thing on technique passes -[pixel shader todo] +[pixel shader] technique tech1 { pass pass1

1 0

Francisco Casas : tests: Separate the valid stateblock function names test from the string arg test.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: f15d8dc9e92ddbc513de46d71945d8e489c80579 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/f15d8dc9e92ddbc513de46d71945d… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Thu Jun 6 16:00:18 2024 -0400 tests: Separate the valid stateblock function names test from the string arg test. This test is important because it checks that all the valid names for stateblock functions with the expected amount of arguments are tested, but, after parsing state block function calls, the only reason it is not passing is that we don't parse strings yet. --- tests/hlsl/state-block-function-syntax.shader_test | 27 ++++++++++++++-------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/tests/hlsl/state-block-function-syntax.shader_test b/tests/hlsl/state-block-function-syntax.shader_test index 8af53ec5..53279a36 100644 --- a/tests/hlsl/state-block-function-syntax.shader_test +++ b/tests/hlsl/state-block-function-syntax.shader_test @@ -3,21 +3,30 @@ [pixel shader todo] sampler sam { - SetBlendState(foo, bar, baz); // 3 parameters - SetDepthStencilState(foo, 2); // 2 parameters - SetRasterizerState(foo); // 1 parameter - SetVertexShader(vs); // 1 parameter - SetDomainShader(ds); // 1 paramter - SetHullShader(100); // 1 parameter - SetGeometryShader(foo + bar); // 1 parameter - SetPixelShader(ps1); // 1 parameter - SetComputeShader("random string"); // 1 parameter + SetBlendState(foo, bar, baz); // 3 parameters + SetDepthStencilState(foo, 2); // 2 parameters + SetRasterizerState(foo); // 1 parameter + SetVertexShader(vs); // 1 parameter + SetDomainShader(ds); // 1 paramter + SetHullShader(100); // 1 parameter + SetGeometryShader(foo + bar); // 1 parameter + SetPixelShader(ps1); // 1 parameter + SetComputeShader(ARG); // 1 parameter OMSetRenderTargets(RTV0, RTV1, RTV2, RTV3, RTV4, RTV5, RTV6, RTV7, DSV); // 2 to 9 parameters }; float4 main() : sv_target { return 0; } +[pixel shader todo] +sampler sam +{ + SetComputeShader("random string"); +}; + +float4 main() : sv_target { return 0; } + + [pixel shader fail(sm<6)] sampler sam {

1 0

Francisco Casas : vkd3d-shader/hlsl: Free array sizes on function parameters (Valgrind).
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: 7bd53cf6d9beedad54395003fe51948d68356dab URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/7bd53cf6d9beedad54395003fe519… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue May 21 17:51:44 2024 -0400 vkd3d-shader/hlsl: Free array sizes on function parameters (Valgrind). --- libs/vkd3d-shader/hlsl.y | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index a0269239..ba617346 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -6856,6 +6856,8 @@ parameter: } type = hlsl_new_array_type(ctx, type, $4.sizes[i]); } + vkd3d_free($4.sizes); + $$.type = type; if (hlsl_version_ge(ctx, 5, 1) && type->class == HLSL_CLASS_ARRAY && hlsl_type_is_resource(type))

1 0

Francisco Casas : vkd3d-shader/d3dbc: Don't write inconsequential MOVs.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: b92baa40ec51f38da4dbf8df96a8d2937129d324 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/b92baa40ec51f38da4dbf8df96a8d… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Thu May 9 12:32:35 2024 -0400 vkd3d-shader/d3dbc: Don't write inconsequential MOVs. CASTs from floats to integers are implemented as mere MOVs. These often, but not always, end up moving the value from one register to the same register. This patch avoids writing the MOV instructions if they have no effect. --- libs/vkd3d-shader/d3dbc.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 53cf7169..ea9fe775 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -1882,6 +1882,32 @@ struct sm1_instruction unsigned int has_dst; }; +static bool is_inconsequential_instr(const struct sm1_instruction *instr) +{ + const struct sm1_src_register *src = &instr->srcs[0]; + const struct sm1_dst_register *dst = &instr->dst; + unsigned int i; + + if (instr->opcode != D3DSIO_MOV) + return false; + if (dst->mod != D3DSPDM_NONE) + return false; + if (src->mod != D3DSPSM_NONE) + return false; + if (src->type != dst->type) + return false; + if (src->reg != dst->reg) + return false; + + for (i = 0; i < 4; ++i) + { + if ((dst->writemask & (1 << i)) && (vsir_swizzle_get_component(src->swizzle, i) != i)) + return false; + } + + return true; +} + static void write_sm1_dst_register(struct vkd3d_bytecode_buffer *buffer, const struct sm1_dst_register *reg) { assert(reg->writemask); @@ -1901,6 +1927,9 @@ static void d3dbc_write_instruction(struct d3dbc_compiler *d3dbc, const struct s uint32_t token = instr->opcode; unsigned int i; + if (is_inconsequential_instr(instr)) + return; + token |= VKD3D_SM1_INSTRUCTION_FLAGS_MASK & (instr->flags << VKD3D_SM1_INSTRUCTION_FLAGS_SHIFT); if (version->major > 1)

1 0

Francisco Casas : vkd3d-shader/d3dbc: Use vsir_program I/O signatures to write dcls.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: daa13934a4b6c883026d2d52b2bbaca098083870 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/daa13934a4b6c883026d2d52b2bba… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue May 21 14:51:17 2024 -0400 vkd3d-shader/d3dbc: Use vsir_program I/O signatures to write dcls. Instead of relying on ctx->extern vars, semantics are now stored in the vsir_program signatures, and then read to write the declarations. --- libs/vkd3d-shader/d3dbc.c | 35 ++++++++++-------- libs/vkd3d-shader/hlsl_codegen.c | 79 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 98 insertions(+), 16 deletions(-) diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index d0b19362..53cf7169 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -2156,7 +2156,8 @@ static void d3dbc_write_constant_defs(struct d3dbc_compiler *d3dbc) } } -static void d3dbc_write_semantic_dcl(struct d3dbc_compiler *d3dbc, const struct hlsl_ir_var *var, bool output) +static void d3dbc_write_semantic_dcl(struct d3dbc_compiler *d3dbc, + const struct signature_element *element, bool output) { const struct vkd3d_shader_version *version = &d3dbc->program->shader_version; struct vkd3d_bytecode_buffer *buffer = &d3dbc->buffer; @@ -2165,20 +2166,18 @@ static void d3dbc_write_semantic_dcl(struct d3dbc_compiler *d3dbc, const struct D3DDECLUSAGE usage; bool ret; - if ((!output && !var->last_read) || (output && !var->first_write)) - return; - - if (hlsl_sm1_register_from_semantic(version, var->semantic.name, var->semantic.index, output, &reg.type, &reg.reg)) + if (hlsl_sm1_register_from_semantic(version, element->semantic_name, + element->semantic_index, output, &reg.type, &reg.reg)) { usage = 0; usage_idx = 0; } else { - ret = hlsl_sm1_usage_from_semantic(var->semantic.name, var->semantic.index, &usage, &usage_idx); + ret = hlsl_sm1_usage_from_semantic(element->semantic_name, element->semantic_index, &usage, &usage_idx); assert(ret); reg.type = output ? VKD3DSPR_OUTPUT : VKD3DSPR_INPUT; - reg.reg = var->regs[HLSL_REGSET_NUMERIC].id; + reg.reg = element->register_index; } token = D3DSIO_DCL; @@ -2191,17 +2190,17 @@ static void d3dbc_write_semantic_dcl(struct d3dbc_compiler *d3dbc, const struct token |= usage_idx << D3DSP_DCL_USAGEINDEX_SHIFT; put_u32(buffer, token); - reg.writemask = (1 << var->data_type->dimx) - 1; + reg.writemask = element->mask; write_sm1_dst_register(buffer, &reg); } static void d3dbc_write_semantic_dcls(struct d3dbc_compiler *d3dbc) { - const struct vkd3d_shader_version *version = &d3dbc->program->shader_version; + struct vsir_program *program = d3dbc->program; + const struct vkd3d_shader_version *version; bool write_in = false, write_out = false; - struct hlsl_ctx *ctx = d3dbc->ctx; - struct hlsl_ir_var *var; + version = &program->shader_version; if (version->type == VKD3D_SHADER_TYPE_PIXEL && version->major >= 2) write_in = true; else if (version->type == VKD3D_SHADER_TYPE_VERTEX && version->major == 3) @@ -2209,12 +2208,16 @@ static void d3dbc_write_semantic_dcls(struct d3dbc_compiler *d3dbc) else if (version->type == VKD3D_SHADER_TYPE_VERTEX && version->major < 3) write_in = true; - LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) + if (write_in) + { + for (unsigned int i = 0; i < program->input_signature.element_count; ++i) + d3dbc_write_semantic_dcl(d3dbc, &program->input_signature.elements[i], false); + } + + if (write_out) { - if (write_in && var->is_input_semantic) - d3dbc_write_semantic_dcl(d3dbc, var, false); - if (write_out && var->is_output_semantic) - d3dbc_write_semantic_dcl(d3dbc, var, true); + for (unsigned int i = 0; i < program->output_signature.element_count; ++i) + d3dbc_write_semantic_dcl(d3dbc, &program->output_signature.elements[i], true); } } diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 8c4cccc9..f9f5c8ed 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -5527,6 +5527,83 @@ void hlsl_run_const_passes(struct hlsl_ctx *ctx, struct hlsl_block *body) } while (progress); } +static void sm1_generate_vsir_signature_entry(struct hlsl_ctx *ctx, + struct vsir_program *program, bool output, struct hlsl_ir_var *var) +{ + enum vkd3d_shader_sysval_semantic sysval = VKD3D_SHADER_SV_NONE; + enum vkd3d_shader_register_type type; + struct shader_signature *signature; + struct signature_element *element; + unsigned int register_index, mask; + + if ((!output && !var->last_read) || (output && !var->first_write)) + return; + + if (output) + signature = &program->output_signature; + else + signature = &program->input_signature; + + if (!vkd3d_array_reserve((void **)&signature->elements, &signature->elements_capacity, + signature->element_count + 1, sizeof(*signature->elements))) + { + ctx->result = VKD3D_ERROR_OUT_OF_MEMORY; + return; + } + element = &signature->elements[signature->element_count++]; + + if (!hlsl_sm1_register_from_semantic(&program->shader_version, + var->semantic.name, var->semantic.index, output, &type, &register_index)) + { + unsigned int usage, usage_idx; + bool ret; + + register_index = var->regs[HLSL_REGSET_NUMERIC].id; + + ret = hlsl_sm1_usage_from_semantic(var->semantic.name, var->semantic.index, &usage, &usage_idx); + assert(ret); + /* With the exception of vertex POSITION output, none of these are + * system values. Pixel POSITION input is not equivalent to + * SV_Position; the closer equivalent is VPOS, which is not declared + * as a semantic. */ + if (program->shader_version.type == VKD3D_SHADER_TYPE_VERTEX + && output && usage == VKD3D_DECL_USAGE_POSITION) + sysval = VKD3D_SHADER_SV_POSITION; + } + mask = (1 << var->data_type->dimx) - 1; + + memset(element, 0, sizeof(*element)); + if (!(element->semantic_name = vkd3d_strdup(var->semantic.name))) + { + --signature->element_count; + ctx->result = VKD3D_ERROR_OUT_OF_MEMORY; + return; + } + element->semantic_index = var->semantic.index; + element->sysval_semantic = sysval; + element->component_type = VKD3D_SHADER_COMPONENT_FLOAT; + element->register_index = register_index; + element->target_location = register_index; + element->register_count = 1; + element->mask = mask; + element->used_mask = mask; + if (program->shader_version.type == VKD3D_SHADER_TYPE_PIXEL && !output) + element->interpolation_mode = VKD3DSIM_LINEAR; +} + +static void sm1_generate_vsir_signature(struct hlsl_ctx *ctx, struct vsir_program *program) +{ + struct hlsl_ir_var *var; + + LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) + { + if (var->is_input_semantic) + sm1_generate_vsir_signature_entry(ctx, program, false, var); + if (var->is_output_semantic) + sm1_generate_vsir_signature_entry(ctx, program, true, var); + } +} + /* OBJECTIVE: Translate all the information from ctx and entry_func to the * vsir_program and ctab blob, so they can be used as input to d3dbc_compile() * without relying on ctx and entry_func. */ @@ -5554,6 +5631,8 @@ static void sm1_generate_vsir(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl } ctab->code = buffer.data; ctab->size = buffer.size; + + sm1_generate_vsir_signature(ctx, program); } int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func,

1 0

Francisco Casas : vkd3d-shader/d3dbc: Don't require a hlsl_semantic to get register and usage.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: 704ce0356174bfeca802a1abef7d696bdd405824 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/704ce0356174bfeca802a1abef7d6… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue May 21 18:19:23 2024 -0400 vkd3d-shader/d3dbc: Don't require a hlsl_semantic to get register and usage. --- libs/vkd3d-shader/d3dbc.c | 27 ++++++++++++++------------- libs/vkd3d-shader/hlsl.h | 7 ++++--- libs/vkd3d-shader/hlsl_codegen.c | 5 +++-- 3 files changed, 21 insertions(+), 18 deletions(-) diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 2544952d..d0b19362 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -1354,8 +1354,8 @@ int d3dbc_parse(const struct vkd3d_shader_compile_info *compile_info, uint64_t c return ret; } -bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, - const struct hlsl_semantic *semantic, bool output, enum vkd3d_shader_register_type *type, unsigned int *reg) +bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, const char *semantic_name, + unsigned int semantic_index, bool output, enum vkd3d_shader_register_type *type, unsigned int *reg) { unsigned int i; @@ -1405,7 +1405,7 @@ bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, for (i = 0; i < ARRAY_SIZE(register_table); ++i) { - if (!ascii_strcasecmp(semantic->name, register_table[i].semantic) + if (!ascii_strcasecmp(semantic_name, register_table[i].semantic) && output == register_table[i].output && version->type == register_table[i].shader_type && version->major == register_table[i].major_version) @@ -1414,7 +1414,7 @@ bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, if (register_table[i].type == VKD3DSPR_MISCTYPE || register_table[i].type == VKD3DSPR_RASTOUT) *reg = register_table[i].offset; else - *reg = semantic->index; + *reg = semantic_index; return true; } } @@ -1422,7 +1422,8 @@ bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, return false; } -bool hlsl_sm1_usage_from_semantic(const struct hlsl_semantic *semantic, D3DDECLUSAGE *usage, uint32_t *usage_idx) +bool hlsl_sm1_usage_from_semantic(const char *semantic_name, + uint32_t semantic_index, D3DDECLUSAGE *usage, uint32_t *usage_idx) { static const struct { @@ -1454,10 +1455,10 @@ bool hlsl_sm1_usage_from_semantic(const struct hlsl_semantic *semantic, D3DDECLU for (i = 0; i < ARRAY_SIZE(semantics); ++i) { - if (!ascii_strcasecmp(semantic->name, semantics[i].name)) + if (!ascii_strcasecmp(semantic_name, semantics[i].name)) { *usage = semantics[i].usage; - *usage_idx = semantic->index; + *usage_idx = semantic_index; return true; } } @@ -2167,14 +2168,14 @@ static void d3dbc_write_semantic_dcl(struct d3dbc_compiler *d3dbc, const struct if ((!output && !var->last_read) || (output && !var->first_write)) return; - if (hlsl_sm1_register_from_semantic(version, &var->semantic, output, &reg.type, &reg.reg)) + if (hlsl_sm1_register_from_semantic(version, var->semantic.name, var->semantic.index, output, &reg.type, &reg.reg)) { usage = 0; usage_idx = 0; } else { - ret = hlsl_sm1_usage_from_semantic(&var->semantic, &usage, &usage_idx); + ret = hlsl_sm1_usage_from_semantic(var->semantic.name, var->semantic.index, &usage, &usage_idx); assert(ret); reg.type = output ? VKD3DSPR_OUTPUT : VKD3DSPR_INPUT; reg.reg = var->regs[HLSL_REGSET_NUMERIC].id; @@ -2572,8 +2573,8 @@ static void d3dbc_write_load(struct d3dbc_compiler *d3dbc, const struct hlsl_ir_ } else if (load->src.var->is_input_semantic) { - if (!hlsl_sm1_register_from_semantic(&d3dbc->program->shader_version, &load->src.var->semantic, - false, &sm1_instr.srcs[0].type, &sm1_instr.srcs[0].reg)) + if (!hlsl_sm1_register_from_semantic(&d3dbc->program->shader_version, load->src.var->semantic.name, + load->src.var->semantic.index, false, &sm1_instr.srcs[0].type, &sm1_instr.srcs[0].reg)) { assert(reg.allocated); sm1_instr.srcs[0].type = VKD3DSPR_INPUT; @@ -2693,8 +2694,8 @@ static void d3dbc_write_store(struct d3dbc_compiler *d3dbc, const struct hlsl_ir sm1_instr.dst.type = VKD3DSPR_TEMP; sm1_instr.dst.reg = 0; } - else if (!hlsl_sm1_register_from_semantic(&d3dbc->program->shader_version, - &store->lhs.var->semantic, true, &sm1_instr.dst.type, &sm1_instr.dst.reg)) + else if (!hlsl_sm1_register_from_semantic(&d3dbc->program->shader_version, store->lhs.var->semantic.name, + store->lhs.var->semantic.index, true, &sm1_instr.dst.type, &sm1_instr.dst.reg)) { assert(reg.allocated); sm1_instr.dst.type = VKD3DSPR_OUTPUT; diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 82b399b2..fdd013dd 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -1469,9 +1469,10 @@ bool hlsl_transform_ir(struct hlsl_ctx *ctx, bool (*func)(struct hlsl_ctx *ctx, D3DXPARAMETER_CLASS hlsl_sm1_class(const struct hlsl_type *type); D3DXPARAMETER_TYPE hlsl_sm1_base_type(const struct hlsl_type *type); -bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, - const struct hlsl_semantic *semantic, bool output, enum vkd3d_shader_register_type *type, unsigned int *reg); -bool hlsl_sm1_usage_from_semantic(const struct hlsl_semantic *semantic, D3DDECLUSAGE *usage, uint32_t *usage_idx); +bool hlsl_sm1_register_from_semantic(const struct vkd3d_shader_version *version, const char *semantic_name, + unsigned int semantic_index, bool output, enum vkd3d_shader_register_type *type, unsigned int *reg); +bool hlsl_sm1_usage_from_semantic(const char *semantic_name, + uint32_t semantic_index, D3DDECLUSAGE *usage, uint32_t *usage_idx); void write_sm1_uniforms(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer); int d3dbc_compile(struct vsir_program *program, uint64_t config_flags, diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index e86e6d38..8c4cccc9 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -4727,8 +4727,9 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var version.major = ctx->profile->major_version; version.minor = ctx->profile->minor_version; version.type = ctx->profile->type; - builtin = hlsl_sm1_register_from_semantic(&version, &var->semantic, output, &type, &reg); - if (!builtin && !hlsl_sm1_usage_from_semantic(&var->semantic, &usage, &usage_idx)) + builtin = hlsl_sm1_register_from_semantic(&version, + var->semantic.name, var->semantic.index, output, &type, &reg); + if (!builtin && !hlsl_sm1_usage_from_semantic(var->semantic.name, var->semantic.index, &usage, &usage_idx)) { hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC, "Invalid semantic '%s'.", var->semantic.name);

1 0

Francisco Casas : vkd3d-shader/d3dbc: Use program->shader_version instead of ctx->profile.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: 003f4c7600a7cdbb64f02b30d6090475d8c5e8bd URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/003f4c7600a7cdbb64f02b30d6090… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Fri May 17 22:06:58 2024 -0400 vkd3d-shader/d3dbc: Use program->shader_version instead of ctx->profile. --- libs/vkd3d-shader/d3dbc.c | 65 ++++++++++++++++++++++------------------ libs/vkd3d-shader/hlsl.h | 4 +-- libs/vkd3d-shader/hlsl_codegen.c | 6 +++- 3 files changed, 43 insertions(+), 32 deletions(-)

1 0

Francisco Casas : vkd3d-shader/d3dbc: Introduce struct d3dbc_compiler.
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: a3330902889dd1248a546f641b65dcec9494362e URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/a3330902889dd1248a546f641b65d… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Fri May 17 21:25:29 2024 -0400 vkd3d-shader/d3dbc: Introduce struct d3dbc_compiler. --- libs/vkd3d-shader/d3dbc.c | 227 +++++++++++++++++++++++++--------------------- 1 file changed, 123 insertions(+), 104 deletions(-)

1 0

Francisco Casas : vkd3d-shader/hlsl: Generate CTAB outside d3dbc_compile().
by Alexandre Julliard 09 Jul '24

09 Jul '24

Module: vkd3d Branch: master Commit: dd8aa2ec91358b74561c94e2ea3d0b11071107e8 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/dd8aa2ec91358b74561c94e2ea3d0… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Mon May 20 16:29:09 2024 -0400 vkd3d-shader/hlsl: Generate CTAB outside d3dbc_compile(). There is no way to store this information from the vsir_program alone, so we make d3dbc_compile() expect the CTAB blob. --- libs/vkd3d-shader/d3dbc.c | 7 +++---- libs/vkd3d-shader/hlsl.h | 3 ++- libs/vkd3d-shader/hlsl_codegen.c | 24 +++++++++++++++++++----- 3 files changed, 24 insertions(+), 10 deletions(-) diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 1b966afc..82d1af29 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -1683,8 +1683,7 @@ static void sm1_sort_externs(struct hlsl_ctx *ctx) list_move_tail(&ctx->extern_vars, &sorted); } -static void write_sm1_uniforms(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, - struct hlsl_ir_function_decl *entry_func) +void write_sm1_uniforms(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer) { size_t ctab_offset, ctab_start, ctab_end, vars_start, size_offset, creator_offset, offset; unsigned int uniform_count = 0; @@ -2784,7 +2783,7 @@ static void write_sm1_block(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer * * and be declared in vkd3d_shader_private.h and used without relying on HLSL * IR structs. */ int d3dbc_compile(struct vsir_program *program, uint64_t config_flags, - const struct vkd3d_shader_compile_info *compile_info, + const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_code *ctab, struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context, struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func) { @@ -2792,7 +2791,7 @@ int d3dbc_compile(struct vsir_program *program, uint64_t config_flags, put_u32(&buffer, sm1_version(ctx->profile->type, ctx->profile->major_version, ctx->profile->minor_version)); - write_sm1_uniforms(ctx, &buffer, entry_func); + bytecode_put_bytes(&buffer, ctab->code, ctab->size); write_sm1_constant_defs(ctx, &buffer); write_sm1_semantic_dcls(ctx, &buffer); diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 9ea6bc2e..8ca1aa6b 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -1473,8 +1473,9 @@ bool hlsl_sm1_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_sem bool output, enum vkd3d_shader_register_type *type, unsigned int *reg); bool hlsl_sm1_usage_from_semantic(const struct hlsl_semantic *semantic, D3DDECLUSAGE *usage, uint32_t *usage_idx); +void write_sm1_uniforms(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer); int d3dbc_compile(struct vsir_program *program, uint64_t config_flags, - const struct vkd3d_shader_compile_info *compile_info, + const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_code *ctab, struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context, struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func); diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 458d2fec..777dbea8 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -5523,12 +5523,13 @@ void hlsl_run_const_passes(struct hlsl_ctx *ctx, struct hlsl_block *body) } /* OBJECTIVE: Translate all the information from ctx and entry_func to the - * vsir_program, so it can be used as input to d3dbc_compile() without relying - * on ctx and entry_func. */ + * vsir_program and ctab blob, so they can be used as input to d3dbc_compile() + * without relying on ctx and entry_func. */ static void sm1_generate_vsir(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, - uint64_t config_flags, struct vsir_program *program) + uint64_t config_flags, struct vsir_program *program, struct vkd3d_shader_code *ctab) { struct vkd3d_shader_version version = {0}; + struct vkd3d_bytecode_buffer buffer = {0}; version.major = ctx->profile->major_version; version.minor = ctx->profile->minor_version; @@ -5538,6 +5539,16 @@ static void sm1_generate_vsir(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl ctx->result = VKD3D_ERROR_OUT_OF_MEMORY; return; } + + write_sm1_uniforms(ctx, &buffer); + if (buffer.status) + { + vkd3d_free(buffer.data); + ctx->result = buffer.status; + return; + } + ctab->code = buffer.data; + ctab->size = buffer.size; } int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, @@ -5724,18 +5735,21 @@ int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry case VKD3D_SHADER_TARGET_D3D_BYTECODE: { uint32_t config_flags = vkd3d_shader_init_config_flags(); + struct vkd3d_shader_code ctab = {0}; struct vsir_program program; int result; - sm1_generate_vsir(ctx, entry_func, config_flags, &program); + sm1_generate_vsir(ctx, entry_func, config_flags, &program, &ctab); if (ctx->result) { vsir_program_cleanup(&program); + vkd3d_shader_free_shader_code(&ctab); return ctx->result; } - result = d3dbc_compile(&program, config_flags, NULL, out, ctx->message_context, ctx, entry_func); + result = d3dbc_compile(&program, config_flags, NULL, &ctab, out, ctx->message_context, ctx, entry_func); vsir_program_cleanup(&program); + vkd3d_shader_free_shader_code(&ctab); return result; }

1 0

← Newer
1
...
27
28
29
30
31
32
33
...
52
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 July 2024