wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-01-28 13:05:02 -08:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader/ir: Eliminate struct vkd3d_shader_normaliser.

Browse Source
This commit is contained in:
Conor McCarthy 2023-05-05 17:23:56 +10:00 committed by Alexandre Julliard
parent 31682c52c7
commit 110e48e54d
Notes: Alexandre Julliard 2023-05-24 22:33:51 +02:00 
Approved-by: Henri Verbeet (@hverbeet)
Approved-by: Alexandre Julliard (@julliard)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/181
3 changed files with 77 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
libs/vkd3d-shader/ir.c
View File

@ -85,14 +85,21 @@ static void shader_instruction_eliminate_phase_instance_id(struct vkd3d_shader_i
shader_register_eliminate_phase_addressing((struct vkd3d_shader_register *)&ins->dst[i].reg, instance_id); shader_register_eliminate_phase_addressing((struct vkd3d_shader_register *)&ins->dst[i].reg, instance_id);
} }
static bool normaliser_is_in_control_point_phase(const struct vkd3d_shader_normaliser *normaliser) struct hull_flattener
{ {
return normaliser->phase == VKD3DSIH_HS_CONTROL_POINT_PHASE; struct vkd3d_shader_instruction_array instructions;
}
static bool normaliser_is_in_fork_or_join_phase(const struct vkd3d_shader_normaliser *normaliser) unsigned int max_temp_count;
unsigned int temp_dcl_idx;
unsigned int instance_count;
unsigned int phase_body_idx;
enum vkd3d_shader_opcode phase;
};
static bool flattener_is_in_fork_or_join_phase(const struct hull_flattener *flattener)
{ {
return normaliser->phase == VKD3DSIH_HS_FORK_PHASE || normaliser->phase == VKD3DSIH_HS_JOIN_PHASE; return flattener->phase == VKD3DSIH_HS_FORK_PHASE || flattener->phase == VKD3DSIH_HS_JOIN_PHASE;
} }
struct shader_phase_location struct shader_phase_location
@ -109,7 +116,7 @@ struct shader_phase_location_array
unsigned int count; unsigned int count;
}; };
static void shader_normaliser_eliminate_phase_related_dcls(struct vkd3d_shader_normaliser *normaliser, static void flattener_eliminate_phase_related_dcls(struct hull_flattener *normaliser,
unsigned int index, struct shader_phase_location_array *locations) unsigned int index, struct shader_phase_location_array *locations)
{ {
struct vkd3d_shader_instruction *ins = &normaliser->instructions.elements[index]; struct vkd3d_shader_instruction *ins = &normaliser->instructions.elements[index];
@ -118,7 +125,7 @@ static void shader_normaliser_eliminate_phase_related_dcls(struct vkd3d_shader_n
if (ins->handler_idx == VKD3DSIH_HS_FORK_PHASE || ins->handler_idx == VKD3DSIH_HS_JOIN_PHASE) if (ins->handler_idx == VKD3DSIH_HS_FORK_PHASE || ins->handler_idx == VKD3DSIH_HS_JOIN_PHASE)
{ {
b = normaliser_is_in_fork_or_join_phase(normaliser); b = flattener_is_in_fork_or_join_phase(normaliser);
/* Reset the phase info. */ /* Reset the phase info. */
normaliser->phase_body_idx = ~0u; normaliser->phase_body_idx = ~0u;
normaliser->phase = ins->handler_idx; normaliser->phase = ins->handler_idx;
@ -173,7 +180,7 @@ static void shader_normaliser_eliminate_phase_related_dcls(struct vkd3d_shader_n
} }
} }
static enum vkd3d_result shader_normaliser_flatten_phases(struct vkd3d_shader_normaliser *normaliser, static enum vkd3d_result flattener_flatten_phases(struct hull_flattener *normaliser,
struct shader_phase_location_array *locations) struct shader_phase_location_array *locations)
{ {
struct shader_phase_location *loc; struct shader_phase_location *loc;
@ -246,46 +253,55 @@ static void shader_instruction_init(struct vkd3d_shader_instruction *ins, enum v
ins->handler_idx = handler_idx; ins->handler_idx = handler_idx;
} }
void shader_normaliser_init(struct vkd3d_shader_normaliser *normaliser, enum vkd3d_result instruction_array_flatten_hull_shader_phases(struct vkd3d_shader_instruction_array *src_instructions)
struct vkd3d_shader_instruction_array *instructions)
{ {
memset(normaliser, 0, sizeof(*normaliser)); struct hull_flattener flattener = {*src_instructions};
normaliser->phase = VKD3DSIH_INVALID; struct vkd3d_shader_instruction_array *instructions;
normaliser->instructions = *instructions;
memset(instructions, 0, sizeof(*instructions));
}
enum vkd3d_result shader_normaliser_flatten_hull_shader_phases(struct vkd3d_shader_normaliser *normaliser)
{
struct vkd3d_shader_instruction_array *instructions = &normaliser->instructions;
struct shader_phase_location_array locations; struct shader_phase_location_array locations;
enum vkd3d_result result = VKD3D_OK; enum vkd3d_result result = VKD3D_OK;
unsigned int i; unsigned int i;
for (i = 0, locations.count = 0; i < instructions->count; ++i) instructions = &flattener.instructions;
shader_normaliser_eliminate_phase_related_dcls(normaliser, i, &locations);
if ((result = shader_normaliser_flatten_phases(normaliser, &locations)) < 0) flattener.phase = VKD3DSIH_INVALID;
for (i = 0, locations.count = 0; i < instructions->count; ++i)
flattener_eliminate_phase_related_dcls(&flattener, i, &locations);
if ((result = flattener_flatten_phases(&flattener, &locations)) < 0)
return result; return result;
if (normaliser->phase != VKD3DSIH_INVALID) if (flattener.phase != VKD3DSIH_INVALID)
{ {
if (normaliser->temp_dcl_idx) if (flattener.temp_dcl_idx)
instructions->elements[normaliser->temp_dcl_idx].declaration.count = normaliser->max_temp_count; instructions->elements[flattener.temp_dcl_idx].declaration.count = flattener.max_temp_count;
if (!shader_instruction_array_reserve(&normaliser->instructions, normaliser->instructions.count + 1)) if (!shader_instruction_array_reserve(&flattener.instructions, flattener.instructions.count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY; return VKD3D_ERROR_OUT_OF_MEMORY;
shader_instruction_init(&instructions->elements[instructions->count++], VKD3DSIH_RET); shader_instruction_init(&instructions->elements[instructions->count++], VKD3DSIH_RET);
} }
*src_instructions = flattener.instructions;
return result; return result;
} }
static struct vkd3d_shader_src_param *shader_normaliser_create_outpointid_param(struct vkd3d_shader_normaliser *normaliser) struct control_point_normaliser
{
struct vkd3d_shader_instruction_array instructions;
enum vkd3d_shader_opcode phase;
struct vkd3d_shader_src_param *outpointid_param;
};
static bool control_point_normaliser_is_in_control_point_phase(const struct control_point_normaliser *normaliser)
{
return normaliser->phase == VKD3DSIH_HS_CONTROL_POINT_PHASE;
}
static struct vkd3d_shader_src_param *instruction_array_create_outpointid_param(
struct vkd3d_shader_instruction_array *instructions)
{ {
struct vkd3d_shader_src_param *rel_addr; struct vkd3d_shader_src_param *rel_addr;
if (!(rel_addr = shader_src_param_allocator_get(&normaliser->instructions.src_params, 1))) if (!(rel_addr = shader_src_param_allocator_get(&instructions->src_params, 1)))
return NULL; return NULL;
shader_register_init(&rel_addr->reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_UINT, 0); shader_register_init(&rel_addr->reg, VKD3DSPR_OUTPOINTID, VKD3D_DATA_UINT, 0);
@ -296,11 +312,11 @@ static struct vkd3d_shader_src_param *shader_normaliser_create_outpointid_param(
} }
static void shader_dst_param_normalise_outpointid(struct vkd3d_shader_dst_param *dst_param, static void shader_dst_param_normalise_outpointid(struct vkd3d_shader_dst_param *dst_param,
struct vkd3d_shader_normaliser *normaliser) struct control_point_normaliser *normaliser)
{ {
struct vkd3d_shader_register *reg = &dst_param->reg; struct vkd3d_shader_register *reg = &dst_param->reg;
if (normaliser_is_in_control_point_phase(normaliser) && reg->type == VKD3DSPR_OUTPUT) if (control_point_normaliser_is_in_control_point_phase(normaliser) && reg->type == VKD3DSPR_OUTPUT)
{ {
/* The TPF reader validates idx_count. */ /* The TPF reader validates idx_count. */
assert(reg->idx_count == 1); assert(reg->idx_count == 1);
@ -321,7 +337,7 @@ static void shader_dst_param_io_init(struct vkd3d_shader_dst_param *param, const
shader_register_init(&param->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count); shader_register_init(&param->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count);
} }
static enum vkd3d_result shader_normaliser_emit_hs_input(struct vkd3d_shader_normaliser *normaliser, static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_point_normaliser *normaliser,
const struct shader_signature *s, unsigned int input_control_point_count, unsigned int dst) const struct shader_signature *s, unsigned int input_control_point_count, unsigned int dst)
{ {
struct vkd3d_shader_instruction *ins; struct vkd3d_shader_instruction *ins;
@ -372,22 +388,26 @@ static enum vkd3d_result shader_normaliser_emit_hs_input(struct vkd3d_shader_nor
return VKD3D_OK; return VKD3D_OK;
} }
enum vkd3d_result shader_normaliser_normalise_hull_shader_control_point_io(struct vkd3d_shader_normaliser *normaliser, enum vkd3d_result instruction_array_normalise_hull_shader_control_point_io(
const struct shader_signature *input_signature) struct vkd3d_shader_instruction_array *src_instructions, const struct shader_signature *input_signature)
{ {
struct vkd3d_shader_instruction_array *instructions = &normaliser->instructions; struct vkd3d_shader_instruction_array *instructions;
struct control_point_normaliser normaliser;
unsigned int input_control_point_count; unsigned int input_control_point_count;
struct vkd3d_shader_instruction *ins; struct vkd3d_shader_instruction *ins;
enum vkd3d_result ret;
unsigned int i, j; unsigned int i, j;
if (!(normaliser->outpointid_param = shader_normaliser_create_outpointid_param(normaliser))) if (!(normaliser.outpointid_param = instruction_array_create_outpointid_param(src_instructions)))
{ {
ERR("Failed to allocate src param.\n"); ERR("Failed to allocate src param.\n");
return VKD3D_ERROR_OUT_OF_MEMORY; return VKD3D_ERROR_OUT_OF_MEMORY;
} }
normaliser.instructions = *src_instructions;
instructions = &normaliser.instructions;
normaliser.phase = VKD3DSIH_INVALID;
normaliser->phase = VKD3DSIH_INVALID; for (i = 0; i < normaliser.instructions.count; ++i)
for (i = 0; i < normaliser->instructions.count; ++i)
{ {
ins = &instructions->elements[i]; ins = &instructions->elements[i];
@ -396,18 +416,18 @@ enum vkd3d_result shader_normaliser_normalise_hull_shader_control_point_io(struc
case VKD3DSIH_HS_CONTROL_POINT_PHASE: case VKD3DSIH_HS_CONTROL_POINT_PHASE:
case VKD3DSIH_HS_FORK_PHASE: case VKD3DSIH_HS_FORK_PHASE:
case VKD3DSIH_HS_JOIN_PHASE: case VKD3DSIH_HS_JOIN_PHASE:
normaliser->phase = ins->handler_idx; normaliser.phase = ins->handler_idx;
break; break;
default: default:
if (shader_instruction_is_dcl(ins)) if (shader_instruction_is_dcl(ins))
break; break;
for (j = 0; j < ins->dst_count; ++j) for (j = 0; j < ins->dst_count; ++j)
shader_dst_param_normalise_outpointid((struct vkd3d_shader_dst_param *)&ins->dst[j], normaliser); shader_dst_param_normalise_outpointid((struct vkd3d_shader_dst_param *)&ins->dst[j], &normaliser);
break; break;
} }
} }
normaliser->phase = VKD3DSIH_INVALID; normaliser.phase = VKD3DSIH_INVALID;
input_control_point_count = 1; input_control_point_count = 1;
for (i = 0; i < instructions->count; ++i) for (i = 0; i < instructions->count; ++i)
@ -420,19 +440,19 @@ enum vkd3d_result shader_normaliser_normalise_hull_shader_control_point_io(struc
input_control_point_count = ins->declaration.count; input_control_point_count = ins->declaration.count;
break; break;
case VKD3DSIH_HS_CONTROL_POINT_PHASE: case VKD3DSIH_HS_CONTROL_POINT_PHASE:
*src_instructions = normaliser.instructions;
return VKD3D_OK; return VKD3D_OK;
case VKD3DSIH_HS_FORK_PHASE: case VKD3DSIH_HS_FORK_PHASE:
case VKD3DSIH_HS_JOIN_PHASE: case VKD3DSIH_HS_JOIN_PHASE:
return shader_normaliser_emit_hs_input(normaliser, input_signature, input_control_point_count, i); ret = control_point_normaliser_emit_hs_input(&normaliser, input_signature,
input_control_point_count, i);
*src_instructions = normaliser.instructions;
return ret;
default: default:
break; break;
} }
} }
*src_instructions = normaliser.instructions;
return VKD3D_OK; return VKD3D_OK;
} }
void shader_normaliser_destroy(struct vkd3d_shader_normaliser *normaliser)
{
shader_instruction_array_destroy(&normaliser->instructions);
}

15
libs/vkd3d-shader/spirv.c
View File

@ -9689,7 +9689,7 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler,
struct vkd3d_shader_instruction_array *instructions = &parser->instructions; struct vkd3d_shader_instruction_array *instructions = &parser->instructions;
const struct vkd3d_shader_spirv_domain_shader_target_info *ds_info; const struct vkd3d_shader_spirv_domain_shader_target_info *ds_info;
struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
struct vkd3d_shader_normaliser normaliser; struct vkd3d_shader_instruction_array normalised_instructions;
enum vkd3d_result result = VKD3D_OK; enum vkd3d_result result = VKD3D_OK;
unsigned int i; unsigned int i;
@ -9698,11 +9698,12 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler,
if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL) if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL)
{ {
shader_normaliser_init(&normaliser, instructions); normalised_instructions = parser->instructions;
if ((result = shader_normaliser_flatten_hull_shader_phases(&normaliser)) >= 0) memset(&parser->instructions, 0, sizeof(parser->instructions));
result = shader_normaliser_normalise_hull_shader_control_point_io(&normaliser, instructions = &normalised_instructions;
if ((result = instruction_array_flatten_hull_shader_phases(instructions)) >= 0)
result = instruction_array_normalise_hull_shader_control_point_io(instructions,
&parser->shader_desc.input_signature); &parser->shader_desc.input_signature);
instructions = &normaliser.instructions;
if (result >= 0 && TRACE_ON()) if (result >= 0 && TRACE_ON())
vkd3d_shader_trace(instructions, &parser->shader_version); vkd3d_shader_trace(instructions, &parser->shader_version);
@ -9714,8 +9715,8 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler,
result = spirv_compiler_handle_instruction(compiler, &instructions->elements[i]); result = spirv_compiler_handle_instruction(compiler, &instructions->elements[i]);
} }
if (instructions == &normaliser.instructions) if (instructions == &normalised_instructions)
shader_normaliser_destroy(&normaliser); shader_instruction_array_destroy(&normalised_instructions);
if (result < 0) if (result < 0)
return result; return result;

23
libs/vkd3d-shader/vkd3d_shader_private.h
View File

@ -1363,25 +1363,8 @@ void dxbc_writer_add_section(struct dxbc_writer *dxbc, uint32_t tag, const void
void dxbc_writer_init(struct dxbc_writer *dxbc); void dxbc_writer_init(struct dxbc_writer *dxbc);
int dxbc_writer_write(struct dxbc_writer *dxbc, struct vkd3d_shader_code *code); int dxbc_writer_write(struct dxbc_writer *dxbc, struct vkd3d_shader_code *code);
struct vkd3d_shader_normaliser enum vkd3d_result instruction_array_flatten_hull_shader_phases(struct vkd3d_shader_instruction_array *instructions);
{ enum vkd3d_result instruction_array_normalise_hull_shader_control_point_io(
struct vkd3d_shader_instruction_array instructions; struct vkd3d_shader_instruction_array *instructions, const struct shader_signature *input_signature);
unsigned int max_temp_count;
unsigned int temp_dcl_idx;
unsigned int instance_count;
unsigned int phase_body_idx;
enum vkd3d_shader_opcode phase;
struct vkd3d_shader_src_param *outpointid_param;
};
void shader_normaliser_init(struct vkd3d_shader_normaliser *normaliser,
struct vkd3d_shader_instruction_array *instructions);
enum vkd3d_result shader_normaliser_flatten_hull_shader_phases(struct vkd3d_shader_normaliser *normaliser);
enum vkd3d_result shader_normaliser_normalise_hull_shader_control_point_io(struct vkd3d_shader_normaliser *normaliser,
const struct shader_signature *input_signature);
void shader_normaliser_destroy(struct vkd3d_shader_normaliser *normaliser);
#endif /* __VKD3D_SHADER_PRIVATE_H */ #endif /* __VKD3D_SHADER_PRIVATE_H */