This MR replaces `vkd3d_shader_register.immconst_type` with `vkd3d_shader_register.dimension` which is intended for all register types and not just immconsts.
This dimension is parsed in tpf.c, and initialized according to the register type in d3dbc.c.
Having this field in vkd3d_shader_register allows us to avoid hardcoding special cases for the register dimensions when writing sm4 bytecode (e.g. for the sampler src register in gather instructions). Also, it allows for some fixes to d3d_asm.c, which are introduced in part 2 (https://gitlab.winehq.org/fcasas/vkd3d/-/commits/add_vkd3d_reg_dim).
-- v4: vkd3d-shader/d3dbc: Initialize register dimension for all register types. vkd3d-shader/tpf: Parse register dimension for all register types. vkd3d-shader: Turn vkd3d_shader_register.immconst_type into vkd3d_shader_register.dimension. vkd3d-shader/tpf: Use vsir_register_init() in shader_sm1_parse_dst_param(). vkd3d-shader/tpf: Use vsir_register_init() in shader_sm1_parse_src_param(). vkd3d-shader/tpf: Use vsir_register_init() in shader_sm4_read_param(). vkd3d-shader/spirv: Use vsir_register_init() to initialize registers. vkd3d-shader/ir: Use vsir_register_init() in shader_register_normalise_flat_constants(). vkd3d-shader: Rename shader_register_init() to vsir_register_init().
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/dxil.c | 4 ++-- libs/vkd3d-shader/ir.c | 6 +++--- libs/vkd3d-shader/vkd3d_shader_private.h | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index 666d8b08..158e9fbd 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -2063,7 +2063,7 @@ static void dst_param_io_init(struct vkd3d_shader_dst_param *param, param->shift = 0; /* DXIL types do not have signedness. Load signed elements as unsigned. */ component_type = e->component_type == VKD3D_SHADER_COMPONENT_INT ? VKD3D_SHADER_COMPONENT_UINT : e->component_type; - shader_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(component_type), 0); + vsir_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(component_type), 0); }
static void sm6_parser_init_signature(struct sm6_parser *sm6, const struct shader_signature *s, @@ -2292,7 +2292,7 @@ static void sm6_parser_emit_unhandled(struct sm6_parser *sm6, struct vkd3d_shade return;
type = sm6_type_get_scalar_type(dst->type, 0); - shader_register_init(&dst->u.reg, VKD3DSPR_UNDEF, vkd3d_data_type_from_sm6_type(type), 0); + vsir_register_init(&dst->u.reg, VKD3DSPR_UNDEF, vkd3d_data_type_from_sm6_type(type), 0); /* dst->is_undefined is not set here because it flags only explicitly undefined values. */ }
diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 6d7c8965..2d727f80 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -296,7 +296,7 @@ static enum vkd3d_result flattener_flatten_phases(struct hull_flattener *normali return VKD3D_OK; }
-void shader_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, +void vsir_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, enum vkd3d_data_type data_type, unsigned int idx_count) { reg->type = reg_type; @@ -370,7 +370,7 @@ static struct vkd3d_shader_src_param *instruction_array_create_outpointid_param( if (!(rel_addr = shader_src_param_allocator_get(&instructions->src_params, 1))) return NULL;
- shader_register_init(&rel_addr->reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_UINT, 0); + vsir_register_init(&rel_addr->reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_UINT, 0); rel_addr->swizzle = 0; rel_addr->modifiers = 0;
@@ -400,7 +400,7 @@ static void shader_dst_param_io_init(struct vkd3d_shader_dst_param *param, const param->write_mask = e->mask; param->modifiers = 0; param->shift = 0; - shader_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count); + vsir_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count); }
static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_point_normaliser *normaliser, diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index eab1c730..982564a6 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -741,7 +741,7 @@ struct vkd3d_shader_register } u; };
-void shader_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, +void vsir_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_register_type reg_type, enum vkd3d_data_type data_type, unsigned int idx_count);
struct vkd3d_shader_dst_param
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/ir.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 2d727f80..39d6f96d 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -1205,8 +1205,7 @@ static void shader_register_normalise_flat_constants(struct vkd3d_shader_src_par { if (normaliser->defs[i].set == set && normaliser->defs[i].index == index) { - param->reg.type = VKD3DSPR_IMMCONST; - param->reg.idx_count = 0; + vsir_register_init(¶m->reg, VKD3DSPR_IMMCONST, 0, 0); param->reg.immconst_type = VKD3D_IMMCONST_VEC4; for (j = 0; j < 4; ++j) param->reg.u.immconst_uint[j] = normaliser->defs[i].value[j]; @@ -1214,11 +1213,10 @@ static void shader_register_normalise_flat_constants(struct vkd3d_shader_src_par } }
- param->reg.type = VKD3DSPR_CONSTBUFFER; + vsir_register_init(¶m->reg, VKD3DSPR_CONSTBUFFER, 0, 3); param->reg.idx[0].offset = set; /* register ID */ param->reg.idx[1].offset = set; /* register index */ param->reg.idx[2].offset = index; /* buffer index */ - param->reg.idx_count = 3; }
static enum vkd3d_result instruction_array_normalise_flat_constants(struct vkd3d_shader_parser *parser)
From: Francisco Casas fcasas@codeweavers.com
---
Since spirv.c only consumes vkd3d-shader IR, and doesn't output it, in most cases we don't care about the register's dimension or data_type, so I am just preserving the current initialization scheme for both fields. --- libs/vkd3d-shader/spirv.c | 61 +++++++++++---------------------------- 1 file changed, 17 insertions(+), 44 deletions(-)
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 95f6914a..31822dd1 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -4361,11 +4361,7 @@ static uint32_t spirv_compiler_get_invocation_id(struct spirv_compiler *compiler
assert(compiler->shader_type == VKD3D_SHADER_TYPE_HULL);
- memset(&r, 0, sizeof(r)); - r.type = VKD3DSPR_OUTPOINTID; - r.idx[0].offset = ~0u; - r.idx[1].offset = ~0u; - r.idx_count = 0; + vsir_register_init(&r, VKD3DSPR_OUTPOINTID, 0, 0); return spirv_compiler_get_register_id(compiler, &r); }
@@ -5262,10 +5258,7 @@ static void spirv_compiler_emit_hull_shader_builtins(struct spirv_compiler *comp struct vkd3d_shader_dst_param dst;
memset(&dst, 0, sizeof(dst)); - dst.reg.type = VKD3DSPR_OUTPOINTID; - dst.reg.idx[0].offset = ~0u; - dst.reg.idx[1].offset = ~0u; - dst.reg.idx_count = 0; + vsir_register_init(&dst.reg, VKD3DSPR_OUTPOINTID, 0, 0); dst.write_mask = VKD3DSP_WRITEMASK_0; spirv_compiler_emit_input_register(compiler, &dst); } @@ -5388,11 +5381,8 @@ static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compil if (temp->component_count != 4) FIXME("Unhandled component count %u.\n", temp->component_count);
- memset(®, 0, sizeof(reg)); - reg.type = VKD3DSPR_IDXTEMP; + vsir_register_init(®, VKD3DSPR_IDXTEMP, 0, 1); reg.idx[0].offset = temp->register_idx; - reg.idx[1].offset = ~0u; - reg.idx_count = 1;
function_location = spirv_compiler_get_current_function_location(compiler); vkd3d_spirv_begin_function_stream_insertion(builder, function_location); @@ -5571,15 +5561,12 @@ static void spirv_compiler_emit_cbv_declaration(struct spirv_compiler *compiler, const SpvStorageClass storage_class = SpvStorageClassUniform; struct vkd3d_push_constant_buffer_binding *push_cb; struct vkd3d_descriptor_variable_info var_info; + struct vkd3d_shader_register reg; struct vkd3d_symbol reg_symbol; unsigned int size;
- struct vkd3d_shader_register reg = - { - .type = VKD3DSPR_CONSTBUFFER, - .idx[0].offset = register_id, - .idx_count = 1, - }; + vsir_register_init(®, VKD3DSPR_CONSTBUFFER, 0, 1); + reg.idx[0].offset = register_id;
size = size_in_bytes / (VKD3D_VEC4_SIZE * sizeof(uint32_t));
@@ -5644,8 +5631,7 @@ static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compi vkd3d_spirv_build_op_name(builder, icb_id, "icb"); vkd3d_free(elements);
- memset(®, 0, sizeof(reg)); - reg.type = VKD3DSPR_IMMCONSTBUFFER; + vsir_register_init(®, VKD3DSPR_IMMCONSTBUFFER, 0, 0); vkd3d_symbol_make_register(®_symbol, ®); vkd3d_symbol_set_register_info(®_symbol, icb_id, SpvStorageClassPrivate, VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); @@ -5658,15 +5644,12 @@ static void spirv_compiler_emit_sampler_declaration(struct spirv_compiler *compi const SpvStorageClass storage_class = SpvStorageClassUniformConstant; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; struct vkd3d_descriptor_variable_info var_info; + struct vkd3d_shader_register reg; struct vkd3d_symbol reg_symbol; uint32_t type_id, var_id;
- const struct vkd3d_shader_register reg = - { - .type = VKD3DSPR_SAMPLER, - .idx[0].offset = register_id, - .idx_count = 1, - }; + vsir_register_init(®, VKD3DSPR_SAMPLER, 0, 1); + reg.idx[0].offset = register_id;
vkd3d_symbol_make_sampler(®_symbol, ®); reg_symbol.info.sampler.range = *range; @@ -5872,13 +5855,10 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp const struct vkd3d_spirv_resource_type *resource_type_info; enum vkd3d_shader_component_type sampled_type; struct vkd3d_symbol resource_symbol; + struct vkd3d_shader_register reg;
- struct vkd3d_shader_register reg = - { - .type = is_uav ? VKD3DSPR_UAV : VKD3DSPR_RESOURCE, - .idx[0].offset = register_id, - .idx_count = 1, - }; + vsir_register_init(®, is_uav ? VKD3DSPR_UAV : VKD3DSPR_RESOURCE, 0, 1); + reg.idx[0].offset = register_id;
if (resource_type == VKD3D_SHADER_RESOURCE_TEXTURE_2DMS && sample_count == 1) resource_type = VKD3D_SHADER_RESOURCE_TEXTURE_2D; @@ -6361,20 +6341,13 @@ static void spirv_compiler_emit_default_control_point_phase(struct spirv_compile invocation_id = spirv_compiler_emit_load_invocation_id(compiler);
memset(&invocation, 0, sizeof(invocation)); - invocation.reg.type = VKD3DSPR_OUTPOINTID; - invocation.reg.data_type = VKD3D_DATA_INT; - invocation.reg.idx[0].offset = ~0u; - invocation.reg.idx[1].offset = ~0u; - invocation.reg.idx[2].offset = ~0u; - invocation.reg.idx_count = 0; + vsir_register_init(&invocation.reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_INT, 0); invocation.swizzle = VKD3D_SHADER_NO_SWIZZLE;
- memset(&input_reg, 0, sizeof(input_reg)); - input_reg.type = VKD3DSPR_INPUT; - input_reg.data_type = VKD3D_DATA_FLOAT; + vsir_register_init(&input_reg, VKD3DSPR_INPUT, VKD3D_DATA_FLOAT, 2); + input_reg.idx[0].offset = 0; input_reg.idx[0].rel_addr = &invocation; - input_reg.idx[2].offset = ~0u; - input_reg.idx_count = 2; + input_reg.idx[1].offset = 0; input_id = spirv_compiler_get_register_id(compiler, &input_reg);
assert(input_signature->element_count == output_signature->element_count);
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/tpf.c | 29 ++++++++--------------------- 1 file changed, 8 insertions(+), 21 deletions(-)
diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index 7949be15..6ecebd09 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -1713,6 +1713,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui enum vkd3d_data_type data_type, struct vkd3d_shader_register *param, enum vkd3d_shader_src_modifier *modifier) { const struct vkd3d_sm4_register_type_info *register_type_info; + enum vkd3d_shader_register_type vsir_register_type; enum vkd3d_sm4_register_precision precision; enum vkd3d_sm4_register_type register_type; enum vkd3d_sm4_extended_operand_type type; @@ -1731,15 +1732,16 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui if (!register_type_info) { FIXME("Unhandled register type %#x.\n", register_type); - param->type = VKD3DSPR_TEMP; + vsir_register_type = VKD3DSPR_TEMP; } else { - param->type = register_type_info->vkd3d_type; + vsir_register_type = register_type_info->vkd3d_type; } + + vsir_register_init(param, vsir_register_type, data_type, 0); param->precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; param->non_uniform = false; - param->data_type = data_type;
*modifier = VKD3DSPSM_NONE; if (token & VKD3D_SM4_EXTENDED_OPERAND) @@ -1811,12 +1813,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui
order = (token & VKD3D_SM4_REGISTER_ORDER_MASK) >> VKD3D_SM4_REGISTER_ORDER_SHIFT;
- if (order < 1) - { - param->idx[0].offset = ~0u; - param->idx[0].rel_addr = NULL; - } - else + if (order >= 1) { DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK0) >> VKD3D_SM4_ADDRESSING_SHIFT0; if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, ¶m->idx[0]))) @@ -1826,12 +1823,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui } }
- if (order < 2) - { - param->idx[1].offset = ~0u; - param->idx[1].rel_addr = NULL; - } - else + if (order >= 2) { DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK1) >> VKD3D_SM4_ADDRESSING_SHIFT1; if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, ¶m->idx[1]))) @@ -1841,12 +1833,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui } }
- if (order < 3) - { - param->idx[2].offset = ~0u; - param->idx[2].rel_addr = NULL; - } - else + if (order >= 3) { DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK2) >> VKD3D_SM4_ADDRESSING_SHIFT2; if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, ¶m->idx[2])))
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/d3dbc.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)
diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 2b02d51f..1a9d9b2a 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -457,18 +457,14 @@ static uint32_t swizzle_from_sm1(uint32_t swizzle) static void shader_sm1_parse_src_param(uint32_t param, const struct vkd3d_shader_src_param *rel_addr, struct vkd3d_shader_src_param *src) { - src->reg.type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) + enum vkd3d_shader_register_type reg_type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) | ((param & VKD3D_SM1_REGISTER_TYPE_MASK2) >> VKD3D_SM1_REGISTER_TYPE_SHIFT2); + + vsir_register_init(&src->reg, reg_type, VKD3D_DATA_FLOAT, 1); src->reg.precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; src->reg.non_uniform = false; - src->reg.data_type = VKD3D_DATA_FLOAT; src->reg.idx[0].offset = param & VKD3D_SM1_REGISTER_NUMBER_MASK; src->reg.idx[0].rel_addr = rel_addr; - src->reg.idx[1].offset = ~0u; - src->reg.idx[1].rel_addr = NULL; - src->reg.idx[2].offset = ~0u; - src->reg.idx[2].rel_addr = NULL; - src->reg.idx_count = 1; src->swizzle = swizzle_from_sm1((param & VKD3D_SM1_SWIZZLE_MASK) >> VKD3D_SM1_SWIZZLE_SHIFT); src->modifiers = (param & VKD3D_SM1_SRC_MODIFIER_MASK) >> VKD3D_SM1_SRC_MODIFIER_SHIFT; }
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/d3dbc.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)
diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 1a9d9b2a..993e477f 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -472,18 +472,14 @@ static void shader_sm1_parse_src_param(uint32_t param, const struct vkd3d_shader static void shader_sm1_parse_dst_param(uint32_t param, const struct vkd3d_shader_src_param *rel_addr, struct vkd3d_shader_dst_param *dst) { - dst->reg.type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) + enum vkd3d_shader_register_type reg_type = ((param & VKD3D_SM1_REGISTER_TYPE_MASK) >> VKD3D_SM1_REGISTER_TYPE_SHIFT) | ((param & VKD3D_SM1_REGISTER_TYPE_MASK2) >> VKD3D_SM1_REGISTER_TYPE_SHIFT2); + + vsir_register_init(&dst->reg, reg_type, VKD3D_DATA_FLOAT, 1); dst->reg.precision = VKD3D_SHADER_REGISTER_PRECISION_DEFAULT; dst->reg.non_uniform = false; - dst->reg.data_type = VKD3D_DATA_FLOAT; dst->reg.idx[0].offset = param & VKD3D_SM1_REGISTER_NUMBER_MASK; dst->reg.idx[0].rel_addr = rel_addr; - dst->reg.idx[1].offset = ~0u; - dst->reg.idx[1].rel_addr = NULL; - dst->reg.idx[2].offset = ~0u; - dst->reg.idx[2].rel_addr = NULL; - dst->reg.idx_count = 1; dst->write_mask = (param & VKD3D_SM1_WRITEMASK_MASK) >> VKD3D_SM1_WRITEMASK_SHIFT; dst->modifiers = (param & VKD3D_SM1_DST_MODIFIER_MASK) >> VKD3D_SM1_DST_MODIFIER_SHIFT; dst->shift = (param & VKD3D_SM1_DSTSHIFT_MASK) >> VKD3D_SM1_DSTSHIFT_SHIFT;
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/d3d_asm.c | 16 ++++++++-------- libs/vkd3d-shader/d3dbc.c | 12 ++++++------ libs/vkd3d-shader/dxil.c | 4 ++-- libs/vkd3d-shader/ir.c | 6 +++--- libs/vkd3d-shader/spirv.c | 4 ++-- libs/vkd3d-shader/tpf.c | 4 ++-- libs/vkd3d-shader/vkd3d_shader_private.h | 9 +++++---- 7 files changed, 28 insertions(+), 27 deletions(-)
diff --git a/libs/vkd3d-shader/d3d_asm.c b/libs/vkd3d-shader/d3d_asm.c index d72402eb..38ded510 100644 --- a/libs/vkd3d-shader/d3d_asm.c +++ b/libs/vkd3d-shader/d3d_asm.c @@ -1074,9 +1074,9 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const if (reg->type == VKD3DSPR_IMMCONST) { shader_addline(buffer, "%s(", compiler->colours.reset); - switch (reg->immconst_type) + switch (reg->dimension) { - case VKD3D_IMMCONST_SCALAR: + case VKD3D_SHADER_DIMENSION_SCALAR: switch (reg->data_type) { case VKD3D_DATA_FLOAT: @@ -1096,7 +1096,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const } break;
- case VKD3D_IMMCONST_VEC4: + case VKD3D_SHADER_DIMENSION_VEC4: switch (reg->data_type) { case VKD3D_DATA_FLOAT: @@ -1126,7 +1126,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const break;
default: - shader_addline(buffer, "<unhandled immconst_type %#x>", reg->immconst_type); + shader_addline(buffer, "<unhandled immconst dimension %#x>", reg->dimension); break; } shader_addline(buffer, ")"); @@ -1134,13 +1134,13 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const else if (reg->type == VKD3DSPR_IMMCONST64) { shader_addline(buffer, "%s(", compiler->colours.reset); - /* A double2 vector is treated as a float4 vector in enum vkd3d_immconst_type. */ - if (reg->immconst_type == VKD3D_IMMCONST_SCALAR || reg->immconst_type == VKD3D_IMMCONST_VEC4) + /* A double2 vector is treated as a float4 vector in enum vkd3d_shader_dimension. */ + if (reg->dimension == VKD3D_SHADER_DIMENSION_SCALAR || reg->dimension == VKD3D_SHADER_DIMENSION_VEC4) { if (reg->data_type == VKD3D_DATA_DOUBLE) { shader_print_double_literal(compiler, "", reg->u.immconst_double[0], ""); - if (reg->immconst_type == VKD3D_IMMCONST_VEC4) + if (reg->dimension == VKD3D_SHADER_DIMENSION_VEC4) shader_print_double_literal(compiler, ", ", reg->u.immconst_double[1], ""); } else @@ -1150,7 +1150,7 @@ static void shader_dump_register(struct vkd3d_d3d_asm_compiler *compiler, const } else { - shader_addline(buffer, "<unhandled immconst_type %#x>", reg->immconst_type); + shader_addline(buffer, "<unhandled immconst64 dimension %#x>", reg->dimension); } shader_addline(buffer, ")"); } diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 993e477f..bfeebd60 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -943,9 +943,9 @@ static void shader_sm1_read_semantic(struct vkd3d_shader_sm1_parser *sm1, }
static void shader_sm1_read_immconst(struct vkd3d_shader_sm1_parser *sm1, const uint32_t **ptr, - struct vkd3d_shader_src_param *src_param, enum vkd3d_immconst_type type, enum vkd3d_data_type data_type) + struct vkd3d_shader_src_param *src_param, enum vkd3d_shader_dimension dimension, enum vkd3d_data_type data_type) { - unsigned int count = type == VKD3D_IMMCONST_VEC4 ? 4 : 1; + unsigned int count = dimension == VKD3D_SHADER_DIMENSION_VEC4 ? 4 : 1;
if (*ptr >= sm1->end || sm1->end - *ptr < count) { @@ -967,7 +967,7 @@ static void shader_sm1_read_immconst(struct vkd3d_shader_sm1_parser *sm1, const src_param->reg.idx[2].offset = ~0u; src_param->reg.idx[2].rel_addr = NULL; src_param->reg.idx_count = 0; - src_param->reg.immconst_type = type; + src_param->reg.dimension = dimension; memcpy(src_param->reg.u.immconst_uint, *ptr, count * sizeof(uint32_t)); src_param->swizzle = VKD3D_SHADER_NO_SWIZZLE; src_param->modifiers = 0; @@ -1124,19 +1124,19 @@ static void shader_sm1_read_instruction(struct vkd3d_shader_sm1_parser *sm1, str else if (ins->handler_idx == VKD3DSIH_DEF) { shader_sm1_read_dst_param(sm1, &p, dst_param); - shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_FLOAT); + shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_SHADER_DIMENSION_VEC4, VKD3D_DATA_FLOAT); shader_sm1_scan_register(sm1, &dst_param->reg, dst_param->write_mask, true); } else if (ins->handler_idx == VKD3DSIH_DEFB) { shader_sm1_read_dst_param(sm1, &p, dst_param); - shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_SCALAR, VKD3D_DATA_UINT); + shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_SHADER_DIMENSION_SCALAR, VKD3D_DATA_UINT); shader_sm1_scan_register(sm1, &dst_param->reg, dst_param->write_mask, true); } else if (ins->handler_idx == VKD3DSIH_DEFI) { shader_sm1_read_dst_param(sm1, &p, dst_param); - shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_IMMCONST_VEC4, VKD3D_DATA_INT); + shader_sm1_read_immconst(sm1, &p, &src_params[0], VKD3D_SHADER_DIMENSION_VEC4, VKD3D_DATA_INT); shader_sm1_scan_register(sm1, &dst_param->reg, dst_param->write_mask, true); } else diff --git a/libs/vkd3d-shader/dxil.c b/libs/vkd3d-shader/dxil.c index 158e9fbd..f4f1e534 100644 --- a/libs/vkd3d-shader/dxil.c +++ b/libs/vkd3d-shader/dxil.c @@ -1495,7 +1495,7 @@ static unsigned int register_get_uint_value(const struct vkd3d_shader_register * if (!register_is_constant(reg) || !data_type_is_integer(reg->data_type)) return UINT_MAX;
- if (reg->immconst_type == VKD3D_IMMCONST_VEC4) + if (reg->dimension == VKD3D_SHADER_DIMENSION_VEC4) WARN("Returning vec4.x.\n");
if (reg->type == VKD3DSPR_IMMCONST64) @@ -1912,7 +1912,7 @@ static enum vkd3d_result sm6_parser_constants_init(struct sm6_parser *sm6, const dst->type = type; dst->value_type = VALUE_TYPE_REG; dst->u.reg.type = reg_type; - dst->u.reg.immconst_type = VKD3D_IMMCONST_SCALAR; + dst->u.reg.dimension = VKD3D_SHADER_DIMENSION_SCALAR; dst->u.reg.data_type = reg_data_type;
switch (record->code) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 39d6f96d..1b67a924 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -74,7 +74,7 @@ static void shader_instruction_eliminate_phase_instance_id(struct vkd3d_shader_i reg->idx[2].offset = ~0u; reg->idx[2].rel_addr = NULL; reg->idx_count = 0; - reg->immconst_type = VKD3D_IMMCONST_SCALAR; + reg->dimension = VKD3D_SHADER_DIMENSION_SCALAR; reg->u.immconst_uint[0] = instance_id; continue; } @@ -310,7 +310,7 @@ void vsir_register_init(struct vkd3d_shader_register *reg, enum vkd3d_shader_reg reg->idx[2].offset = ~0u; reg->idx[2].rel_addr = NULL; reg->idx_count = idx_count; - reg->immconst_type = VKD3D_IMMCONST_SCALAR; + reg->dimension = VKD3D_SHADER_DIMENSION_SCALAR; }
void shader_instruction_init(struct vkd3d_shader_instruction *ins, enum vkd3d_shader_opcode handler_idx) @@ -1206,7 +1206,7 @@ static void shader_register_normalise_flat_constants(struct vkd3d_shader_src_par if (normaliser->defs[i].set == set && normaliser->defs[i].index == index) { vsir_register_init(¶m->reg, VKD3DSPR_IMMCONST, 0, 0); - param->reg.immconst_type = VKD3D_IMMCONST_VEC4; + param->reg.dimension = VKD3D_SHADER_DIMENSION_VEC4; for (j = 0; j < 4; ++j) param->reg.u.immconst_uint[j] = normaliser->defs[i].value[j]; return; diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 31822dd1..1739ca02 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -3576,7 +3576,7 @@ static uint32_t spirv_compiler_emit_load_constant(struct spirv_compiler *compile
assert(reg->type == VKD3DSPR_IMMCONST);
- if (reg->immconst_type == VKD3D_IMMCONST_SCALAR) + if (reg->dimension == VKD3D_SHADER_DIMENSION_SCALAR) { for (i = 0; i < component_count; ++i) values[i] = *reg->u.immconst_uint; @@ -3603,7 +3603,7 @@ static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compi
assert(reg->type == VKD3DSPR_IMMCONST64);
- if (reg->immconst_type == VKD3D_IMMCONST_SCALAR) + if (reg->dimension == VKD3D_SHADER_DIMENSION_SCALAR) { for (i = 0; i < component_count; ++i) values[i] = *reg->u.immconst_uint64; diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index 6ecebd09..598dee71 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -1859,7 +1859,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui switch (dimension) { case VKD3D_SM4_DIMENSION_SCALAR: - param->immconst_type = VKD3D_IMMCONST_SCALAR; + param->dimension = VKD3D_SHADER_DIMENSION_SCALAR; dword_count = 1 + (register_type == VKD3D_SM4_RT_IMMCONST64); if (end - *ptr < dword_count) { @@ -1871,7 +1871,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui break;
case VKD3D_SM4_DIMENSION_VEC4: - param->immconst_type = VKD3D_IMMCONST_VEC4; + param->dimension = VKD3D_SHADER_DIMENSION_VEC4; if (end - *ptr < VKD3D_VEC4_SIZE) { WARN("Invalid ptr %p, end %p.\n", *ptr, end); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 982564a6..3e95bdb8 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -563,10 +563,11 @@ static inline bool data_type_is_integer(enum vkd3d_data_type data_type) return data_type == VKD3D_DATA_INT || data_type == VKD3D_DATA_UINT8 || data_type == VKD3D_DATA_UINT; }
-enum vkd3d_immconst_type +enum vkd3d_shader_dimension { - VKD3D_IMMCONST_SCALAR, - VKD3D_IMMCONST_VEC4, + VKD3D_SHADER_DIMENSION_NONE, + VKD3D_SHADER_DIMENSION_SCALAR, + VKD3D_SHADER_DIMENSION_VEC4, };
enum vkd3d_shader_src_modifier @@ -730,7 +731,7 @@ struct vkd3d_shader_register enum vkd3d_data_type data_type; struct vkd3d_shader_register_index idx[3]; unsigned int idx_count; - enum vkd3d_immconst_type immconst_type; + enum vkd3d_shader_dimension dimension; union { DWORD immconst_uint[VKD3D_VEC4_SIZE];
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/tpf.c | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-)
diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index 598dee71..3be4efcc 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -519,6 +519,22 @@ enum vkd3d_sm4_dimension VKD3D_SM4_DIMENSION_VEC4 = 0x2, };
+static enum vkd3d_shader_dimension get_vkd3d_shader_dimension_from_sm4_dimension(enum vkd3d_sm4_dimension dim) +{ + switch (dim) + { + case VKD3D_SM4_DIMENSION_NONE: + return VKD3D_SHADER_DIMENSION_NONE; + case VKD3D_SM4_DIMENSION_SCALAR: + return VKD3D_SHADER_DIMENSION_SCALAR; + case VKD3D_SM4_DIMENSION_VEC4: + return VKD3D_SHADER_DIMENSION_VEC4; + default: + FIXME("Unknown SM4 dimension %#x.\n", dim); + return VKD3D_SHADER_DIMENSION_NONE; + } +} + enum vkd3d_sm4_resource_type { VKD3D_SM4_RESOURCE_BUFFER = 0x1, @@ -1718,6 +1734,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui enum vkd3d_sm4_register_type register_type; enum vkd3d_sm4_extended_operand_type type; enum vkd3d_sm4_register_modifier m; + enum vkd3d_sm4_dimension sm4_dimension; uint32_t token, order, extended;
if (*ptr >= end) @@ -1851,14 +1868,16 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui
param->idx_count = order;
+ sm4_dimension = (token & VKD3D_SM4_DIMENSION_MASK) >> VKD3D_SM4_DIMENSION_SHIFT; + param->dimension = get_vkd3d_shader_dimension_from_sm4_dimension(sm4_dimension); + if (register_type == VKD3D_SM4_RT_IMMCONST || register_type == VKD3D_SM4_RT_IMMCONST64) { - enum vkd3d_sm4_dimension dimension = (token & VKD3D_SM4_DIMENSION_MASK) >> VKD3D_SM4_DIMENSION_SHIFT; unsigned int dword_count;
- switch (dimension) + switch (param->dimension) { - case VKD3D_SM4_DIMENSION_SCALAR: + case VKD3D_SHADER_DIMENSION_SCALAR: param->dimension = VKD3D_SHADER_DIMENSION_SCALAR; dword_count = 1 + (register_type == VKD3D_SM4_RT_IMMCONST64); if (end - *ptr < dword_count) @@ -1870,7 +1889,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui *ptr += dword_count; break;
- case VKD3D_SM4_DIMENSION_VEC4: + case VKD3D_SHADER_DIMENSION_VEC4: param->dimension = VKD3D_SHADER_DIMENSION_VEC4; if (end - *ptr < VKD3D_VEC4_SIZE) { @@ -1882,7 +1901,7 @@ static bool shader_sm4_read_param(struct vkd3d_shader_sm4_parser *priv, const ui break;
default: - FIXME("Unhandled dimension %#x.\n", dimension); + FIXME("Unhandled dimension %#x.\n", param->dimension); break; } }
From: Francisco Casas fcasas@codeweavers.com
--- libs/vkd3d-shader/d3dbc.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index bfeebd60..b7fb0062 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -465,6 +465,12 @@ static void shader_sm1_parse_src_param(uint32_t param, const struct vkd3d_shader src->reg.non_uniform = false; src->reg.idx[0].offset = param & VKD3D_SM1_REGISTER_NUMBER_MASK; src->reg.idx[0].rel_addr = rel_addr; + if (src->reg.type == VKD3DSPR_SAMPLER) + src->reg.dimension = VKD3D_SHADER_DIMENSION_NONE; + else if (src->reg.type == VKD3DSPR_DEPTHOUT) + src->reg.dimension = VKD3D_SHADER_DIMENSION_SCALAR; + else + src->reg.dimension = VKD3D_SHADER_DIMENSION_VEC4; src->swizzle = swizzle_from_sm1((param & VKD3D_SM1_SWIZZLE_MASK) >> VKD3D_SM1_SWIZZLE_SHIFT); src->modifiers = (param & VKD3D_SM1_SRC_MODIFIER_MASK) >> VKD3D_SM1_SRC_MODIFIER_SHIFT; } @@ -480,6 +486,12 @@ static void shader_sm1_parse_dst_param(uint32_t param, const struct vkd3d_shader dst->reg.non_uniform = false; dst->reg.idx[0].offset = param & VKD3D_SM1_REGISTER_NUMBER_MASK; dst->reg.idx[0].rel_addr = rel_addr; + if (dst->reg.type == VKD3DSPR_SAMPLER) + dst->reg.dimension = VKD3D_SHADER_DIMENSION_NONE; + else if (dst->reg.type == VKD3DSPR_DEPTHOUT) + dst->reg.dimension = VKD3D_SHADER_DIMENSION_SCALAR; + else + dst->reg.dimension = VKD3D_SHADER_DIMENSION_VEC4; dst->write_mask = (param & VKD3D_SM1_WRITEMASK_MASK) >> VKD3D_SM1_WRITEMASK_SHIFT; dst->modifiers = (param & VKD3D_SM1_DST_MODIFIER_MASK) >> VKD3D_SM1_DST_MODIFIER_SHIFT; dst->shift = (param & VKD3D_SM1_DSTSHIFT_MASK) >> VKD3D_SM1_DSTSHIFT_SHIFT;
:arrow_up: I applied the suggestions: * The first patch now renames `shader_register_init()` to `vsir_register_init()`. * Ex 5/5 was moved and spliced into in 2/9 and 3/9. I could split 3/9 further but I didn't want to create as many patches. * Now vsir_register_init() is being used in shader_sm4_read_param(), shader_sm1_parse_src_param(), and shader_sm1_parse_dst_param(), they correspond to 4/9, 5/9, and 6/9 respectively. * The suggested change in ex 2/5 (now 8/9) was applied.
This seems largely fine; couple of comments:
- Ex 5/5 was moved and spliced into in 2/9 and 3/9. I can split 3/9 further but I didn't want to end up with too many patches.
I don't think ending up with too many patches is ever a concern.
Subject: [PATCH 2/9] vkd3d-shader/ir: Use vsir_register_init() in shader_register_normalise_flat_constants().
That changes behaviour though; shader_register_normalise_flat_constants() is modifying existing registers, not creating new ones. Arguably it's benign, but I'd still say it's wrong.
- memset(&r, 0, sizeof(r)); - r.type = VKD3DSPR_OUTPOINTID; - r.idx[0].offset = ~0u; - r.idx[1].offset = ~0u; - r.idx_count = 0; + vsir_register_init(&r, VKD3DSPR_OUTPOINTID, 0, 0);
Whether right or wrong, 0 above is VKD3D_DATA_FLOAT. That happens in a couple of other places as well. (I'd argue for "wrong, but largely irrelevant" for most of these; we could fix them up in follow-up patches if we care.)
+static enum vkd3d_shader_dimension get_vkd3d_shader_dimension_from_sm4_dimension(enum vkd3d_sm4_dimension dim) +{ + switch (dim) + { + case VKD3D_SM4_DIMENSION_NONE: + return VKD3D_SHADER_DIMENSION_NONE; + case VKD3D_SM4_DIMENSION_SCALAR: + return VKD3D_SHADER_DIMENSION_SCALAR; + case VKD3D_SM4_DIMENSION_VEC4: + return VKD3D_SHADER_DIMENSION_VEC4; + default: + FIXME("Unknown SM4 dimension %#x.\n", dim); + return VKD3D_SHADER_DIMENSION_NONE; + } +}
I'd argue for "vsir_dimension_from_sm4()".
I don't think ending up with too many patches is ever a concern.
Okay, I split the patch into several patches, one for each function in spirv.c.
That changes behaviour though; shader_register_normalise_flat_constants() is modifying existing registers, not creating new ones. Arguably it's benign, but I'd still say it's wrong.
I see, I dropped the patch then.
Whether right or wrong, 0 above is VKD3D_DATA_FLOAT. That happens in a couple of other places as well. (I'd argue for "wrong, but largely irrelevant" for most of these; we could fix them up in follow-up patches if we care.)
Yep, in these cases I used zero to preserve the current behavior given by `memset(.,0,.)`, maybe we could also consider removing the `data_type` argument in vsir_register_init() if it is not relevant in many places, and set it up explicitly after initializing the register where needed.
I'd argue for "vsir_dimension_from_sm4()".
Okay, I renamed the function.
However, I have been told that it is better if function names start with a verb, but I guess we are not following that rule much in this part of the code base.
-
Francisco Casas -
Francisco Casas (＠fcasas)
-
Henri Verbeet (＠hverbeet)