Skip to content
Snippets Groups Projects

vkd3d-shader/ir: Prepare the CFG structurizer for handling Hull Shaders.

Merged Giovanni Mascellani requested to merge giomasce/vkd3d:stromboli into master
3 unresolved threads
1 file
+ 19
11
Compare changes
  • Side-by-side
  • Inline
+ 277
217
@@ -2917,19 +2917,19 @@ struct vsir_cfg_structure
union
{
struct vsir_block *block;
struct
struct vsir_cfg_structure_loop
{
struct vsir_cfg_structure_list body;
unsigned idx;
} loop;
struct
struct vsir_cfg_structure_selection
{
struct vkd3d_shader_src_param *condition;
struct vsir_cfg_structure_list if_body;
struct vsir_cfg_structure_list else_body;
bool invert_condition;
} selection;
struct
struct vsir_cfg_structure_jump
{
enum vsir_cfg_jump_type
{
@@ -3013,6 +3013,14 @@ static void vsir_cfg_structure_cleanup(struct vsir_cfg_structure *structure)
}
}
struct vsir_cfg_emit_target
{
struct vkd3d_shader_instruction *instructions;
size_t ins_capacity, ins_count;
unsigned int jump_target_temp_idx;
unsigned int temp_count;
};
struct vsir_cfg
{
struct vkd3d_shader_message_context *message_context;
@@ -3064,10 +3072,7 @@ struct vsir_cfg
struct vsir_cfg_structure_list structured_program;
struct vkd3d_shader_instruction *instructions;
size_t ins_capacity, ins_count;
unsigned int jump_target_temp_idx;
unsigned int temp_count;
struct vsir_cfg_emit_target *target;
};
static void vsir_cfg_cleanup(struct vsir_cfg *cfg)
@@ -3262,7 +3267,7 @@ static void vsir_cfg_dump_structured_program(struct vsir_cfg *cfg)
}
static enum vkd3d_result vsir_cfg_init(struct vsir_cfg *cfg, struct vsir_program *program,
struct vkd3d_shader_message_context *message_context)
struct vkd3d_shader_message_context *message_context, struct vsir_cfg_emit_target *target)
{
struct vsir_block *current_block = NULL;
enum vkd3d_result ret;
@@ -3272,6 +3277,7 @@ static enum vkd3d_result vsir_cfg_init(struct vsir_cfg *cfg, struct vsir_program
cfg->message_context = message_context;
cfg->program = program;
cfg->block_count = program->block_count;
cfg->target = target;
vsir_block_list_init(&cfg->order);
@@ -4436,199 +4442,244 @@ static enum vkd3d_result vsir_cfg_optimize(struct vsir_cfg *cfg)
}
static enum vkd3d_result vsir_cfg_structure_list_emit(struct vsir_cfg *cfg,
struct vsir_cfg_structure_list *list, unsigned int loop_idx)
struct vsir_cfg_structure_list *list, unsigned int loop_idx);
static enum vkd3d_result vsir_cfg_structure_list_emit_block(struct vsir_cfg *cfg,
struct vsir_block *block)
{
struct vsir_cfg_emit_target *target = cfg->target;
if (!reserve_instructions(&target->instructions, &target->ins_capacity,
target->ins_count + (block->end - block->begin)))
return VKD3D_ERROR_OUT_OF_MEMORY;
memcpy(&target->instructions[target->ins_count], block->begin,
(char *)block->end - (char *)block->begin);
target->ins_count += block->end - block->begin;
return VKD3D_OK;
}
static enum vkd3d_result vsir_cfg_structure_list_emit_loop(struct vsir_cfg *cfg,
struct vsir_cfg_structure_loop *loop, unsigned int loop_idx)
{
struct vsir_cfg_emit_target *target = cfg->target;
const struct vkd3d_shader_location no_loc = {0};
enum vkd3d_result ret;
size_t i;
for (i = 0; i < list->count; ++i)
if (!reserve_instructions(&target->instructions, &target->ins_capacity, target->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
vsir_instruction_init(&target->instructions[target->ins_count++], &no_loc, VKD3DSIH_LOOP);
if ((ret = vsir_cfg_structure_list_emit(cfg, &loop->body, loop->idx)) < 0)
return ret;
if (!reserve_instructions(&target->instructions, &target->ins_capacity, target->ins_count + 5))
return VKD3D_ERROR_OUT_OF_MEMORY;
vsir_instruction_init(&target->instructions[target->ins_count++], &no_loc, VKD3DSIH_ENDLOOP);
/* Add a trampoline to implement multilevel jumping depending on the stored
* jump_target value. */
if (loop_idx != UINT_MAX)
{
struct vsir_cfg_structure *structure = &list->structures[i];
/* If the multilevel jump is a `continue' and the target is the loop we're inside
* right now, then we can finally do the `continue'. */
const unsigned int outer_continue_target = loop_idx << 1 | 1;
/* If the multilevel jump is a `continue' to any other target, or if it is a `break'
* and the target is not the loop we just finished emitting, then it means that
* we have to reach an outer loop, so we keep breaking. */
const unsigned int inner_break_target = loop->idx << 1;
switch (structure->type)
{
case STRUCTURE_TYPE_BLOCK:
{
struct vsir_block *block = structure->u.block;
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, VKD3DSIH_IEQ, 1, 2))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + (block->end - block->begin)))
return VKD3D_ERROR_OUT_OF_MEMORY;
dst_param_init_temp_bool(&target->instructions[target->ins_count].dst[0], target->temp_count);
src_param_init_temp_uint(&target->instructions[target->ins_count].src[0], target->jump_target_temp_idx);
src_param_init_const_uint(&target->instructions[target->ins_count].src[1], outer_continue_target);
memcpy(&cfg->instructions[cfg->ins_count], block->begin, (char *)block->end - (char *)block->begin);
++target->ins_count;
cfg->ins_count += block->end - block->begin;
break;
}
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, VKD3DSIH_CONTINUEP, 0, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
case STRUCTURE_TYPE_LOOP:
{
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
src_param_init_temp_bool(&target->instructions[target->ins_count].src[0], target->temp_count);
vsir_instruction_init(&cfg->instructions[cfg->ins_count++], &no_loc, VKD3DSIH_LOOP);
++target->ins_count;
++target->temp_count;
if ((ret = vsir_cfg_structure_list_emit(cfg, &structure->u.loop.body, structure->u.loop.idx)) < 0)
return ret;
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, VKD3DSIH_IEQ, 1, 2))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + 5))
return VKD3D_ERROR_OUT_OF_MEMORY;
dst_param_init_temp_bool(&target->instructions[target->ins_count].dst[0], target->temp_count);
src_param_init_temp_uint(&target->instructions[target->ins_count].src[0], target->jump_target_temp_idx);
src_param_init_const_uint(&target->instructions[target->ins_count].src[1], inner_break_target);
vsir_instruction_init(&cfg->instructions[cfg->ins_count++], &no_loc, VKD3DSIH_ENDLOOP);
++target->ins_count;
/* Add a trampoline to implement multilevel jumping depending on the stored
* jump_target value. */
if (loop_idx != UINT_MAX)
{
/* If the multilevel jump is a `continue' and the target is the loop we're inside
* right now, then we can finally do the `continue'. */
const unsigned int outer_continue_target = loop_idx << 1 | 1;
/* If the multilevel jump is a `continue' to any other target, or if it is a `break'
* and the target is not the loop we just finished emitting, then it means that
* we have to reach an outer loop, so we keep breaking. */
const unsigned int inner_break_target = structure->u.loop.idx << 1;
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, VKD3DSIH_BREAKP, 0, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
target->instructions[target->ins_count].flags |= VKD3D_SHADER_CONDITIONAL_OP_Z;
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count],
&no_loc, VKD3DSIH_IEQ, 1, 2))
return VKD3D_ERROR_OUT_OF_MEMORY;
src_param_init_temp_bool(&target->instructions[target->ins_count].src[0], target->temp_count);
dst_param_init_temp_bool(&cfg->instructions[cfg->ins_count].dst[0], cfg->temp_count);
src_param_init_temp_uint(&cfg->instructions[cfg->ins_count].src[0], cfg->jump_target_temp_idx);
src_param_init_const_uint(&cfg->instructions[cfg->ins_count].src[1], outer_continue_target);
++target->ins_count;
++target->temp_count;
}
++cfg->ins_count;
return VKD3D_OK;
}
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count],
&no_loc, VKD3DSIH_CONTINUEP, 0, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
static enum vkd3d_result vsir_cfg_structure_list_emit_selection(struct vsir_cfg *cfg,
struct vsir_cfg_structure_selection *selection, unsigned int loop_idx)
{
struct vsir_cfg_emit_target *target = cfg->target;
const struct vkd3d_shader_location no_loc = {0};
enum vkd3d_result ret;
src_param_init_temp_bool(&cfg->instructions[cfg->ins_count].src[0], cfg->temp_count);
if (!reserve_instructions(&target->instructions, &target->ins_capacity, target->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
++cfg->ins_count;
++cfg->temp_count;
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, VKD3DSIH_IF, 0, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count],
&no_loc, VKD3DSIH_IEQ, 1, 2))
return VKD3D_ERROR_OUT_OF_MEMORY;
target->instructions[target->ins_count].src[0] = *selection->condition;
dst_param_init_temp_bool(&cfg->instructions[cfg->ins_count].dst[0], cfg->temp_count);
src_param_init_temp_uint(&cfg->instructions[cfg->ins_count].src[0], cfg->jump_target_temp_idx);
src_param_init_const_uint(&cfg->instructions[cfg->ins_count].src[1], inner_break_target);
if (selection->invert_condition)
target->instructions[target->ins_count].flags |= VKD3D_SHADER_CONDITIONAL_OP_Z;
++cfg->ins_count;
++target->ins_count;
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count],
&no_loc, VKD3DSIH_BREAKP, 0, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
cfg->instructions[cfg->ins_count].flags |= VKD3D_SHADER_CONDITIONAL_OP_Z;
if ((ret = vsir_cfg_structure_list_emit(cfg, &selection->if_body, loop_idx)) < 0)
return ret;
src_param_init_temp_bool(&cfg->instructions[cfg->ins_count].src[0], cfg->temp_count);
if (selection->else_body.count != 0)
{
if (!reserve_instructions(&target->instructions, &target->ins_capacity, target->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
++cfg->ins_count;
++cfg->temp_count;
}
vsir_instruction_init(&target->instructions[target->ins_count++], &no_loc, VKD3DSIH_ELSE);
break;
}
if ((ret = vsir_cfg_structure_list_emit(cfg, &selection->else_body, loop_idx)) < 0)
return ret;
}
case STRUCTURE_TYPE_SELECTION:
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (!reserve_instructions(&target->instructions, &target->ins_capacity, target->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count], &no_loc,
VKD3DSIH_IF, 0, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
vsir_instruction_init(&target->instructions[target->ins_count++], &no_loc, VKD3DSIH_ENDIF);
cfg->instructions[cfg->ins_count].src[0] = *structure->u.selection.condition;
return VKD3D_OK;
}
if (structure->u.selection.invert_condition)
cfg->instructions[cfg->ins_count].flags |= VKD3D_SHADER_CONDITIONAL_OP_Z;
static enum vkd3d_result vsir_cfg_structure_list_emit_jump(struct vsir_cfg *cfg,
struct vsir_cfg_structure_jump *jump, unsigned int loop_idx)
{
struct vsir_cfg_emit_target *target = cfg->target;
const struct vkd3d_shader_location no_loc = {0};
/* Encode the jump target as the loop index plus a bit to remember whether
* we're breaking or continueing. */
unsigned int jump_target = jump->target << 1;
enum vkd3d_shader_opcode opcode;
switch (jump->type)
{
case JUMP_CONTINUE:
/* If we're continueing the loop we're directly inside, then we can emit a
* `continue'. Otherwise we first have to break all the loops between here
* and the loop to continue, recording our intention to continue
* in the lowest bit of jump_target. */
if (jump->target == loop_idx)
{
opcode = jump->condition ? VKD3DSIH_CONTINUEP : VKD3DSIH_CONTINUE;
break;
}
jump_target |= 1;
/* fall through */
++cfg->ins_count;
case JUMP_BREAK:
opcode = jump->condition ? VKD3DSIH_BREAKP : VKD3DSIH_BREAK;
break;
if ((ret = vsir_cfg_structure_list_emit(cfg, &structure->u.selection.if_body, loop_idx)) < 0)
return ret;
case JUMP_RET:
assert(!jump->condition);
opcode = VKD3DSIH_RET;
break;
if (structure->u.selection.else_body.count != 0)
{
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
default:
vkd3d_unreachable();
}
vsir_instruction_init(&cfg->instructions[cfg->ins_count++], &no_loc, VKD3DSIH_ELSE);
if (!reserve_instructions(&target->instructions, &target->ins_capacity, target->ins_count + 2))
return VKD3D_ERROR_OUT_OF_MEMORY;
if ((ret = vsir_cfg_structure_list_emit(cfg, &structure->u.selection.else_body, loop_idx)) < 0)
return ret;
}
if (opcode == VKD3DSIH_BREAK || opcode == VKD3DSIH_BREAKP)
{
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, VKD3DSIH_MOV, 1, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
dst_param_init_temp_uint(&target->instructions[target->ins_count].dst[0], target->jump_target_temp_idx);
src_param_init_const_uint(&target->instructions[target->ins_count].src[0], jump_target);
vsir_instruction_init(&cfg->instructions[cfg->ins_count++], &no_loc, VKD3DSIH_ENDIF);
break;
++target->ins_count;
}
case STRUCTURE_TYPE_JUMP:
{
/* Encode the jump target as the loop index plus a bit to remember whether
* we're breaking or continueing. */
unsigned int jump_target = structure->u.jump.target << 1;
enum vkd3d_shader_opcode opcode;
if (!vsir_instruction_init_with_params(cfg->program, &target->instructions[target->ins_count],
&no_loc, opcode, 0, !!jump->condition))
return VKD3D_ERROR_OUT_OF_MEMORY;
switch (structure->u.jump.type)
{
case JUMP_CONTINUE:
/* If we're continueing the loop we're directly inside, then we can emit a
* `continue'. Otherwise we first have to break all the loops between here
* and the loop to continue, recording our intention to continue
* in the lowest bit of jump_target. */
if (structure->u.jump.target == loop_idx)
{
opcode = structure->u.jump.condition ? VKD3DSIH_CONTINUEP : VKD3DSIH_CONTINUE;
break;
}
jump_target |= 1;
/* fall through */
case JUMP_BREAK:
opcode = structure->u.jump.condition ? VKD3DSIH_BREAKP : VKD3DSIH_BREAK;
break;
case JUMP_RET:
assert(!structure->u.jump.condition);
opcode = VKD3DSIH_RET;
break;
default:
vkd3d_unreachable();
}
if (jump->invert_condition)
target->instructions[target->ins_count].flags |= VKD3D_SHADER_CONDITIONAL_OP_Z;
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->ins_count + 2))
return VKD3D_ERROR_OUT_OF_MEMORY;
if (jump->condition)
target->instructions[target->ins_count].src[0] = *jump->condition;
if (opcode == VKD3DSIH_BREAK || opcode == VKD3DSIH_BREAKP)
{
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count],
&no_loc, VKD3DSIH_MOV, 1, 1))
return VKD3D_ERROR_OUT_OF_MEMORY;
++target->ins_count;
dst_param_init_temp_uint(&cfg->instructions[cfg->ins_count].dst[0], cfg->jump_target_temp_idx);
src_param_init_const_uint(&cfg->instructions[cfg->ins_count].src[0], jump_target);
return VKD3D_OK;
}
++cfg->ins_count;
}
static enum vkd3d_result vsir_cfg_structure_list_emit(struct vsir_cfg *cfg,
struct vsir_cfg_structure_list *list, unsigned int loop_idx)
{
enum vkd3d_result ret;
size_t i;
if (!vsir_instruction_init_with_params(cfg->program, &cfg->instructions[cfg->ins_count],
&no_loc, opcode, 0, !!structure->u.jump.condition))
return VKD3D_ERROR_OUT_OF_MEMORY;
for (i = 0; i < list->count; ++i)
{
struct vsir_cfg_structure *structure = &list->structures[i];
if (structure->u.jump.invert_condition)
cfg->instructions[cfg->ins_count].flags |= VKD3D_SHADER_CONDITIONAL_OP_Z;
switch (structure->type)
{
case STRUCTURE_TYPE_BLOCK:
if ((ret = vsir_cfg_structure_list_emit_block(cfg, structure->u.block)) < 0)
return ret;
break;
if (structure->u.jump.condition)
cfg->instructions[cfg->ins_count].src[0] = *structure->u.jump.condition;
case STRUCTURE_TYPE_LOOP:
if ((ret = vsir_cfg_structure_list_emit_loop(cfg, &structure->u.loop, loop_idx)) < 0)
return ret;
break;
++cfg->ins_count;
case STRUCTURE_TYPE_SELECTION:
if ((ret = vsir_cfg_structure_list_emit_selection(cfg, &structure->u.selection,
loop_idx)) < 0)
return ret;
break;
case STRUCTURE_TYPE_JUMP:
if ((ret = vsir_cfg_structure_list_emit_jump(cfg, &structure->u.jump,
loop_idx)) < 0)
return ret;
break;
}
default:
vkd3d_unreachable();
@@ -4639,40 +4690,81 @@ static enum vkd3d_result vsir_cfg_structure_list_emit(struct vsir_cfg *cfg,
}
static enum vkd3d_result vsir_cfg_emit_structured_program(struct vsir_cfg *cfg)
{
return vsir_cfg_structure_list_emit(cfg, &cfg->structured_program, UINT_MAX);
}
static enum vkd3d_result vsir_program_structurize_function(struct vsir_program *program,
struct vkd3d_shader_message_context *message_context, struct vsir_cfg_emit_target *target)
{
enum vkd3d_result ret;
size_t i;
struct vsir_cfg cfg;
if ((ret = vsir_cfg_init(&cfg, program, message_context, target)) < 0)
return ret;
vsir_cfg_compute_dominators(&cfg);
if ((ret = vsir_cfg_compute_loops(&cfg)) < 0)
goto out;
if ((ret = vsir_cfg_sort_nodes(&cfg)) < 0)
goto out;
if ((ret = vsir_cfg_generate_synthetic_loop_intervals(&cfg)) < 0)
goto out;
if ((ret = vsir_cfg_build_structured_program(&cfg)) < 0)
goto out;
if ((ret = vsir_cfg_optimize(&cfg)) < 0)
goto out;
ret = vsir_cfg_emit_structured_program(&cfg);
out:
vsir_cfg_cleanup(&cfg);
return ret;
}
static enum vkd3d_result vsir_program_structurize(struct vsir_program *program,
struct vkd3d_shader_message_context *message_context)
{
struct vsir_cfg_emit_target target = {0};
enum vkd3d_result ret;
unsigned int i;
cfg->jump_target_temp_idx = cfg->program->temp_count;
cfg->temp_count = cfg->program->temp_count + 1;
target.jump_target_temp_idx = program->temp_count;
target.temp_count = program->temp_count + 1;
if (!reserve_instructions(&cfg->instructions, &cfg->ins_capacity, cfg->program->instructions.count))
if (!reserve_instructions(&target.instructions, &target.ins_capacity, program->instructions.count))
return VKD3D_ERROR_OUT_OF_MEMORY;
/* Copy declarations until the first block. */
for (i = 0; i < cfg->program->instructions.count; ++i)
for (i = 0; i < program->instructions.count; ++i)
{
struct vkd3d_shader_instruction *ins = &cfg->program->instructions.elements[i];
struct vkd3d_shader_instruction *ins = &program->instructions.elements[i];
if (ins->handler_idx == VKD3DSIH_LABEL)
break;
cfg->instructions[cfg->ins_count++] = *ins;
target.instructions[target.ins_count++] = *ins;
}
if ((ret = vsir_cfg_structure_list_emit(cfg, &cfg->structured_program, UINT_MAX)) < 0)
if ((ret = vsir_program_structurize_function(program, message_context, &target)) < 0)
goto fail;
vkd3d_free(cfg->program->instructions.elements);
cfg->program->instructions.elements = cfg->instructions;
cfg->program->instructions.capacity = cfg->ins_capacity;
cfg->program->instructions.count = cfg->ins_count;
cfg->program->temp_count = cfg->temp_count;
vkd3d_free(program->instructions.elements);
program->instructions.elements = target.instructions;
program->instructions.capacity = target.ins_capacity;
program->instructions.count = target.ins_count;
program->temp_count = target.temp_count;
return VKD3D_OK;
fail:
vkd3d_free(cfg->instructions);
vkd3d_free(target.instructions);
return ret;
}
@@ -4769,6 +4861,24 @@ done:
return VKD3D_OK;
}
static enum vkd3d_result vsir_program_materialize_undominated_ssas_to_temps(struct vsir_program *program,
struct vkd3d_shader_message_context *message_context)
{
enum vkd3d_result ret;
struct vsir_cfg cfg;
if ((ret = vsir_cfg_init(&cfg, program, message_context, NULL)) < 0)
return ret;
vsir_cfg_compute_dominators(&cfg);
ret = vsir_cfg_materialize_undominated_ssas_to_temps(&cfg);
vsir_cfg_cleanup(&cfg);
return ret;
}
struct validation_context
{
struct vkd3d_shader_message_context *message_context;
@@ -5646,69 +5756,19 @@ enum vkd3d_result vsir_program_normalise(struct vsir_program *program, uint64_t
if (program->shader_version.major >= 6)
{
struct vsir_cfg cfg;
if ((result = vsir_program_materialise_phi_ssas_to_temps(program)) < 0)
return result;
if ((result = lower_switch_to_if_ladder(program)) < 0)
return result;
if ((result = vsir_cfg_init(&cfg, program, message_context)) < 0)
if ((result = vsir_program_structurize(program, message_context)) < 0)
return result;
vsir_cfg_compute_dominators(&cfg);
if ((result = vsir_cfg_compute_loops(&cfg)) < 0)
{
vsir_cfg_cleanup(&cfg);
return result;
}
if ((result = vsir_cfg_sort_nodes(&cfg)) < 0)
{
vsir_cfg_cleanup(&cfg);
return result;
}
if ((result = vsir_cfg_generate_synthetic_loop_intervals(&cfg)) < 0)
{
vsir_cfg_cleanup(&cfg);
return result;
}
if ((result = vsir_cfg_build_structured_program(&cfg)) < 0)
{
vsir_cfg_cleanup(&cfg);
return result;
}
if ((result = vsir_cfg_optimize(&cfg)) < 0)
{
vsir_cfg_cleanup(&cfg);
return result;
}
if ((result = vsir_cfg_emit_structured_program(&cfg)) < 0)
{
vsir_cfg_cleanup(&cfg);
return result;
}
vsir_cfg_cleanup(&cfg);
if ((result = vsir_program_flatten_control_flow_constructs(program, message_context)) < 0)
return result;
if ((result = vsir_cfg_init(&cfg, program, message_context)) < 0)
return result;
vsir_cfg_compute_dominators(&cfg);
result = vsir_cfg_materialize_undominated_ssas_to_temps(&cfg);
vsir_cfg_cleanup(&cfg);
if (result < 0)
if ((result = vsir_program_materialize_undominated_ssas_to_temps(program, message_context)) < 0)
return result;
}
else
Loading