| /* |
| * Copyright © 2024 Valve Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include "nir_test.h" |
| |
| class nir_opt_loop_test : public nir_test { |
| protected: |
| nir_opt_loop_test(); |
| |
| nir_deref_instr *add_loop_terminators(nir_if **term1, nir_if **term2, |
| bool break_in_else, bool deref_array); |
| void create_loop_phis(nir_loop *loop, nir_if *term1, nir_if *term2, |
| nir_def *def1, nir_def *def2); |
| void test_merged_if(bool break_in_else); |
| |
| nir_def *in_def; |
| nir_variable *out_var; |
| nir_variable *ubo_var; |
| nir_variable *ubo_var_array; |
| }; |
| |
| nir_opt_loop_test::nir_opt_loop_test() |
| : nir_test::nir_test("nir_opt_loop_test", MESA_SHADER_FRAGMENT) |
| { |
| nir_variable *var = nir_variable_create(b->shader, nir_var_shader_in, glsl_int_type(), "in"); |
| in_def = nir_load_var(b, var); |
| |
| ubo_var = nir_variable_create(b->shader, nir_var_mem_ubo, glsl_int_type(), "ubo1"); |
| ubo_var_array = nir_variable_create(b->shader, nir_var_mem_ubo, glsl_array_type(glsl_int_type(), 4, 0), "ubo_array"); |
| |
| out_var = nir_variable_create(b->shader, nir_var_shader_out, glsl_int_type(), "out"); |
| } |
| |
| nir_deref_instr * |
| nir_opt_loop_test::add_loop_terminators(nir_if **term1, nir_if **term2, |
| bool break_in_else, bool deref_array) |
| { |
| /* Add first terminator */ |
| nir_def *one = nir_imm_int(b, 1); |
| nir_def *cmp_result = nir_ieq(b, in_def, one); |
| nir_if *nif = nir_push_if(b, cmp_result); |
| |
| if (break_in_else) |
| nir_push_else(b, nif); |
| |
| nir_jump(b, nir_jump_break); |
| nir_pop_if(b, nif); |
| |
| if (term1) |
| *term1 = nif; |
| |
| nir_deref_instr *deref; |
| if (deref_array) { |
| nir_def *index = nir_imm_int(b, 3); |
| deref = nir_build_deref_array(b, nir_build_deref_var(b, ubo_var_array), index); |
| } else { |
| deref = nir_build_deref_var(b, ubo_var); |
| } |
| nir_def *ubo_def = nir_load_deref(b, deref); |
| |
| /* Add second terminator */ |
| nir_def *two = nir_imm_int(b, 2); |
| nir_def *cmp_result2 = nir_ieq(b, ubo_def, two); |
| nir_if *nif2 = nir_push_if(b, cmp_result2); |
| |
| if (break_in_else) |
| nir_push_else(b, nif2); |
| |
| nir_jump(b, nir_jump_break); |
| nir_pop_if(b, nif2); |
| |
| if (term2) |
| *term2 = nif2; |
| |
| return deref; |
| } |
| |
| void |
| nir_opt_loop_test::create_loop_phis(nir_loop *loop, |
| nir_if *term1, nir_if *term2, |
| nir_def *def1, nir_def *def2) |
| { |
| nir_phi_instr *phi_instr = nir_phi_instr_create(b->shader); |
| nir_def_init(&phi_instr->instr, &phi_instr->def, 1, 32); |
| nir_phi_instr_add_src(phi_instr, nir_if_first_then_block(term1), def1); |
| nir_phi_instr_add_src(phi_instr, nir_if_first_then_block(term2), def2); |
| |
| nir_instr_insert(nir_after_cf_node(&loop->cf_node), |
| &phi_instr->instr); |
| } |
| |
| void |
| nir_opt_loop_test::test_merged_if(bool break_in_else) |
| { |
| /* Tests that opt_loop_merge_terminators results in valid nir and that |
| * the test condition is correct based on the location of the break in |
| * the terminators. |
| */ |
| nir_loop *loop = nir_push_loop(b); |
| |
| nir_if *term1; |
| nir_if *term2; |
| add_loop_terminators(&term1, &term2, break_in_else, false); |
| |
| nir_pop_loop(b, loop); |
| |
| ASSERT_TRUE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_merge_terminators_break_in_then) |
| { |
| test_merged_if(false); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b7 |
| 32 %2 = load_const (0x00000001) |
| 1 %3 = ieq %1, %2 (0x1) |
| // succs: b2 b3 |
| if %3 { |
| block b2: // preds: b1 |
| 1 %4 = undefined |
| // succs: b4 |
| } else { |
| block b3: // preds: b1 |
| 32 %5 = deref_var &ubo1 (ubo int) |
| 32 %6 = @load_deref (%5) (access=none) |
| 32 %7 = load_const (0x00000002) |
| 1 %8 = ieq %6, %7 (0x2) |
| // succs: b4 |
| } |
| block b4: // preds: b2 b3 |
| 1 %9 = phi b2: %4, b3: %8 |
| 1 %10 = ior %9, %3 |
| // succs: b5 b6 |
| if %10 { |
| block b5:// preds: b4 |
| break |
| // succs: b8 |
| } else { |
| block b6: // preds: b4, succs: b7 |
| } |
| block b7: // preds: b6, succs: b1 |
| } |
| block b8: // preds: b5, succs: b9 |
| block b9: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_merge_terminators_break_in_else) |
| { |
| test_merged_if(true); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b7 |
| 32 %2 = load_const (0x00000001) |
| 1 %3 = ieq %1, %2 (0x1) |
| // succs: b2 b3 |
| if %3 { |
| block b2: // preds: b1 |
| 32 %4 = deref_var &ubo1 (ubo int) |
| 32 %5 = @load_deref (%4) (access=none) |
| 32 %6 = load_const (0x00000002) |
| 1 %7 = ieq %5, %6 (0x2) |
| // succs: b4 |
| } else { |
| block b3: // preds: b1 |
| 1 %8 = undefined |
| // succs: b4 |
| } |
| block b4: // preds: b2 b3 |
| 1 %9 = phi b2: %7, b3: %8 |
| 1 %10 = iand %9, %3 |
| // succs: b5 b6 |
| if %10 { |
| block b5: // preds: b4, succs: b7 |
| } else { |
| block b6:// preds: b4 |
| break |
| // succs: b8 |
| } |
| block b7: // preds: b5, succs: b1 |
| } |
| block b8: // preds: b6, succs: b9 |
| block b9: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_merge_terminators_deref_after_first_if) |
| { |
| /* Tests that opt_loop_merge_terminators creates valid nir after it merges |
| * terminators that have a deref statement between them: |
| */ |
| nir_loop *loop = nir_push_loop(b); |
| |
| nir_deref_instr *deref = add_loop_terminators(NULL, NULL, false, false); |
| |
| /* Load from deref that will be moved inside the continue branch of the |
| * first if-statements continue block. If not handled correctly during |
| * the merge this will fail nir validation. |
| */ |
| nir_def *ubo_def = nir_load_deref(b, deref); |
| nir_store_var(b, out_var, ubo_def, 1); |
| |
| nir_pop_loop(b, loop); |
| |
| ASSERT_TRUE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b7 |
| 32 %2 = load_const (0x00000001) |
| 1 %3 = ieq %1, %2 (0x1) |
| // succs: b2 b3 |
| if %3 { |
| block b2: // preds: b1 |
| 1 %4 = undefined |
| // succs: b4 |
| } else { |
| block b3: // preds: b1 |
| 32 %5 = deref_var &ubo1 (ubo int) |
| 32 %6 = @load_deref (%5) (access=none) |
| 32 %7 = load_const (0x00000002) |
| 1 %8 = ieq %6, %7 (0x2) |
| // succs: b4 |
| } |
| block b4: // preds: b2 b3 |
| 1 %9 = phi b2: %4, b3: %8 |
| 1 %10 = ior %9, %3 |
| // succs: b5 b6 |
| if %10 { |
| block b5:// preds: b4 |
| break |
| // succs: b8 |
| } else { |
| block b6: // preds: b4, succs: b7 |
| } |
| block b7: // preds: b6 |
| 32 %11 = deref_var &ubo1 (ubo int) |
| 32 %12 = @load_deref (%11) (access=none) |
| 32 %13 = deref_var &out (shader_out int) |
| @store_deref (%13, %12) (wrmask=x, access=none) |
| // succs: b1 |
| } |
| block b8: // preds: b5, succs: b9 |
| block b9: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_merge_terminators_deref_phi_index) |
| { |
| /* Tests that opt_loop_merge_terminators creates valid nir after it merges |
| * terminators that have a deref statement and index value between them and |
| * where that deref and index are both later used again later in the code: |
| */ |
| nir_loop *loop = nir_push_loop(b); |
| |
| nir_deref_instr *deref = add_loop_terminators(NULL, NULL, false, true); |
| |
| /* Load from deref that will be moved inside the continue branch of the |
| * first if-statements continue block. If not handled correctly during |
| * the merge this will fail nir validation. |
| */ |
| nir_def *ubo_def = nir_load_deref(b, deref); |
| nir_store_var(b, out_var, ubo_def, 1); |
| |
| nir_pop_loop(b, loop); |
| |
| ASSERT_TRUE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b7 |
| 32 %2 = load_const (0x00000001) |
| 1 %3 = ieq %1, %2 (0x1) |
| // succs: b2 b3 |
| if %3 { |
| block b2: // preds: b1 |
| 1 %4 = undefined |
| 32 %5 = undefined |
| // succs: b4 |
| } else { |
| block b3: // preds: b1 |
| 32 %6 = load_const (0x00000003 = 0.000000) |
| 32 %7 = deref_var &ubo_array (ubo int[4]) |
| 32 %8 = deref_array &(*%7)[3] (ubo int) // &ubo_array[3] |
| 32 %9 = @load_deref (%8) (access=none) |
| 32 %10 = load_const (0x00000002) |
| 1 %11 = ieq %9, %10 (0x2) |
| // succs: b4 |
| } |
| block b4: // preds: b2 b3 |
| 1 %12 = phi b2: %4, b3: %11 |
| 32 %13 = phi b2: %5, b3: %6 (0x3) |
| 1 %14 = ior %12, %3 |
| // succs: b5 b6 |
| if %14 { |
| block b5:// preds: b4 |
| break |
| // succs: b8 |
| } else { |
| block b6: // preds: b4, succs: b7 |
| } |
| block b7: // preds: b6 |
| 32 %15 = deref_var &ubo_array (ubo int[4]) |
| 32 %16 = deref_array &(*%15)[%13] (ubo int) // &ubo_array[%13] |
| 32 %17 = @load_deref (%16) (access=none) |
| 32 %18 = deref_var &out (shader_out int) |
| @store_deref (%18, %17) (wrmask=x, access=none) |
| // succs: b1 |
| } |
| block b8: // preds: b5, succs: b9 |
| block b9: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_merge_terminators_skip_merge_if_phis) |
| { |
| /* Tests that opt_loop_merge_terminators skips merging the terminators if |
| * the loop has phis. We can update or remove this test if support for |
| * phis is added to this pass: |
| */ |
| nir_deref_instr *deref = nir_build_deref_var(b, ubo_var); |
| nir_def *ubo_def = nir_load_deref(b, deref); |
| |
| nir_loop *loop = nir_push_loop(b); |
| |
| nir_if *term1; |
| nir_if *term2; |
| add_loop_terminators(&term1, &term2, false, false); |
| |
| nir_pop_loop(b, loop); |
| |
| create_loop_phis(loop, term1, term2, in_def, ubo_def); |
| |
| ASSERT_FALSE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| 32 %2 = deref_var &ubo1 (ubo int) |
| 32 %3 = @load_deref (%2) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b7 |
| 32 %4 = load_const (0x00000001) |
| 1 %5 = ieq %1, %4 (0x1) |
| // succs: b2 b3 |
| if %5 { |
| block b2:// preds: b1 |
| break |
| // succs: b8 |
| } else { |
| block b3: // preds: b1, succs: b4 |
| } |
| block b4: // preds: b3 |
| 32 %6 = deref_var &ubo1 (ubo int) |
| 32 %7 = @load_deref (%6) (access=none) |
| 32 %8 = load_const (0x00000002) |
| 1 %9 = ieq %7, %8 (0x2) |
| // succs: b5 b6 |
| if %9 { |
| block b5:// preds: b4 |
| break |
| // succs: b8 |
| } else { |
| block b6: // preds: b4, succs: b7 |
| } |
| block b7: // preds: b6, succs: b1 |
| } |
| block b8: // preds: b2 b5 |
| 32 %10 = phi b2: %1, b5: %3 |
| // succs: b9 |
| block b9: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_merge_terminators_skip_merge_if_phis_nested_loop) |
| { |
| /* Tests that opt_loop_merge_terminators skips merging the terminators if |
| * the loop has phis. We can update or remove this test if support for |
| * phis is added to this pass: |
| */ |
| nir_deref_instr *deref = nir_build_deref_var(b, ubo_var); |
| nir_def *ubo_def = nir_load_deref(b, deref); |
| |
| nir_loop *loop = nir_push_loop(b); |
| |
| /* Add a nested loop to make sure we test the correct loop for trailing phis */ |
| nir_loop *nested_loop = nir_push_loop(b); |
| nir_pop_loop(b, nested_loop); |
| |
| nir_if *term1; |
| nir_if *term2; |
| add_loop_terminators(&term1, &term2, false, false); |
| |
| nir_pop_loop(b, loop); |
| |
| create_loop_phis(loop, term1, term2, in_def, ubo_def); |
| |
| ASSERT_FALSE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| 32 %2 = deref_var &ubo1 (ubo int) |
| 32 %3 = @load_deref (%2) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b9, succs: b2 |
| loop { |
| block b2: // preds: b1 b2, succs: b2 |
| } |
| block b3: // preds: |
| 32 %4 = load_const (0x00000001) |
| 1 %5 = ieq %1, %4 (0x1) |
| // succs: b4 b5 |
| if %5 { |
| block b4:// preds: b3 |
| break |
| // succs: b10 |
| } else { |
| block b5: // preds: b3, succs: b6 |
| } |
| block b6: // preds: b5 |
| 32 %6 = deref_var &ubo1 (ubo int) |
| 32 %7 = @load_deref (%6) (access=none) |
| 32 %8 = load_const (0x00000002) |
| 1 %9 = ieq %7, %8 (0x2) |
| // succs: b7 b8 |
| if %9 { |
| block b7:// preds: b6 |
| break |
| // succs: b10 |
| } else { |
| block b8: // preds: b6, succs: b9 |
| } |
| block b9: // preds: b8, succs: b1 |
| } |
| block b10: // preds: b4 b7 |
| 32 %10 = phi b4: %1, b7: %3 |
| // succs: b11 |
| block b11: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_peel_initial_break_ends_with_jump) |
| { |
| nir_loop *loop = nir_push_loop(b); |
| |
| /* the break we want to move down: */ |
| nir_break_if(b, nir_imm_true(b)); |
| |
| /* do_work_2: */ |
| nir_push_if(b, nir_imm_true(b)); |
| nir_jump(b, nir_jump_continue); |
| nir_pop_if(b, NULL); |
| nir_jump(b, nir_jump_return); |
| |
| nir_pop_loop(b, loop); |
| |
| ASSERT_FALSE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b5 |
| 1 %2 = load_const (true) |
| // succs: b2 b3 |
| if %2 (true) { |
| block b2:// preds: b1 |
| break |
| // succs: b8 |
| } else { |
| block b3: // preds: b1, succs: b4 |
| } |
| block b4: // preds: b3 |
| 1 %3 = load_const (true) |
| // succs: b5 b6 |
| if %3 (true) { |
| block b5:// preds: b4 |
| continue |
| // succs: b1 |
| } else { |
| block b6: // preds: b4, succs: b7 |
| } |
| block b7:// preds: b6 |
| return |
| // succs: b9 |
| } |
| block b8: // preds: b2, succs: b9 |
| block b9: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_peel_initial_break_nontrivial_break) |
| { |
| nir_loop *loop = nir_push_loop(b); |
| |
| nir_push_if(b, nir_imm_true(b)); |
| |
| nir_push_if(b, nir_imm_true(b)); |
| nir_push_if(b, nir_imm_true(b)); |
| nir_jump(b, nir_jump_break); |
| nir_pop_if(b, NULL); |
| nir_pop_if(b, NULL); |
| nir_nop(b); |
| |
| nir_jump(b, nir_jump_break); |
| nir_pop_if(b, NULL); |
| |
| /* do_work_2: */ |
| nir_nop(b); |
| |
| nir_pop_loop(b, loop); |
| |
| ASSERT_FALSE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| // succs: b1 |
| loop { |
| block b1: // preds: b0 b10 |
| 1 %2 = load_const (true) |
| // succs: b2 b9 |
| if %2 (true) { |
| block b2: // preds: b1 |
| 1 %3 = load_const (true) |
| // succs: b3 b7 |
| if %3 (true) { |
| block b3: // preds: b2 |
| 1 %4 = load_const (true) |
| // succs: b4 b5 |
| if %4 (true) { |
| block b4:// preds: b3 |
| break |
| // succs: b11 |
| } else { |
| block b5: // preds: b3, succs: b6 |
| } |
| block b6: // preds: b5, succs: b8 |
| } else { |
| block b7: // preds: b2, succs: b8 |
| } |
| block b8:// preds: b6 b7 |
| @nop |
| break |
| // succs: b11 |
| } else { |
| block b9: // preds: b1, succs: b10 |
| } |
| block b10:// preds: b9 |
| @nop |
| // succs: b1 |
| } |
| block b11: // preds: b4 b8, succs: b12 |
| block b12: |
| } |
| )")); |
| } |
| |
| TEST_F(nir_opt_loop_test, opt_loop_peel_initial_break_deref) |
| { |
| nir_loop *loop = nir_push_loop(b); |
| |
| nir_deref_instr *var_deref = nir_build_deref_var(b, out_var); |
| |
| nir_push_if(b, nir_imm_true(b)); |
| nir_jump(b, nir_jump_break); |
| nir_pop_if(b, NULL); |
| |
| nir_store_deref(b, var_deref, nir_imm_int(b, 42), 0x1); |
| |
| nir_pop_loop(b, loop); |
| |
| ASSERT_TRUE(nir_opt_loop(b->shader)); |
| |
| nir_validate_shader(b->shader, NULL); |
| |
| check_nir_string(NIR_REFERENCE_SHADER(R"( |
| shader: MESA_SHADER_FRAGMENT |
| name: nir_opt_loop_test |
| subgroup_size: 0 |
| decl_var shader_in INTERP_MODE_SMOOTH none int in (VARYING_SLOT_POS.x, 0, 0) |
| decl_var shader_out INTERP_MODE_NONE none int out (FRAG_RESULT_DEPTH.x, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int ubo1 (0, 0, 0) |
| decl_var ubo INTERP_MODE_NONE none int[4] ubo_array (0, 0, 0) |
| decl_function main () (entrypoint) |
| |
| impl main { |
| block b0: // preds: |
| 32 %0 = deref_var &in (shader_in int) |
| 32 %1 = @load_deref (%0) (access=none) |
| 1 %2 = load_const (true) |
| // succs: b1 b2 |
| if %2 (true) { |
| block b1: // preds: b0, succs: b8 |
| } else { |
| block b2: // preds: b0, succs: b3 |
| loop { |
| block b3: // preds: b2 b6 |
| 32 %3 = load_const (0x0000002a = 42) |
| 32 %4 = deref_var &out (shader_out int) |
| @store_deref (%4, %3 (0x2a)) (wrmask=x, access=none) |
| 1 %5 = load_const (true) |
| // succs: b4 b5 |
| if %5 (true) { |
| block b4:// preds: b3 |
| break |
| // succs: b7 |
| } else { |
| block b5: // preds: b3, succs: b6 |
| } |
| block b6: // preds: b5, succs: b3 |
| } |
| block b7: // preds: b4, succs: b8 |
| } |
| block b8: // preds: b1 b7, succs: b9 |
| block b9: |
| } |
| )")); |
| } |
