[PATCH 0/5] MR585: vkd3d-shader/ir: Introduce struct vsir_program.

List overview All Threads

newer

older

Re: [PATCH v18 0/4] MR4661:...

Henri Verbeet (＠hverbeet)

22 Jan 2024 22 Jan '24

7:50 p.m.

-- https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/585

Show replies by date

Henri Verbeet

22 Jan 22 Jan

7:50 p.m.

New subject: [PATCH 1/5] vkd3d-shader/ir: Introduce struct vsir_program.

From: Henri Verbeet hverbeet@codeweavers.com

diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index a2dd358b1..717419133 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -883,7 +883,7 @@ static void shader_sm1_destroy(struct vkd3d_shader_parser *parser) { struct vkd3d_shader_sm1_parser *sm1 = vkd3d_shader_sm1_parser(parser);

- shader_instruction_array_destroy(&parser->instructions); + vsir_program_cleanup(&parser->program); free_shader_desc(&sm1->p.shader_desc); vkd3d_free(sm1); } @@ -1334,7 +1334,7 @@ int vkd3d_shader_sm1_parser_create(const struct vkd3d_shader_compile_info *compi return ret; }

- instructions = &sm1->p.instructions; + instructions = &sm1->p.program.instructions; while (!shader_sm1_is_end(sm1)) { if (!shader_instruction_array_reserve(instructions, instructions->count + 1)) diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index 186460540..7f0972145 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -2524,7 +2524,7 @@ static enum vkd3d_result value_allocate_constant_array(struct sm6_value *dst, co "Out of memory allocating an immediate constant buffer of count %u.", count); return VKD3D_ERROR_OUT_OF_MEMORY; } - if (!shader_instruction_array_add_icb(&sm6->p.instructions, icb)) + if (!shader_instruction_array_add_icb(&sm6->p.program.instructions, icb)) { ERR("Failed to store icb object.\n"); vkd3d_free(icb); @@ -2720,12 +2720,12 @@ static bool bitcode_parse_alignment(uint64_t encoded_alignment, unsigned int *al

static struct vkd3d_shader_instruction *sm6_parser_require_space(struct sm6_parser *sm6, size_t extra) { - if (!shader_instruction_array_reserve(&sm6->p.instructions, sm6->p.instructions.count + extra)) + if (!shader_instruction_array_reserve(&sm6->p.program.instructions, sm6->p.program.instructions.count + extra)) { ERR("Failed to allocate instruction.\n"); return NULL; } - return &sm6->p.instructions.elements[sm6->p.instructions.count]; + return &sm6->p.program.instructions.elements[sm6->p.program.instructions.count]; }

/* Space should be reserved before calling this. It is intended to require no checking of the returned pointer. */ @@ -2735,7 +2735,7 @@ static struct vkd3d_shader_instruction *sm6_parser_add_instruction(struct sm6_pa struct vkd3d_shader_instruction *ins = sm6_parser_require_space(sm6, 1); assert(ins); vsir_instruction_init(ins, &sm6->p.location, handler_idx); - ++sm6->p.instructions.count; + ++sm6->p.program.instructions.count; return ins; }

@@ -2998,9 +2998,9 @@ static enum vkd3d_result sm6_parser_globals_init(struct sm6_parser *sm6) }

/* Resolve initialiser forward references. */ - for (i = 0; i < sm6->p.instructions.count; ++i) + for (i = 0; i < sm6->p.program.instructions.count; ++i) { - ins = &sm6->p.instructions.elements[i]; + ins = &sm6->p.program.instructions.elements[i]; if (ins->handler_idx == VKD3DSIH_DCL_INDEXABLE_TEMP && ins->declaration.indexable_temp.initialiser) { ins->declaration.indexable_temp.initialiser = resolve_forward_initialiser( @@ -5402,9 +5402,9 @@ static enum vkd3d_result sm6_function_emit_blocks(const struct sm6_function *fun sm6_parser_emit_label(sm6, block->id); sm6_block_emit_phi(block, sm6);

- memcpy(&sm6->p.instructions.elements[sm6->p.instructions.count], block->instructions, + memcpy(&sm6->p.program.instructions.elements[sm6->p.program.instructions.count], block->instructions, block->instruction_count * sizeof(*block->instructions)); - sm6->p.instructions.count += block->instruction_count; + sm6->p.program.instructions.count += block->instruction_count;

sm6_block_emit_terminator(block, sm6); } @@ -5890,7 +5890,7 @@ static enum vkd3d_result sm6_parser_descriptor_type_init(struct sm6_parser *sm6, }

++sm6->descriptor_count; - ++sm6->p.instructions.count; + ++sm6->p.program.instructions.count; }

return VKD3D_OK; @@ -6497,7 +6497,7 @@ static void sm6_parser_destroy(struct vkd3d_shader_parser *parser)

dxil_block_destroy(&sm6->root_block); dxil_global_abbrevs_cleanup(sm6->abbrevs, sm6->abbrev_count); - shader_instruction_array_destroy(&parser->instructions); + vsir_program_cleanup(&parser->program); sm6_type_table_cleanup(sm6->types, sm6->type_count); sm6_symtab_cleanup(sm6->global_symbols, sm6->global_symbol_count); sm6_functions_cleanup(sm6->functions, sm6->function_count); diff --git a/libs/vkd3d-shader/glsl.c b/libs/vkd3d-shader/glsl.c index f8d68b5a7..bdd03c1e7 100644 --- a/libs/vkd3d-shader/glsl.c +++ b/libs/vkd3d-shader/glsl.c @@ -91,7 +91,7 @@ static void vkd3d_glsl_handle_instruction(struct vkd3d_glsl_generator *generator }

int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator, - struct vkd3d_shader_parser *parser, struct vkd3d_shader_code *out) + struct vsir_program *program, struct vkd3d_shader_code *out) { unsigned int i; void *code; @@ -100,10 +100,10 @@ int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator, vkd3d_string_buffer_printf(&generator->buffer, "void main()\n{\n");

generator->location.column = 0; - for (i = 0; i < parser->instructions.count; ++i) + for (i = 0; i < program->instructions.count; ++i) { generator->location.line = i + 1; - vkd3d_glsl_handle_instruction(generator, &parser->instructions.elements[i]); + vkd3d_glsl_handle_instruction(generator, &program->instructions.elements[i]); }

if (generator->failed) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 14288a38b..2264138a4 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -18,6 +18,16 @@

#include "vkd3d_shader_private.h"

+bool vsir_program_init(struct vsir_program *program, unsigned int reserve) +{ + return shader_instruction_array_init(&program->instructions, reserve); +} + +void vsir_program_cleanup(struct vsir_program *program) +{ + shader_instruction_array_destroy(&program->instructions); +} + static inline bool shader_register_is_phase_instance_id(const struct vkd3d_shader_register *reg) { return reg->type == VKD3DSPR_FORKINSTID || reg->type == VKD3DSPR_JOININSTID; @@ -1229,7 +1239,7 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi

static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parser *parser) { - struct io_normaliser normaliser = {parser->instructions}; + struct io_normaliser normaliser = {parser->program.instructions}; struct vkd3d_shader_instruction *ins; bool has_control_point_phase; unsigned int i, j; @@ -1241,9 +1251,9 @@ static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parse normaliser.output_signature = &parser->shader_desc.output_signature; normaliser.patch_constant_signature = &parser->shader_desc.patch_constant_signature;

- for (i = 0, has_control_point_phase = false; i < parser->instructions.count; ++i) + for (i = 0, has_control_point_phase = false; i < parser->program.instructions.count; ++i) { - ins = &parser->instructions.elements[i]; + ins = &parser->program.instructions.elements[i];

switch (ins->handler_idx) { @@ -1286,7 +1296,7 @@ static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parse || !shader_signature_merge(&parser->shader_desc.output_signature, normaliser.output_range_map, false) || !shader_signature_merge(&parser->shader_desc.patch_constant_signature, normaliser.pc_range_map, true)) { - parser->instructions = normaliser.instructions; + parser->program.instructions = normaliser.instructions; return VKD3D_ERROR_OUT_OF_MEMORY; }

@@ -1294,7 +1304,7 @@ static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parse for (i = 0; i < normaliser.instructions.count; ++i) shader_instruction_normalise_io_params(&normaliser.instructions.elements[i], &normaliser);

- parser->instructions = normaliser.instructions; + parser->program.instructions = normaliser.instructions; parser->shader_desc.use_vocp = normaliser.use_vocp; return VKD3D_OK; } @@ -1308,7 +1318,6 @@ struct flat_constant_def

struct flat_constants_normaliser { - struct vkd3d_shader_parser *parser; struct flat_constant_def *defs; size_t def_count, defs_capacity; }; @@ -1383,14 +1392,14 @@ static void shader_register_normalise_flat_constants(struct vkd3d_shader_src_par param->reg.idx_count = 3; }

-static enum vkd3d_result instruction_array_normalise_flat_constants(struct vkd3d_shader_parser *parser) +static enum vkd3d_result instruction_array_normalise_flat_constants(struct vsir_program *program) { - struct flat_constants_normaliser normaliser = {.parser = parser}; + struct flat_constants_normaliser normaliser = {0}; unsigned int i, j;

- for (i = 0; i < parser->instructions.count; ++i) + for (i = 0; i < program->instructions.count; ++i) { - struct vkd3d_shader_instruction *ins = &parser->instructions.elements[i]; + struct vkd3d_shader_instruction *ins = &program->instructions.elements[i];

if (ins->handler_idx == VKD3DSIH_DEF || ins->handler_idx == VKD3DSIH_DEFI || ins->handler_idx == VKD3DSIH_DEFB) { @@ -1422,14 +1431,14 @@ static enum vkd3d_result instruction_array_normalise_flat_constants(struct vkd3d return VKD3D_OK; }

-static void remove_dead_code(struct vkd3d_shader_parser *parser) +static void remove_dead_code(struct vsir_program *program) { size_t i, depth = 0; bool dead = false;

switch (ins->handler_idx) { @@ -1516,15 +1525,15 @@ static enum vkd3d_result normalise_combined_samplers(struct vkd3d_shader_parser { unsigned int i;

- for (i = 0; i < parser->instructions.count; ++i) + for (i = 0; i < parser->program.instructions.count; ++i) { - struct vkd3d_shader_instruction *ins = &parser->instructions.elements[i]; + struct vkd3d_shader_instruction *ins = &parser->program.instructions.elements[i]; struct vkd3d_shader_src_param *srcs;

switch (ins->handler_idx) { case VKD3DSIH_TEX: - if (!(srcs = shader_src_param_allocator_get(&parser->instructions.src_params, 3))) + if (!(srcs = shader_src_param_allocator_get(&parser->program.instructions.src_params, 3))) return VKD3D_ERROR_OUT_OF_MEMORY; memset(srcs, 0, sizeof(*srcs) * 3);

@@ -1872,7 +1881,7 @@ static enum vkd3d_result cf_flattener_iterate_instruction_array(struct cf_flatte struct vkd3d_shader_instruction *dst_ins; size_t i;

- instructions = &parser->instructions; + instructions = &parser->program.instructions; is_hull_shader = parser->shader_version.type == VKD3D_SHADER_TYPE_HULL; main_block_open = !is_hull_shader; after_declarations_section = is_hull_shader; @@ -2220,10 +2229,10 @@ static enum vkd3d_result flatten_control_flow_constructs(struct vkd3d_shader_par

if (result >= 0) { - vkd3d_free(parser->instructions.elements); - parser->instructions.elements = flattener.instructions; - parser->instructions.capacity = flattener.instruction_capacity; - parser->instructions.count = flattener.instruction_count; + vkd3d_free(parser->program.instructions.elements); + parser->program.instructions.elements = flattener.instructions; + parser->program.instructions.capacity = flattener.instruction_capacity; + parser->program.instructions.count = flattener.instruction_count; parser->shader_desc.block_count = flattener.block_id; } else @@ -2242,7 +2251,7 @@ static enum vkd3d_result flatten_control_flow_constructs(struct vkd3d_shader_par enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, const struct vkd3d_shader_compile_info *compile_info) { - struct vkd3d_shader_instruction_array *instructions = &parser->instructions; + struct vkd3d_shader_instruction_array *instructions = &parser->program.instructions; enum vkd3d_result result = VKD3D_OK;

if (parser->shader_desc.is_dxil) @@ -2262,10 +2271,10 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, result = shader_normalise_io_registers(parser);

if (result >= 0) - result = instruction_array_normalise_flat_constants(parser); + result = instruction_array_normalise_flat_constants(&parser->program);

if (result >= 0) - remove_dead_code(parser); + remove_dead_code(&parser->program);

if (result >= 0) result = flatten_control_flow_constructs(parser); @@ -2703,9 +2712,10 @@ static void vsir_validate_cf_type(struct validation_context *ctx,

static void vsir_validate_instruction(struct validation_context *ctx) { - const struct vkd3d_shader_instruction *instruction = &ctx->parser->instructions.elements[ctx->instruction_idx]; + const struct vkd3d_shader_instruction *instruction; size_t i;

+ instruction = &ctx->parser->program.instructions.elements[ctx->instruction_idx]; ctx->parser->location = instruction->location;

for (i = 0; i < instruction->dst_count; ++i) @@ -2994,7 +3004,7 @@ enum vkd3d_result vsir_validate(struct vkd3d_shader_parser *parser) if (!(ctx.ssas = vkd3d_calloc(parser->shader_desc.ssa_count, sizeof(*ctx.ssas)))) goto fail;

- for (ctx.instruction_idx = 0; ctx.instruction_idx < parser->instructions.count; ++ctx.instruction_idx) + for (ctx.instruction_idx = 0; ctx.instruction_idx < parser->program.instructions.count; ++ctx.instruction_idx) vsir_validate_instruction(&ctx);

ctx.invalid_instruction_idx = true; diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index e8068f3a3..12fa19795 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -9696,8 +9696,8 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, if (parser->shader_desc.block_count && !spirv_compiler_init_blocks(compiler, parser->shader_desc.block_count)) return VKD3D_ERROR_OUT_OF_MEMORY;

- instructions = parser->instructions; - memset(&parser->instructions, 0, sizeof(parser->instructions)); + instructions = parser->program.instructions; + memset(&parser->program.instructions, 0, sizeof(parser->program.instructions));

compiler->input_signature = shader_desc->input_signature; compiler->output_signature = shader_desc->output_signature; diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index e4dfb5235..671d5e7d2 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -796,7 +796,7 @@ static void shader_sm4_read_shader_data(struct vkd3d_shader_instruction *ins, ui icb->element_count = icb_size / VKD3D_VEC4_SIZE; icb->is_null = false; memcpy(icb->data, tokens, sizeof(*tokens) * icb_size); - shader_instruction_array_add_icb(&priv->p.instructions, icb); + shader_instruction_array_add_icb(&priv->p.program.instructions, icb); ins->declaration.icb = icb; }

@@ -1732,7 +1732,7 @@ static void shader_sm4_destroy(struct vkd3d_shader_parser *parser) { struct vkd3d_shader_sm4_parser *sm4 = vkd3d_shader_sm4_parser(parser);

- shader_instruction_array_destroy(&parser->instructions); + vsir_program_cleanup(&parser->program); free_shader_desc(&parser->shader_desc); vkd3d_free(sm4); } @@ -2676,7 +2676,7 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi return VKD3D_ERROR_INVALID_SHADER; }

- instructions = &sm4->p.instructions; + instructions = &sm4->p.program.instructions; while (sm4->ptr != sm4->end) { if (!shader_instruction_array_reserve(instructions, instructions->count + 1)) diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 31d4fc69e..dbcc22fc7 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -542,7 +542,7 @@ bool vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser, parser->shader_version = *version; parser->ops = ops; parser->config_flags = vkd3d_shader_init_config_flags(); - return shader_instruction_array_init(&parser->instructions, instruction_reserve); + return vsir_program_init(&parser->program, instruction_reserve); }

void VKD3D_PRINTF_FUNC(3, 4) vkd3d_shader_parser_error(struct vkd3d_shader_parser *parser, @@ -1406,13 +1406,11 @@ static int scan_with_parser(const struct vkd3d_shader_compile_info *compile_info descriptor_info1, combined_sampler_info, message_context);

if (TRACE_ON()) - { - vkd3d_shader_trace(&parser->instructions, &parser->shader_version); - } + vkd3d_shader_trace(&parser->program.instructions, &parser->shader_version);

- for (i = 0; i < parser->instructions.count; ++i) + for (i = 0; i < parser->program.instructions.count; ++i) { - instruction = &parser->instructions.elements[i]; + instruction = &parser->program.instructions.elements[i]; if ((ret = vkd3d_shader_scan_instruction(&context, instruction)) < 0) break; } @@ -1585,7 +1583,8 @@ static int vkd3d_shader_parser_compile(struct vkd3d_shader_parser *parser, switch (compile_info->target_type) { case VKD3D_SHADER_TARGET_D3D_ASM: - ret = vkd3d_dxbc_binary_to_text(&parser->instructions, &parser->shader_version, compile_info, out, VSIR_ASM_D3D); + ret = vkd3d_dxbc_binary_to_text(&parser->program.instructions, + &parser->shader_version, compile_info, out, VSIR_ASM_D3D); break;

case VKD3D_SHADER_TARGET_GLSL: @@ -1599,7 +1598,7 @@ static int vkd3d_shader_parser_compile(struct vkd3d_shader_parser *parser, return VKD3D_ERROR; }

- ret = vkd3d_glsl_generator_generate(glsl_generator, parser, out); + ret = vkd3d_glsl_generator_generate(glsl_generator, &parser->program, out); vkd3d_glsl_generator_destroy(glsl_generator); vkd3d_shader_free_scan_descriptor_info1(&scan_descriptor_info); break; diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index c801d1187..1180b166c 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -1264,6 +1264,14 @@ enum vkd3d_shader_config_flags VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION = 0x00000001, };

+struct vsir_program +{ + struct vkd3d_shader_instruction_array instructions; +}; + +bool vsir_program_init(struct vsir_program *program, unsigned int reserve); +void vsir_program_cleanup(struct vsir_program *program); + struct vkd3d_shader_parser { struct vkd3d_shader_message_context *message_context; @@ -1273,7 +1281,7 @@ struct vkd3d_shader_parser struct vkd3d_shader_desc shader_desc; struct vkd3d_shader_version shader_version; const struct vkd3d_shader_parser_ops *ops; - struct vkd3d_shader_instruction_array instructions; + struct vsir_program program;

uint64_t config_flags; }; @@ -1295,13 +1303,13 @@ void vkd3d_shader_parser_warning(struct vkd3d_shader_parser *parser, static inline struct vkd3d_shader_dst_param *shader_parser_get_dst_params( struct vkd3d_shader_parser *parser, unsigned int count) { - return shader_dst_param_allocator_get(&parser->instructions.dst_params, count); + return shader_dst_param_allocator_get(&parser->program.instructions.dst_params, count); }

static inline struct vkd3d_shader_src_param *shader_parser_get_src_params( struct vkd3d_shader_parser *parser, unsigned int count) { - return shader_src_param_allocator_get(&parser->instructions.src_params, count); + return shader_src_param_allocator_get(&parser->program.instructions.src_params, count); }

static inline void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser) @@ -1455,7 +1463,7 @@ struct vkd3d_glsl_generator; struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shader_version *version, struct vkd3d_shader_message_context *message_context, const struct vkd3d_shader_location *location); int vkd3d_glsl_generator_generate(struct vkd3d_glsl_generator *generator, - struct vkd3d_shader_parser *parser, struct vkd3d_shader_code *out); + struct vsir_program *program, struct vkd3d_shader_code *out); void vkd3d_glsl_generator_destroy(struct vkd3d_glsl_generator *generator);

#define SPIRV_MAX_SRC_COUNT 6

-- GitLab https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/585

Henri Verbeet

7:50 p.m.

New subject: [PATCH 2/5] vkd3d-shader/ir: Store the shader version in struct vsir_program.

From: Henri Verbeet hverbeet@codeweavers.com

--- libs/vkd3d-shader/d3d_asm.c | 14 +++++----- libs/vkd3d-shader/d3dbc.c | 30 ++++++++++---------- libs/vkd3d-shader/dxil.c | 4 +-- libs/vkd3d-shader/ir.c | 35 ++++++++++++++---------- libs/vkd3d-shader/spirv.c | 2 +- libs/vkd3d-shader/tpf.c | 9 +++--- libs/vkd3d-shader/vkd3d_shader_main.c | 12 ++++---- libs/vkd3d-shader/vkd3d_shader_private.h | 11 ++++---- 8 files changed, 61 insertions(+), 56 deletions(-)

diff --git a/libs/vkd3d-shader/d3d_asm.c b/libs/vkd3d-shader/d3d_asm.c index 412b8f29c..d9751945d 100644 --- a/libs/vkd3d-shader/d3d_asm.c +++ b/libs/vkd3d-shader/d3d_asm.c @@ -2017,10 +2017,11 @@ static void shader_dump_instruction(struct vkd3d_d3d_asm_compiler *compiler, shader_addline(buffer, "\n"); }

-enum vkd3d_result vkd3d_dxbc_binary_to_text(const struct vkd3d_shader_instruction_array *instructions, - const struct vkd3d_shader_version *shader_version, const struct vkd3d_shader_compile_info *compile_info, +enum vkd3d_result vkd3d_dxbc_binary_to_text(const struct vsir_program *program, + const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, enum vsir_asm_dialect dialect) { + const struct vkd3d_shader_version *shader_version = &program->shader_version; enum vkd3d_shader_compile_option_formatting_flags formatting; struct vkd3d_d3d_asm_compiler compiler = { @@ -2089,9 +2090,9 @@ enum vkd3d_result vkd3d_dxbc_binary_to_text(const struct vkd3d_shader_instructio shader_version->minor, compiler.colours.reset);

indent = 0; - for (i = 0; i < instructions->count; ++i) + for (i = 0; i < program->instructions.count; ++i) { - struct vkd3d_shader_instruction *ins = &instructions->elements[i]; + struct vkd3d_shader_instruction *ins = &program->instructions.elements[i];

switch (ins->handler_idx) { @@ -2145,13 +2146,12 @@ enum vkd3d_result vkd3d_dxbc_binary_to_text(const struct vkd3d_shader_instructio return result; }

-void vkd3d_shader_trace(const struct vkd3d_shader_instruction_array *instructions, - const struct vkd3d_shader_version *shader_version) +void vkd3d_shader_trace(const struct vsir_program *program) { const char *p, *q, *end; struct vkd3d_shader_code code;

- if (vkd3d_dxbc_binary_to_text(instructions, shader_version, NULL, &code, VSIR_ASM_VSIR) != VKD3D_OK) + if (vkd3d_dxbc_binary_to_text(program, NULL, &code, VSIR_ASM_VSIR) != VKD3D_OK) return;

end = (const char *)code.code + code.size; diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 717419133..8896a36e9 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -414,6 +414,7 @@ static bool has_relative_address(uint32_t param) static const struct vkd3d_sm1_opcode_info *shader_sm1_get_opcode_info( const struct vkd3d_shader_sm1_parser *sm1, enum vkd3d_sm1_opcode opcode) { + const struct vkd3d_shader_version *version = &sm1->p.program.shader_version; const struct vkd3d_sm1_opcode_info *info; unsigned int i = 0;

@@ -424,8 +425,8 @@ static const struct vkd3d_sm1_opcode_info *shader_sm1_get_opcode_info( return NULL;

if (opcode == info->sm1_opcode - && vkd3d_shader_ver_ge(&sm1->p.shader_version, info->min_version.major, info->min_version.minor) - && (vkd3d_shader_ver_le(&sm1->p.shader_version, info->max_version.major, info->max_version.minor) + && vkd3d_shader_ver_ge(version, info->min_version.major, info->min_version.minor) + && (vkd3d_shader_ver_le(version, info->max_version.major, info->max_version.minor) || !info->max_version.major)) return info; } @@ -567,7 +568,7 @@ static bool add_signature_element(struct vkd3d_shader_sm1_parser *sm1, bool outp element->register_count = 1; element->mask = mask; element->used_mask = is_dcl ? 0 : mask; - if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL && !output) + if (sm1->p.program.shader_version.type == VKD3D_SHADER_TYPE_PIXEL && !output) element->interpolation_mode = VKD3DSIM_LINEAR;

return true; @@ -597,20 +598,20 @@ static void add_signature_mask(struct vkd3d_shader_sm1_parser *sm1, bool output, static bool add_signature_element_from_register(struct vkd3d_shader_sm1_parser *sm1, const struct vkd3d_shader_register *reg, bool is_dcl, unsigned int mask) { + const struct vkd3d_shader_version *version = &sm1->p.program.shader_version; unsigned int register_index = reg->idx[0].offset;

switch (reg->type) { case VKD3DSPR_TEMP: - if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL - && sm1->p.shader_version.major == 1 && !register_index) + if (version->type == VKD3D_SHADER_TYPE_PIXEL && version->major == 1 && !register_index) return add_signature_element(sm1, true, "COLOR", 0, VKD3D_SHADER_SV_TARGET, 0, is_dcl, mask); return true;

case VKD3DSPR_INPUT: /* For vertex shaders or sm3 pixel shaders, we should have already * had a DCL instruction. Otherwise, this is a colour input. */ - if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_VERTEX || sm1->p.shader_version.major == 3) + if (version->type == VKD3D_SHADER_TYPE_VERTEX || version->major == 3) { add_signature_mask(sm1, false, register_index, mask); return true; @@ -620,19 +621,19 @@ static bool add_signature_element_from_register(struct vkd3d_shader_sm1_parser *

case VKD3DSPR_TEXTURE: /* For vertex shaders, this is ADDR. */ - if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_VERTEX) + if (version->type == VKD3D_SHADER_TYPE_VERTEX) return true; return add_signature_element(sm1, false, "TEXCOORD", register_index, VKD3D_SHADER_SV_NONE, register_index, is_dcl, mask);

case VKD3DSPR_OUTPUT: - if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_VERTEX) + if (version->type == VKD3D_SHADER_TYPE_VERTEX) { /* For sm < 2 vertex shaders, this is TEXCRDOUT. * * For sm3 vertex shaders, this is OUTPUT, but we already * should have had a DCL instruction. */ - if (sm1->p.shader_version.major == 3) + if (version->major == 3) { add_signature_mask(sm1, true, register_index, mask); return true; @@ -700,6 +701,7 @@ static bool add_signature_element_from_register(struct vkd3d_shader_sm1_parser * static bool add_signature_element_from_semantic(struct vkd3d_shader_sm1_parser *sm1, const struct vkd3d_shader_semantic *semantic) { + const struct vkd3d_shader_version *version = &sm1->p.program.shader_version; const struct vkd3d_shader_register *reg = &semantic->resource.reg.reg; enum vkd3d_shader_sysval_semantic sysval = VKD3D_SHADER_SV_NONE; unsigned int mask = semantic->resource.reg.write_mask; @@ -731,13 +733,13 @@ static bool add_signature_element_from_semantic(struct vkd3d_shader_sm1_parser * return add_signature_element_from_register(sm1, reg, true, mask);

/* sm2 pixel shaders use DCL but don't provide a semantic. */ - if (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_PIXEL && sm1->p.shader_version.major == 2) + if (version->type == VKD3D_SHADER_TYPE_PIXEL && version->major == 2) return add_signature_element_from_register(sm1, reg, true, mask);

/* 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 (sm1->p.shader_version.type == VKD3D_SHADER_TYPE_VERTEX + if (version->type == VKD3D_SHADER_TYPE_VERTEX && output && semantic->usage == VKD3D_DECL_USAGE_POSITION) sysval = VKD3D_SHADER_SV_POSITION;

@@ -824,7 +826,7 @@ static void shader_sm1_read_param(struct vkd3d_shader_sm1_parser *sm1, * VS >= 2.0 have relative addressing (with token) * VS >= 1.0 < 2.0 have relative addressing (without token) * The version check below should work in general. */ - if (sm1->p.shader_version.major < 2) + if (sm1->p.program.shader_version.major < 2) { *addr_token = (1u << 31) | ((VKD3DSPR_ADDR << VKD3D_SM1_REGISTER_TYPE_SHIFT2) & VKD3D_SM1_REGISTER_TYPE_MASK2) @@ -853,7 +855,7 @@ static void shader_sm1_skip_opcode(const struct vkd3d_shader_sm1_parser *sm1, co /* Version 2.0+ shaders may contain address tokens, but fortunately they * have a useful length mask - use it here. Version 1.x shaders contain no * such tokens. */ - if (sm1->p.shader_version.major >= 2) + if (sm1->p.program.shader_version.major >= 2) { length = (opcode_token & VKD3D_SM1_INSTRUCTION_LENGTH_MASK) >> VKD3D_SM1_INSTRUCTION_LENGTH_SHIFT; *ptr += length; @@ -1109,7 +1111,7 @@ static void shader_sm1_read_instruction(struct vkd3d_shader_sm1_parser *sm1, str vkd3d_shader_parser_error(&sm1->p, VKD3D_SHADER_ERROR_D3DBC_INVALID_OPCODE, "Invalid opcode %#x (token 0x%08x, shader version %u.%u).", opcode_token & VKD3D_SM1_OPCODE_MASK, opcode_token, - sm1->p.shader_version.major, sm1->p.shader_version.minor); + sm1->p.program.shader_version.major, sm1->p.program.shader_version.minor); goto fail; }

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index 7f0972145..5133c0e08 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -6240,9 +6240,9 @@ static enum vkd3d_result sm6_parser_emit_thread_group(struct sm6_parser *sm6, co unsigned int group_sizes[3]; unsigned int i;

- if (sm6->p.shader_version.type != VKD3D_SHADER_TYPE_COMPUTE) + if (sm6->p.program.shader_version.type != VKD3D_SHADER_TYPE_COMPUTE) { - WARN("Shader of type %#x has thread group dimensions.\n", sm6->p.shader_version.type); + WARN("Shader of type %#x has thread group dimensions.\n", sm6->p.program.shader_version.type); vkd3d_shader_parser_error(&sm6->p, VKD3D_SHADER_ERROR_DXIL_INVALID_PROPERTIES, "Shader has thread group dimensions but is not a compute shader."); return VKD3D_ERROR_INVALID_SHADER; diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 2264138a4..8be142916 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -18,8 +18,9 @@

#include "vkd3d_shader_private.h"

-bool vsir_program_init(struct vsir_program *program, unsigned int reserve) +bool vsir_program_init(struct vsir_program *program, const struct vkd3d_shader_version *version, unsigned int reserve) { + program->shader_version = *version; return shader_instruction_array_init(&program->instructions, reserve); }

@@ -1245,8 +1246,8 @@ static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parse unsigned int i, j;

normaliser.phase = VKD3DSIH_INVALID; - normaliser.shader_type = parser->shader_version.type; - normaliser.major = parser->shader_version.major; + normaliser.shader_type = parser->program.shader_version.type; + normaliser.major = parser->program.shader_version.major; normaliser.input_signature = &parser->shader_desc.input_signature; normaliser.output_signature = &parser->shader_desc.output_signature; normaliser.patch_constant_signature = &parser->shader_desc.patch_constant_signature; @@ -1878,11 +1879,12 @@ static enum vkd3d_result cf_flattener_iterate_instruction_array(struct cf_flatte bool main_block_open, is_hull_shader, after_declarations_section; struct vkd3d_shader_parser *parser = flattener->parser; struct vkd3d_shader_instruction_array *instructions; + struct vsir_program *program = &parser->program; struct vkd3d_shader_instruction *dst_ins; size_t i;

- instructions = &parser->program.instructions; - is_hull_shader = parser->shader_version.type == VKD3D_SHADER_TYPE_HULL; + instructions = &program->instructions; + is_hull_shader = program->shader_version.type == VKD3D_SHADER_TYPE_HULL; main_block_open = !is_hull_shader; after_declarations_section = is_hull_shader;

@@ -2257,11 +2259,11 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, if (parser->shader_desc.is_dxil) return result;

- if (parser->shader_version.type != VKD3D_SHADER_TYPE_PIXEL + if (parser->program.shader_version.type != VKD3D_SHADER_TYPE_PIXEL && (result = remap_output_signature(parser, compile_info)) < 0) return result;

- if (parser->shader_version.type == VKD3D_SHADER_TYPE_HULL + if (parser->program.shader_version.type == VKD3D_SHADER_TYPE_HULL && (result = instruction_array_flatten_hull_shader_phases(instructions)) >= 0) { result = instruction_array_normalise_hull_shader_control_point_io(instructions, @@ -2283,7 +2285,7 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, result = normalise_combined_samplers(parser);

if (result >= 0 && TRACE_ON()) - vkd3d_shader_trace(instructions, &parser->shader_version); + vkd3d_shader_trace(&parser->program);

if (result >= 0 && !parser->failed) result = vsir_validate(parser); @@ -2297,6 +2299,7 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser, struct validation_context { struct vkd3d_shader_parser *parser; + const struct vsir_program *program; size_t instruction_idx; bool invalid_instruction_idx; bool dcl_temps_found; @@ -2364,7 +2367,7 @@ static void vsir_validate_register(struct validation_context *ctx, unsigned int i, temp_count = ctx->temp_count;

/* SM1-3 shaders do not include a DCL_TEMPS instruction. */ - if (ctx->parser->shader_version.major <= 3) + if (ctx->program->shader_version.major <= 3) temp_count = ctx->parser->shader_desc.temp_count;

if (reg->type >= VKD3DSPR_COUNT) @@ -2712,10 +2715,11 @@ static void vsir_validate_cf_type(struct validation_context *ctx,

static void vsir_validate_instruction(struct validation_context *ctx) { + const struct vkd3d_shader_version *version = &ctx->program->shader_version; const struct vkd3d_shader_instruction *instruction; size_t i;

- instruction = &ctx->parser->program.instructions.elements[ctx->instruction_idx]; + instruction = &ctx->program->instructions.elements[ctx->instruction_idx]; ctx->parser->location = instruction->location;

for (i = 0; i < instruction->dst_count; ++i) @@ -2738,7 +2742,7 @@ static void vsir_validate_instruction(struct validation_context *ctx) case VKD3DSIH_HS_JOIN_PHASE: vsir_validate_dst_count(ctx, instruction, 0); vsir_validate_src_count(ctx, instruction, 0); - if (ctx->parser->shader_version.type != VKD3D_SHADER_TYPE_HULL) + if (version->type != VKD3D_SHADER_TYPE_HULL) validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER, "Phase instruction %#x is only valid in a hull shader.", instruction->handler_idx); if (ctx->depth != 0) @@ -2753,9 +2757,9 @@ static void vsir_validate_instruction(struct validation_context *ctx) break; }

- if (ctx->parser->shader_version.type == VKD3D_SHADER_TYPE_HULL && - ctx->phase == VKD3DSIH_INVALID) - validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER, "Instruction %#x appear before any phase instruction in a hull shader.", + if (version->type == VKD3D_SHADER_TYPE_HULL && ctx->phase == VKD3DSIH_INVALID) + validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER, + "Instruction %#x appear before any phase instruction in a hull shader.", instruction->handler_idx);

/* We support two different control flow types in shaders: @@ -2830,7 +2834,7 @@ static void vsir_validate_instruction(struct validation_context *ctx) case VKD3DSIH_LOOP: vsir_validate_cf_type(ctx, instruction, CF_TYPE_STRUCTURED); vsir_validate_dst_count(ctx, instruction, 0); - vsir_validate_src_count(ctx, instruction, ctx->parser->shader_version.major <= 3 ? 2 : 0); + vsir_validate_src_count(ctx, instruction, version->major <= 3 ? 2 : 0); if (!vkd3d_array_reserve((void **)&ctx->blocks, &ctx->blocks_capacity, ctx->depth + 1, sizeof(*ctx->blocks))) return; ctx->blocks[ctx->depth++] = instruction->handler_idx; @@ -2991,6 +2995,7 @@ enum vkd3d_result vsir_validate(struct vkd3d_shader_parser *parser) struct validation_context ctx = { .parser = parser, + .program = &parser->program, .phase = VKD3DSIH_INVALID, }; unsigned int i; diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 12fa19795..3d3ee96ef 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -9807,7 +9807,7 @@ int spirv_compile(struct vkd3d_shader_parser *parser, struct spirv_compiler *spirv_compiler; int ret;

- if (!(spirv_compiler = spirv_compiler_create(&parser->shader_version, &parser->shader_desc, + if (!(spirv_compiler = spirv_compiler_create(&parser->program.shader_version, &parser->shader_desc, compile_info, scan_descriptor_info, message_context, &parser->location, parser->config_flags))) { ERR("Failed to create SPIR-V compiler.\n"); diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index 671d5e7d2..729e2cfe5 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -711,7 +711,7 @@ static struct vkd3d_shader_sm4_parser *vkd3d_shader_sm4_parser(struct vkd3d_shad

static bool shader_is_sm_5_1(const struct vkd3d_shader_sm4_parser *sm4) { - const struct vkd3d_shader_version *version = &sm4->p.shader_version; + const struct vkd3d_shader_version *version = &sm4->p.program.shader_version;

return version->major >= 5 && version->minor >= 1; } @@ -2020,7 +2020,7 @@ static bool register_is_control_point_input(const struct vkd3d_shader_register * { return reg->type == VKD3DSPR_INCONTROLPOINT || reg->type == VKD3DSPR_OUTCONTROLPOINT || (reg->type == VKD3DSPR_INPUT && (priv->phase == VKD3DSIH_HS_CONTROL_POINT_PHASE - || priv->p.shader_version.type == VKD3D_SHADER_TYPE_GEOMETRY)); + || priv->p.program.shader_version.type == VKD3D_SHADER_TYPE_GEOMETRY)); }

static uint32_t mask_from_swizzle(uint32_t swizzle) @@ -2662,7 +2662,7 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi /* DXBC stores used masks inverted for output signatures, for some reason. * We return them un-inverted. */ uninvert_used_masks(&shader_desc->output_signature); - if (sm4->p.shader_version.type == VKD3D_SHADER_TYPE_HULL) + if (sm4->p.program.shader_version.type == VKD3D_SHADER_TYPE_HULL) uninvert_used_masks(&shader_desc->patch_constant_signature);

if (!shader_sm4_parser_validate_signature(sm4, &shader_desc->input_signature, @@ -2697,7 +2697,8 @@ int vkd3d_shader_sm4_parser_create(const struct vkd3d_shader_compile_info *compi } ++instructions->count; } - if (sm4->p.shader_version.type == VKD3D_SHADER_TYPE_HULL && !sm4->has_control_point_phase && !sm4->p.failed) + if (sm4->p.program.shader_version.type == VKD3D_SHADER_TYPE_HULL + && !sm4->has_control_point_phase && !sm4->p.failed) shader_sm4_validate_default_phase_index_ranges(sm4);

if (!sm4->p.failed) diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index dbcc22fc7..459aac5aa 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -539,10 +539,9 @@ bool vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser, parser->location.source_name = source_name; parser->location.line = 1; parser->location.column = 0; - parser->shader_version = *version; parser->ops = ops; parser->config_flags = vkd3d_shader_init_config_flags(); - return vsir_program_init(&parser->program, instruction_reserve); + return vsir_program_init(&parser->program, version, instruction_reserve); }

void VKD3D_PRINTF_FUNC(3, 4) vkd3d_shader_parser_error(struct vkd3d_shader_parser *parser, @@ -1402,11 +1401,11 @@ static int scan_with_parser(const struct vkd3d_shader_compile_info *compile_info descriptor_info1 = &local_descriptor_info1; }

- vkd3d_shader_scan_context_init(&context, &parser->shader_version, compile_info, + vkd3d_shader_scan_context_init(&context, &parser->program.shader_version, compile_info, descriptor_info1, combined_sampler_info, message_context);

if (TRACE_ON()) - vkd3d_shader_trace(&parser->program.instructions, &parser->shader_version); + vkd3d_shader_trace(&parser->program);

for (i = 0; i < parser->program.instructions.count; ++i) { @@ -1583,14 +1582,13 @@ static int vkd3d_shader_parser_compile(struct vkd3d_shader_parser *parser, switch (compile_info->target_type) { case VKD3D_SHADER_TARGET_D3D_ASM: - ret = vkd3d_dxbc_binary_to_text(&parser->program.instructions, - &parser->shader_version, compile_info, out, VSIR_ASM_D3D); + ret = vkd3d_dxbc_binary_to_text(&parser->program, compile_info, out, VSIR_ASM_D3D); break;

case VKD3D_SHADER_TARGET_GLSL: if ((ret = scan_with_parser(&scan_info, message_context, &scan_descriptor_info, parser)) < 0) return ret; - if (!(glsl_generator = vkd3d_glsl_generator_create(&parser->shader_version, + if (!(glsl_generator = vkd3d_glsl_generator_create(&parser->program.shader_version, message_context, &parser->location))) { ERR("Failed to create GLSL generator.\n"); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 1180b166c..8e5c5216a 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -1266,10 +1266,11 @@ enum vkd3d_shader_config_flags

struct vsir_program { + struct vkd3d_shader_version shader_version; struct vkd3d_shader_instruction_array instructions; };

-bool vsir_program_init(struct vsir_program *program, unsigned int reserve); +bool vsir_program_init(struct vsir_program *program, const struct vkd3d_shader_version *version, unsigned int reserve); void vsir_program_cleanup(struct vsir_program *program);

struct vkd3d_shader_parser @@ -1279,7 +1280,6 @@ struct vkd3d_shader_parser bool failed;

struct vkd3d_shader_desc shader_desc; - struct vkd3d_shader_version shader_version; const struct vkd3d_shader_parser_ops *ops; struct vsir_program program;

@@ -1338,8 +1338,7 @@ struct vkd3d_shader_scan_descriptor_info1 unsigned int descriptor_count; };

-void vkd3d_shader_trace(const struct vkd3d_shader_instruction_array *instructions, - const struct vkd3d_shader_version *shader_version); +void vkd3d_shader_trace(const struct vsir_program *program);

const char *shader_get_type_prefix(enum vkd3d_shader_type type);

@@ -1361,8 +1360,8 @@ enum vsir_asm_dialect VSIR_ASM_D3D, };

-enum vkd3d_result vkd3d_dxbc_binary_to_text(const struct vkd3d_shader_instruction_array *instructions, - const struct vkd3d_shader_version *shader_version, const struct vkd3d_shader_compile_info *compile_info, +enum vkd3d_result vkd3d_dxbc_binary_to_text(const struct vsir_program *program, + const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, enum vsir_asm_dialect dialect); void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer); struct vkd3d_string_buffer *vkd3d_string_buffer_get(struct vkd3d_string_buffer_cache *list);

-- GitLab https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/585

Henri Verbeet

7:50 p.m.

New subject: [PATCH 3/5] vkd3d-shader/ir: Store the "use_vocp" field in struct vsir_program.

From: Henri Verbeet hverbeet@codeweavers.com

--- libs/vkd3d-shader/ir.c | 15 ++++++++------- libs/vkd3d-shader/spirv.c | 7 ++++--- libs/vkd3d-shader/vkd3d_shader_private.h | 4 ++-- 3 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 8be142916..48ac2a8e8 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -1241,20 +1241,21 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parser *parser) { struct io_normaliser normaliser = {parser->program.instructions}; + struct vsir_program *program = &parser->program; struct vkd3d_shader_instruction *ins; bool has_control_point_phase; unsigned int i, j;

normaliser.phase = VKD3DSIH_INVALID; - normaliser.shader_type = parser->program.shader_version.type; - normaliser.major = parser->program.shader_version.major; + normaliser.shader_type = program->shader_version.type; + normaliser.major = program->shader_version.major; normaliser.input_signature = &parser->shader_desc.input_signature; normaliser.output_signature = &parser->shader_desc.output_signature; normaliser.patch_constant_signature = &parser->shader_desc.patch_constant_signature;

- for (i = 0, has_control_point_phase = false; i < parser->program.instructions.count; ++i) + for (i = 0, has_control_point_phase = false; i < program->instructions.count; ++i) { - ins = &parser->program.instructions.elements[i]; + ins = &program->instructions.elements[i];

switch (ins->handler_idx) { @@ -1297,7 +1298,7 @@ static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parse || !shader_signature_merge(&parser->shader_desc.output_signature, normaliser.output_range_map, false) || !shader_signature_merge(&parser->shader_desc.patch_constant_signature, normaliser.pc_range_map, true)) { - parser->program.instructions = normaliser.instructions; + program->instructions = normaliser.instructions; return VKD3D_ERROR_OUT_OF_MEMORY; }

@@ -1305,8 +1306,8 @@ static enum vkd3d_result shader_normalise_io_registers(struct vkd3d_shader_parse for (i = 0; i < normaliser.instructions.count; ++i) shader_instruction_normalise_io_params(&normaliser.instructions.elements[i], &normaliser);

- parser->program.instructions = normaliser.instructions; - parser->shader_desc.use_vocp = normaliser.use_vocp; + program->instructions = normaliser.instructions; + program->use_vocp = normaliser.use_vocp; return VKD3D_OK; }

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 3d3ee96ef..e66d16b3d 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -9677,6 +9677,7 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; struct vkd3d_shader_desc *shader_desc = &parser->shader_desc; struct vkd3d_shader_instruction_array instructions; + struct vsir_program *program = &parser->program; enum vkd3d_result result = VKD3D_OK; unsigned int i;

@@ -9696,8 +9697,8 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, if (parser->shader_desc.block_count && !spirv_compiler_init_blocks(compiler, parser->shader_desc.block_count)) return VKD3D_ERROR_OUT_OF_MEMORY;

- instructions = parser->program.instructions; - memset(&parser->program.instructions, 0, sizeof(parser->program.instructions)); + instructions = program->instructions; + memset(&program->instructions, 0, sizeof(program->instructions));

compiler->input_signature = shader_desc->input_signature; compiler->output_signature = shader_desc->output_signature; @@ -9705,7 +9706,7 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, memset(&shader_desc->input_signature, 0, sizeof(shader_desc->input_signature)); memset(&shader_desc->output_signature, 0, sizeof(shader_desc->output_signature)); memset(&shader_desc->patch_constant_signature, 0, sizeof(shader_desc->patch_constant_signature)); - compiler->use_vocp = parser->shader_desc.use_vocp; + compiler->use_vocp = program->use_vocp; compiler->block_names = parser->shader_desc.block_names; compiler->block_name_count = parser->shader_desc.block_name_count;

diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 8e5c5216a..8075ef302 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -1031,8 +1031,6 @@ struct vkd3d_shader_desc uint32_t used, external; } flat_constant_count[3];

- bool use_vocp; - const char **block_names; size_t block_name_count; }; @@ -1268,6 +1266,8 @@ struct vsir_program { struct vkd3d_shader_version shader_version; struct vkd3d_shader_instruction_array instructions; + + bool use_vocp; };

bool vsir_program_init(struct vsir_program *program, const struct vkd3d_shader_version *version, unsigned int reserve);

-- GitLab https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/585

Henri Verbeet

7:50 p.m.

New subject: [PATCH 4/5] vkd3d-shader/ir: Store the SSA register count in struct vsir_program.

From: Henri Verbeet hverbeet@codeweavers.com

--- libs/vkd3d-shader/dxil.c | 2 +- libs/vkd3d-shader/ir.c | 15 ++++++++------- libs/vkd3d-shader/spirv.c | 4 ++-- libs/vkd3d-shader/vkd3d_shader_private.h | 2 +- 4 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index 5133c0e08..7e5f3b779 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -6771,7 +6771,7 @@ static enum vkd3d_result sm6_parser_init(struct sm6_parser *sm6, const uint32_t return VKD3D_ERROR_OUT_OF_MEMORY; }

- sm6->p.shader_desc.ssa_count = sm6->ssa_next_id; + sm6->p.program.ssa_count = sm6->ssa_next_id;

if (!(fn = sm6_parser_get_function(sm6, sm6->entry_point))) { diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 48ac2a8e8..aac10a0d4 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -2465,10 +2465,11 @@ static void vsir_validate_register(struct validation_context *ctx, if (reg->idx[0].rel_addr) validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX, "Non-NULL relative address for a SSA register.");

- if (reg->idx[0].offset >= ctx->parser->shader_desc.ssa_count) + if (reg->idx[0].offset >= ctx->program->ssa_count) { - validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX, "SSA register index %u exceeds the maximum count %u.", - reg->idx[0].offset, ctx->parser->shader_desc.ssa_count); + validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_INDEX, + "SSA register index %u exceeds the maximum count %u.", + reg->idx[0].offset, ctx->program->ssa_count); break; }

@@ -2600,7 +2601,7 @@ static void vsir_validate_dst_param(struct validation_context *ctx, dst->shift); }

- if (dst->reg.type == VKD3DSPR_SSA && dst->reg.idx[0].offset < ctx->parser->shader_desc.ssa_count) + if (dst->reg.type == VKD3DSPR_SSA && dst->reg.idx[0].offset < ctx->program->ssa_count) { struct validation_context_ssa_data *data = &ctx->ssas[dst->reg.idx[0].offset];

@@ -2635,7 +2636,7 @@ static void vsir_validate_src_param(struct validation_context *ctx, validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_MODIFIERS, "Source has invalid modifiers %#x.", src->modifiers);

- if (src->reg.type == VKD3DSPR_SSA && src->reg.idx[0].offset < ctx->parser->shader_desc.ssa_count) + if (src->reg.type == VKD3DSPR_SSA && src->reg.idx[0].offset < ctx->program->ssa_count) { struct validation_context_ssa_data *data = &ctx->ssas[src->reg.idx[0].offset]; unsigned int i; @@ -3007,7 +3008,7 @@ enum vkd3d_result vsir_validate(struct vkd3d_shader_parser *parser) if (!(ctx.temps = vkd3d_calloc(parser->shader_desc.temp_count, sizeof(*ctx.temps)))) goto fail;

- if (!(ctx.ssas = vkd3d_calloc(parser->shader_desc.ssa_count, sizeof(*ctx.ssas)))) + if (!(ctx.ssas = vkd3d_calloc(ctx.program->ssa_count, sizeof(*ctx.ssas)))) goto fail;

for (ctx.instruction_idx = 0; ctx.instruction_idx < parser->program.instructions.count; ++ctx.instruction_idx) @@ -3018,7 +3019,7 @@ enum vkd3d_result vsir_validate(struct vkd3d_shader_parser *parser) if (ctx.depth != 0) validator_error(&ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_CONTROL_FLOW, "%zu nested blocks were not closed.", ctx.depth);

- for (i = 0; i < parser->shader_desc.ssa_count; ++i) + for (i = 0; i < ctx.program->ssa_count; ++i) { struct validation_context_ssa_data *data = &ctx.ssas[i];

diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index e66d16b3d..2b6b26d04 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -9686,8 +9686,8 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler,

if (parser->shader_desc.temp_count) spirv_compiler_emit_temps(compiler, parser->shader_desc.temp_count); - if (parser->shader_desc.ssa_count) - spirv_compiler_allocate_ssa_register_ids(compiler, parser->shader_desc.ssa_count); + if (program->ssa_count) + spirv_compiler_allocate_ssa_register_ids(compiler, program->ssa_count);

spirv_compiler_emit_descriptor_declarations(compiler);

diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 8075ef302..d83628026 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -1023,7 +1023,6 @@ struct vkd3d_shader_desc unsigned int input_control_point_count, output_control_point_count;

uint32_t temp_count; - unsigned int ssa_count; unsigned int block_count;

struct @@ -1267,6 +1266,7 @@ struct vsir_program struct vkd3d_shader_version shader_version; struct vkd3d_shader_instruction_array instructions;

+ unsigned int ssa_count; bool use_vocp; };

-- GitLab https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/585

Henri Verbeet

7:50 p.m.

New subject: [PATCH 5/5] vkd3d-shader/ir: Store the temporary register count in struct vsir_program.

From: Henri Verbeet hverbeet@codeweavers.com

diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 8896a36e9..035095d5b 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -765,13 +765,13 @@ static void record_constant_register(struct vkd3d_shader_sm1_parser *sm1, static void shader_sm1_scan_register(struct vkd3d_shader_sm1_parser *sm1, const struct vkd3d_shader_register *reg, unsigned int mask, bool from_def) { - struct vkd3d_shader_desc *desc = &sm1->p.shader_desc; + struct vsir_program *program = &sm1->p.program; uint32_t register_index = reg->idx[0].offset;

switch (reg->type) { case VKD3DSPR_TEMP: - desc->temp_count = max(desc->temp_count, register_index + 1); + program->temp_count = max(program->temp_count, register_index + 1); break;

case VKD3DSPR_CONST: diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index aac10a0d4..a797e4930 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -2369,7 +2369,7 @@ static void vsir_validate_register(struct validation_context *ctx,

/* SM1-3 shaders do not include a DCL_TEMPS instruction. */ if (ctx->program->shader_version.major <= 3) - temp_count = ctx->parser->shader_desc.temp_count; + temp_count = ctx->program->temp_count;

if (reg->type >= VKD3DSPR_COUNT) validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_REGISTER_TYPE, "Invalid register type %#x.", @@ -2421,10 +2421,10 @@ static void vsir_validate_register(struct validation_context *ctx, break; }

- /* parser->shader_desc.temp_count might be smaller then - * temp_count if the parser made a mistake; we still don't - * want to overflow the array. */ - if (reg->idx[0].offset >= ctx->parser->shader_desc.temp_count) + /* program->temp_count might be smaller then temp_count if the + * parser made a mistake; we still don't want to overflow the + * array. */ + if (reg->idx[0].offset >= ctx->program->temp_count) break; data = &ctx->temps[reg->idx[0].offset];

@@ -2788,9 +2788,10 @@ static void vsir_validate_instruction(struct validation_context *ctx) vsir_validate_src_count(ctx, instruction, 0); if (ctx->dcl_temps_found) validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_DUPLICATE_DCL_TEMPS, "Duplicate DCL_TEMPS instruction."); - if (instruction->declaration.count > ctx->parser->shader_desc.temp_count) - validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_DCL_TEMPS, "Invalid DCL_TEMPS count %u, expected at most %u.", - instruction->declaration.count, ctx->parser->shader_desc.temp_count); + if (instruction->declaration.count > ctx->program->temp_count) + validator_error(ctx, VKD3D_SHADER_ERROR_VSIR_INVALID_DCL_TEMPS, + "Invalid DCL_TEMPS count %u, expected at most %u.", + instruction->declaration.count, ctx->program->temp_count); ctx->dcl_temps_found = true; ctx->temp_count = instruction->declaration.count; break; @@ -3005,7 +3006,7 @@ enum vkd3d_result vsir_validate(struct vkd3d_shader_parser *parser) if (!(parser->config_flags & VKD3D_SHADER_CONFIG_FLAG_FORCE_VALIDATION)) return VKD3D_OK;

- if (!(ctx.temps = vkd3d_calloc(parser->shader_desc.temp_count, sizeof(*ctx.temps)))) + if (!(ctx.temps = vkd3d_calloc(ctx.program->temp_count, sizeof(*ctx.temps)))) goto fail;

if (!(ctx.ssas = vkd3d_calloc(ctx.program->ssa_count, sizeof(*ctx.ssas)))) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 2b6b26d04..fa9bc83a3 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -9684,8 +9684,8 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, if ((result = vkd3d_shader_normalise(parser, compile_info)) < 0) return result;

- if (parser->shader_desc.temp_count) - spirv_compiler_emit_temps(compiler, parser->shader_desc.temp_count); + if (program->temp_count) + spirv_compiler_emit_temps(compiler, program->temp_count); if (program->ssa_count) spirv_compiler_allocate_ssa_register_ids(compiler, program->ssa_count);

diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index 729e2cfe5..ecd784842 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -1072,7 +1072,7 @@ static void shader_sm4_read_declaration_count(struct vkd3d_shader_instruction *i { ins->declaration.count = *tokens; if (opcode == VKD3D_SM4_OP_DCL_TEMPS) - priv->p.shader_desc.temp_count = max(priv->p.shader_desc.temp_count, *tokens); + priv->p.program.temp_count = max(priv->p.program.temp_count, *tokens); }

static void shader_sm4_read_declaration_dst(struct vkd3d_shader_instruction *ins, uint32_t opcode, diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index d83628026..79aef736c 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -1022,7 +1022,6 @@ struct vkd3d_shader_desc

unsigned int input_control_point_count, output_control_point_count;

- uint32_t temp_count; unsigned int block_count;

struct @@ -1266,6 +1265,7 @@ struct vsir_program struct vkd3d_shader_version shader_version; struct vkd3d_shader_instruction_array instructions;

+ unsigned int temp_count; unsigned int ssa_count; bool use_vocp; };

-- GitLab https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/585

383

Age (days ago)

383

Last active (days ago)

wine-gitlab@winehq.org

5 comments

2 participants

tags (0)

participants (2)

Henri Verbeet
Henri Verbeet (＠hverbeet)