/*
* This file implements an optimization that deletes statically
- * unreachable/dead code. In NIR, one way this can happen if if an if
+ * unreachable/dead code. In NIR, one way this can happen is when an if
* statement has a constant condition:
*
* if (true) {
* }
* ...
*
- * Finally, we also handle removing useless loops, i.e. loops with no side
- * effects and without any definitions that are used elsewhere. This case is a
- * little different from the first two in that the code is actually run (it
- * just never does anything), but there are similar issues with needing to
- * be careful with restarting after deleting the cf_node (see dead_cf_list())
- * so this is a convenient place to remove them.
+ * Finally, we also handle removing useless loops and ifs, i.e. loops and ifs
+ * with no side effects and without any definitions that are used
+ * elsewhere. This case is a little different from the first two in that the
+ * code is actually run (it just never does anything), but there are similar
+ * issues with needing to be careful with restarting after deleting the
+ * cf_node (see dead_cf_list()) so this is a convenient place to remove them.
*/
static void
* point to the correct source.
*/
nir_block *after = nir_cf_node_as_block(nir_cf_node_next(&if_stmt->cf_node));
- nir_block *last_block =
- nir_cf_node_as_block(condition ? nir_if_last_then_node(if_stmt)
- : nir_if_last_else_node(if_stmt));
+ nir_block *last_block = condition ? nir_if_last_then_block(if_stmt)
+ : nir_if_last_else_block(if_stmt);
nir_foreach_instr_safe(instr, after) {
if (instr->type != nir_instr_type_phi)
nir_phi_instr *phi = nir_instr_as_phi(instr);
nir_ssa_def *def = NULL;
- nir_foreach_phi_src(phi, phi_src) {
+ nir_foreach_phi_src(phi_src, phi) {
if (phi_src->pred != last_block)
continue;
: &if_stmt->else_list;
nir_cf_list list;
- nir_cf_extract(&list, nir_before_cf_list(cf_list),
- nir_after_cf_list(cf_list));
+ nir_cf_list_extract(&list, cf_list);
nir_cf_reinsert(&list, nir_after_cf_node(&if_stmt->cf_node));
nir_cf_node_remove(&if_stmt->cf_node);
}
cf_node_has_side_effects(nir_cf_node *node)
{
nir_foreach_block_in_cf_node(block, node) {
+ bool inside_loop = node->type == nir_cf_node_loop;
+ for (nir_cf_node *n = &block->cf_node; !inside_loop && n != node; n = n->parent) {
+ if (n->type == nir_cf_node_loop)
+ inside_loop = true;
+ }
+
nir_foreach_instr(instr, block) {
if (instr->type == nir_instr_type_call)
return true;
/* Return instructions can cause us to skip over other side-effecting
* instructions after the loop, so consider them to have side effects
* here.
+ *
+ * When the block is not inside a loop, break and continue might also
+ * cause a skip.
*/
if (instr->type == nir_instr_type_jump &&
- nir_instr_as_jump(instr)->type == nir_jump_return)
+ (!inside_loop || nir_instr_as_jump(instr)->type == nir_jump_return))
return true;
if (instr->type != nir_instr_type_intrinsic)
continue;
nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
- if (!nir_intrinsic_infos[intrin->intrinsic].flags &
- NIR_INTRINSIC_CAN_ELIMINATE)
+ if (!(nir_intrinsic_infos[intrin->intrinsic].flags &
+ NIR_INTRINSIC_CAN_ELIMINATE))
return true;
}
}
}
/*
- * Test if a loop is dead. A loop is dead if:
+ * Test if a loop node or if node is dead. Such nodes are dead if:
*
* 1) It has no side effects (i.e. intrinsics which could possibly affect the
* state of the program aside from producing an SSA value, indicated by a lack
* of NIR_INTRINSIC_CAN_ELIMINATE).
*
- * 2) It has no phi nodes after it, since those indicate values inside the
- * loop being used after the loop.
+ * 2) It has no phi instructions after it, since those indicate values inside
+ * the node being used after the node.
+ *
+ * 3) None of the values defined inside the node is used outside the node,
+ * i.e. none of the definitions that dominate the node exit are used outside.
*
- * 3) If there are no phi nodes after the loop, then the only way a value
- * defined inside the loop can be used outside the loop is if its definition
- * dominates the block after the loop. If none of the definitions that
- * dominate the loop exit are used outside the loop, then the loop is dead
- * and it can be deleted.
+ * If those conditions hold, then the node is dead and can be deleted.
*/
static bool
-loop_is_dead(nir_loop *loop)
+node_is_dead(nir_cf_node *node)
{
- nir_block *before = nir_cf_node_as_block(nir_cf_node_prev(&loop->cf_node));
- nir_block *after = nir_cf_node_as_block(nir_cf_node_next(&loop->cf_node));
+ assert(node->type == nir_cf_node_loop || node->type == nir_cf_node_if);
+
+ nir_block *before = nir_cf_node_as_block(nir_cf_node_prev(node));
+ nir_block *after = nir_cf_node_as_block(nir_cf_node_next(node));
if (!exec_list_is_empty(&after->instr_list) &&
nir_block_first_instr(after)->type == nir_instr_type_phi)
return false;
- if (cf_node_has_side_effects(&loop->cf_node))
+ if (cf_node_has_side_effects(node))
return false;
- nir_function_impl *impl = nir_cf_node_get_function(&loop->cf_node);
+ nir_function_impl *impl = nir_cf_node_get_function(node);
nir_metadata_require(impl, nir_metadata_live_ssa_defs |
nir_metadata_dominance);
- for (nir_block *cur = after->imm_dom; cur != before; cur = cur->imm_dom) {
+ for (nir_block *cur = after->imm_dom; cur && cur != before;
+ cur = cur->imm_dom) {
nir_foreach_instr(instr, cur) {
if (!nir_foreach_ssa_def(instr, def_not_live_out, after))
return false;
{
nir_if *following_if = nir_block_get_following_if(block);
if (following_if) {
- nir_const_value *const_value =
- nir_src_as_const_value(following_if->condition);
+ if (node_is_dead(&following_if->cf_node)) {
+ nir_cf_node_remove(&following_if->cf_node);
+ return true;
+ }
+
+ nir_const_value *const_value =
+ nir_src_as_const_value(following_if->condition);
- if (!const_value)
- return false;
+ if (!const_value)
+ return false;
opt_constant_if(following_if, const_value->u32[0] != 0);
return true;
if (!following_loop)
return false;
- if (!loop_is_dead(following_loop))
+ if (!node_is_dead(&following_loop->cf_node))
return false;
nir_cf_node_remove(&following_loop->cf_node);
{
bool progress = false;
- nir_foreach_function(shader, function)
+ nir_foreach_function(function, shader)
if (function->impl)
progress |= opt_dead_cf_impl(function->impl);